Java 继承,抽象类以及 super、this、final 关键字

  一.继承    二.方法重写     构造方法的访问特点          super 与 this 关键字总结          抽象类及继承           final关键字

   成员变量和成员方法的访问

一.继承 

   使用 extends 关键字继承一个 父类  即获得父类的 成员变量 和 成员方法包括私有方法         public class Zi extends Father { } 

      java 可以 多 级继承    不能 多继承(一个儿子两个爸爸)    但是可以有兄弟类  

     1.new 的谁 优先使用该类中的,子类没有再往上找       2. 间接通过成员方法 时 该方法属于谁就用谁,没有再往上找

     1. 单独打印 age  采用就近原则    2. this 表示本类       3.super 表示 父类

     1.无论是成员方法还是成员变量,如果没有就I往上找,绝不可能 会向下找

 二.方法重写  

    1. 重写 :override 方法的名称一样, 参数列表也一样 . 覆盖,覆写       2. 重载:overload 方法的名称一样. 参数列表不一样 . 

    3. 子类的方法 返回值 必须小于等于 父类方法的返回值                   扩展: @Override()写在方法的上面,检测 重写的正确性       

    4.子类方法的权限 大于等于 父类的 权限修饰符          public> protect > (default表示什么也不写) > private  

public class Father {   父类
    public void say(){
        System.out.println("1");
    }
}
public class Zi extends Father {   子类
    @Override
    public void say() {
        super.say();             @1如果想访问运行原来的方法 使用 super.say()关键字
        System.out.println("2");
        System.out.println("3");
    }
}

   继承关系中  父子类 构造方法的访问特点

      1. 首先一个类 如果没有写构造方法  JVM赠送一个,

      2.如果一个子类继承一个父类    子类JVM赠送的构造方法中还赠送一个super();  这个super();调用 父类的无参构造方法

      3.super(); 也可以来调用父类重载构造方法.  当父类的构造方法 含有参数时 super( 15 ) ;

       4.注意 super 必须写在子类 构造方法内 的第一行 并且是唯一的  ; 并且子类必须调用父类的构造方法,要么赠送要么自己写

  super 与 this 关键字总结

      super 1.在子类成员方法中,访问父类的成员变量, 

                 2. 在子类的成员方法中, 调用父类的成员方法,             3.在子类的构造方法中,调用父类的构造方法

      this     1.在本类的成员方法中,访问本类的成员变量            

                  2.在本类的成员方法中, 访问本类的另一个成员方法可以是私有的  3.在本类的构造方法中,访问本类的另一个构造方法

      注意: this 和super 不能同时在一个构造方法中,且  每一个构造方第一行写super this 且是唯一的

       如果一个子类继承一个父类, 子类中有狠多 构造方法, 那么 父类的构造方法总是先执行  程序从super开始执行

      

 抽象类及继承

    抽象的概念  如果一个父类的功能是计算面积    而 子类是三角形 正方形 圆形     这时 没有一个具体的 计算面积的方法

      把这个在父类中 抽象的 方法叫做 抽象 方法   含有抽象方法的类 必须是一个抽象类  ,一个抽象类 可以没有抽象方法

       注意关键字 abstract        1.抽象类 不能直接被 new 出来   要使用必须用一个子类来继承它 

      2.普通子类必须重写抽象父类中的所有 抽象方法 不然报错   ,,重写时加上大括号

      3.子类如果是一个抽象类就可以不用全部重写父类中的抽象方法, 那么子子类 就要重写完子类没有写完的父类中的抽象方法

public abstract class FatherAbstract {          父类
    public abstract void eat();
    public abstract void cat();
    public void method(){
        System.out.println("这还是父类普通的方法!");
    }}
public abstract class Zi extends FatherAbstract {   子类
    @Override  
    public void eat() {
        System.out.println("子类重写eat");
    }}
public  class Zizi extends Zi  {                    子子类重写完了所有抽象方法
    @Override
    public void cat() {
        System.out.println("子子类重写cat方法");
    }}

 final关键字

    代表最终的不可改变的

      1. 用来修饰一个类 :  那么这个类不能被继承

      2. 用来修饰一个方法 :  那么所在类被继承后,这个方法不能被重写

      3 . 用来修饰一个局部变量  :  那么这个变量就不能进行 更改 .

             final  int  num = 200;   ---->   num = 250;  //错误写法!      num=200;   //错误写法!          int age ;  --->  final age = 18;错误

             final int num ;   ---->   num = 200 ;       //正确写法!  只要保证唯一一次赋值即可!

            注意对于:基本数据类型 针对值,对于引用类型数据针对 内存地址

              final  Student stu = new Student()  ; ---->   stu = new Student( )    //错误写法 !

      4. 用来修饰一个成员变量

             1.对于成员变量,使用final 修饰后就必须 手动赋值,JVM 不在赠送  2.通过构造方法赋值,但必须保证所有情况最后会赋值

public class DemoFinal {
    private final int age ;
    //private final int age =15;       1.要么手动赋值后不可变
    public DemoFinal() {
        this.age=15;              
    } 
    public DemoFinal(int age) {        2.要么两个构造方法,保证age会赋值
        this.age = age;
    }}

成员变量和成员方法的访问

     1.成员变量     

         1. 直接通过对象名称访问成员变量,看等号左边是谁,就优先用谁,没有则往上找 如果父类中是私有的也不行,   找不到就报错,

          2.间接通过成员方法访问,看该方法属于谁,优先用谁,没有往上找

          3.私有变量 只能通过所在类的成员方法访问

          4.  成员变量 可以是任意数据类型   类 和 接口都可以作为成员变量          String 就是一个类

      2.成员方法  

          1.直接通过对象名称访问成员方法,看等号左边是谁,就优先用谁,没有则往上找 如果父类中是私有的也不行,   找不到就报错,

           2.私有方法不能被重写  可以被继承