java面向对象---多态，接口，匿名内部类

多态

   1 多态：指的是一个事务的多重形态，polymorphic
   2 多态分为：对象的多态和类型的多态
   3 对象多态:指的是一个对象，在不同的环境下可以有不同的名称，在Java中指new出来的一个对象，可以使用不同的类型的引用指向它。 本质：同一个事物可以不同名称名称和描述。
   4  类的多态：指的是同一了类，在不同的环境中可以有不同的表现，在java中的表现就是一个类型，可以有不同子类类型，或者不同子类对象。本质是：同一个名字和描述，可以在不同的场景下有不同真实体现。
   人类： 老师类，学生类，护士类，司机类
   在java中： Person类，提供一些子类，Student类，Nurse类，Driver类
   Person p ;
   p = new Teacher();
   p = new Student();
   p = new Nurse();
   5 多态实现的前提
       1 必须要有继承关系（继承或者实现关系）
       2 必须要写出父类类型的引用，指向子类对象的语法
       3 多态都会伴随着子类对父类方法的重写，重写父类方法的目的是为了让多态更加的合理
   6 总结：多态就一句话，父类类型的引用指向子类的对象，接口类型的引用指向其实现类对象。

多态中访问成员变量的特点

		1 编译看左边，运行看左边
		2 编译的时候看左边：要看父类类型中，有没有定义这个方法的成员变量。如果有就编译通过，如果没有就编译失败
		3 运行的时候看左边：要看父类类型中，给要访问的成员变量时什么值，父类中赋的是什么值，取出的就是什么值
		多态中访问成员变量的父类类型的引用，拥有的权限和super关键字一样。

多态访问成员方法的特点

        1 编译看左边，运行看右边
        2 编译看右边：要看父类类型中有没有定义这样一个成员方法，如果有就编译通过，如果没有编译失败
		3 运行时看右边，要看子类类型中如何对这个方法i进行重写没醉中走的是子类方法的内容。运行的执行子类的实现也是为了让多态更加的合理。
        4 补充：如果子类没有重写父类方法的方法，走的就是父类方法的实现。

多态中访问静态内容的特点

	    1 编译看左边，运行还看左边
	    2 静态内容：指的是静态变量和静态方法
	    3 在多态中访问静态内容走的都是父类提供的内容
	    4 编译看左边：看父类中有没有定义这样一个静态的成员变量和静态方法，如果有就编译通过，没有，就编译失败。
	    5 运行的时候：看父类中给静态变量赋的什么值，静态方法提供什么实现。
	    6 静态的最终解释：
	    静态变量和静态方法：都存储在方法区中的静态区，是被所有对象共享的区域，不会随着对象的变化而变化。

引类型中向上向下转型

        1 向上转型：
        自己类型的引用指向自己创建的对象。（正常引用）
        使用父类类型的引用指向子类对象。（向上转型）
        缺点：缩小的了子类对象的访问范围，减少了访问的权限。子类中独有的内容，就无法访问了。
        2 向下转型
        只有发生向上转型之后，才能做向下转型，没有发生向上转型，还要写向下转型就会运行报错。
        子类类型的引用     子类引用 = （子类类型）父类对象的引用
        3 不要对没有发生向上转型的类型做向下转型，否则就会报类型转换异常
        4 向下转型的本质是：恢复子类类型对象原本的访问权限
        5 多态的好处
            1） 提高代码的扩展性
            2） 以后我们定义方法的时候，如果方法的参数是父类类型的参数时，那么实参既可以是父类对象也可以是他的子类对选哪个，这样就可以提高程序的扩展性。如果我们定义方法返回值类型是父类类型，return后可以跟父类的对象，也可以跟子类的对象。
            以后我们对象获取方法还可以通过反射方式，或者网络传输，还可以从文件中去读取。

抽象类

       概述：抽象类指的是能定义抽象方法的类叫做抽象类
       1 抽象方法
           抽象：抽取像的，相同的，相似的，把 能提取公共的特征的过程叫做抽象。
           抽象方法:这种方法只有方法的声明部分，没有方法的实现。这样的方法就叫做抽象方法。
       2 为什么要设计出抽象方法？
           如果在父类中提供了一个方法，发现这个父类所有的子类都对这个方法进行重写，此时父类还有必要的方法实现吗？就没有必要提供方法的实现了，父类中提供了，子类都会重写后覆盖，父类提供方法实现了多余了。干脆就设计出一种方法，只提供方法名，不提供方法体的实现。
       3 如何定义一个抽象方法
           定义一个抽象方法的关键字：abstract
           格式：
           public abstract 返回值类型 方法名（参数列表）;
           格式说明
           public 访问权限最大，在任何位置都能看到，保证这个类任何子类都能够看到这个方法，对抽象方法进行重写，
           abstract 就是关键字，表示抽象的意思。
           最后的分号一定不要省掉，否则会报错。
       4 抽象类的定义
           1 格式
              public abstract class 类名｛
                 成员变量
                 成员方法
                 静态变量
                 静态方法
                 抽象方法
                 ***总的来说就是比之前学的多了个抽象方法***     
              ｝
           2 抽象方法必须在抽象类中
           3 抽象类是不能直接实例化，抽象类设计出来就是用来当父类的，只能使用其他类继承这个类中，重写抽象类中定义的抽象方法。

注意

           1 抽象类和抽象方法必须用abstract
           2 抽象类和抽象方法关系
              抽象方法必须在抽象类中
              抽象类中不一定含有抽象方法，虽然语法上允许，建议以后定义的抽象类都要写抽象方法
           3 抽象方法可以出现构造方法，虽然抽象类不能实例化，但是它可以有子类，子类在创建自己对象的时候，优先把父类的成员变量初始化。抽象类中设计构造方法就是为了子类初始化自己的数据时同也初始化抽象类的成员变量。
           4 抽象子类的特点
              1 抽象类的子类的特点可以分为两种：第一种就是普通类，第二种依然还是一个抽象类
              2 子类是普通类，子类没有用abstract修饰，这种子类就必须实现抽象父类所有的抽象方法。
              3 子类是抽象类，可以不完全实现抽象父类的方法，可以重写，也可以不重写。
              4 抽象类作为父亲，也可以写出多态，抽象类的引用指向它的子类

抽象的使用总结

           1 抽象类是能实例化（创建对象），所以抽象类设计出来就能被继承的，虽然他无法实例化，但是它的子类可以实例化。
           2 抽象方法不能使用private修饰  原因：一旦private修饰，只能在本类中看到，子类都看不到怎么重写的，private 修饰会报错。
           3 抽象类可以被继承，所有抽象类可以写出多态
           4 抽象类中可以带有的实现的方法，为啥要这么做，为了提高代码的复用

接口

     1 接口的概述
          1 广义：一切定义的规则都是接口，这些规则只是要求应该怎么做，具体怎么做是由需要遵守规则的人来实现。
          2 狭义：java中用于定义方法名字的规则就是接口，java中专门提供了一种数据类型interface（接口）。这个类型只能定义抽象方法，这个类型只是告诉我们应该做哪些事情。
          java接口中，都是抽象方法，这里都是方法的声明
          3 接口的好处，可以让规则的定义者和规则的实现者分离，方法的声明者方法的实现者分离。这样的好处就是达到解耦的目的。  耦合就是两个事物之间的关联性。

2 接口的特点

        1 接口的定义：使用interface关键字
         interface 接口名｛
           方法的声明（抽象方法）；
         ｝
         2 接口定义的时候使用的关键字是interface，不在是class,但是接口的本质还是一个类，因为编译之后生成 ****.class文件。
         3 抽象类中只能定义抽象方法，具体的实现由其实现类决定，只能定义规则。
         4 如何实现接口？
            使用java类实现接口，一个类要实现某个接口使用一个关键字：implements
         修饰符 class 实现类名 implements 接口名｛
            实现接口中的抽象反方法；
        ｝
        5 接口是不能实例化的，也就是不能创建对象
        但是接口的实现类可以创建对象，可以重写接口中的抽象方法。
        6 接口的实现类也有两种：
        抽象类：该类就可以不实现接口中的抽象方法
        普通类：就必须实现该接口中所有实现方法

接口中成员变量

       1 成员变量
          只能定义静态常量
          定义完成成员变量之后不管我们加不加public static final修饰，系统都会默认添加
          命名按照常量符号的要求命名
          以后建议自己手动加上
       2 在接口中能有构造方法，因为在接口没有成员变量，构造方法的作用就是给成员变量初始化的，没有成员变量，提供的构造方法也就没有意义。
       3 成员方法：系统会默认添加public abstract，建议手动添加上public abstract
       权限修饰符一定不能用private,protected
       权限修饰符只能是public

类与类，类与接口，接口与接口之间的关系

     1 ：类与类的关系，使用关键字：extends
           可以单继承，可以多层继承，但是不支持多继承
     2：类与接口
                  实现的关系：使用implements
                  一个类可以单实现，可以多实现，不能多实现
     3：接口与接口之间的关系
                   继承的关系：使用extends关键字
                   可以单继承，也可以多继承，可以多层继承
                   interface 子接口 extends 父接口｛
                   ｝
                   interface 子接口 extends 父接口1，父接口1，.....{
                   ｝             
     4: 抽象类和接口的区别，这两个都位于继承树的顶端。一个被用来继承，一个用来被实现。
         抽象类：定义这类中与生就有的特征和行为，而接口中定义这类事物可以后天培养（训练）出来的行为，能力。

匿名内部类

         1 没有名字的内部类
         2 匿名内部类使用是有前提的
            匿名类：继承一个类
            匿名类:实现某个接口
            匿名内部类的作用就是快速为某个类提供子类或者快捷为某个接口提供一个实现类。
         3 格式
           new 父类类名或者接口名(){
               重写接口或者抽象类中的方法
           }