18-oop继承

继承

• 继承的本质是堆某一批类的抽象，从而实现对现实世界更好的建模
• extands：扩展。子类是父类的扩展
• Java中类只有单继承，没有多继承，一个儿子只有一个爸爸，一个爸爸可以有多个儿子
• 继承是类间关系，还有依赖、组合、聚合等
• 被final修饰的类不能继承
• Ctrl+H -->查看继承树

//在Java中，所有类都默认继承Object类
//人类 :父类
public class Person {

    //public
    public void say(){
        System.out.println("说了一句话");
    }
    //private
    private int money = 10_0000_0000;
    //通过get/set方法操作私有属性
    public int getMoney() {
        return money;
    }
    public void setMoney(int money) {
        this.money = money;
    }
}

//学生 is 人
//子类继承了父类所有public的东西,private的东西无法继承
public class Student extends Person {
    //Ctrl + H  -->继承树
}
/*
    public static void main(String[] args) {
        Student student = new Student();
        student.say();//继承了父类
    }
 */

super与this

• super代表父
• this代表当前的

public class Person {
    public Person() {
        System.out.println("Person无参构造执行");
    }
    protected String name = "狂神";
    public void print(){
        System.out.println("Person");
    }
}

public class Student extends Person {
    public Student() {
        //隐藏代码：调用了父类的无参构造    现有父后有子
        //super()[这个代码被隐藏了] 调用父类构造器，必须在子类构造器第一行，不用写默认存在
        System.out.println("Student无参构造执行");
    }
    private String name = "qinjiang";
    public void print(){
        System.out.println("Student");
    }
    public void test(String name){
        System.out.println(name);//秦疆，输出的传递的参数
        System.out.println(this.name);//qinjiang，当前对象的name
        System.out.println(super.name);//狂神,父类的name
    }
    public void test1(){
        print();//Student
        this.print();//Student
        super.print();//Person
    }
}
/*
    public static void main(String[] args) {
        Student student = new Student();
        //Person无参构造执行
        //Student无参构造执行
        //注：先默认调用父类的无参构造，再调用子类的
    }
 */

super注意点：

1. super调用父类的构造方法，必须在构造方法的第一个
2. super必须只能出现在子类的方法或构造方法中
3. super和this不能同时调用构造方法（因为都必须在第一行）

Vs this:

• 代表的对象不同：
  this：本身调用者这个对象
  super：代表父类对象的应用
• 前提
  this：没有继承也可以使用
  super：只能在继承条件才可以使用
• 构造方法
  this（）：本类的构造
  super（）：父类的构造

方法重写

• 重写都是方法的重写，与属性无关
• 重写只能非静态方法有关，与静态方法无关
• 重写需要有继承关系，子类重写父类的方法

//父类
public class B {
    public static void test(){
        System.out.println("B=>test()");
    }
}

static方法重写

//继承
public class A extends B{
    public static void test(){
        System.out.println("A=>test()");
    }
}
/*
    public static void main(String[] args) {
        //static方法的调用 只和左边即定义的数据类型有关
        A a = new A();
        a.test();//A=>test()

        //父类的引用指向了子类
        //A的构造函数中包含了B的构造函数
        B b = new A();
        b.test();//B=>test()
    }
 */

非静态方法

//继承
public class A extends B{
    //Override 重写
    @Override//注解：有功能的注释！
    public void test() {
        System.out.println("A=>test()");
    }
}
/*
    public static void main(String[] args) {
        A a = new A();
        a.test();//A=>test()

        B b = new A();//子类重写了父类的方法（非静态方法）
        b.test();//A=>test()
    }
    //区别与重载，，重载是参数列表不同
 */

Note：

1. 方法名必须相同
2. 参数列表必须相同
3. 修饰符：范围可以扩大（不能缩小） ： public>Protected>Default>private
4. 抛出的异常：范围，可以被缩小，但不能扩大： ClassNotFoundException-->Exception（大）
5. 子类的方法和父类必须一致，但方法体不同！

为什么需要重写：

• 父类的功能，子类不一定需要，或者不一定满足
• 快捷键：Alt + Insert ： override