继承

继承

• 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
• extends 的意思是”扩展“，子类是父类的扩展。
• Java中类只有单继承，没有多继承。
• 继承是类和类之间的一种关系，除此之外，类和类之间的关系还有依赖、组合、聚合等。
• 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。字类继承父类，使用关键字 extends 来表示。
• 子类和父类之间，从意义上讲应该具有”is a“的关系。

代码示例：

父类：Person

package cheng.oop.demo03;

// 在Java中，所有的类，都默认直接或者间接继承Object类
// Person : 父类
public class Person {
    // public：公有的，可以继承
    // protected：受保护的
    // defaul：默认的
    // private：私有的，不可以继承
    private int age;// 不可继承
    public int money = 10_0000_0000;// 可以继承

    public void say() {
        System.out.println("说了一句话");
    }
}

字类：Student

package cheng.oop.demo03;

// Student（也是人） : 字类，派生类
// 字类继承了父类，就会继承父类的所有方法
public class Student extends Person {

}

使用：

package cheng.oop;

import cheng.oop.demo03.Student;

// 一个项目应该只有一个main方法
public class Application {
    public static void main(String[] args) {

        Student student = new Student();

        student.say();
        System.out.println(student.money);
    }
}

运行效果：

说了一句话
1000000000

super

• super 注意点：

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

• -super 和 this

  • 代表的对象不同：

    this：本身调用者这个对象

    super：代表父类对象的引用

  • 前提：

    this：没有继承也可以使用

    super：只能在继承条件下才可以使用

  • 构造方法：

    this()：本类的构造

    super()：父类的构造

代码示例：

父类：Person

package cheng.oop.demo04;

// 在Java中，所有的类，都默认直接或者间接继承Object类
// Person : 父类
public class Person {

    public Person() {
        System.out.println("执行Person的无参构造！");
    }

    protected String name = "王老六";

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

字类：Student

package cheng.oop.demo04;

// Student（也是人） : 字类，派生类
// 字类继承了父类，就会继承父类的所有方法
public class Student extends Person {

    // 调用父类的构造器 “super();” 必须要保证在第一行
    // 调用子类的构造器 “this();” 必须要保证在第一行
    // 如果写了有参构造，需要将无参构造也写出来才能调用无参构造

    public Student() {
        System.out.println("执行Student的无参构造！");
    }

    protected String name = "王六";

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

    public void test(String name) {
        System.out.println(name);// 输出传入的name
        System.out.println(this.name);// 输出当前的对象的name
        System.out.println(super.name);// 输出父类对象的name
    }

    public void test1() {
        print();// 调当前类的print()
        this.print();// 调用当前类的print()
        super.print();// 调用父类的print()
    }
}

使用：

package cheng.oop;

import cheng.oop.demo04.Student;

// 一个项目应该只有一个main方法
public class Application {
    public static void main(String[] args) {

        // 先调用父类的无参构造
        // 再调用当前对象的无参构造
        Student student = new Student();
        student.test("wangliu");

        System.out.println("==========================");

        student.test1();

    }
}

运行结果：

执行Person的无参构造！
执行Student的无参构造！
wangliu
王六
王老六
==========================
Studen
Studen
Person

方法重写

• 重写：需要有继承关系，子类重写父类的方法。重写是方法的重写，和属性无关。

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

  关系总结：子类的方法和父类必须一致，方法体不同！

• 为什么需要重写？
  父类的功能子类不一定需要，或者不一定满足

• 快捷键：Alt+Insert，选中Override Motheds选项

代码示例：

父类：B

package cheng.oop.demo04;

// 重写都是方法的重写，和属性无关
public class B {

    public void test() {
        System.out.println("B => test()");
    }
    
}

字类：A

package cheng.oop.demo04;

public class A extends B {

    // Override：重写
    @Override // 注解：有功能的注释
    public void test() {
        System.out.println("A => test()");
    }
}

调用：

package cheng.oop;

import cheng.oop.demo04.A;
import cheng.oop.demo04.B;

public class Application {
    // 静态方法和非静态方法区别很大
    // 方法的调用，只和左边定义的数据类型有关
    // 非静态：重写
    public static void main(String[] args) {

        A a = new A();
        a.test();// A => test() 

        // 父类的引用指向了字类
        B b = new A();
        // 如果test()是静态方法：B => test() 
        // 如果test()是非静态方法：A => test()
        b.test();
    }
}