继承

final关键字
  加上final后的类是最终类，不能有子类，不能被继承


1 什么是继承？
     多个类中存在相同的属性和行为时，将这些内容抽取到单独的一个类中，那么多分类无须再单独定义这些属性和行为，只需继承那个类即可。
     多个类称为子类，单独的要被继承的类称为父类、超类或者基类。
     子类可以直接访问父类中的非私有的类和方法。
     通过extends关键字让类与类产生继承关系：
           class  Zi  extends  Fu;  Fu是父类，Zi是子类

2 继承的好处？
    1、提高了代码的复用性
    2、让类与类之间产生了关系，这是多态的前提

3 继承的特点

     1、java只支持单继承，不支持多继承
          //只能有一个父类，不能同时有多个父类

       class  Zi extends  Fu;//合法
       class  Zi extends Fu,Fu1...;//不合法
   
     2、Java支持多重继承体系
        //一个可以有父类和父父类
      
        class A{};
        class B extends A{};
        class C extends B{};

4 super和this
  super是一个关键字，代表父类的存储空间标识。
  this和super的用法相似。
 
  this代表对象的引用（在那个类中就代表谁的东西）；
  super代表当前子类对直属父类的引用。

使用场景：
      1 当子父类出现同名成员时，可以用super来进行区分；
      2 子类要调用父类的构造方法时，可以用super语句。

区别：
      1 成员变量
          this.变量     ---本类的
          super.变量     ---父类的
      2 构造方法
           this（.....） ---本类的
           super(.....)  ---父类的
      3 成员方法
            this.方法名  --本类的
            super.方法名  ---父类的
 
         super()和this（）都是在构造函数的第一行，不能同时出现

5 方法的重写（覆盖）
        1  子类中出现与父类一模一样的方法时（除了权限修饰符，权限修饰符大于等于不包括private，返回值类型
    ，方法名和参数列表相同），会出现覆盖操作，也称为重写和复写。
          
        2  父类的私有方法子类无法复写。
 
覆盖注意事项：
           1 覆盖时，子类方法权限一定大于等于父类的方法权限；
           2 静态只能覆盖静态

覆盖的使用场景：
       
        当子类需要父类的功能，而子类又有自己的特有功能时，可以复写父类中的方法，这样，既沿袭了父类的功能    ，又定义了子类特有大的内容。

方法重写和重载有什么区别？
         方法的重写用在子类方法与父类方法一模一样时，除权限修饰符外，返回值，方法名和参数列表都是相同的  
         
         重载用在同一类中个方法方法名相同，参数列表不同（与返回值没有关系）的情况。

子父类中构造方法的用法：
         1 子类的初始化过程中，首先会执行父类的初始化动作。因为子类中默认有一个super()。子类要使用父类的成员变量，这个初始化，必须在子类初始化之前完成。所以，子类的初始化过程中，会首先执行父类的初始化。
         
         2 如果父类没有空参构造
              （1）使用super调用父类的带参构造
              （2）使用this调用本身的其他构造
 
静态代码块、构造代码块，构造方法的执行顺序：
       
            父类静态代码块---》子类静态代码块--》父类构造代码块--》父类构造方法--》子类构造代码块--》子                    类构造方法

6 final关键字
   final是一个关键字，可以用于修饰类，成员变量，成员方法

 特点：
      1、它修饰的类不能被继承
      2、它修饰的成员变量是一个常量
      3、它修饰的成员方法是不能被子类重写的

 final修饰的常量名称一般所有字母都是大写
 
 final修饰成员变量必须被初始化，初始化有两种：
       （1）显示初始化（直接赋值）
       （2）构造方法初始化。（构造函数赋值）
                 但是不能两个一起初始化（初始化就是赋值）
 
 final和private的区别：
       （1）final修饰的类可以被访问；
            private修饰的类不能被访问
       （2）final修饰的变量只能在显示初始化或者构造函数初始化时赋值一次，以后不能更改；
            private修饰的变量，也不允许直接被子类或一个包中的其它类访问或修改，但是可以通过set和get方法            对其改值和取值。
7 多态
      概念：
             对象在不同时刻表现出来的不同状态
      多态的前提：
           （1）要有继承或者实现关系
           （2）要有方法的重写
           （3）要有父类引用指向子类对象
      
      程序中的体现：
             父类或者接口的引用指向或者接收自己的子类对象
        
                   父类/接口  实例化对象=new 子类；

      好处和作用：
             多态的存在提高了程序的扩展行和后期可维护性

      弊端：
             父类调用的时候只能调用父类里的方法，不能调用子类的特有方法
      
      多态的成员特点：
             （1）成员变量：
                      编译时期：看引用型变量所属类中是否有所调用的变量（看父类）
                      运行时期：也是看引用型变量所属类是否有调用的变量（看父类）

                  成员变量无论编译还是运行都看引用型变量所属的类，简记为成员变量，编译和运行都看等号左边
           
              

             （2）成员方法：
                      编译时期：查看父类中是否有所调用的成员
                      运行时期：要查看子类中是否有所调用的成员。如果父子出现同名的方法，会运行子类中的方                        法，因为方法有覆盖的特性
                  
                  编译看左边运行看右边


          一定不能够将父类的对象转换成子类类型！

          多态都是子类对象在变化！

    //多态向下转型和向上转型的例子，多态转型解决了多态中父类引用不能使用子类特有成员的弊端

         class Phone{
             String color;
             int price;
             public void print(){
                   System.out.println("Phone---"+color+"-----"+price);
                 }
           }

         class Nokia extends Phone{                            class Moto extends Phone{
              String color="red";                                  String color="yellow";
              int price="1009";                                    int price="1999";
           }                                                       public void print(){
                                                                         System.out.println("Moto---"+color+"-----"+price);
                                                                          }
                                                                     }

          class Nexus extends Phone{
             String color = "black";
             int price = 1999;

             public void print(){
                  System.out.println("Nexus---" + color + "---" + price);
                 }
           }

         class TestDemo{
             public static void main(String[] args){
                     Phone p1=new Nokia();//向上转型，类型提升
                     Nokia no=(Nokia)p1;//向下转型，强制将父类的引用转换成子类类型，不能将Nokia类型转成Moto或Nexus类型
                     no.print();                    //输出结果为Phone---null---0，因为继承了父类的方法

                     Phone p2 = new Moto();
                     Moto m = (Moto)p2;
                     m.print();                    //输出结果为Moto---yellow---1599，方法重写，子类方法覆盖父类方法

                     Phone p3 = new Nexus();
                     Nexus ne = (Nexus)p3;
                     ne.print();
                    }
                }