C#-从入门到精通-第17章 面向对象技术高级应用

【抽象类与抽象方法】
使用abstract关键字
一般将父类定义为抽象类。

public  abstract  class  myClass
{
        public  int  i;
        public  void  method（）；
}

抽象方法必须声明在抽象类中；
声明抽象方法，不能使用virtual、static、private修饰符

public abstract class myClass
{
        public abstract void method（）；
}

public abstract class myClass//定义抽象类
    {
        private string id = "";
        private string name = "";
        /// <summary>
        /// 编号属性及实现
        /// </summary>
        public string ID
        {
            get
            {
                return id;
            }
            set
            {
                id = value;
            }
        }
        /// <summary>
        /// 姓名属性及实现
        /// </summary>
        public string Name
        {
            get
            {
                return name;
            }
            set
            {
                name = value;
            }
        }
        /// <summary>
        /// 抽象方法，用来输出信息
        /// </summary>
        public abstract void ShowInfo();
    }
    public class DriveClass : myClass					//继承抽象类
    {
        /// <summary>
        /// 重写抽象类中输出信息的方法
        /// </summary>
        public override void ShowInfo()
        {
            Console.WriteLine(ID + " " + Name);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            DriveClass driveclass = new DriveClass();		//实例化派生类
            myClass myclass = driveclass;				//使用派生类对象实例化抽象类
            myclass.ID = "BH0001";					//使用抽象类对象访问抽象类中的编号属性
            myclass.Name = "TM";						//使用抽象类对象访问抽象类中的姓名属性
            myclass.ShowInfo();						//使用抽象类对象调用派生类中的方法
        }
    }

【接口】
使用interface关键字
接口的成员必须是公共的。
1.接口的实现与继承
一个类虽然只能继承一个基类，但可以继承任意接口。

interface ImyInterface//声明接口
    {
        /// <summary>
        /// 编号（可读可写）
        /// </summary>
        string ID
        {
            get;
            set;
        }
        /// <summary>
        /// 姓名（可读可写）
        /// </summary>
        string Name
        {
            get;
            set;
        }
        /// <summary>
        /// 显示定义的编号和姓名
        /// </summary>
        void ShowInfo();
    }
    class Program:ImyInterface//继承自接口
    {
        string id = "";
        string name = "";
        /// <summary>
        /// 编号
        /// </summary>
        public string ID
        {
            get
            {
                return id;
            }
            set
            {
                id = value;
            }
        }
        /// <summary>
        /// 姓名
        /// </summary>
        public string Name
        {
            get
            {
                return name;
            }
            set
            {
                name = value;
            }
        }
        /// <summary>
        /// 显示定义的编号和姓名
        /// </summary>
        public void ShowInfo()
        {
            Console.WriteLine("编号\t 姓名");
            Console.WriteLine(ID + "\t " + Name);
        }
        static void Main(string[] args)
        {
            Program program = new Program();               //实例化Program类对象
            ImyInterface imyinterface = program;           //使用派生类对象实例化接口ImyInterface
            imyinterface.ID = "TM";                        //为派生类中的ID属性赋值
            imyinterface.Name = "C# 2.0从入门到应用开发";  //为派生类中的Name属性赋值
            imyinterface.ShowInfo();                       //调用派生类中方法显示定义的属性值
        }
    }

接口可以多重继承。使用多重继承时，接口之间用逗号隔开。
2.显示接口成员实现
一个类继承两个接口中有一个相同的方法时，可以使用显式接口成员。
即接口名加句点命名该类成员。

interface ImyInterface1
    {
        /// <summary>
        /// 求和方法
        /// </summary>
        /// <returns>加法运算的和</returns>
        int Add();
    }
    interface ImyInterface2
    {
        /// <summary>
        /// 求和方法
        /// </summary>
        /// <returns>加法运算的和</returns>
        int Add();
    }
    class myClass : ImyInterface1, ImyInterface2		//继承接口
    {
        /// <summary>
        /// 求和方法
        /// </summary>
        /// <returns>加法运算的和</returns>
        int ImyInterface1.Add()					//显式接口成员实现
        {
            int x = 3;
            int y = 5;
            return x + y;
        }
        /// <summary>
        /// 求和方法
        /// </summary>
        /// <returns>加法运算的和</returns>
        int ImyInterface2.Add()					//显式接口成员实现
        {
            int x = 3;
            int y = 5;
            int z = 7;
            return x + y + z;
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            myClass myclass = new myClass();			//实例化接口继承类的对象
            ImyInterface1 imyinterface1 = myclass;		//使用接口继承类的对象实例化接口
            Console.WriteLine(imyinterface1.Add());		//使用接口对象调用接口中的方法
            ImyInterface2 imyinterface2 = myclass;		//使用接口继承类的对象实例化接口
            Console.WriteLine(imyinterface2.Add());		//使用接口对象调用接口中的方法
        }
    }

【密封类与密封方法】
如果密封了某个类，则其他类不能从该类继承，如果密封了某个成员，则派生类不能重写该成员。
使用sealed关键字。
不是每个方法都可以声明为密封方法。只有基类的虚方法才可以声明为密封方法，并且提供具体的实现。

        public class myClass1
        {
            public virtual void Method()
            {
                Console.WriteLine("基类中的虚方法");
            }
        }
        public sealed class myClass2:myClass1
        {
            public sealed override void Method()
            {
                base.Method();//调用基类中的Method方法，是一种简写
                Console.WriteLine("密封类中重写后的方法");
            }
        }

密封类与密封方法的使用

public class myClass1
    {
        /// <summary>
        /// 虚方法，用来显示信息
        /// </summary>
        public virtual void ShowInfo()
        {
        }
    }
    public sealed class myClass2 : myClass1//密封类，继承自myClass1
    {
        private string id = "";//string类型变量，用来记录编号
        private string name = "";//string类型变量，用来记录名称
        /// <summary>
        /// 编号属性
        /// </summary>
        public string ID
        {
            get
            {
                return id;
            }
            set
            {
                id = value;
            }
        }
        /// <summary>
        /// 名称属性
        /// </summary>
        public string Name
        {
            get
            {
                return name;
            }
            set
            {
                name = value;
            }
        }
        /// <summary>
        /// 密封并重写基类中的ShowInfo方法
        /// </summary>
        public sealed override void ShowInfo()
        {
            Console.WriteLine(ID + " " + Name);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            myClass2 myclass2 = new myClass2();//实例化密封类对象
            myclass2.ID = "BH0001";//为密封类中的编号属性赋值
            myclass2.Name = "TM";//为密封类中的名称属性赋值
            myclass2.ShowInfo();//调用密封类中的密封方法
        }
    }