【Java学习】面向对象三大特性之继承、多态

前言

本文为继承和多态的学习笔记，刚开始学习Java，有错误及不完善的地方还请大佬们指出~

1.继承

1.1 定义

类的继承是指在一个现有类的基础上去构建一个新的类，构建出来的新类被称作子类，现有类被称作父类或超类，子类会自动拥有父类所有非私有的属性和方法。

继承分为两种：

• 显式继承：通过extends关键字实现继承

class Person { //创建Person类
    String name;
    int age ;
}

class Teacher extends Person { //子类Teacher类继承于父类Person
    void teach(){
        System.out.println(name + "是老师，今年" + age + "岁");
    }
}

class Student extends Person { //子类Student类继承于父类Person
    void study(){
        System.out.println(name + "是学生，今年" + age + "岁");
    }
}

class Test {
    public static void main(String[] args){
        Teacher t = new Teacher(); //创建Teacher对象
        t. name = "张三" ; //继承了父类的name属性
        t. age = 30; //继承了父类的age属性
        t.teach(); //调用子类的方法
        
        Student s = new Student(); //创建Student对象
        s. name = "李四" ;
        s. age = 20;
        s.study();
    }
}

• 隐式继承：不写extends关键字，自动继承Object类的属性和方法

1.2 作用

通过继承可以快速创建新的类，实现代码的重用，提高程序的可维护性，节省大量创建新类的时间，提高开发效率和开发质量。

1.3 特点

Java中子类不允许同时继承于多个父类，只能单继承

• 一个子类只能继承于一个父类
• 一个父类可以有多个子类
• 允许多层继承，即子类继承于父类，父类再继承于其他父类（A继承于B，B继承于C，则A也为C的子类）

1.4 super关键字

用于指代父类的对象

• super(); → 调用父类的构造函数
  【tips】必须写在构造函数内，且必须为第一句

public class A {
    String str;
    int num;

    public A() {
        System.out.println("这是A类无参的构造函数");
    }

    public A(String str) {
        System.out.println("这是A类1个参的构造函数");
    }

    public A(String str, int num) {
        System.out.println("这是A类2个参的构造函数");
    }
}

public class B extends A {
    public B() {
        //默认调用父类无参构造函数
        System.out.println("这是B类无参的构造函数");
    }

    public B(String str) {
        super(str,20); //调用A类2个参数的构造函数
        System.out.println("这是B类1个参的构造函数");
    }
}

public class Test {
    public static void main(String[] args) {
        B b1 = new B(); //创建B类对象（无参）
        System.out.println("--------------------------");
        B b2 = new B("123"); //创建B类对象（1个参数）
    }
}

运行结果：

• 用于调用父类的属性和方法

public class A {

    public int add(int x, int y) {
        return x + y;
    }
}

public class B extends A {

    public B() {
        System.out.println(super.add(15, 20)); //调用父类add方法
    }
}

public class Test {

    public static void main(String[] args) {
        B b1 = new B();
    }
}

运行结果：

• 子类和父类中成员属性同名用super指代父类

public class A {
    String str = "A的str";
}

public class B extends A {
    String str = "B的str";
    
    public B() {
        System.out.println(super.str); //输出A类str
        System.out.println(str); //输出B类str
    }
}

public class Test {

    public static void main(String[] args) {
        B b1 = new B();
    }
}

运行结果：

1.5 重写（override）

子类中将父类方法重写一遍，用于子类需要父类主体功能，而主体功能又有子类特定内容时。

重写要求：子类中方法声明与父类中的完全相同，即返回值、方法名、形参（类型、个数、顺序）均相同

public class A {

    public void hello() {
        System.out.println("Hello, world!");
    }

    public void bye() {
        System.out.println("Goodbye~");
    }
}

public class B extends A {

    public void hello() { //重写父类hello方法
        System.out.println("你好，世界！");
    }
}

public class Test {

    public static void main(String[] args) {
        B b1 = new B();
        b1.hello(); //调用子类hello()
        b1.bye(); //调用父类继承的bye()
    }
}

运行结果：

【tips】

• 重写后返回值可以缩小，即父类中返回父类对象，则子类中可以改为返回子类对象
• 重写后抛出异常可以缩小
• 重写后访问权限只能放大或不变，不能缩小

2.多态

2.1 具体体现

• 重载（overload）
• 重写（override）
• 父类引用指向子类对象
• 接口可以有多个实现类

2.2 父类引用指向子类对象

父类类型 对象名 = new 子类类型()；
例：A a = new B(); 其中B继承于A

【tips】

• 在B类中定义A类没有的方法，A类引用无法调用该方法
• 如果B类中没有重写A类的方法，则继承A类方法，否则调用B类

public class A {

    public void hello() {
        System.out.println("Hello, world!");
    }

    public void bye() {
        System.out.println("Goodbye~");
    }
}

public class B extends A {

    public void hello() {
        System.out.println("你好，世界！");
    }

    public void goodbye() { //子类中定义而父类中没有，因此无法调用
        System.out.println("拜拜~");
    }
}

public class Test {

    public static void main(String[] args) {
        A a = new B();
        a.hello(); //子类中重写，调用子类
        a.bye(); //子类中未重写，继承父类
    }
}

运行结果：

2.3 接口

2.3.1 抽象类

含有抽象方法的类称为抽象类，其中抽象方法为只有方法声明而没有方法体的方法。抽象方法和抽象类都必须用abstract关键字修饰

• 抽象类中可以既有抽象方法又有非抽象方法
• 抽象类用于给子类提供统一的功能声明
• 抽象类不能创建对象
• 抽象类中可以有构造函数

2.3.2 接口 —— 特殊的抽象类

用于解决Java中类只能单继承的问题，通过interface关键字定义接口，一个类可以实现（关键字implements）多个接口。而一个类实现了某个接口，则这个类称为实现类。

【tips】

• jdk8之前
  • 接口中所有方法都必须是抽象方法
  • 不能直接在接口中实现
• jdk8之后
  • 接口中允许有实现方法，但需要写为静态方法，通过接口名调用
  • 实现方法不写静态时，必须用default修饰，通过实现类对象调用
• 接口中所有属性默认为public static final类型

//单实现

public interface InterfaceA { //定义接口InterfaceA
    public void printA();
}

public class ImplementA implements InterfaceA { //实现类实现接口
    @Override
    public void printA() { //重写InterfaceA接口中的printA方法
        System.out.println("实现了接口A");
    }
}

//多实现

public interface InterfaceB { //定义新的接口InterfaceB
    public void printB();
}

public class ImplementB implements InterfaceA,InterfaceB { //实现类ImplementB同时实现InterfaceA和InterfaceB两个接口
    @Override
    public void printA() { //重写InterfaceA接口中的printA方法
        System.out.println("实现了接口A");
    }

    @Override
    public void printB() { //重写InterfaceB接口中的printB方法
        System.out.println("实现了接口B");
    }
}