[Java笔记8] 面向对象3（继承）

package com.test.d10_extends_field_method;

public class ExtendsDemo {
    public static void main(String[] args) {
        Wolf w = new Wolf();
        System.out.println(w.name); // 子类的
        w.showName();
    }
}

class Animal{
    public String name = "父类动物";
}

class Wolf extends Animal{
    public String name = "子类动物";

    public void showName(){
        String name = "局部名称";
        System.out.println(name); // 局部的
        System.out.println(this.name); // 子类name
        System.out.println(super.name); // 父类name
    }
}

输出为：

子类动物
局部名称
子类动物
父类动物

方法重写

子类写一个与父类申明一样的方法覆盖父类的方法。

方法重写的应用场景:
当子类需要父类的功能，但父类的该功能不完全满足自己的需求时。

方法重写建议加上@Override注解，可以校验重写是否正确，同时可读性好。

【例】定义一个Voice类，再定义一个Voicetext子类，重写方法sendvoice()

Voice.java

package com.test.d11_extends_methodoverride;

public class Voice {
    public void sendvoice(){
        System.out.println("发送语音!@#$%^&*");
    }
}

Voicetext.java

package com.test.d11_extends_methodoverride;

public class Voicetext extends Voice{
    /**
     方法重写了
     */
    @Override
    public void sendvoice(){
        super.sendvoice();
        System.out.println("语言转换为文本OO");
    }
}

执行测试类 VoiceDemo.java

package com.test.d11_extends_methodoverride;

public class VoiceDemo {
    public static void main(String[] args) {
        Voicetext message = new Voicetext();
        message.sendvoice();
    }
}

输出为：

发送语音!@#$%^&*
语言转换为文本OO

方法重写注意事项：
重写方法的名称、形参列表必须与被重写方法的名称和参数列表一致
子类重写父类方法时，访问权限必须大于或者等于父类（缺省 < protected < public）
子类不能重写父类的私有方法、静态方法

子类构造器的特点

子类中所有的构造器默认都会先访问父类中无参的构造器，再执行自己。
子类构造器的第一行语句默认都是：super()，不写也存在。

【例】Shark -> Animal

Animal.java

package com.test.d12_extends_constructor;

public class Animal {
    public Animal(){
        System.out.println("==父类Animal无参数构造器被执行===");
    }
}

Shark.java

package com.test.d12_extends_constructor;

public class Shark extends Animal{
    public Shark(){
        super(); // 默认的，写不写都有，默认就是找父类无参数构造器
        System.out.println("==子类Shark无参数构造器被执行===");
    }

    public Shark(String n){
        super(); // 默认的，写不写都有，默认就是找父类无参数构造器
        System.out.println("==子类Shark"+"/"+n+"/"+"有参数构造器被执行===");
    }
}

执行测试类 Test.java

package com.test.d12_extends_constructor;

public class Test {
    public static void main(String[] args) {
        Shark c = new Shark();
        System.out.println("//");
        Shark c1 = new Shark("BLAHAJ");
    }
}

从输出可以看出子类默认会访问父类的无参构造器

子类构造器访问父类有参构造器

super调用父类有参数构造器的作用 => 初始化继承自父类的数据。

如果父类中没有无参数构造器，只有有参构造器，会报错。因为子类默认是调用父类无参构造器的。如何解决？=>
子类构造器中可以通过书写 super(…)，手动调用父类的有参数构造器

【例】Shark -> Animal 调用父类的有参构造器

Animal.java

package com.test.d13_extends_constructor2;

public class Animal {
    private String name;
    private int age;

    public Animal() {
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

Shark.java

package com.test.d13_extends_constructor2;

public class Shark extends Animal {
    private String oceanName;

    public Shark(){
    }

    public Shark(String name, int age, String oceanName) {
        super(name, age);
        this.oceanName = oceanName;
    }

    public String getOceanName() {
        return oceanName;
    }

    public void setOceansName(String oceanName) {
        this.oceanName = oceanName;
    }
}

执行测试类Test.java

package com.test.d13_extends_constructor2;

public class Test {
    public static void main(String[] args) {
        Shark s = new Shark("鲨鲨", 3, "大西洋");
        System.out.println(s.getName()+s.getAge()+"岁啦~在"+s.getOceanName()+"快乐地游啊游~");
    }
}

输出：鲨鲨3岁啦~在大西洋快乐地游啊游~

this、super的使用

this -> 本类对象的引用
super -> 父类存储空间的标识

【例】Shark如果只给一个参数，使用this()传另一个参数的默认值

Shark.java

package com.test.d14_this;

public class Shark {
    private String name;
    private String oceanName;

    public Shark() {
    }

    public Shark(String name) {
        // 借用兄弟构造器！
        this(name, "北冰洋");
    }


    public Shark(String name, String oceanName) {
        this.name = name;
        this.oceanName = oceanName;
    }

    public String getName() {
        return name;
    }

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

    public String getOceanName() {
        return oceanName;
    }

    public void setOceanName(String oceanName) {
        this.oceanName = oceanName;
    }
}

Test.java

package com.test.d14_this;

public class Test {
    public static void main(String[] args) {
        Shark s1 = new Shark("鲨鲨1号", "太平洋");
        System.out.println(s1.getName()+"来自"+s1.getOceanName());

        Shark s2 = new Shark("鲨鲨2号");
        System.out.println(s2.getName()+"来自"+s2.getOceanName());
    }
}

输出：

鲨鲨1号来自太平洋
鲨鲨2号来自北冰洋