2015 5.16 C# 继承和多态

类的层次结构有两种基本的构造方式  自顶向下  自底向上

基类的保护成员是指允许派生类的方法代码访问，而不是指通过派生类的对象访问

如果基类中的字段通过公有且可读写的属性进行了封装，那么建议将字段定义为私有的，这样包括其派生类在内的所有其他类型都必须通过属性进行访问

隐藏基类成员

如果派生类中定义了与基类相同的成员，默认情况下基类的成员在派生类中会被隐藏，即派生类成员覆盖了基类成员   用new来修饰提高代码可读性

base 关键字，当派生类隐藏了基类成员时，base关键字就能发挥作用：直接写出的成员名表示派生类的成员，增加了base引用的成员表示被隐藏的基类成员

用base声明创建对象时调用的基类重载构造函数

虚拟方法和重载方法

using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main()
        {
            foreach (Automobile a in GetAutos())
            {
                a.Speak();
                Console.WriteLine("{0}行驶1000公里需要{1}小时", a.Name, a.Run(1000));
            }
            //Console.ReadLine();
        }
        static Automobile[] GetAutos()
        {
            Automobile[] autos = new Automobile[4];
            autos[0] = new Bus("客车", 20);
            autos[1] = new Truck("东风卡车", 30);
            autos[2] = new Truck("黄河卡车", 45);
            autos[3] = new Automobile("汽车", 80, 3);
            return autos;
        }
    }

    public class Automobile
    {
        private string name;
        public string Name
        {
            get { return name; }
        }

        private float speed;
        public float Speed
        {
            get { return speed; }
        }

        private float weight;
        public float Weight
        {
            get { return weight; }
            set { weight = value; }
        }

        public Automobile(string name, float speed, float weight)
        {
            this.name = name;
            this.speed = speed;
            this.weight = weight;
        }

        public virtual float Run(float distance)//虚拟方法
        {
            return distance / speed;
        }

        public virtual void Speak()
        {
            Console.WriteLine("汽车鸣笛……");
        }
    }
    public class Bus : Automobile
    {
        private int passangers;
        public int Passangers
        {
            get { return passangers; }
            set { passangers = value; }
        }
        public Bus(string name, int passangers)
            : base(name, 60, 10)
        {
            this.passangers = passangers;
        }
        public override void Speak()
        {
            Console.WriteLine("嘀……嘀……");
        }
    }

    public class Truck : Automobile
    {
        private float load;
        public float Load
        {
            get { return load; }
            set { load = value; }
        }
        public Truck(string name, int load)
            : base(name, 50, 15)
        {
            this.load = load;
        }
        public override float Run(float distance)//重载方法
        {
            return (1 + load / Weight / 2) * base.Run(distance);
        }
        public override void Speak()//重载方法
        {
            Console.WriteLine("叭……叭……");
        }
    }

}

抽象类和抽象方法（抽象类不能直接用new创建对象，但可以与派生类的实例相关联）

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main()
        {
            Vehicle v1 = new Train();
            v1.Speak();
            Console.WriteLine("行驶1000公里需{0}小时", v1.Run(1000));
            v1 = new Truck(16, 24);
            v1.Speak();
            Console.WriteLine("行驶1000公里需{0}小时", v1.Run(1000));
            Console.ReadLine();
        }
    }

    public abstract class Vehicle
    {
        private float speed;
        public float Speed
        {
            get { return speed; }
        }

        public virtual float Run(float distance)
        {
            return distance / speed;
        }

        public abstract void Speak();//抽象方法：无执行代码

        public Vehicle(float speed)
        {
            this.speed = speed;
        }
    }

    public class Train : Vehicle
    {
        public Train()
            : base(160)
        { }

        public override void Speak()
        {
            Console.WriteLine("呜……");
        }
    }

    public abstract class Automobile:Vehicle
    {
        public Automobile(float speed):base(speed)
        { }

        public override abstract void Speak();//重载+抽象
    }

    public class Truck : Automobile
    {
        private float weight;
        public float Weight
        {
            get { return weight; }
        }

        private float load;
        public float Load
        {
            get { return load; }
        }

        public Truck(int weight, int load)
            : base(50)
        {
            this.weight = weight;
            this.load = load;
        }

        public override float Run(float distance)
        {
            return (1 + load / Weight / 2 )* base.Run(distance);
        }

        public override void Speak()
        {
            Console.WriteLine("叭……叭……");
        }
    }
}

密封类和密封方法

一些类型不允许或是不需要再有派生类型   sealed   密封类是对类继承的截止   密封方法是对类继承中方法重载的截止

sing System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main()
        {
            Student s1=new Student(101,"王小红");
            Console.WriteLine(s1);
            Student s2=new Graduate(101,"王晓红","张大伟");
            Console.WriteLine(s2);
            Console.WriteLine(s1.Equals(s2));
            Console.ReadLine();
        }
    }

    public class Student
    {
        private string name;
        public string Name
        {
            get { return name; }
        }

        private int id;
        public int ID
        {
            get { return id; }
        }

        public Student(int id, string name)
        {
            this.id = id;
            this.name = name;
        }

        public override string ToString()
        {
            return string.Format("学号{0}，姓名{1}", id, name);
        }

        public sealed override bool Equals(object obj)
        {
            if (obj is Student && ((Student)obj).id == this.id)
                return true;
            else
                return false;
        }
    }

    public class Graduate : Student
    {
        private string supervisor;
        public string Supervisor
        {
            get { return supervisor; }
            set { supervisor = value; }
        }

        public Graduate(int id, string name, string supervisor)
            : base(id, name)
        {
            this.supervisor = supervisor;
        }

        public override string ToString()
        {
            return base.ToString() + ",导师：" + supervisor;
        }
    }
}