黑马程序员：C#基础篇（四）抽象类、接口、继承与多态

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------

抽象类

抽象类与接口主要都是为了实现多态，使用abstract关键字可以创建仅用于继承用途的类和成员。对于接口，从定义就可以发现是对方法的抽象，也可描述成对能力的抽象；而抽象类是 对以事物的抽象，与具体的对象有关。
抽象类的成员与一般类无异，只不过一般定义成抽象的，给派生类重写，从而实现多态，一般定义的抽象成员有方法，事件，属性，索引器。抽象类的构造函数主要是为了对非抽象成员的初始化”抽象类是不能实例化的“，派生类会默认调用父类的无参构造函数，因此其也不能是私有的。例子：

    delegate void MyDelegate();    abstract class MyClass    {        public abstract void Func();//抽象成员必须是公共的        public abstract string AttriBute        {            get;//可以只有一个访问器            set;        }        public abstract string this[int num]        {            get;//与属性类似            set;        }        public abstract event MyDelegate BaseEvent;    }    class MyClass1:MyClass    {        public override string AttriBute        {            get            {                return "123";            }            set            {                Console.WriteLine(value);            }        }        public override string this[int num]        {            get            {                return num.ToString();            }            set            {                Console.WriteLine(value);            }        }        public override void Func()        {            Console.WriteLine("123");        }        public override event MyDelegate BaseEvent;//自动补全add，remove访问器   }

抽象类的抽象成员可以自定义的，也可以来自接口，也可以来自某个基类。将基类的虚方法用abstract修饰，例子：

    interface IMyInterface    {        string Attribute        {            get;        }    }    class TestClass    {        public virtual void Func()        {             //...        }    }    abstract class BaseClass : TestClass, IMyInterface    {        public abstract string Attribute        {            get;//实现接口成员             set; //自定义抽象成员        }        public abstract new void Func();//隐藏父类成员    }

接口

接口主要为了实现多态和多继承。接口的特点：

（1）类或结构可继承多个接口

（2）当类或接口继承接口时继承成员定义，但不继承实现

（3）类似抽象基类，继承接口的任何非抽象类型都必须实现接口的所有成员

（4）不能直接实例化

（5）可以包含事件、索引器、属性和方法

（6）不包含方法的实现

（7）类和接口可从多个接口继承

（8）自身可从多个接口继承

若要实现接口，类中的对应成员必须是公共的且非静态的，并且与接口成员具有相同的签名和名称。
实现接口的类分三种，一是抽象类，二是一般的类，再就是结构. 而实现方式又分为实 现接口和显式实现接口。

    interface IMyInterface    {        void Func();        string this[int index] { get; set; }        string Value { get; set; }        event EventHandler MyEventHandler;    }    public abstract class MyClass : IMyInterface     {          public void Func()         {         // 实现代码         }         public string Value {  get;  set; }         public event EventHandler MyEventHandler;         public string this[int index]         {              get             {                // 实现代码             }             set             {                 // 实现代码             }         }    } 

此处的属性与接口中的属性意义是不同的，此处为自动属性，在代码的后台编译器 会自动生成一个字段，并填补 get 和 set 读取器. 。此处的事件也与接口中的事件意义不同（从代码角度看几乎一样），这里的事件，编 译器会自动生成一个同名的私有委托，并将 add 方法与 remove 方法补全。 

如果不希望具体实现接口成员，只要前面加abstract就行。

    public abstract class MyClass : IMyInterface     {        public abstract void Func();        public abstract string Value {  get;  set; }         public abstract event EventHandler MyEventHandler;        public abstract string this[int index] { get; set; }    } 

显示实现的话（1）显示实现的接口，不允许有访问修饰符 （2）事件不允许使用默认系统自定义的方式，需要自己添加 add 方法和 remove 方法（3）另外显示实现接口的成员不允许使用 abstract 进行修饰.。

    public abstract class MyClass : IMyInterface     {        void IMyInterface.Func()          {              // 方法体        }          string IMyInterface.Value  {   get;   set;  }          event EventHandler IMyInterface.MyEventHandler          {              add             {                   // 实现代码             }             remove             {                // 实现代码             }         }        string IMyInterface.this[int index]        {            get            {                // 实现代码             }            set            {                // 实现代码            }        }    } 

封装继承多态

封装

封装就是指将数据和基于数据的操作封装在一起，数据被保护在类型的内部，系统的其他部分只有通过包裹在数据外面的被授权的操作，才能够与这个数据类型交流与交互。

sealed关键字可以防止派生。用在类上可以防止类的派生，用在成员上可以中断成员的继承。

继承

继承会继承父类的所有公共成员，子类中可以隐藏，可以重写，例子：

    class A    {        public string str = "A";        public void Show()        { Console.WriteLine("Show A"); }    }    class B:A    {        public string str = "B";        public virtual void Show()        { Console.WriteLine("Show B"); }    }    abstract class C:B    {        public abstract void Show();//这叫隐藏        //public override void Show()//这叫重写        //{ Console.WriteLine("Show C"); }//抽象类可以继承类或接口，可以重写虚方法也可以不重写，但是抽象成员如果继承了则必须被重写    }    class D:C    {        public string str = "D";        public override void Show()//必须重写抽象成员，虚方法就可以不重写        { Console.WriteLine("Show D"); }    }    class MyClass    {        static void Main(string[] args)        {            D d = new D();            C c = d;            B b = d;            A a = d;            Console.WriteLine(d.str);//D            Console.WriteLine(c.str);//B            Console.WriteLine(b.str);//B            Console.WriteLine(a.str);//A            Console.WriteLine();                        d.Show();//D            c.Show();//D            b.Show();//B            a.Show();//A            Console.ReadKey();        }

多态

多态，通过继承一个类或接口可以用做多种类型，如可以用做自己的类型、任何基类型、或者在实现接口时用做接口类型，这称为多态性，例子：

    abstract class Myclass    {        public abstract void Func();    }    class A : Myclass    {        public override void Func()        {            Console.WriteLine("我是A");        }    }    class B : Myclass    {        public override void Func()        {            Console.WriteLine("我是B");        }    }    class C : Myclass    {        public override void Func()        {            Console.WriteLine("我是C");        }        static void Main(string[] args)        {            List<Myclass> list = new List<Myclass>();            list.Add(new A());            list.Add(new B());            list.Add(new C());            foreach (Myclass item in list)            {                item.Func();            }            Console.ReadKey();        }    }

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------