.net面向对象所有的知识点



                                     面向对象所有的知识点
1.什么是类：
 类是创建对象的模板    
2.什么是对象：
 万物皆对象

概念 ： 
3.变量：
 能够随意变换的量就是变量  本身没有什么意义
4.变量的作用域：
 就是指变量存在的范围

5.成员变量：（全局变量） (实例变量)
 通常将类的属性称为类的全局变量（成员变量），
 1.类中方法外
 2.在堆中 
 3.有默认值，在整个类中都可以访问
 
6.局部变量：（将方法中的属性称为局部变量）  方法体
 1.就是在方法中内部的变量  
 2.在栈中
 3.没有默认值，必须定义，赋值，然后才能使用
局部变量必须初始化才能使用，否则编译出错

定义一个学生类：
  成员变量：name，age
  成员方法：show()方法
7.静态变量(类变量) 
 1.由static修饰的变量称为静态变量，其实质上就是一个全局变量。
 2. 静态变量可以被对象调用，还可以被类名调用。
 3. 静态变量也称为类变量
 4.静态变量位于方法区

注意事项：
局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。
首先在局部范围找，有就使用；接着在成员位置找。

8.静态方法：
 1.由static修饰的方法称为静态方法

9.类型：
基本类型： 8种基本数据类型
引用类型：类引用  接口引用  数组引用

10.this关键字：
 1.所有对象的引用名都是this；
 2.当前对象；
 注意：
  只能在构造方法或者实例方法内使用this关键字
  静态方法和静态代码块中不能使用this关键字

11.new关键字：
 1.实例化对象
 2.调用构造方法
 3.返回对象的引用

12.static关键字
  static变量：
 1.用static修饰的成员变量称为静态变量，可以直接通过类名来访问
 2.用static修饰的成员方法称为静态方法，可以直接通过类名来访问
  static方法：
 1.用static修饰的方法叫做静态方法或者类方法
 2.不需要创建类的实例，可以直接通过类名来访问
 3.静态方法中不能使用this关键字
 4.static不能和abstract连用 
 5.在静态方法中不能直接访问实例方法和实例变量
 6.静态方法不能被abstract修饰 （就是说一个静态方法不能被定义为抽象方法）
  static代码块：
 1.static{}  用于初始化类，给类的静态变量赋初始值

13.abstract修饰符：
 1.抽象类不能被实例化
 2.抽象类中可以没有抽象方法，但是包含抽象方法的类必须被定义为抽象类。
 3.如果子类没有实现父类中的所有的抽象方法，那么子类也必须定义为抽象类。
 4.抽象类不能被定义为final和static类型
 5.抽象方法不能被定义为private和final 和static类型
 6.没有抽象构造方法
 7.抽象方法没有方法体

14.构造方法：
 1.方法名必须与类名相同；
 2.没有返回类型；
 3.构造方法不能被子类继承 ，不能用final和abstract修饰
 4.构造方法能够重载（方法名相同，参数不同）
 5.构造方法能够被子类调用  （用super语句调用父类构造方法）
15.什么是构造器：
 1.构造器一个特殊的方法
 2.作用：帮助我们初始化对象
 3.创建对象的时候才会调用构造函数
 4.构造函数是可以有重载的  重载就是方法名相同，参数列别不同
     5.只要看见构造函数就要和new关键字联系在一起  就是初始化对象  给对象的属性进行赋值  默认的创建了一个无参的构造函数
特别注意：
 1.构造器与类同名
 2.构造器没有返回值，连void也不能写
 3.构造器总是和new一起使用
  不要在构造器中定义与实例域重名的局部变量？？
 4.get方法又叫域访问器    就是因为get方法的返回值只是返回到了实例域值 
16.静态与非静态的区别

 1.静态域被称为类域  就是属性中有static关键字
 2.静态方法就是不能向对象实施操作的方法  就是没有this这个隐士参数
 3.要通过类名来调用静态函数（因为静态）

特别注意：
 1.在调用实例成员的时候，需要通过对象名.实例成员；

 2.在调用静态成员的时候，需要通过类名.静态成员名；

总结：
 1.静态成员必须使用类名来调用，而实例成员使用对象名来调用
 2.静态函数中，只能访问静态成员，不能访问实例成员
 3.实例函数中，既可以使用静态成员，也可以使用实例成员
 4.静态类中只允许有静态成员，不允许出现非静态成员（实例成员）
 5.静态类中不能实例化

17.继承

 1.子类不能继承父类的构造函数，但是子类可以调用父类无参数的构造函数

 2.子类在创建对象的同时也创建了父类对象，是因为子类继承了父类的成员

 3.子类对象可以调用父类成员，但是父类对象永远只能调用自己的成员，不能够调用子类的成员

 4.继承里面有参数的构造函数的是子类base父类的构造函数（实例化）这个是C#中
18.多态 
 实现多态的三种方法：
  1：虚方法 2：抽象类 3：接口

    1：虚方法

 将父类的方法标记为虚方法，使用关键字 virtual 这个函数可以被子类重新写一遍（重写）

 就是在函数void前面 父类的加上virtual 子类的加上override

多态的实现步骤：
 1：首先想到继承的思想   要有一个父类    父类里面都有和子类相同的方法
 2：用继承的思想来通过父类继承父类的构造函数（暂时这么理解 因为本身子类是不能继承父类构造函数的）
 3：用父类对象声明数组 让子类对象传到里面
 4：在父类的函数中也就是void前面写上virtual
 5：在子类的函数中写上override
 6：利用for循环进行遍历

问题：
 子类重写父类的方法

   2：抽象类

 当父类中的方法不知道如何去实现的时候，可以考虑将父类写成抽象类，将方法写成抽象方法

特别注意：

 1.用abstract修饰的类是抽象类  
 2.用abstract修饰的方法是抽象方法
 3.抽象方法没有方法体 
 4.方法体就是{}

-------5.抽象类是不允许创建对象的  也就是不能new  

-------6.接口也是不允许创建对象的  也就是不能new

 7.抽象类不能实例化  abstract修饰的就是抽象的 

 8.子类继承抽象类后，必须把父类中的所有抽象成员都重写（除非子类也是一个抽象类，则可以不重写）

 9.抽象类中可以包含实例成员  就是private 的私有字段，并且抽象类中的实例成员可以不被子类实现。

 10.抽象类是有构造函数的。虽然不能被实例化

 11.如果父类的抽象方法中有参数，那么继承这个抽象父类的子类在重写父类的方法的时候必须传入对应的参数。
 12.如果抽象父类的抽象方法中有返回值，那么子类在重写这个抽象方法的时候也必须要传入返回值。

方法签名：返回值和参数

19.访问修饰符
 public：公开的，公共的
 private：私有的，只能在当前类的内部 访问
 protected：受保护的，只能在当前类的内部以及该类的子类中访问
 internal：只能在当前项目中访问。在同一个项目中，internal和public的权限是一样的

 能够修饰类的访问修饰符只有两个   public internal 但是internal的访问性比较低
 子类的访问修饰符不能超过基类的访问修饰符，会暴露基类的成员
 internal只能在当前项目中访问

静态方法和抽象方法都不能实例化

                                 接口的专属

1：接口
 1.接口就是一个规范、能力
 2.关键字interface 
  I...able  一种能力  
 3.接口中成员不能添加访问修饰符 默认就是public
 4.自动属性（既没有字段也没有方法体）默认的就有了
 5.不允许写具有方法体的函数
特别注意：
 为了多态 接口不能实例化  抽象类    静态类

2.接口中只能有方法 属性 索引器 事件 
3.不能有字段（不能存贮数据 只是个规范 、能力）和构造函数（因为不能实例化，所以没有对象，就不用初始化）
4.接口与接口之间可以继承，并且可以多继承

5. 什么时候用虚方法来实现多态

6.什么时候使用抽象类来实现多态

7.什么时候用接口来实现多态
 里面找不出来他们的父类

8.定义一个接口  
  接口的实现类  会实现接口里面所有的方法 
  然后我们在实现类重写接口的方法
  就是说 你用了接口的实现类实例化了子类对象 
  如果在父类中声明一个 抽象方法  那么子类就会继承父类的抽象方法（重写）  ——用子类来实现父类的抽象方法  子类就会变成了一般方法   override

9.
 接口不是类
 接口的方法是默认的public  不能写关键字public  并且没有方法体
 接口的实现类 必须全部实现接口的方法
 接口没有实例
 接口可以看成是 没有实例域的抽象类   就是不能new
           2017/12/12
                                                                                                     北京   高圣荣