多态总结复习

虚方法

调用父类的方法时，会调用被子类重写过的方法

        static void Main(string[] args)
        {
            //让一个对象能够表现出多种的状态(类型)
            Cow_cat cat1 = new Cow_cat("zeze");
            Orrange_cat cat2 = new Orrange_cat("huahua");
            Cat[] mycat = { cat1, cat2 };//子类可以赋值给父类
            for (int i = 0; i < mycat.Length; i++)
            {
                mycat[i].display();//调用的是父类的方法
            }
            Console.ReadKey();


        }
        public class Cat
        {
            string _name;//字段
            public string Name //属性
            {
                get { return _name; }
                set { _name = value; }
            }
            public Cat(string name)//构造函数
            {
                this.Name = name;
            }
            public virtual void display() //方法
            {
                Console.WriteLine("{0} is a cute cat.", this.Name);
            }

        }

        public class Cow_cat : Cat
        {
            public Cow_cat(string name) : base(name)
            {

            }
            public override void display()
            {
                Console.WriteLine("{0} is a cute but naughty cat.", this.Name);
            }
        }

        public class Orrange_cat : Cat
        {
            public Orrange_cat(string name):base(name)
            {

            }
            public override void display()
            {
                Console.WriteLine("{0} is a cute but edacity cat.", this.Name);
            }
        }

抽象类

当父类中的方法不知道如何实现时，可以将方法写为抽象方法，抽象方法没有方法体，抽象类和接口都不允许创建对象

        static void Main(string[] args)
        {
            Cat cat1 = new Cow_cat();//抽象类不允许创建对象，但是可以创建子类对象给父类抽象类
            cat1.display();//调用的是父类函数，但被子类重写，因此为调用子类重写的方法
            Console.ReadKey();
        }
        public abstract class Cat
        {
            public abstract void display();
        }
        public class Cow_cat
            : Cat
        {
            public override void display()
            {
                Console.WriteLine("Cow cat is a cute but naughty cat.");
            }
        }

接口

接口提供派生类应遵循的标准结构
接口与接口之间可以继承，且可以多继承
接口不能继承类，类可以继承接口
实现接口的子类必须实现该接口的全部成员

        public class Cat
        {

            public void display() //方法
            {
                Console.WriteLine("Cat is cute.");
            }

        }
        public interface color
        {
            void catcolor();
        }
        public class Cow_cat : Cat, color//可以继承类和接口
        {

            public void catcolor()
            {
                Console.WriteLine("Cow cat is black and white.");
            }
        }
                public class Orrange_cat : Cat, color
        {
        public class Orrange_cat : Cat, color
        {

            public void catcolor()
            {
                Console.WriteLine("Orrange cat is orrange.");
            }
        }

抽象类与接口异同

相同点：

• 都可以被继承
• 都不能直接被实例化
• 都可以包含方法且都没有实现
• 派生类必须实现未实现的成员

不同点：

• 接口可以多重实现，抽象类只能被单一继承
• 抽象类可以定义字段，接口不能

抽象类与接口的用法

• 抽象类表示共性，而接口表示规范
• 抽象类主要用于关系密切的对象，接口适合为不相关的类提供通用功能
• 接口的定义应该具有专一的功能性，而不是多功能