JAVA面向对象高级（二） 继承

JAVA面向对象高级（二） 继承（黑马课程）

---

前言

一、继承

1.什么是继承

2.继承的执行原理

3.继承的好处，应用场景

能够减少代码的重复性，精简代码，将一些公共属性的代码写在一个类中表示父类，子类继承父类，虽然父类中有的变量是私有的，我们可以通过调用它公开的方法来进行使用

二、继承的注意事项

1.权限修饰符

protected修饰的只能在子类中调用，日常开发中常用的是private和public修饰

2.单继承，Object类

object类是众多类的祖宗类

3.方法重写

在进行方法重写时会遵循就近原则，比如本来在A类中定义了某种方法，结果B中也重写了这个方法，那么我在测试类中调用这个方法时，会先调用B中重写的方法。

方法重写的应用场景

方法重写的一个应用场景是toString方法，因为在输出对象时，默认会输出object类中的toString方法，该方法默认输出的是地址，我们可以对该方法进行重写，直接输出值。
另一个重写的例子

在日常开发中，我们也可以通过generate快速对toString方法进行一个重写

总结

3.子类中访问其他成员的特点

（1）就近原则

一般情况下，按照就近原则，输出的是局部名称，但如果要输出子类的成员变量，我们可以借助this这样输出的就是“子类名称”如果想要输出父类的成员变量，就需要借助super.name

4.子类中构造器

子类运行时，会调用父类的无参构造器，因为子类中默认有代码 super()

package advance._extends._constructor;
class F{
    public F(){
        System.out.println("父类的无参数构造器执行了");

    }
    public F(String name){
        System.out.println("父类的有参构造器执行了");
    }
}
class Z extends F{
    public Z(){
        super();
        System.out.println("子类Z的无参数构造器执行了");
    }
    public Z(String name){
       
        System.out.println("子类Z的无参数构造器执行了");
    }
}
public class Test {
    public static void main(String[] args) {
        Z z=new Z();
        Z z2=new Z("halcyon");

    }
}

从运行的代码可以看出子类在运行时会先调用父类的无参构造器，而不是有参构造器。
在父类有参构造器存在的情况下，子类如果想要调用无参构造器需要用super
（好想玩手机，我忍!-_-)


（好想看手机，我忍！）
为什么子类一定要调用父类的呢：

这是因为，我们在创建一个对象时，是借助父类和子类一同创建的，但是在子类中接收父类中定义的参数时，不能直接用this.变量为参数赋值，那么我们就需要super关键字加上参数，来为name,和age赋值。

package advance._extends._constructor;

public class Test2 {
    public static void main(String[] args) {
    Teacher t =new Teacher("Halcyon",22,"java");
        System.out.println(t.getName());
        System.out.println(t.getAge());
        System.out.println(t.getSkill());
    }
}

class Teacher extends People{
    private String skill;
   public Teacher(String name,int age,String skill){
       super(name,age);
       this.skill=skill;
   }
    public String getSkill() {
        return skill;
    }

    public void setSkill(String skill) {
        this.skill = skill;
    }
}
class People{
    private String name;
    private int age;

    public People() {
    }

    public People(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;
    }
}

子类调用父类构造器的实现原理

5.补充知识

this()调用兄弟构造器，可以用来简化代码，比如说，本来是传三个参数，结果我只传两个最后一个学校的信息要是默认的话，如果一个一个赋值，既麻烦又浪费内存，那么我可以创建一个有参构造器，参数为该对象此时有得参数。内部内容用this(,“需要传得默认得值”)
super,和this都需要在第一行，两个不能同时用

package advance._extends._constructor;

public class Test3 {
    public static void main(String[] args) {
        Student s1=new Student("halcyon",22,"NWU");
        //如果没填学校就默认为家里蹲大学
        Student s2=new Student("张三",23);
        System.out.println(s2.getName());
        System.out.println(s2.getAge());
        System.out.println(s2.getSchoolName());

    }
}
class Student{
    private String name;
    private int age;
    private String schoolName;

    public Student() {
    }
    public Student(String name,int age){
        /*this.name=name;
        this.age=age;
        this.schoolName="哈佛大学";*/
        //原来的方法也行，但是有重复代码，为了对其进行精简，我们可以调用下边已经有的
        this( name,age,"哈佛大学");

    }

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

    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;
    }

    public String getSchoolName() {
        return schoolName;
    }

    public void setSchoolName(String schoolName) {
        this.schoolName = schoolName;
    }
}