类----（二）多态

类的特性：封装，继承，多态。
多态：子类继承了父类的行为，可以调用父类的方法。但是有时，子类的行为要不同于父类，此时可以重写父类的方法。

相同的类型，调用相同的方法却有不同的行为–这就是多态。为了重写父类方法可以用virtual与override关键字来实现。
只有基类成员声明为virtual 或abstract时，才可以被子类重写；如果子类要重写父类的虚方法，则必须用override关键字
基类用于定义公共成员，因此一般不用于实例化，所以为防止实例化基类，可以将基类定义为abstract—抽象类。
如果要阻止子类重写父类虚方法，可以使用sealed关键字。
如果想在子类中声明与父类相同的成员，可以用new关键字来实现，如此时仍想访问父类成员，可以将子类强转为父类，然后来访问。
example：

using System;

namespace classTest014
{
    class Person
    {
        private string name;
        public string Name
        {
            get { return name; }
            set { name = value; }
        }
        private int age;//对不合法的数据进行控制，保护内部数据正确，使外部无法直接访问，这就是封装
        public int Age
        {
            get { return age; }
            set
            {
                if ((value) < 0 || (value > 130))
                    Console.WriteLine("数据不合法");
                age = value;
            }
        }
    }
    class Animal//子类访问父类中的（protected ,public）属性或字段。这样就不用重复在子类中定义相同的字段或属性。
    {
        private int age;
        private string name;
        public string Name
        {
            get { return name; }
            set { name = value; }
        }
        public int Age
        {
            get { return age; }
            set
            {
                if ((value < 0) || (value > 10))
                    Console.WriteLine("输入数据不合法");
                age = value;
            }
        }
        public void Print()
        {
            Console.WriteLine("name:{0},age:{1}", name, age);
        }
        public virtual void Voice()
        {
            Console.WriteLine("动物会发声音！。。。");
        }
        public  void Eat()
        {
            Console.WriteLine("动物需要吃饭");
        } 

    }
    class Hourse : Animal
    {
        public override void Voice()
        {
            base.Voice();// 使用 base调用了基类方法。
            Console.WriteLine("马发出的声音----唔哦---唔哦--");
        }
        public new void Eat()
        {
            Console.WriteLine("小马吃草----！");
        }
    }
    class Dog : Animal
    {
        public override void Voice()   // 使用override 重写方法 
        {
            base.Voice();
            Console.WriteLine("狗发出的叫声----汪汪汪--汪汪--");
        }
    }
    class Parent
    {
        public Parent()
        {
            Console.WriteLine("调用基类的构造函数");
        }

    }
    class Child : Parent
    {
        private string FiledA = "chileA de ziduan";
        public Child()
        {

            Console.WriteLine("调用子类的构造函数");
        }
        public void Print()
        {
            Console.WriteLine(FiledA);
        }
    }



    class Program
    {
        static void Main(string[] args)
        {
            Hourse h = new Hourse();
            h.Name = "house";
            h.Print();

            Dog d = new Dog();
            d.Name = "puppy";
            d.Print();

            Child cha = new Child();//1.初始化字段。2. 调用基类构造函数。3.调用子类构造函数。

            cha.Print();

            Animal house = new Hourse();//相同的类型，调用相同的方法，表现的行为不一样--多态。
            Animal dog = new Dog();
            house.Voice();
            dog.Voice();
            //基类用于定义公共成员，因此一般不用于 实例化，所以为防止实例化基类，可以将基类定义为abstract---抽象类。
            Hourse childHouse = new Hourse(); //子类对象可以转为父类对象
            Animal parent = (Animal)childHouse;
            parent.Voice();

            //Animal p = new Animal();
            //Hourse chouse = (Hourse)p;  //无法将父类对象转为子类对象,
            //chouse.Voice();

            //如果要阻止子类重写父类虚方法，可以使用sealed关键字。
             // 如果想在子类中声明与父类相同的成员，可以用new关键字来实现，如此时仍想访问父类成员，可以将子类强转为父类，然后来访问。
            Hourse newtest = new Hourse();
            newtest.Eat();//调用子类成员。
            ((Animal)newtest).Eat();//调用父类成员。

            Console.ReadKey();
        }
    }
}

猜你喜欢