1.泛型类：装载同类型类的容器，实例化泛型类后依靠泛型类内中的方法连续处理相同类型的类

class A<T>{}   //泛型类

class B{}   //B类

A a =new A<B>()  //实例化传入类B

2.泛型方法，可以在泛型类中也可以是普通类

public void print<T>(T t){ 

    return defualt(T);    //返回传入的类的写法

}  //传入t可以是类也可以是数据

3.加入约束可以规定泛型类或泛型方法的传入值类型,解决2的问题

class A<T> where T:······{} 

public void print<T>(T t)  where T:······{}     // ······可以是a.具体类名[本类以及派生类]，class[所有类都可以]，struct[所有结构都可以];  b.具体接口名或泛型接口[本接口以及实现该接口的类型];   c.     new( ) [带有无参数并且共有的构造函数的相关类型，好像是让泛型类实例化后可以调用传入类的构造函数]。注意：同时有约束多个，必须是主约束只一个【a的三个只能有一个】，再来是若干个接口约束【可以多个接口】，构造约束的顺序。

4.泛型接口，格式和泛型类大致相同，注意接口和类本身的不同就行

重载运算符，不可改变运算原有规则，如加变减，其实是可以用方法完成所要的运算功能，只是利用已有的运算符规则，简化过程直接使用重载的运算符；

除=，&&，||，[ ]索引，( )的运算符都可以重载，一元运算符必须操作对象是类或结构，二元至少有一个是类或结构，在(实例化后)类或结构直接使用重载运算符，如A++；

public static 返回值类型 operator 运算符 (B b){}

自定义装换，主要是类或结构使用，区别是显示在调用时需要加括号，括号内是需要装换类型的对象，如A a=new A(); a=(A)B；如果是隐式就直接B赋给a;

显式装换语法public static explicit operator A(B b){`````}

隐式示装换语法public static implicit operator A(B b){`````}

装箱，使用的是类型装换的方法，但实质是创建一个新的引用类型数据，与原来的值类型数据完全无关，两方重新赋值互不影响；

静态只能处理静态成员，静态构造函数处理静态变量，静态构造函数不带访问类型；

静态类不可继承；

接口内成员默认public，不能写访问类型；

同时有继承父类和接口时，继承父类写最前；

sealed密闭类不可再继承；密闭方法不可被重写（就算是已有派生类中的重写方法也可在最前加sealed防止下一级子类重写该类的重【写】方法）

1.所有子类都有相同的一个使用字段时，可以将该字段的的赋值交给父类的构造函数，由子类传入即可（因为实例化是是先调用父类构造函数再子类的构造函数）。

public A(string name){ this.name=name;}  //父类构造函数

public B(string name):base(name){}  //子类构造函数

2.不想如1的话，在子类的构造函数后加this就可以使用本子类的构造函数，这样实例化时使用的就是子类构造函数

public B(string name):this(name){}  //子类构造函数

虚方法和多态

一个设计原则：

面向对象编程中，都遵循一个原则：依赖倒置原则。就是程序设计要依赖于抽象类，而不依赖于具体类；

基类的引用：-----基类类型的引用指向派生类；

派生类的对象包含基类部分和派生类部分，所以，我们可以通过一个基类类型的引用指向派生类。通过指向派生类的基类引用，我们仅仅能访问派生类的基类部分；

虚方法和多态的武器：

虚方法：声明为virtual的方法就是虚方法。基类的虚方法可以在派生类中使用override进行重写；

多态：通过指向派生类的基类引用，调用虚函数，会根据引用所指向派生类的实际类型，调用派生类的同名重写函数，即为多态；

关于虚方法的其他知识点：

1. 重写虚方法必须具体相同的可访问性，且基类方法不能是private；

2. 不能重写static方法或者非虚方法；

3. 方法，属性，索引器，事件，都可以声明为virtual 或override

隐藏：

我们不能删除基类中的任何成员，但是可以用与基类成员名称相同的成员来屏蔽基类成员；

语法细节：

屏蔽数据成员：在派生类中声明名称和类型相同的成员；

屏蔽函数成员：在派生类中声明新的带有相同函数签名的成员；要求函数名，参数的类型及个数必须相同，但是函数的返回值可以不同；

让编译器知道：可以添加new关键字，否则会警告；

---例子：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            dog dogs = new dog();
            dogs.strName = "小黑";
            dogs.writename();
            cat cats = new cat();
            cats.strName = "小花";
            cats.writename();
            Console.ReadKey();

        }
    }
    public class pet
    {
        public string strName;

        public void writename()
        {
            Console.WriteLine("Pet's name is" + strName );
        }
    }

    public class dog : pet
    {

----隐藏基类的函数，使用new关键字
       new public void writename()
        {
            Console.WriteLine("宠物的名字是" + strName);
        }
    }

---继承基类pet
    public class cat : pet
    {
   
    }
}

继承：

继承：一个类派生于另一个基类型；它拥有该基础类型的所有成员字段和函数；

class childclass : parentclass

{

}