java 面向对象1之继承

首先是需要创建的类,统一创建在oopTest包下：

student类为父类，smallStudent类与bigStudent类继续student类。

student类的代码如下，其中有姓名和成绩两个属性并带有一个显示的方法

package oopTest;

public class Student {
    String name;
    double score;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public double getScore() {
        return score;
    }
    public void setScore(double score) {
        this.score = score;
    }
    public void showScore() {
        System.out.println("姓名为：" + name + "	成绩为：" + score);
    }
}

smallStudent类的代码如下，自带的方法为music()，唱跳.....

package oopTest;

public class smallStudent extends Student{
    public void music() {
        System.out.println("小学生会音乐");
    }
}

bigStudent类的代码如下，自带的方法为reading()，疯狂阅读...

package oopTest;

public class bigStudent  extends Student{
    public void reading() {
        System.out.println("大学生会阅读");
    }
}

最后需要一个测试类来测试子类继续的属性与方法，代码如下

package oopTest;

public class TestExtendsMain {
    public static void main(String[] args) {
        smallStudent smalls = new smallStudent();
        smalls.setName("小学生");
        smalls.setScore(90);
        smalls.music();
        smalls.showScore();
        
        bigStudent bigs = new bigStudent();
        bigs.setName("大学生");
        bigs.setScore(100);
        bigs.reading();
        bigs.showScore();
    }
}

运行结果和预料的一样，这是最基本的类继承的常识，不多说（下面开始剖析this(),super()还有构造方法与继承的关系）

package oopTest;

public class TestExtendsMain {
    public static void main(String[] args) {
        smallStudent smalls = new smallStudent();
        smalls.setName("小学生");
        smalls.setScore(90);
        smalls.music();
        smalls.showScore();
        
        bigStudent bigs = new bigStudent();
        bigs.setName("大学生");
        bigs.setScore(100);
        bigs.reading();
        bigs.showScore();
    }
}

先贴上上面代码的继承关系图

开始今天的重点，this(),super()

this()，测试的代码如下，初始化子类smallStudent

package oopTest;

public class TestExtendsMain {
    public static void main(String[] args) {
        smallStudent smalls = new smallStudent();
    }
}

为父类student添加一个无参构造方法并显示出来

package oopTest;

public class Student {
    String name;
    double score;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public double getScore() {
        return score;
    }
    public void setScore(double score) {
        this.score = score;
    }
    public void showScore() {
        System.out.println("姓名为：" + name + "	成绩为：" + score);
    }
    public Student() {
        System.out.println("调用父类的无参构造方法");
    }
}

为子类smallstudent分别添加一个无参构造方法和有参构造方法，并在无参构造方法中使用this()调用有参构造方法

package oopTest;

public class smallStudent extends Student{
    public void music() {
        System.out.println("小学生会音乐");
    }
    public smallStudent() {
        this("jump");
        System.out.println("子类的无参构造方法");
    }
    public smallStudent(String behavior) {
        System.out.println("子类的有参构造方法");
    }
}

看看结果，可以知道子类的构造方法在初始化时会先调用父类的无参构造方法，而this()可以通过输入的参数调用本类相应的构造方法

注意：this()与super()调用的构造方法必须存在并且this()和super()必须写在构造方法的最顶层否则会报错，如下初始化错误

看看super()方法，依旧是通过初始化一个子类的方式来看

package oopTest;

public class TestExtendsMain {
    public static void main(String[] args) {
        smallStudent smalls = new smallStudent();
    }
}

父类依旧

package oopTest;

public class Student {
    String name;
    double score;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public double getScore() {
        return score;
    }
    public void setScore(double score) {
        this.score = score;
    }
    public void showScore() {
        System.out.println("姓名为：" + name + "	成绩为：" + score);
    }
    public Student() {
        System.out.println("调用父类的无参构造方法");
    }
}

将子类的this()方法改为super()

package oopTest;

public class smallStudent extends Student{
    public void music() {
        System.out.println("小学生会音乐");
    }
    public smallStudent() {
        super();
        System.out.println("子类的无参构造方法");
    }
    public smallStudent(String behavior) {
        System.out.println("子类的有参构造方法");
    }
}

运行结果如下，说明子类的构造器在初始化时会在顶层默认调用super()方法

以下代码使用子类的有参构造方法进行初始化，并没有写下super()，结果依然调用了父类的无参构造方法

package oopTest;

public class TestExtendsMain {
    public static void main(String[] args) {
        smallStudent smalls = new smallStudent("jump");
    }
}

package oopTest;

public class smallStudent extends Student{
    public void music() {
        System.out.println("小学生会音乐");
    }
    public smallStudent() {
        System.out.println("子类的无参构造方法");
    }
    public smallStudent(String behavior) {
        System.out.println("子类的有参构造方法");
    }
}

-----------------------------------------------------------------------------------------------------------------------------------------------------------------------

接下来创建三个类，a,b,c类，a继承b类，b类继承c类

 以下为a类的代码，只有一个无参构造方法

package oopTest;

public class a {
    public a() {
        System.out.println("我是a类的无参构造方法");
    }
}

以下为b类的代码，提供一个无参的构造方法

package oopTest;

public class b extends a{
    public b() {
        System.out.println("调用了b类的无参构造方法");
    }
}

以下为c类的代码，提供一个无参与有参的构造方法

package oopTest;

public class c extends b{
    public c() {
        this("string");
        System.out.println("调用了c类的无参构造方法");
    }
    public c(String args) {
        System.out.println("调用类c类的有参构造方法");
    }
}

测试代码，初始化一个c类

package oopTest;

public class TestExtendsMain {
    public static void main(String[] args) {
        c c1 = new c();
    }
}

可以推测一下结果，首先初始化c类的构造器，但是因为c类继承类b类，所以先初始化b类的构造器，以此类推，a类的无参构造方法--》b类的无参构造方法--》c类的有参构造方法--》c类的无参构造方法

运行结果为

可以发现结果是调用了c类的父类b类与它的父类a类的“一个”构造方法，当然它也只有一个构造方法于是给a类和b类写上一个有参的构造方法，看看会不会在初始化时调用父类的两个构造方法

代码如下，分别在a类和b类创建了有参的构造方法

package oopTest;

public class a {
    public a() {
        System.out.println("我是a类的无参构造方法");
    }
    public a(String args) {
        System.out.println("我是a类的有参构造方法");
    }
}

package oopTest;

public class b extends a{
    public b() {
        System.out.println("调用了b类的无参构造方法");
    }
    public b(String args) {
        System.out.println("调用类b类的有参构造方法");
    }
}

在c类的无参构造方法中使用super()，结果如下

package oopTest;

public class c extends b{
    public c() {
        super();
        System.out.println("调用了c类的无参构造方法");
    }
    public c(String args) {
        System.out.println("调用类c类的有参构造方法");
    }
}

 如果给c类的super()加上参数会怎么样？

package oopTest;

public class c extends b{
    public c() {
        super("string");
        System.out.println("调用了c类的无参构造方法");
    }
    public c(String args) {
        System.out.println("调用类c类的有参构造方法");
    }
}

通过结果可以看到，c类的super(string)调用了父类b类的“一个”有参构造方法，证明父类只会调用一个构造方法？

我们试试以下这段代码

package oopTest;

public class c extends b{
    public c() {
        this("string");
        System.out.println("调用了c类的无参构造方法");
    }
    public c(String args) {
        super("string");
        System.out.println("调用类c类的有参构造方法");
    }
}

通过初始化c类的无参构造方法，运行的顺序为 a类的无参构造方法--》b类的无参构造方法--》c类的有参构造方法--》b类的有参构造方法--》c类的有参构造方法

结果为

从上面的运行顺序来看，b类的无参构造方法确实调用了（临时），但是在之后它被b类的有参构造方法顶替了，而a类即使有两个构造方法也没有被顶替掉，由此可见，父类的构造器在初始化时只会把最后调用的一个构造器显示出来。

最后，我们如果在b类的有参构造方法中使用super()调用a类的有参构造方法是否也会这样呢？

package oopTest;

public class b extends a{
    public b() {
        System.out.println("调用了b类的无参构造方法");
    }
    public b(String args) {
        super("string");
        System.out.println("调用类b类的有参构造方法");
    }
}

结果是肯定的，a类的无参构造方法被销毁了（也许是被重载了这部分我也有点迷），谢谢耐心观看本篇文章的小伙伴们，下一篇，封装！！