Java核心(接口、继承和多态-继承)_在项目中创建subroutine类和两个父类-CSDN博客

本文链接：https://blog.csdn.net/js940814/article/details/80259413

一、类的继承

继承在面向对象开发思想中是一个非常重要的概念，它使整个程序架构具有一定的弹性，在程序中复用一些已经定义完善的类不仅可以减少软件开发周期，也可以提高软件的可维护性和可扩展性。

继承的基本思想是基于某个父类的扩展，指定出一个新的子类，子类可以继承父类原有的属性和方法，也可以增加父类所不具备的属性和方法，或者直接重写父类中的某些方法。例如：平行四边形是特殊的四边形，可以说平行四边形类继承了四边形，这时平行四边形类将所有四边形具有的属性和方法都保留下来，并基于四边形类扩展了一些新的平行四边形特有的属性和方法。

eg ：分别创建 Test1 类和 Test2 类，在 Test1 类中编写成员方法 doSomething() 和 doIt() ，使 Test2 类继承 Test1 类，重写父类的这两个方法和构造方法，并新增 doSomethingnew() 方法。其他 Test2 类的构造方法中使用 super 关键字调用父类的构造方法和成员方法等。

class Test1 {
    public Test1(){                                        //构造方法
        System.out.println("Test1.Test1()");
    }
    protected void doSomething() {                         //成员方法
        System.out.println("Test1.doSomething()");
    }
    protected Test1 doIt() {                               //方法返回值类型为 Test1 类型
        System.out.println("Test1.doIt()");
        return new Test1();
    }
}
class Test2 extends Test1{                                 //继承父类
    public Test2 () {                                      //构造方法
        super();                                           //调用父类的构造方法
        super.doSomething();                               //调用父类成员方法
        System.out.println("Test2.Test2()");
    }
    public void doSomethingnew() {                         //新增方法
        System.out.println("Test2.doSomethingnew()");
    }
    public void doSomething() {                            //重写父类方法
        System.out.println("Test2.doSomething()");
    }
    public Test2 doIt() {                                  //重写父类方法，方法返回值类型为 Test2 类型
        System.out.println("Test2.doIt()");
        return new Test2();
    }
}

定义了两个类，其他 Test2 类继承 Test1 类，可以说 Test1 类为 Test2 类的父类， Test2 类为 Test1 类的子类。在子类中可以连通初始化父类构造方法来完成子类初始化操作，既可以在子类的构造方法中使用 super() 语句调用父类的构造方法，也可以在子类中使用 super 关键字调用父类的成员方法等，但是子类没有权限调用父类中被修饰为 private 的方法，只可以调用父类中修饰为 public 或 protected 的成员方法，例如，子类构造方法中可以使用 super 关键字调用父类的 doSomething 方法，因为 doSomething() 方法的权限修饰符为 protected 。同时在子类中也可以定义一些新方法，如子类中的 doSomethingnew() 方法。

继承并不只是扩展父类的功能，还可以重写父类的成员方法。重写(换可以称为覆盖)就是在子类中将父类的成员方法的名称保留，重写成员方法的实现内容，更改成员方法的存储权限，或是修改成员方法的返回值类型。例如，子类中的 doSomething|() 方法，除了重写方法的实现内容之外，还将方法的修饰权限修改为 public 。

在继承中还有一种特殊的重写方式，子类与父类的成员方法返回值、方法名称、参数类型即个数完全相同，唯一不同的是方法实现内容，这种特殊重写方式被称为重构。

当重写父类方法时，修改方法的修饰权限只能从小的范围到大的范围改变，例如父类中的 doSomethin() 方法的修饰权限为 protected ，继承后子类中的方法 doSomething() 的修饰权限只能修改为 public ，不能修改为 private 。

在 Java 中一切都以对象的形式处理，在继承的机制中，创建一个子类对象，将包含一个父类子对象，这个对象与父类创建的对象一样。两者的区别在与后者来自外部，而前者来自子类对象的内部。当实例化子类对象时，父类对象也相应被实例化，换句话说，在实例化子类对象时，Java 编辑器会在子类的构造方法中自动调用父类的无参构造方法。

eg ：创建 Subroutine 类和两个父类，分别为 Parent 和 SubParent 。这 3 个类的继承关系是 Subroutine 类继承 SubParent 类，而 SubParent 类继承 Parent 类。分别在这 3 个类的构造方法中输出构造方法名称，然后创建 Subroutine 类的实例对象，继承机制将使该类的父类对象自动初始化。

class Parent{//父类
    public Parent() {
        System.out.println("调用父类的 parent() 构造方法");
    }
}
class SubParent extends Parent{                                        //继承 Parent 类
    public SubParent() {
        System.out.println("调用子类的 SubParent() 构造方法");
    }
}
public class Subroutine extends SubParent{                             //继承 SubParent 类
    public Subroutine() {
        System.out.println("调用子类的 Subroutine()构造方法");
    }
    public static void main(String[] args) {
        Subroutine s = new Subroutine();                               //实例化子类对象
    }
}

运行结果为：

调用父类的 parent() 构造方法
调用子类的 SubParent() 构造方法
调用子类的 Subroutine()构造方法

在子类 Subroutine 的主方法中只调用子类的构造方法实例化子类对象，并且在子类构造方法中没有调用父类构造方法的任何语句，但是在实例化子类对象时它相应太哦用了父类的构造方法。在结果中可以看到调用构造方法的顺序，首先是顶级父类，然后使上一级父类，最后是子类。也就是说实例化子类对象时首先要实例化父类对象，然后再实例化子类对象，所以在子类构造方法访问父类的构造方法之前，父类已经完成实例化操作。

在实例化子类对象时，父类无参构造方法将被自动调用，但由参构造方法并不能被自动调用，只能依赖于 super 关键字显式地调用父类的构造方法。

如果使用 finalize() 方法对对象进行清理，需要确保子类的 finalize() 方法的最后一个动作是调用父类的 finalize() 方法，以保证当垃圾回收对象占用内存时，对象的所有部分都能被正常终止。