方法的重写、关键字super

方法重写的概念

子类对父类中继承来的方法进行改造、重置、覆盖，利用同名进行再编写

重写规定

权限修饰符 返回值类型 方法名(形参列表）

1、子类对父类进行重写的时候，方法名与形参和父类的一致

2、权限修饰符在界定权限的时候，子类的权限一定是大于等于父类的，子类的权限是不可以小于父类的

3、返回值类型，若父类被重写的方法返回值是void，那么子类重写的方法结果也只能是void；若父类被重写的方法的返回值类型是A类，那么子类重写的返回值可以是A类或者是A的子类

可以总结为，若父类被重写的方法的返回值类型是基本数据类型，那么子类重写方法的数据类型就与父类被重写的返回值类型一致；但是如果返回的类型是类，那么就可以是该类的子类

重写在子父类继承中尤为重要

public class Person
{
    private String name;
    private int age = 1;
    private boolean isMale;
    public void eat()
    {
        System.out.println("人可以吃饭");
    }
    public void sleep()
    {
        System.out.println("人可以睡觉");
    }
    public void talk(String language)
    {
        System.out.println("人可以说话，使用的是："+language);
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public boolean isMale() {
        return isMale;
    }

    public void setName(String name) {
        this.name = name;
    }

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

    public void setMale(boolean male) {
        isMale = male;
    }
};
class Chinese extends Person{
    private String nation;

    public void setNation(String nation) {
        this.nation = nation;
    }

    public String getNation() {
        return nation;
    }
    
    public void sleep()
    {
        System.out.println("中国人会睡觉");
    }
    
    public void eat()
    {
        System.out.println("中国人会睡觉");
    }

    public void talk(String language)
    {
        System.out.println("中国人可以说话，说的是"+ language);
    }
}

上述举例中，在Chinese这个子类中，eat()和sleep()全是对于Person类中的重写，接下来我们进行测试

public class Persontext
{
    public static void main(String[] args)
    {
        Chinese c1 = new Chinese();
        c1.sleep();
        c1.eat();

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

        Person p1=new Person();
        p1.sleep();
        p1.eat();
    }
};

测试结果如下，sleep函数和eat函数的显示结果已经发生了改变

super关键字

如果想利用父类中已经被覆盖的方法和属性，就要使用super

比如我们可以在Chinese这个类中进行类似操作

class Chinese extends Person{
    private String nation;

    public void setNation(String nation) {
        this.nation = nation;
    }

    public String getNation() {
        return nation;
    }

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

    public void eat()
    {
        System.out.println("中国人会睡觉");
        super.eat();
    }

    public void talk(String language)
    {
        System.out.println("中国人可以说话，说的是"+ language);
    }
}

再利用和上次测试代码进行测试，会发现这个时候原本的输出结果已经发生了改变

如图所示，在已经重写的方法后面，再次打印了之前没有重写的内容

使用super的注意事项

1、在子类和方法或者构造器中可以显式的调用父类的方法和属性

2、当子父类中有同名属性，若子类调用父类中的属性，则此时就可以利用super

3、能调用父类中已经被重写的方法，如果该方法没有被重写，那么不是没有利用super，而是super已经被省略了

4、在构造器的首行，实际上都有一个super()，调用了父类的构造器（此处需要注意的一定是在首行），只不过是默认省略super()，this()和super()只能够调用一个，但是每个构造器的首行，都至少有this()和super()其中之一

这里稍微提一下关于子类对象实例化的过程

1、创建子类对象时在堆空间中会先加载父类的相关属性

2、通过子类的构造器，一定会直接或者间接的调用到父类构造器，直到调用到Object的空参构造器，加载过父类结构，所以才可以看到内存中有父类结构

注：object类可以说是所有类的直接或者间接父类

虽然无数次的调用父类的构造器，但是实际上创造对象的从始至终都只有object类的构造器，所以无论调用多少次，都只会创建一个对象