Java面向对象（进阶）-- super关键字的使用与子类对象实例化全过程

一、super关键字的使用

（1）为什么需要super？

举例1：子类继承父类以后，对父类的方法进行了重写，那么在子类中，是否还可以对父类中被重写的方法进行调用？

可以！

举例2：子类继承父类以后，发现子类和父类中定义了同名的属性（若子类造对象，就会有两个同名属性），是否可以在子类中区分两个同名的属性？（方法可以覆盖，属性不能覆盖）

可以！

如何调用？ 使用super关键字即可。

（2）super的理解

super的理解：父类的

在子类中，若想调用父类中被重写的方法，就用super.方法即可；若想调用父类中的属性，就用super.属性即可。

若没有写super，调用的就是子类中重写的方法和子类里面声明的属性。

在Java类中使用super来调用父类中的指定操作：

• super可用于访问父类中定义的属性
• super可用于调用父类中定义的成员方法
• super可用于在子类构造器中调用父类的构造器

注意：

• 尤其当子父类出现同名成员时，可以用super表明调用的是父类中的成员
• super的追溯不仅限于直接父类
• super和this的用法相像，this代表本类对象的引用，super代表父类的内存空间的标识

（3）super可以调用的结构

super可以调用的结构：属性、方法、构造器

具体的：

1、super调用方法

• 如果子类没有重写父类的方法，只要权限修饰符允许，在子类中完全可以直接调用父类的方法；
• 如果子类重写了父类的方法，在子类中需要通过super.才能调用父类被重写的方法，否则默认调用的子类重写的方法

举例1

观察下面代码的输出结果。

【Person.java】

package yuyi01;

public class Person {
    //属性
    String name;
    private int age;

    //方法
    public void eat(){
        System.out.println("人吃饭");
    }

    public void sleep(){
        System.out.println("人睡觉");
    }
}

【Student.java】

package yuyi01;

public class Student extends Person {
    //属性
    String school;

    //方法
    public void study(){
        System.out.println("学生学习");
    }

    //重写
    public void eat(){
        System.out.println("学生多吃有营养的食物");
    }

    public void sleep(){
        System.out.println("学生保证每天不低于七小时睡眠");
    }
}

【StudentTest.java】

package yuyi01;

public class StudentTest {
    public static void main(String[] args) {
        Student s1=new Student();
        s1.eat();
        s1.sleep();

    }
}

输出结果：

---

举例2

如何在子类方法（Student.java里面，还能够调用父类中被重写的方法呢？

如果此时在子类方法里面调用eat()方法，毫无疑问，这个eat()方法指的是自己类里面重写的方法。如下：

当然，使用eat()调用和this.eat()调用效果一样，前者只是省略了this.而已。

若现在想调用父类中的eat()方法，很简单，只需要在前面写super.即可。（以不影响封装性为前提）

【Student.java】

package yuyi01;

public class Student extends Person {
    //属性
    String school;

    //重写
    public void eat(){
        System.out.println("学生多吃有营养的食物");
    }
	//...
    public void show(){
        eat();  //省略了this
        this.eat();

        super.eat();    //父类中的eat()方法
    }
}

this.eat();直接在本类找，找到了，就直接调用本类的重写方法即可。

super.eat();直接在直接父类中找，找到了，就直接调用父类被重写的方法即可。

eat();是省略了this.，所以本质上也是调用本类中的方法，若本类中找不到，才会去父类中找。

测试类【StudentTest.java】

package yuyi01;

public class StudentTest {
    public static void main(String[] args) {
        Student s1=new Student();
        //...
        s1.show();
    }
}

运行结果：

---

举例3

父类【Person.java】

package yuyi01;

public class Person {
    //...
    public void doSport(){
        System.out.println("人运动");
    }
}

子类【Student.java】

package yuyi01;

public class Student extends Person {
    //...
    public void show1(){
        doSport();
    }
}

此时子类中调用的doSport()毫无疑问是父类中的方法，因为子类中没有重写它。

这时候它的前缀是啥呢？

若在本类中调用方法，前缀都会省略this.。调用show1()方法的时候，它会在本类中找doSport()方法，找不到就会去父类中找。

此时本类中没有doSport()方法，就会去父类中找，找到并调用。若父类中还没有，就会继续往上找，直到Object，还没有找到就会报错了。

画个图看看：

此时Sutdent类里面没有重写doSport()，所以只有一个父类Person中的doSport()而已，只能调用它。

从结果上说，this.doSport()和super.doSport()一致；但是从过程上来说，this.doSport()先从本类开始找，super.doSport()直接向直接父类中找。

【Student.java】

package yuyi01;

public class Student extends Person {
    //...
    public void show1(){
        doSport();
        this.doSport();
        super.doSport();
    }
}

测试类【StudentTest.java】

package yuyi01;

public class StudentTest {
    public static void main(String[] args) {
        Student s1=new Student();
        //...
        s1.show1();
    }
}

运行结果：

小结

• 方法前面没有super.和this.
  • 先从子类找匹配方法，如果没有，再从直接父类找，再没有，继续往上追溯
• 方法前面有this.
  • 先从子类找匹配方法，如果没有，再从直接父类找，再没有，继续往上追溯
• 方法前面有super.
  • 从当前子类的直接父类找，如果没有，继续往上追溯

2、super调用属性

• 如果实例变量与局部变量重名，可以在实例变量前面加this.进行区别
• 如果子类实例变量和父类实例变量重名，并且父类的该实例变量在子类仍然可见，在子类中要访问父类声明的实例变量需要在父类实例变量前加super.，否则默认访问的是子类自己声明的实例变量
• 如果父子类实例变量没有重名，只要权限修饰符允许，在子类中完全可以直接访问父类中声明的实例变量，也可以用this.实例访问，也可以用super.实例变量访问

举例1

暂且不考虑权限的事情。此时父类Person和子类Student中有同名的属性id。

父类【 Person.java】

package yuyi01;

public class Person {
    //属性
    String name;
    private int age;

    int id; //身份证号

}

子类【Student.java】

package yuyi01;

public class Student extends Person {
    //属性
    String school;
    int id; //学号

}

若此时创建子类Student的对象，那么它拥有几个属性呢？和父类同名的属性会不会被干掉？

来Debug一下：

所以，属性没有方法那样有覆盖之说。

属性不会覆盖，而方法可以覆盖。

---

举例2

既然有两个同名的属性，那么该如何区分它们呢？

此时将父类和子类中的属性id都赋值。

父类【 Person.java】

package yuyi01;

public class Person {
    //属性
    String name;
    private int age;

    int id=1001; //身份证号

}

在子类中写一个show2()方法，输出id的结果是什么呢？

子类【Student.java】

package yuyi01;

public class Student extends Person {
    //属性
    String school;
    int id=1002; //学号

    public void show2(){
        System.out.println(id); //?
    }
}

此时输出语句并没有报错，这里遵循一个就近原则。

就和之前说的get方法一样，比如：

再比如：

当时解决办法是这样：

具体关于this的讲解在这一篇博客：https://blog.csdn.net/m0_55746113/article/details/134089173?spm=1001.2014.3001.5502

---

所以此时的id会就近找一个一样的，然后就找到了本类的id。

若想要父类中的id，就需要加一个super.。

子类【Student.java】

package yuyi01;

public class Student extends Person {
    //属性
    String school;
    int id=1002; //学号

    public void show2(){
        System.out.println(id); 	//1002
        System.out.println(this.id); 	//1002

        System.out.println(super.id); 	//1001
    }
}

测试类【StudentTest.java】

package yuyi01;

public class StudentTest {
    public static void main(String[] args) {
        Student s1=new Student();
    	//...
        System.out.println();
        s1.show2();
    }
}

运行结果：

举例3

父类【Person.java】

package yuyi01;

public class Person {
    //属性
    String name;
    //...
}

子类【Student.java】

package yuyi01;

/**
 * ClassName: Student
 * Package: yuyi04
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/10/29 0029 16:40
 */
public class Student extends Person {
    //属性
    String school;
    int id=1002; //学号

    //方法
    public void show3(){
        System.out.println(name);   //这样写就相当于省略了this
        System.out.println(this.name);
        System.out.println(super.name);
    }
}

name先在当前类里面找，若没有找到，就去父类中找。

从结果上，三个输出值是一样的；但从过程上来说，name先找本类再找父类，super.name直接找父类。

测试类【StudentTest.java】

package yuyi01;

public class StudentTest {
    public static void main(String[] args) {
        Student s1=new Student();

        s1.show3();
    }
}

输出结果：

---

加super与this，就是区分重名的属性，重写的方法。

若没有重名属性和重写的方法，this与super加不加无所谓，只不过一个本类找，一个直接父类找，过程上有区别，结果上没有区别。

若是父类中没有的属性（本类中有），用super直接父类中找是会报错的。

小结

总结：起点不同（就近原则）

• 变量前面没有super.和this.
  • 在构造器、代码块、方法中如果出现使用某个变量，先查看是否是当前块声明的局部变量，
  • 如果不是局部变量，先从当前执行代码的本类去找成员变量
  • 如果从当前执行代码的本类中没有找到，会往上找父类声明的成员变量（权限修饰符允许在子类中访问的）
• 变量前面有this.
  • 通过this找成员变量时，先从当前执行代码的本类去找成员变量
  • 如果从当前执行代码的本类中没有找到，会往上找父类声明的成员变量（权限修饰符允许在子类中访问的）
• 变量前面super.
  • 通过super找成员变量，直接从当前执行代码的直接父类去找成员变量（权限修饰符允许在子类中访问的）
  • 如果直接父类没有，就去父类的父类中找（权限修饰符允许在子类中访问的）

特别说明：应该避免子类声明和父类重名的成员变量

3、super调用构造器

引入

为何要调用构造器？

比如在Student类里new了一个Student对象，可以通过s1调用属性、方法。

【Student.java】

package yuyi01;

public class Student extends Person {
    //属性
    String school;
    int id=1002; //学号

}

若此时父类Person里面的name属性没有限制，那么在测试里面可以调用name属性。

这里我们知道内存中有name属性，才直接调用它。

可我们new的是Student，相当于调用的是Student的构造器，会加载Student的结构，那为啥还会加载父类的结构呢（为啥内存中有

name属性)？这里就涉及到super调用构造器的问题。

举例1

① 子类继承父类时，不会继承父类的构造器（构造器只有在同名的类里面才有）。只能通过“super(形参列表)”的方式调用父类指定的构造器。

父类【Person.java】

package yuyi01;

public class Person {
    //属性
    String name;
    private int age;
    int id=1001; //身份证号

    //构造器
    public Person() {

    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person(String name, int age, int id) {
        this.name = name;
        this.age = age;
        this.id = id;
    }
}

子类【Student.java】

package yuyi01;

public class Student extends Person {
    //属性
    String school;
    int id=1002; //学号

    //测试super调用父类的构造器
    public Student(){

    }
    public Student(String name,int age){

    }
}

比如在子类中调用父类中的空参构造器：

举例2

父类【Person.java】

package yuyi01;

public class Person {
    //构造器
    public Person() {
        System.out.println("Person()...");
    }
}

子类【Student.java】

package yuyi01;

public class Student extends Person {
    //测试super调用父类的构造器
    public Student(){
        super();    //调用父类中空参的构造器
        System.out.println("Student()...");
    }
}

测试类【StudentTest.java】

package yuyi01;

public class StudentTest {
    public static void main(String[] args) {
        Student s2=new Student();
    }
}

输出结果：

当我们调用子类构造器创建对象的时候，先调用父类构造器，输出Person()...，然后再输出Student()...。如下：

可以在子类构造器中调用父类的构造器，格式就是super(形参列表)。

举例3

② 规定：“super(形参列表)”，必须声明在构造器的首行。（和this很像）

如下：

---

③ 我们前面讲过，在构造器的首行可以使用"this(形参列表)"，调用本类中重载的构造器， 结合②，结论：在构造器的首行，“this(形参列表)” 和 "super(形参列表)"只能二选一。

比如：

---

④ 如果在子类构造器的首行既没有显示调用"this(形参列表)“，也没有显式调用"super(形参列表)”， 则子类此构造器默认调用"super()"，即调用父类中空参的构造器。

父类【Person.java】

package yuyi01;

public class Person {
    //构造器
    public Person() {
        System.out.println("Person()...");
    }

}

子类【Student.java】

package yuyi01;

public class Student extends Person {
    public Student(String name,int age){
        //没有显示调用父类中空参的构造器
    }
}

测试类【StudentTest.java】

package yuyi01;

public class StudentTest {
    public static void main(String[] args) {
        Student s3=new Student("Tom",13);
    }
}

输出结果：

---

在Student(String name,int age)构造器首行，并没有写this(形参列表)，也没有写"super(形参列表)"。此时会默认是Super()，而且是空参的。

来Debug看一下：

进入构造器了，如下：

再下一步：

所以，在调Student构造器的时候，没有写this，也没有super语句，会默认父类空参构造器。

若此时将空参构造器注释掉，会发现子类中两个构造器都会报错。第一个是显示调用，但没有找到空参构造器，就会报错；第二个虽然没有显示调用谁，但是默认调用了空参构造器，也没有找到，所以也会报错。如下：

---

⑤ 由③和④得到结论：子类的任何一个构造器中，要么会调用本类中重载的构造器，要么会调用父类的构造器。 只能是这两种情况之一。

画个图瞅瞅：

---

⑥ 由⑤得到：一个类中声明有n个构造器，最多有n-1个构造器中使用了"this(形参列表)“（若有n个就会形成一个环，递归了），则剩下的那个一定使用"super(形参列表)”（显示或者默认）。

子类中的任何一个构造器，都会直接或间接地调用父类的构造器。如下：

开发中常见错误：

如果子类构造器中既未显式调用父类或本类的构造器，且父类中又没有空参的构造器，则编译出错。

调用父类构造器不是为了造对象，造对象需要搭配new，调用父类构造器是为了初始化信息–比如将父类的属性、方法加载到内存中。

---

举例4

父类【Person.java】

package yuyi01;

public class Person {
    //属性
    String name;
    private int age;

    int id=1001; //身份证号

    //方法
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    //构造器
    public Person() {
        System.out.println("Person()...");
    }
}

子类【Student.java】

package yuyi01;

public class Student extends Person {
    //属性
    String school;
    int id=1002; //学号

    public Student(String name,int age){
        //没有显示调用父类中空参的构造器
        setAge(age);
        super.name=name;	//当前类里面没有name属性，这里super也可以写成this
    }
}

---

上面的写法很Low，若父类Person中有这样的构造器：

package yuyi01;

public class Person {
    //属性
    String name;
    private int age;

    int id=1001; //身份证号

    //构造器
    public Person() {
        System.out.println("Person()...");
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

}

子类可以这样写：

package yuyi01;

public class Student extends Person {
    //属性
    String school;
    int id=1002; //学号

    public Student(String name,int age){
       super(name,age);
    }
}

那么子类就可以直接调用父类中的构造器，如下：（若是没有写，调用的就是父类中的空参构造器Person()）

以后声明子类构造器的时候，构造器的首行就可以调用父类指定的结构了。

4、总结

子类继承父类以后（super关键字使用的前提是基于继承），我们就可以在子类的方法或构造器中，调用父类中声明的属性或方法。（满足封装性的前提下）

super调用方法、属性

🗃️如何调用呢？

需要使用"super."的结构，表示调用父类的属性或方法。

一般情况下，我们可以考虑省略"super."的结构。

但是，如果出现子类重写了父类的方法或子父类中出现了同名的属性时，则必须使用"super."的声明，显式地调用父类被重写的方法或父类中声明的同名的属性。

特别说明：应该避免子类声明和父类重名的成员变量（方法没法避开）

在阿里的开发规范等文档中都做出明确说明：

super调用构造器

① 子类继承父类时，不会继承父类的构造器。只能通过“super(形参列表)”的方式调用父类指定的构造器。

② 规定：“super(形参列表)”，必须声明在构造器的首行。

③ 我们前面讲过，在构造器的首行可以使用"this(形参列表)"，调用本类中重载的构造器，
结合②，结论：在构造器的首行，“this(形参列表)” 和 "super(形参列表)"只能二选一。

④ 如果在子类构造器的首行既没有显示调用"this(形参列表)“，也没有显式调用"super(形参列表)”，
则子类此构造器默认调用"super()"，即调用父类中空参的构造器。

⑤ 由③和④得到结论：子类的任何一个构造器中，要么会调用本类中重载的构造器，要么会调用父类的构造器。
只能是这两种情况之一。

⑥ 由⑤得到：一个类中声明有n个构造器，最多有n-1个构造器中使用了"this(形参列表)“，
则剩下的那个一定使用"super(形参列表)”。

–> 我们在通过子类的构造器创建对象时，一定在调用子类构造器的过程中，直接或间接的调用到父类的构造器。
也正因为调用过父类的构造器，我们才会将父类中声明的属性或方法加载到内存中，供子类对象使用。

情景举例1：

class A{

}
class B extends A{

}

class Test{
    public static void main(String[] args){
        B b = new B();
        //A类和B类都是默认有一个无参构造，B类的默认无参构造中还会默认调用A类的默认无参构造
        //但是因为都是默认的，没有打印语句，看不出来
    }
}

情景举例2：

class A{
    A(){
        System.out.println("A类无参构造器");
    }
}
class B extends A{

}
class Test{
    public static void main(String[] args){
        B b = new B();
        //A类显示声明一个无参构造，
        //B类默认有一个无参构造，
        //B类的默认无参构造中会默认调用A类的无参构造
        //可以看到会输出“A类无参构造器"
    }
}

情景举例3：

class A{
    A(){
        System.out.println("A类无参构造器");
    }
}
class B extends A{
    B(){
        System.out.println("B类无参构造器");
    }
}
class Test{
    public static void main(String[] args){
        B b = new B();
        //A类显示声明一个无参构造，
        //B类显示声明一个无参构造，        
        //B类的无参构造中虽然没有写super()，但是仍然会默认调用A类的无参构造
        //可以看到会输出“A类无参构造器"和"B类无参构造器")
    }
}

情景举例4：

class A{
    A(){
        System.out.println("A类无参构造器");
    }
}
class B extends A{
    B(){
        super();
        System.out.println("B类无参构造器");
    }
}
class Test{
    public static void main(String[] args){
        B b = new B();
        //A类显示声明一个无参构造，
        //B类显示声明一个无参构造，        
        //B类的无参构造中明确写了super()，表示调用A类的无参构造
        //可以看到会输出“A类无参构造器"和"B类无参构造器")
    }
}

情景举例5：

class A{
    A(int a){
        System.out.println("A类有参构造器");
    }
}
class B extends A{
    B(){
        System.out.println("B类无参构造器");
    }
}
class Test05{
    public static void main(String[] args){
        B b = new B();
        //A类显示声明一个有参构造，没有写无参构造，那么A类就没有无参构造了
        //B类显示声明一个无参构造，        
        //B类的无参构造没有写super(...)，表示默认调用A类的无参构造
        //编译报错，因为A类没有无参构造
    }
}

情景举例6：

class A{
    A(int a){
        System.out.println("A类有参构造器");
    }
}
class B extends A{
    B(){
        super();
        System.out.println("B类无参构造器");
    }
}
class Test06{
    public static void main(String[] args){
        B b = new B();
        //A类显示声明一个有参构造，没有写无参构造，那么A类就没有无参构造了
        //B类显示声明一个无参构造，        
        //B类的无参构造明确写super()，表示调用A类的无参构造
        //编译报错，因为A类没有无参构造
    }
}

情景举例7：

class A{
    A(int a){
        System.out.println("A类有参构造器");
    }
}
class B extends A{
    B(int a){
        super(a);
        System.out.println("B类有参构造器");
    }
}
class Test07{
    public static void main(String[] args){
        B b = new B(10);
        //A类显示声明一个有参构造，没有写无参构造，那么A类就没有无参构造了
        //B类显示声明一个有参构造，        
        //B类的有参构造明确写super(a)，表示调用A类的有参构造
        //会打印“A类有参构造器"和"B类有参构造器"
    }
}

情景举例8：

class A{
    A(){
        System.out.println("A类无参构造器");
    }
    A(int a){
        System.out.println("A类有参构造器");
    }
}
class B extends A{
    B(){
        super();//可以省略，调用父类的无参构造
        System.out.println("B类无参构造器");
    }
    B(int a){
        super(a);//调用父类有参构造
        System.out.println("B类有参构造器");
    }
}
class Test8{
    public static void main(String[] args){
        B b1 = new B();
        B b2 = new B(10);
    }
}

（4）小结：this与super

1、this和super的意义

this：当前对象

• 在构造器和非静态代码块中，表示正在new的对象
• 在实例方法中，表示调用当前方法的对象

super：引用父类声明的成员

2、this和super的使用格式

• this
  • this.成员变量：表示当前对象的某个成员变量，而不是局部变量
  • this.成员方法：表示当前对象的某个成员方法，完全可以省略this.
  • this()或this(实参列表)：调用另一个构造器协助当前对象的实例化，只能在构造器首行，只会找本类的构造器，找不到就报错
• super
  • super.成员变量：表示当前对象的某个成员变量，该成员变量在父类中声明的
  • super.成员方法：表示当前对象的某个成员方法，该成员方法在父类中声明的
  • super()或super(实参列表)：调用父类的构造器协助当前对象的实例化，只能在构造器首行，只会找直接父类的对应构造器，找不到就报错

（5）练习

1、练习1

🌋题目描述

修改方法重写的练习2中定义的类Kids中employeed()方法，在该方法中调用父类ManKind的employeed()方法，
然后再输出"but Kids should study and no job."

【Kids.java】

package yuyi02;

/**
 * ClassName: Kids
 * Package: yuyi05
 * Description:
 修改继承内容的练习1中定义的类Kids，在Kids中重新定义employeed()方法，
 覆盖父类ManKind中定义的employeed()方法，输出"Kids should study and no job."

 * @Author 雨翼轻尘
 * @Create 2023/10/30 0030 10:56
 */
public class Kids extends Mankind { //父类中声明的属性和方法都被继承到子类了，构造器就不提了。后边提super关键字的时候会提到，在子类当中调用父类中的构造器
    private int yearOld;

    public int getYearOld() {
        return yearOld;
    }

    public void setYearOld(int yearOld) {
        this.yearOld = yearOld;
    }

    public void printAge(){
        System.out.println("I am "+yearOld+" years old");
    }

    @Override
    public void employeed() {
        System.out.println("Kids should study and no job.");
    }

    //构造器
    public Kids(){

    }

    public Kids(int yearOld){
        this.yearOld=yearOld;
    }

    //把父类中的属性也做一个赋值，包括自己的属性
    public Kids(int sex, int salary,int yearOld){
        this.yearOld=yearOld;
        //sex、salary两个 属性是父类继承过来的，怎么给他们赋值？
        setSex(sex);
        setSalary(salary);
    }
}

【Mankind.java】

package yuyi02;

/**
 * ClassName: Mankind
 * Package: yuyi05
 * Description:
 * (1)定义一个ManKind类，包括
 *    成员变量int sex和int salary；
 * - 方法void manOrWoman()：根据sex的值显示“man”(sex==1)或者“woman”(sex==0)；
 *
 * - 方法void employeed()：根据salary的值显示“no job”(salary==0)或者“ job”(salary!=0)。
 * @Author 雨翼轻尘
 * @Create 2023/10/30 0030 10:32
 */
public class Mankind {
    //属性
    private int sex;
    private int salary;

    //方法

    public int getSex() {
        return sex;
    }

    public void setSex(int sex) {
        this.sex = sex;
    }

    public int getSalary() {
        return salary;
    }

    public void setSalary(int salary) {
        this.salary = salary;
    }

    public void manOrWoman(){
        if(sex==1){
            System.out.println("man");
        } else if (sex==0) {
            System.out.println("woman");
        }
    }

    public void employeed(){
        if(salary==0){
            System.out.println("no job");
        } else {
            System.out.println("job");
        }
    }

    //构造器

    public Mankind() {

    }

    public Mankind(int sex, int salary) {
        this.sex = sex;
        this.salary = salary;
    }
}

【KidsTest.java】

package yuyi02;

/**
 * ClassName: KidsTest
 * Package: yuyi05
 * Description:
 *(3)定义类KidsTest，在类的main方法中实例化Kids的对象someKid，用该对象访问其父类的成员变量及方法。
 * @Author 雨翼轻尘
 * @Create 2023/10/30 0030 10:58
 */
public class KidsTest {
    public static void main(String[] args) {
        Kids someKid=new Kids();
        someKid.setSex(1);
        someKid.setSalary(100);
        someKid.setYearOld(12);

        //Kids类自己声明的方法
        someKid.printAge();

        //来自于父类中声明的方法
        someKid.manOrWoman();
        someKid.employeed();

        //
        System.out.println("*************");
        someKid.employeed();

    }
}

🤺代码

【 Kids.java】

package yuyi02;

/**
 * ClassName: Kids
 * Package: yuyi05
 * Description:
 修改方法重写的练习2中定义的类Kids中employeed()方法，在该方法中调用父类ManKind的employeed()方法，
 然后再输出"but Kids should study and no job."

 * @Author 雨翼轻尘
 * @Create 2023/11/4 0030 10:56
 */
public class Kids extends Mankind { //父类中声明的属性和方法都被继承到子类了，构造器就不提了。后边提super关键字的时候会提到，在子类当中调用父类中的构造器
   //...
    
    @Override
    public void employeed() {
        //在子类中调用父类中被重写的方法
        super.employeed();    //先去调用父类中的employeed()方法
        System.out.println("but Kids should study and no job.");
    }
    
	//...
}

【Mankind.java】

package yuyi02;

public class Mankind {
    //...
    public void employeed(){
        if(salary==0){
            System.out.println("no job");
        } else {
            System.out.println("job");
        }
    }
}

【KidsTest.java】

package yuyi02;

public class KidsTest {
    public static void main(String[] args) {
        //...
        Kids someKid=new Kids();
        someKid.employeed();
    }
}

👻输出结果

2、练习2

🌋题目描述

在Cylinder类中修改求表面积的方法findArea()和求体积的方法findVolume(),使用上super。

【Circle.java】

package yuyi03;

/**
 * ClassName: Circle
 * Package: yuyi06
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/10/31 0031 10:07
 */
public class Circle {
    //属性
    private double radius;  //半径
    //方法
    public void setRadius(double radius){
        this.radius=radius;
    }
    public double getRadius(){
        return radius;
    }
    //求圆的面积
    public double findArea(){
        return Math.PI*radius*radius;
    }

    //构造器
    public Circle(){
        radius=1;
    }
}

【Cylinder.java】

package yuyi03;

/**
 * ClassName: Cylinder
 * Package: yuyi06
 * Description:
 *  圆柱类
 * @Author 雨翼轻尘
 * @Create 2023/10/31 0031 10:19
 */
public class Cylinder extends Circle {
    //属性
    private double length;  //高

    //方法
    public void setLength(double length){
        this.length=length;
    }
    public double getLength(){
        return length;
    }
    //求圆柱的体积
    public double findVolume(){
        return Math.PI*getRadius()*getRadius()*getLength(); //底面积*高
        //return findArea()*getLength();    //错误的
    }


    //构造器
    public Cylinder(){
        length=1;
    }

    //求表面积
    @Override
    public double findArea() {
        return Math.PI*getRadius()*getRadius()*2+
        2*Math.PI*getRadius()*getLength();

    }
}

【CylinderTest.java】

package yuyi03;

/**
 * ClassName: CylinderTest
 * Package: yuyi06
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/10/31 0031 10:29
 */
public class CylinderTest {
    public static void main(String[] args) {
        Cylinder cy=new Cylinder();
        cy.setRadius(2.3);
        cy.setLength(1.4);
        System.out.println("圆柱的体积为： "+cy.findVolume());
        System.out.println("圆柱的表面积为： "+cy.findArea());
    }
}

🤺代码

【Cylinder.java】

package yuyi03;

public class Cylinder extends Circle {
    //...

    //求圆柱的体积
    public double findVolume(){
        //return Math.PI*getRadius()*getRadius()*getLength(); //底面积*高  正确的
        //return findArea()*getLength();    //错误的
        return super.findArea()*getLength();
    }

    //...

    //求表面积
    @Override
    public double findArea() {
        return Math.PI*getRadius()*getRadius()*2+
        2*Math.PI*getRadius()*getLength();

    }
}

【Circle.java】

package yuyi03;

public class Circle {
    //...

    //求圆的面积
    public double findArea(){
        return Math.PI*radius*radius;
    }
}

【CylinderTest.java】

package yuyi03;

public class CylinderTest {
    public static void main(String[] args) {
        Cylinder cy=new Cylinder();
        cy.setRadius(2.3);
        cy.setLength(1.4);
        System.out.println("圆柱的体积为： "+cy.findVolume());
        System.out.println("圆柱的表面积为： "+cy.findArea());
    }
}

👻输出结果

3、练习3

🌋题目描述

①写一个名为Account的类模拟账户。该类的属性和方法如下图所示。

该类包括的属性：账号id，余额balance，年利率annualInterestRate；

包含的方法：访问器方法（getter和setter方法），返回月利率的方法getMonthlyInterest()，取款方法withdraw()，存款方法deposit()。

写一个用户程序测试Account类。在用户程序中，创建一个账号为1122、余额为20000、年利率4.5%的Account对象。

使用withdraw方法提款30000元，并打印余额。

再使用withdraw方法提款2500元，使用deposit方法存款3000元，然后打印余额和月利率。

提示：在提款方法withdraw中，需要判断用户余额是否能够满足提款数额的要求，如果不能，应给出提示。

运行结果如图所示。

②创建Account类的一个子类CheckAccount代表可透支的账户，该账户中定义一个属性overdraft代表可透支限额。

在CheckAccount类中重写withdraw方法，其算法如下：

————————————————————————————————————————

如果（取款金额<账户余额），

可直接取款

如果（取款金额>账户余额），

计算需要透支的额度

判断可透支额overdraft是否足够支付本次透支需要，如果可以

将账户余额修改为0，冲减可透支金额

如果不可以

提示用户超过可透支额的限额

————————————————————————————————————————

要求：写一个用户程序测试CheckAccount类。

在用户程序中，创建一个账号为1122、余额为20000、年利率4.5%，可透支限额为5000元的CheckAccount对象。

使用withdraw方法提款5000元，并打印账户余额和可透支额。

再使用withdraw方法提款18000元，并打印账户余额和可透支额。

再使用withdraw方法提款3000元，并打印账户余额和可透支额。

提示：

（1）子类CheckAccount的构造方法需要将从父类继承的3个属性和子类自己的属性全部初始化。

（2）父类Account的属性balance被设置为private，但在子类CheckAccount的withdraw方法中需要修改它的值，因此应修改父类的balance属性，定义其为protected。

运行结果如下图所示。

---

🤺代码①

【Account.java】

package yuyi04;

/**
 * ClassName: Account
 * Package: yuyi04
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/11/4 0004 8:29
 */
public class Account {
    //属性
    private int id; //账户
    private double balance; //余额
    private double annualInterestRate;  //年利率

    //构造器
    public Account(int id,double balance,double annualInterestRate){
        //super();
        this.id=id;
        this.balance=balance;
        this.annualInterestRate=annualInterestRate;
    }

    //方法
    public void setId(int id) {
        this.id = id;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }

    public int getId() {
        return id;
    }

    public double getBalance() {
        return balance;
    }

    public void setAnnualInterestRate(double annualInterestRate) {
        this.annualInterestRate = annualInterestRate;
    }

    /**
     * 获取月利率
     * @return
     */
    public double getMonthlyInterest(){
        return annualInterestRate / 12;
    }

    /**
     * 取钱曹操作
     * @param amount  要取的钱数
     */
    public void withdraw(double amount){
        if(balance>=amount){
            balance-=amount;
        }else{
            System.out.println("余额不足！");
        }
    }

    /**
     * 存钱操作
     * @param amount 要存的额度
     */
    public void deposit(double amount){
        if(amount>0){
            balance+=amount;
        }
    }
}

【AccountTest.java】

package yuyi04;

/**
 * ClassName: AccountTest
 * Package: yuyi04
 * Description:
 * 写一个用户程序测试Account类。在用户程序中，创建一个账号为1122、余额为20000、年利率4.5%的Account对象。
 *   使用withdraw方法提款30000元，并打印余额。
 *   再使用withdraw方法提款2500元，使用deposit方法存款3000元，然后打印余额和月利率。
 * @Author 雨翼轻尘
 * @Create 2023/11/4 0004 10:46
 */
public class AccountTest {
    public static void main(String[] args) {
        Account acct=new Account(1122,20000,0.045);
        acct.withdraw(30000);
        System.out.println("您的账户余额为："+acct.getBalance());
        acct.withdraw(2500);
        acct.deposit(3000);
        System.out.println("您的账户余额为： "+acct.getBalance());
        System.out.println("月利率为： "+acct.getMonthlyInterest());
    }
}

👻运行结果①

---

🤺代码②

【Account.java】

package yuyi04;

/**
 * ClassName: Account
 * Package: yuyi04
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/11/4 0004 8:29
 */
public class Account {
    //属性
    private int id; //账户
    private double balance; //余额
    private double annualInterestRate;  //年利率

    //构造器
    public Account(int id,double balance,double annualInterestRate){
        //super();
        this.id=id;
        this.balance=balance;
        this.annualInterestRate=annualInterestRate;
    }

    //方法
    public void setId(int id) {
        this.id = id;
    }

    /*public void setBalance(double balance) {
        this.balance = balance;
    }*/

    public int getId() {
        return id;
    }

    public double getBalance() {
        return balance;
    }

    public void setAnnualInterestRate(double annualInterestRate) {
        this.annualInterestRate = annualInterestRate;
    }

    /**
     * 获取月利率
     * @return
     */
    public double getMonthlyInterest(){
        return annualInterestRate / 12;
    }

    /**
     * 取钱曹操作
     * @param amount  要取的钱数
     */
    public void withdraw(double amount){
        if(balance>=amount){
            balance-=amount;
        }else{
            System.out.println("余额不足！");
        }
    }

    /**
     * 存钱操作
     * @param amount 要存的额度
     */
    public void deposit(double amount){
        if(amount>0){
            balance+=amount;
        }
    }
}

【CheckAccount.java】

package yuyi04;

/**
 * ClassName: CheckAccount
 * Package: yuyi04
 * Description:
 *  创建Account类的一个子类CheckAccount代表可透支的账户，该账户中定义一个属性overdraft代表可透支限额。
 * @Author 雨翼轻尘
 * @Create 2023/11/4 0004 14:51
 */
public class CheckAccount extends Account{
    //属性
    private double overdraft;   //可透支限额

    //方法
    public double getOverdraft() {
        return overdraft;
    }

    public void setOverdraft(double overdraft) {
        this.overdraft = overdraft;
    }


    //重写withdraw方法
    /**
     * 针对于可透支的账户的取钱操作
     * @param amount  要取的钱数
     */
    public void withdraw(double amount){
        if(getBalance()>=amount){
            //错误的:（左右结果都是一个值，何来赋值一说）
            //getBalance()=getBalance()-amount;

            //正确的
            super.withdraw(amount); //super别去掉了，这里调用的是父类的withdraw方法
        } else if (getBalance()+overdraft>=amount) {
            overdraft-=amount-getBalance(); //可透支的限额剩余量
            super.withdraw(getBalance());   //把原本账户的钱取光
        }else{
            System.out.println("超过可透支限额");
        }
    }


    //构造器
    public CheckAccount(int id,double balance,double annualInterestRate){
        super(id,balance,annualInterestRate);
    }

    public CheckAccount(int id,double balance,double annualInterestRate,double overdraft){
        super(id,balance,annualInterestRate);
        this.overdraft=overdraft;
    }
}

【CheckAccountTest.java】

package yuyi04;

/**
 * ClassName: CheckAccountTest
 * Package: yuyi04
 * Description:
 *  要求：写一个用户程序测试CheckAccount类。
 *  在用户程序中，创建一个账号为1122、余额为20000、年利率4.5%，可透支限额为5000元的CheckAccount对象。
 *
 *  使用withdraw方法提款5000元，并打印账户余额和可透支额。
 *  再使用withdraw方法提款18000元，并打印账户余额和可透支额。
 *  再使用withdraw方法提款3000元，并打印账户余额和可透支额。
 *
 * @Author 雨翼轻尘
 * @Create 2023/11/4 0004 22:05
 */
public class CheckAccountTest {
    public static void main(String[] args) {
        CheckAccount checkAccount=new CheckAccount(1122,20000,0.045,5000);

        checkAccount.withdraw(5000);
        System.out.println("您的账户余额为： "+checkAccount.getBalance());
        System.out.println("您的可透支额为： "+checkAccount.getOverdraft());

        checkAccount.withdraw(18000);
        System.out.println("您的账户余额为： "+checkAccount.getBalance());
        System.out.println("您的可透支额为： "+checkAccount.getOverdraft());

        checkAccount.withdraw(3000);
        System.out.println("您的账户余额为： "+checkAccount.getBalance());
        System.out.println("您的可透支额为： "+checkAccount.getOverdraft());
    }
}

👻输出结果

⚡注意

【注意一】

当我们写完第一问的时候，第二问写CHeckAccount继承于Account，就会报错。

如下：

这是为哈呢？

在声明一个类没有显示写构造器的时候，会默认有一个空参的构造器。任何一个构造器的首行，要么写this(形参列表)，要么是super(形参列表)。若现在构造器也没有写，那就是默认super()。

而现在父类Account里面根本没有提供空参构造器，所以会报错。

有两种解决办法。

第一种是给父类提供空参的构造器：

package yuyi04;

public class Account {
    //...
    //构造器
    //空参构造器
	public Account(){
        
    }
    
    public Account(int id,double balance,double annualInterestRate){
        //super();
        this.id=id;
        this.balance=balance;
        this.annualInterestRate=annualInterestRate;
    }
}

第二种可以直接调用有参的构造器：

---

【注意二】

CheckAccount类里面重写的withdraw方法。

package yuyi04;

public class CheckAccount extends Account{
    //...
    //重写withdraw方法
    /**
     * 针对于可透支的账户的取钱操作
     * @param amount  要取的钱数
     */
    public void withdraw(double amount){
        if(getBalance()>=amount){
            //错误的:（左右结果都是一个值，何来赋值一说）
            //getBalance()=getBalance()-amount;

            //正确的
            super.withdraw(amount); //super别去掉了，这里调用的是父类的withdraw方法
        } else if (getBalance()+overdraft>=amount) {
            overdraft-=amount-getBalance(); //可透支的限额剩余量
            super.withdraw(getBalance());   //把原本账户的钱取光
        }else{
            System.out.println("超过可透支限额");
        }
    }
}

这里很容易弄混：

【小Tips】

按住Ctrl+Shift+向上方向键：本行与上一行互换

【Super的使用】

①子类重写的方法里面，调用父类被重写的方法：

②

（6）面试题

1、第一题

如下代码输出结果是多少？

package com.atguigu05._super.interview;

/**
 * 判断运行结果
 *
 * @author 雨翼轻尘
 * @create 2023/11/5
 */
public class Interview01 {

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

class A {
    public A() {
        System.out.println("A");
    }

    public A(B b) {
        this();
        System.out.println("AB");
    }
}

class B {
   public B() {
       System.out.println("B");
   }
}

最终输出结果是：

分析一下，看图：

2、第二题

如下代码输出结果是多少？

package com.atguigu05._super.interview;

/**
 * 判断运行结果
 *
 * @author 雨翼轻尘
 * @create 2023/11/5
 */
public class Interview01 {

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

class A {
    public A() {
        System.out.println("A");
    }

    public A(B b) {
        this();
        System.out.println("AB");
    }
}

class B extends A{
    public B() {
        System.out.println("B");
    }
}

最终输出结果是：

分析一下，看图：

3、第三题

如下代码输出结果是多少？

package yuyi05;

/**
 * @author 雨翼轻尘
 * @create 2023/11/5
 */
public class Interview02{
        public static void main(String[] args) {
            Father f = new Father();
            Son s = new Son();
            System.out.println(f.getInfo());//atyuyi
            System.out.println(s.getInfo()); //atyuyi
            s.test();//atyuyi atyuyi
            System.out.println("-----------------");
            s.setInfo("轻尘");
            System.out.println(f.getInfo());//atyuyi
            System.out.println(s.getInfo());//轻尘
            s.test(); //轻尘 轻尘
    }
}
class Father{
    private String info = "atyuyi";
    public void setInfo(String info){
        this.info = info;
    }
    public String getInfo(){
        return info;
    }
}
class Son extends Father{
    private String info = "雨翼轻尘";
    public void test(){
        System.out.println(this.getInfo());
        System.out.println(super.getInfo());
    }
}

最终输出结果是：

分析一下，看图：

①

②

③

④

4、第四题

如下代码输出结果是多少？

package yuyi05;

/**
 * @author 雨翼轻尘
 * @create 2023/11/5
 */
public class Interview02{
    public static void main(String[] args) {
        Father f = new Father();
        Son s = new Son();
        System.out.println(f.getInfo());//返回最近的info，即本类的"atyuyi"
        System.out.println(s.getInfo()); //返回最近的info，即本类的"雨翼轻尘"
        s.test();//“雨翼轻尘” atyuyi
        System.out.println("-----------------");
        s.setInfo("轻尘");
        System.out.println(f.getInfo());//atyuyi
        System.out.println(s.getInfo());//雨翼轻尘
        s.test(); //雨翼轻尘 轻尘
    }
}
class Father{
    private String info = "atyuyi";
    public void setInfo(String info){
        this.info = info;
    }
    public String getInfo(){
        return info;
    }
}
class Son extends Father{
    private String info = "雨翼轻尘";
    public void test(){
        System.out.println(this.getInfo());
        System.out.println(super.getInfo());
    }
    //重写
    public String getInfo(){
        return info;
    }
}

最终输出结果是：

分析一下，看图：

①

②

二、子类对象实例化全过程

（1）介绍

调用子类构造器去创建对象的时候，会直接或间接地调用父类地构造器。

整个过程其实可以理解为关于某个类的对象，在创建这个对象的过程当中是什么样的场景。

Dog dog = new Dog("小花","小红");

（2）举例

代码举例：

class Creature{ //生物类
    //声明属性、方法、构造器
}

class Animal extends Creature{ //动物类

}

class Dog extends Animal{ //狗类

}

class DogTest{
    public static void main(String[] args){
        //子类对象DOg在实例化的过程当中整个过程是怎样的呢？
        Dog dog = new Dog();	//创建DOg的对象中，涉及到父类、父类的父类加载的过程？

        //通过dog调用属性、方法，只要是在Animal或Creature里面定义的属性、方法
        dog.xxx();
        
        dog.yyy = ...;
    }
}

1. 从结果的角度来看：体现为类的继承性

当我们创建子类对象后，子类对象就获取了其父类（所有父类，包括直接父类、间接父类）中声明的所有的属性和方法，在权限允许的情况下，可以直接调用。

2. 从过程的角度来看：（继承性它在内存层面是怎么保证它是能够调用的）

当我们通过子类的构造器创建对象时，子类的构造器一定会直接或间接地调用到其父类的构造器，而其父类的构造器同样会直接或间接地调用到其父类的构造器，…，直到调用了Object类中的构造器为止。

正因为我们调用过子类所有的父类的构造器，所以我们就会将父类中声明的属性、方法加载到内存中，供子类的对象使用。

问题：在创建子类对象的过程中，一定会调用父类中的构造器吗？ yes!
先有父类的加载，才有子类的加载。

3. 问题：创建子类的对象时，内存中到底有几个对象？
   就只有一个对象（只new了一次）！即为当前new后面构造器对应的类的对象。

①造对象–>new

②构造器–>初始化<init>

---

叨叨：
这一篇写累死我了，战线拉得很长，不过值得，有任何错误的地方欢迎指正