java继承

java继承

本质：对某一批类的抽象

java中只有单继承，没有多继承

一个子类只能有一个父类，但是一个父类可以有多个子类

被final修饰的类无法继承 即final之后“断子绝孙”

继承使用extends关键字，子类（派生类）是父类（基类）的扩展

这里让Student类继承Person类

package com.yuanyu.Oop;

public class Student extends Person {
}

通过快捷键Ctrl+H可以查看继承关系

在java中，所有类都默认直接或间接继承Object类

java中类与类之间的关系还有依赖、组合、聚合等等...

子类继承父类的所有方法和属性，但是私有的属性方法无法继承

package com.yuanyu.Oop;

public class Person {
    //public
    public int money=100000;
    //private
    private int money1=100000;
  
    public void say(){
        System.out.println("I can speak.");
    }
}

package com.yuanyu.Oop;

public class Student extends Person {
}

package com.yuanyu.Oop;

public class Application {
    public static void main(String[] args) {
        Student student=new Student();
        student.say(); //I can speak.
      
        //public
        System.out.println(student.money); //100000
        //private
        //System.out.println(student.money1); //无法调用
        
    }
}

修饰符：

• public（继承）
• protected
• default
• private （无法继承）

子类调用父类使用super关键字

this表示当前类

子类可以继承父类protected类型的属性

package com.yuanyu.Oop;

public class Person {
    protected String name="shangxian";
}

package com.yuanyu.Oop;

public class Application {
    public static void main(String[] args) {
        Student student=new Student();
        student.test("mixu");
    }
}

package com.yuanyu.Oop;

public class Student extends Person {
    private String name="yuanyu";

    public void test(String name){
        System.out.println(name); //mixu
        System.out.println(this.name); //yuanyu
        System.out.println(super.name); //shangxian
    }
}

子类继承父类的方法

package com.yuanyu.Oop;

public class Person {
    public void print(){
        System.out.println("Person");
    }
}

package com.yuanyu.Oop;

public class Application {
    public static void main(String[] args) {
        Student student=new Student();
        student.test();
    }
}

package com.yuanyu.Oop;

public class Student extends Person {
    public void print(){
        System.out.println("Student");
    }

    public void test(){
        print(); //Student
        this.print(); //Student
        super.print(); //Person
    }
}

继承时构造器的执行

package com.yuanyu.Oop;

public class Person {
    public Person() {
        System.out.println("Person无参构造器");
    }
}

package com.yuanyu.Oop;

public class Student extends Person {
    public Student() {
        //super(); //隐藏调用父类的无参构造器
        System.out.println("Student无参构造器");
    }
}

package com.yuanyu.Oop;

public class Application {
    public static void main(String[] args) {
        Student student=new Student();
    }
}

通过观察运行结果会发现，父类的构造器先执行，子类的构造器后执行，即子类的构造方法中隐藏了调用父类无参构造的代码super();且super();必须放在第一行否则会报错。
父类没有无参构造，子类也不会有无参构造，重写了有参构造要把无参构造写上，若父类重写了有参构造而没有增加无参构造，子类调用父类的有参构造不会有错，但是子类调用的是父类的无参构造或没有调用时则会报错。

super注意点：

1. super调用父类的构造方法，必须在构造方法的第一行

2. super必须只能出现在子类的方法或构造方法中

3. super和this不能同时调用构造方法
   

重写(Override)

重写都是方法的重写，和属性无关

静态方法重写

package com.yuanyu.Oop;

public class B extends A {
    public static void test(){
        System.out.println("B");
    }
}

package com.yuanyu.Oop;

public class A {
    public static void test(){
        System.out.println("A");
    }
}

package com.yuanyu.Oop;

public class Application {
    public static void main(String[] args) {
        B b =new B();
        b.test(); //B

        A a=new B(); //父类的引用指向了子类
        a.test(); //A
    }
}

当把A、B类test()方法中的static去掉之后，发现父类的重写是向下的，子类的重写是向上的

子类直接重写父类的方法

package com.yuanyu.Oop;

public class B extends A {
    @Override
    public void test() {
        super.test();
    }
}

非静态方法重写

package com.yuanyu.Oop;

public class A {
    public  void test(){
        System.out.println("A");
    }
}

package com.yuanyu.Oop;

public class B extends A {
    @Override //重写（有功能的注释）
    public void test() {
        System.out.println("B");
    }
}

package com.yuanyu.Oop;

public class Application {
    public static void main(String[] args) {
        B b =new B();
        b.test(); //B

        A a=new B(); //父类的引用指向了子类
        a.test(); //B
    }
}

静态方法和非静态方法的区别：

• 静态方法的调用只和左边定义的数据类型有关
• 非静态方法的调用需要重写

重写：需要有继承关系，子类重写父类的方法（子类的方法和父类必须一致，方法体不同）

1. 方法名必须相同
2. 参数列表必须相同
3. 修饰符的范围可以扩大但不能缩小
4. 抛出的异常范围可以缩小但不能扩大

重写的原因：子类不一定需要或满足于父类的功能