java——嵌套(二)

一：方法的重写（覆盖/覆写）

1. 方法的重写的意义：

2. 重写（overide）

3. 案例

二：继承中构造方法的调用

1. 子类的构造方法会默认调用父类的构造方法；

2. super 关键字调用父类有参构造

3. 总结:

三：super 的用法

四：this 的用法

五：案例

六：最后

一：方法的重写（覆盖/覆写）

1. 方法的重写的意义：

在设计之中，对于已经投入使用的类，我们尽量不要修改。我们一般创建一个新的类，来继承就旧类的内容，从而降低代码的冗余性，提高代码的复用性，对于一些新增的内容，写在重写方法里面即可；

2. 重写（overide）

格式：方法名相同，参数列表相同;

特点：创建的是子类对象，优先使用子类方法；

2.1 注解（@Override）,用来检测重写是否正确（当然，可以不写）、

2.2 子类方法的返回值类型要小于等于父类的；

另外，Object 类是所有类的公共最高类，即“祖宗类”，

2.3 子类权限修饰符要大于等于父类的；

public > protected > (默认) > private

当然，我们在使用的时候不必那么复杂，我们子类的返回值类型和权限修饰符一般等于父类的就行；

3. 案例

比如一个手机类，其方法有接电话，但是不能显示联系人的头像和语音播报，于是我们通过继承和方法重写增添这两个功能；

public class FirstPhone {
    public void phone(){
        System.out.println("接电话");
        System.out.println("电话铃声");
    }
}

public class SecondPhone extends FirstPhone{
    @Override
    public void phone(){
        super.phone();//降低代码的冗余性，提高复用性
        System.out.println("显示头像");
        System.out.println("语音播报");
    }
}

public class PhoneDemo {
    public static void main(String[] args) {
        FirstPhone f=new FirstPhone();
        f.phone();
        System.out.println("===========");
        SecondPhone s=new SecondPhone();
        s.phone();
    }
}

C:\Java\jdk-17.0.11\bin\java.exe "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2022.1.3\lib\idea_rt.jar=5505:C:\Program Files\JetBrains\IntelliJ IDEA 2022.1.3\bin" -Dfile.encoding=UTF-8 -classpath C:\Test\classDemo\out\production\classDemo PhoneDemo
接电话
电话铃声
===========
接电话
电话铃声
显示头像
语音播报

进程已结束,退出代码0

二：继承中构造方法的调用

1. 子类的构造方法会默认调用父类的构造方法；

这是因为子类的构造方法中会默认存在 " super ( ) ; " 语句，从而优先调用父类的构造方法；

public class Fu {
    //构造方法
    public Fu(){
        System.out.println("这是父类的的构造方法啊");
    }
}

public class Zi extends Fu{
    //子类构造方法
    public Zi(){
        System.out.println("这是子类的构造方法");
    }
}

public class FuZiDemo {
    public static void main(String[] args) {
        Zi z=new Zi();
        }
}

C:\Java\jdk-17.0.11\bin\java.exe "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2022.1.3\lib\idea_rt.jar=7390:C:\Program Files\JetBrains\IntelliJ IDEA 2022.1.3\bin" -Dfile.encoding=UTF-8 -classpath C:\Test\classDemo\out\production\classDemo FuZiDemo
这是父类的的构造方法啊
这是子类的构造方法

进程已结束,退出代码0

2. super 关键字调用父类有参构造

如果父类没有无参构造方法只有有参构造方法呢？

我们可以调用父类的有参构造方法，调用时，需要使用“ super（参数类型参数名）”；

而且 只能放在子类方法的第一行；

public class Fu {
    //构造方法
    public Fu(int age){
        System.out.println("这是父类的的构造方法啊"+age);
    }
}

public class Zi extends Fu{
    //子类构造方法
    public Zi(){
        super(16);
        System.out.println("这是子类的构造方法");
    }
}

public class FuZiDemo {
    public static void main(String[] args) {
        Zi z=new Zi();
        }
}

3. 总结:

子类必须调用父类的构造方法，不写会赠送 super（），写了则使用指定的super 调用，此外，super 只能有一个，且必须放在子类方法的第一行；

比如下面，我重载了父类的构造方法，使用super调用时，一直报错，这就证明只能有一个

super（）语句；

三：super 的用法

前面既然提到了 super ,那咱们就详细介绍 super 的用法吧。

（1）在子类的成员方法中，调用父类的成员变量；

（2）在子类的成员方法中，调用父类的成员方法；

（3）在子类的构造方法中，调用父类的构造方法；

（注意前提条件）

public class Fu {
    String name;//成员变量
    //构造方法
    public Fu(int age){
        System.out.println("这是父类的的构造方法啊"+age);
    }
    //成员方法
    public void method1(){
        System.out.println("父类的成员方法");
    }
}

public class Zi extends Fu{
    //子类构造方法
    public Zi(){                        //调用父类的构造方法
        super(99);
    }
    
    public void method(){
        System.out.println(super.name);//调用父类的成员变量
        super.method1();               //调用父类的成员方法
    }
}

四：this 的用法

说到 super 关键字的用法，我又想到了 this 关键字的用法；

        （1）在本类的成员方法中，调用子类的成员变量，以区分局部变量；

        （2）在本类的成员方法中，调用子类的另一个成员方法，（不用this也行），以从字面上强调调用的方法来自是本类；

        （3）在本类的构造方法中，调用本类的另一个构造方法；

A ：构造方法的重载调用（本人记不住也不太明白这个名字），说人话就是在无参构造方法中使用 this关键字调用有参构造方法；

B ：this语句必须放在方法体的第一行，这与super语句也必须放在第一行冲突（在此类有父类的情况下），在此情况下，默认的 super语句就不再提供了；

这里的前提条件是本类，与父子类和继承什么的毫无关系；

public class ThisDemo {
    String name="吃饭!";
    public ThisDemo(){                //调用本类一个参数的有参构造方法
       this(11);
    }
    public ThisDemo(int age){        //一个参数的有参构造方法调用本类两个参数的
        this(11,99);
    }

    public ThisDemo(int age1,int age2){//本类两个参数的构造方法调用父类的默认super语句

    }

    public void method(){
        String name="行，行，好";
        System.out.println(this.name);//访问本类成员变量
    }
    public void eat(){
        this.method();               //调用本类的成员方法，从字面上强调其来自本类
        System.out.println("不辜负爱与美食");
    }
}

五：案例

前面说了super,this关键字的用法，我们不妨创建一个案例慢慢感知他们在实际应用中的作用：

public class Fu2 {
    String name="曹操操";
    public Fu2(){
        System.out.println("这是父类的构造方法");
    }
    public void method(){
        System.out.println("这是父类的成员方法");
    }
}

public class Zi2 extends Fu2{
    String name="刘备备";
    public Zi2(){
        super();//调用父类构造方法
        System.out.println("这是子类的构造方法");
    }
    @Override//注解尽量去写
    public void method(){
        String name="吕小布";
        System.out.println(name);;//调用局部变量
        System.out.println(this.name);//调用子类成员变量
        System.out.println(super.name);//调用父类成员变量
    }
}

public class FZ2Demo {
    public static void main(String[] args) {
        Zi2 z=new Zi2();//创建对象的同时，调用其构造方法；
        z.method();
    }
}

C:\Java\jdk-17.0.11\bin\java.exe "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2022.1.3\lib\idea_rt.jar=4366:C:\Program Files\JetBrains\IntelliJ IDEA 2022.1.3\bin" -Dfile.encoding=UTF-8 -classpath C:\Test\classDemo\out\production\classDemo FZ2Demo
这是父类的构造方法
这是子类的构造方法
吕小布
刘备备
曹操操

进程已结束,退出代码0