PS面向对象

                             2017年9曰20日

面向对象编程的思想.
-------------------第一部分(类与对象)-------------------------------
一>.类与对象
  1>.什么是对象:万事万物皆为对象.(能够具体存在的就是对象)
  2>.什么是类:一组具有相同对象的属性和方法组成了类(是一个抽象的概念)
  3>.类的组成
     a>.特征(名词)--->属性 如:姓名，年龄，身高....
     b>.行为(动词)--->方法 如:吃饭，睡觉，打王者....
  4>.类
          类的默认访问修饰符为:internal(内部的)
          类中的属性和方法默认为:private(私有的)
  5>.如何创建对象
   · 类名  对象名=new 类名();
  6>.为什么要使用类和对象  
     1>.封装,重复利用
     2>.代码易于维护.
  7>.访问修饰符:
     private:私有的
     public:公开的
     internal:内部的
     protected: 受保护的
     protected+internal:内部的可以访问 外部子类同样可以访问 
  注意：修饰的访问修饰符只有二个 public internal 子类的访问修饰符不能高于父类 因为子类会暴露父类的成员
二>.属性访问器
      1>.为什么要使用属性访问器
 保护类中私有成员变量
      2>.如何定义属性访问器
private string name;
public string Name
{
  get{return name;}
  set{this.name=value;}
}
      3>.属性访问器分类
只写访问器.
        只读访问器.
        读写访问器.        
    方法名:使用驼峰命名 如:ShowName   头字母大写 帕斯卡命名法 如：Showname 
四>.方法类型
   1>.实例方法(现代社会):
       a>.在外面调用时需要通过实例化对象才能调用
       b>.在实例方法既能调用静态方法和静态属性,也能调用实例方法和示例属性
   2>.静态方法(原始社会):
       a>.在外面直接通过类名就能调用
       b>.在静态方法里面不能调用实例方法和示例属性，只能调用静态方法和静态属性
-----------------第二部分(构造函数与重载)-------------------------
一>.变量和常量
   1>.变量:可变得量
   2>.常量:不可变的量 数据类型前面加 const
         注意:必须赋初始值
              不能改变常量的初始值,如果要改变，只能在定义时那里去改变.
              用户经常不变的值，而且不允许再做一次修改.
二>.构造方法
  1>.什么是构造方法?
      是一个特殊的方法,不能写返回类型，且方法名与类名一致;
  2>.如何使用构造方法?
     注意:1>.private的构造方法，虽然语法认同，但是没有任何意义.一般都是public
    2>.实例化对象时首先调用的是构造方法.(系统有一个默认无参数构造方法)
3>.带参数的构造方法可以初始化属性
三>.方法的重载
  1>.什么是方法的重载?
     同名不同参数(方法名相同,参数不相同)
        注意:
       方法名相同,参数的个数不相同--->构成重载
       方法名相同,参数的类型不相同--->构成重载
       方法名相同,参数个数相同,参数类型相同 只有返回类型不相同--->不构成重载
       方法名相同,参数个数相同,参数类型相同(里面的所有参数都是同一类型) 只有参数的顺序不相同--->不构成重载
       方法名相同,参数个数相同,参数类型相同(里面的参数含有不同类型) 参数的顺序不相同--->构成重载
四>.值类型和引用类型
  1>.值类型
  2>.引用类型
   装箱: 值类型 -------> 引用类型  
        int num=10;
        string str = num.ToString();
   拆箱: 引用类型 -------->值类型 
string str="10";
        int num = int.Parse(str)
-------------------第三部分(继承)---------------------------
OOP面向对象的三大特征:
 继承，封装，多态
一>.什么是继承:
    1>.生活中的继承:儿子继承老爸的财产,那么儿子就可以使用老爸的财产.
    2>.程序中的继承:类与类之间的一种关系,如果一个类A继承另一个类B，那么类A就可以使用类B的属性和方法
二>.为什么用继承:  
   解决代码的冗余(重复),可以重复利用.
三>.如何实现继承:将多个类中相同的属性和方法抽取出来放到一个新建的类中,再将这多个类去 继承 新建的类

继承的关键字是 ":"
   类A(子类,派生类):类B(父类,基类/超类)
 继承的原则:
  1>.is a:是一个   如:学员是一个人类 老师是一个人类.
四>.this,base关键字
  1>this:既能调用当前类的属性和方法,又能调用父类的非私有的属性和方法
  2>base:只能调用父类的非私有的属性和方法
 五>.访问修饰符protected（受保护的）
           protected:受保护的,只有继承关系的才可以访问.    
六>.sealed关键字的使用:密封类 
    注意:sealed密封类不能被继承
         static静态类不能被继承
七>.继承特点
  1>单根性:一个子类只允许继承一个父类，一个父类可以被多个子类继承
  2>传递性:类C:类B:类A 那么类C既能访问类B的非私有的属性和方法,也能访问类A的非私有的属性和方法
   c->b->a
八>.构造方法:作用初始化自己的属性
  (各司其责)
 实例化子类对象时首先会默认调用父类的无参数构造方法
 <如果父类定义了一个有参数构造方法,无参数的构造方法就会消失,就会报错!!!>
  解决问题:
     方式一:自己在父类写一个无参数的构造方法(但是没有初始化父类的属性)无意义
     方式二:在子类中使用base关键字明确调用父类有参数的构造方法。      
九>.对象数组（扩展知识1）:
      数组里面保存的是对象.
十>.is,as （扩展知识2）
   is 是判断俩个引用类型是否兼容
   as 是强制类型转换
----------------第四部分(多态)------------------------
一>.为什么需要使用多态:
     父类对象名不能直接调用子类中的方法需要is as
   子类越多，判断is 转换as就越多,造成代码冗余，难以维护.
二>.多态概念:
   针对同一消息(方法),不同对象有着不同的响应(实现)
   目的:父类对象.子类对象的方法.
三>.怎么使用多态来解决
 1>.使用抽象类抽象方法实现多态
    a>.什么是抽象类?
        在类的class前面加上abstract
    b>.什么是抽象方法
        在方法的返回类型前面加上abstract
    c>.实现抽象类和抽象方法的步骤:  
      第一步:把父类变为抽象类
      第二步:在建立一个抽象方法
      第三步:在各自的子类中使用override重写父类的抽象方法(必须重写)
  注意:
       抽象类不能直接使用new关键字创建对象
       抽象方法必须定义在抽象类中.(含有抽象方法的类一定是抽象类)
       抽象方法不能写任何的方法体(包括{}也不能写)
       父类中的抽象方法，子类必须override重写;
       父类中的抽象方法，不能使private私有的
   特点:就是子类必须override重写父类的抽象方法        
 2>.使用虚方法实现多态
    1>.为什么要使用虚方法: 
     抽象类的抽象方法，子类必须重写.
    而我们是要一种:
     子类可以重写也可以不重写,重写就按子类的实现，不重写就按父类的实现.
    2>.怎么使用虚方法实现多态   
       第一步:在方法的返回类型前面加上virtual关键字    
   注意:    
       虚方法可以定义在抽象类中也可以定义在普通类中.(含有虚方法的类不一定是抽象类)
       虚方法必须写法体({}必须写)
       父类中的抽象方法，子类可以重写也可以不重写,重写就按子类的实现，不重写就按父类的实现.
       虚方法，不能使用private私有的
六>.override:
   一个是重写父类的抽象方法
   一个是重写父类的虚方法 
七>.虚方法与抽象方法的区别
  虚方法   抽象方法
用virtual修饰 用abstract修饰
要有方法体 不允许有方法体
可以被子类override 必须被子类override
除了密封类和静态类外都可以写 只能在抽象类中
八>.重写和重载的区别
重写 重载
地点     不同类中(父类和子类之间)同一个类中
形式     同名同参                同名不同参
作用     子类拥有自己的行为需要重写方便调用者调用需要重载
面向对象特征  多态                多态
----------------第五部分(接口)-------------------------
一>.什么是接口: 
   接口是一套规范，遵守这个规范就可以实现功能 
   接口是一套规范(一些抽象方法),实现接口的类必须遵守接口的规范(实现接口中的所有抽象方法)
 二>.为什么使用接口:
   抽象类回顾
  抽象类里面定义抽象方法，子类去继承抽象类，那么子类必须重写抽象类中的所有抽象方法
  注意:重写抽象类的所有方法，是建立在有继承的基础之上，而继承要满足is a原则
看看下面的情形能否用抽象类？
     麻雀会飞，直升飞机也会飞，那怎样表示麻雀和直升飞机的飞的行为？可以用抽象出一个抽象父类,再抽象出一个飞的抽象方法吗?
   答:不能 总会有一个(要么是麻雀，要么是直升机)不满足is a 原则,因为我不能抽象出一个抽象父类类(鸟抽象父类,要么是飞机的抽象父类)
三>.在程序中如何使用接口
1>.定义接口:
                接口使用 interface 关键字
                  类使用 class     关键字
2>.实现接口:
3>.接口特点:  
              接口里面只能定义未实现的方法(特殊的抽象方法:a>.不能写abstract关键字,b>.不能写任何修饰符:默认是public)
              接口里面只能包含未实现的方法
              实现接口的类必须要实现接口中所有未实现的方法(a>.不能写override关键字去实现,b>.使用:去实现接口)
     实现接口的类去实现接口中未实现的方法时(返回类型，方法名，参数)都必须一样
              接口不能直接使用new实例化对象,去使用:接口 对象名 = new 实现接口的类();
             一个类可以实现多个接口，但只能继承一个父类（而且要写在最前面）