3.4（类的继承，类的多态，泛型类）

1.类的继承（为了提高开发的效率，提高附用性）

                   1.单例模式（增强附用性）（在类下对其静态实例化，可直接类下访问，不用先实例）

                       格式：修饰符  static 类名 instances

                    2.类之间的继承

                       1.格式：

class Program : B   //program类继承了B类

{
        public new void _New()   //new在这里主要起到隐藏基类的作用（重点）
        {
            base._New();    //运行了_New()；的指令  //指定派生类调用基类的构造函数
            Console.Write("New\n");
        }

}

 class B
    {
        public void _New()
        {
            Console.Write("_New\n");
        }
    }
                        2.规定：1.c#内继承只能继承单个基类，但可以继承多个接口  2.派生类只能继承（public,protected的变量）,不能继承（private的变量）

                                        3.派生类不能继承析构函数和构造函数；                      4.C继承B；B继承A（则A和B；B和C是直接继承关系，而A和C是间接继承关系）

                                        5.在调用派生类下的构造函数时，就会先调用基类的无参数构造函数，如果没有，就会逻辑错误（就好比装备从底层开始出装的顺序）

                                        6.在调用构造函数其构造函数先从最初始基类开始调用（就好比装备从底层开始出装的顺序；同上）

                                        7.析构函数的执行顺序是与构造函数相反，从最下面开始（即出装从最上开始销毁）

                         3.base：1.用法：1.指定派生类调用基类的构造函数  （格式：派生类的构造函数名称（参数表）：base（基类构造函数的参数表））

                                                         2.指定基类的构造函数（看下代码）

 public Program():base(1,1)  //此时指定了第三个构造函数
        {


        }

class B
    {

public B()
        {
            Console.WriteLine("构造函数1");
         }


        public B(int i)
        {
            Console.WriteLine("构造函数2");
         }


        public B(int i,int j)
        {
            Console.WriteLine("构造函数3");
        }

     }

                      4.new:1.用法1.实例化对象  2.隐藏基类的方法，隐藏派生类基类的名称（用于派生类）  3.忘了                     

2.类的多态（1.即在不同的环境（类）下有多种不同个表现（输出） 2.关键字（abstract））

                      1.重写和虚方法（1.关键字 ：virtual（基类） override （派生类））（2.实例下代码）

class Program : B
    {
        public override void Func()
        {
        }
       

 protected B()
        {
            Console.WriteLine("抽象类");
        }

                       2.抽象类和抽象方法：1.格式：//类的访问修饰符 abstract class 抽象类名称 ；（抽象类）  修饰符 abastact 返回类型 抽象方法名称（参数表）;（抽象方法） 

                                                               2.规定：1.抽象类必须在抽象类下  

                                                                               2.抽象类不能被实例化 抽象类的构造函数是在实例化派生类对象的时候被调用的

                                                                               3.抽象类可以包含抽象方法和非抽象方法  

                                                                               4.派生里面必须要对抽象基类里面的抽象法方法重写,重写抽象方法的时不能改变其访问修饰符，必须与声明抽象方法时的访问修饰符一致

                                                                               5.可以由抽象类派生出其他抽象类

                                                                               6.只允许在抽象类中声明抽象方法，抽象方法声明是不能与static,virual,abstract修饰符同时使用

                                                                               7.除了抽象类和抽象方法，C#还支持抽象属性、抽象索引器、和抽象事件，他们的声明和重写方式与抽象方法类似

                      3.密封类和密封方法：1.关键字：sealed 2.格式：sealed class 类名称（密封类）  修饰符 sealed override 返回类型 方法名称(参数表){}（密封方法）格式见下代码

 class A : D
    {
        public sealed override void Fun()
        {


        }
    }


    class D
    {
        public virtual void Fun()
        {


        }
    }

                                                        3.规定：1.密封类使用了重写（密封类对应的密封方法不能重写）和虚方法（为了保护虚方法不被重写），而且大部分的内容和抽象类（不能被继承）；抽象方法类似

                      4.泛型类（作用：提高代码的附用性）：

                                                        1.default：默认值  格式：T a = default（T）; return a ;    

                                                        2.格式：类修饰符 class 泛型类名称<T>{ 类体； }

                                                        3.链表和字典同属于泛型类<>......

                                                        4.代码：

class Program
    {


        //List<int> list = new List<int>();    //链表
        //Dictionary<int, int> dic = new Dictionary<int, int>();   //字典
        public static void Fun<T1,T2>(T1 x,T2 y)  //声明了一个泛型方法
        {
            
        }


       
        static void Main(string[] args)  //输入相应的参数
        {
            Rect<double> rect = new Rect<double>(0.1,0.1,0.2,0.2);
            Rect<int> rect1 = new Rect<int>(1, 2, 3, 4);
            Console.WriteLine(rect.Area());
            Console.WriteLine(rect1.Area());
        }
    }

    class Rect<T>
    {
        private T x1, y1, x2, y2;


        public Rect(T x1,T y1,T x2,T y2)    //泛型类构造函数（里面相对应的参数（参数表），将上面输入的参数相对应的填入）
        {
            this.x1 = x1;
            this.y1 = y1;
            this.x2 = x2;
            this.y2 = y2;
        }


        public double Area()  //计算方法
        {
            double length, width;
            length = Convert.ToDouble(x2) - Convert.ToDouble(x1);
            width = Convert.ToDouble(y2) - Convert.ToDouble(y1);
            return length * width;
        }
    }