深入理解OOP——继承

• 提高代码的复用性；
• 类与类之间产生的关系（is a)，这是使用多态性的前提

子类继承父类，使用关键字extends；Java是单继承的，如果没有父类，默认父类Object

• 只能访问public修饰符修饰的方法和属性
• 父类的构造器子类不能继承

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

    public void sayHello(){
        System.out.println(name);
    }
    private void sayAge(){
        System.out.println(age);
    }
}

class Worker extends Person{
    public void hi(){
        name = "jack";//访问从父类中继承过来的属性
        sayHello();//调用从父类中继承过来的方法
        
        age = 20;//编译报错，age是父类中的私有属性，子类中不能访问
        sayAge();//sayAge()是父类中的私有方法，子类中不能访问
    }
}

子类继承父类，创建子类对象的时候，会默认调用父类的构造器：

//定义Person类，作为父类
public class Person{
    public Person(){
    System.out.println("Person类中的构造器被调用");
    }
}
//定义Student类，作为子类
class Student extends Person{
    public Student(){
    System.out.println("Student类中的构造器被调用");
    }
}
public static void main(String[] args){
    Student student = new Student();
}
    //输出以下语句：
    Person类中的构造器被调用
    Student类中的构造器被调用

子类继承父类，会继承父类的属性和方法，那么就需要先调用父类的构造器对父类中的属性进行初始化，初始化后再给子类使用

在类中，除了使用this关键字之外，还有super关键字

在子类中使用super关键字一般做以下事情：

• 访问父类的属性；
• 调用父类的方法；
• 调用父类中的构造器；

//父类
public class Person {
    public String name = "1";
    public void sayHello(){
        System.out.println("hello~ I am "+name);
    }
}
//子类
class Worker extends Person{
    public void hi(){
        System.out.println(super.name);  //输出：1
    }

访问父类的属性

//父类
public class Person {
    public String name = "1";
    public void sayHello(){
        System.out.println("hello~ I am "+name);
    }
}
//子类
class Worker extends Person{
    public void hi(){
          sayHello()//输出：hello~ I am "+name
    }

调用父类的方法

调用父类中的构造器：

子类构造器中隐式调用父类无参构造器，例如

public class Person{
    public Person(){
    }
}
public class Student extends Person{
    public Student(){
    //这里会隐式调用（自动调用）父类的无参构造器
    }
}

子类构造器中显式调用父类有参构造器，例如

public class Person{
    public Person(){
    }
    public Person(String name){
    }
}
public class Student extends Person{
    public Student(){
    //也可以使用super关键字，显示调用父类的构造器（有参的无参的都可以调用）
    super("tom");
    }
}

如果子类和父类中出现了相同的方法，这种情况就叫做方法重写 (Override)。

注意，方法重载是发生在同一个类中，方法重写发生在子父类之间

子类继承父类，继承了父类中的方法，但是父类中的方法并不一定能满足子类中的功能需要，所以子类 中需要把方法进行重写。

父类中哪些方法不能被重写：

• 父类中的静态方法不能被子类重写
• 父类中的私有方法不能被子类重写
• 被final修饰的方法不能被重写

也就是说，只有在子类中，可以直接访问到的,父类的方法,并且是非静态的方法，才能被子类重写

public class Person {
    public static void main(String[] args) {
        Worker worker = new Worker();
        worker.sayHello();
        //由于子类重写了sayHello方法，所以这里将会调用到子类中重写后的sayHello
        //如果子类中没有重写sayHello方法，那么这里将会调用到从父类继承过来的sayHello方法
    }
    
    public String name = "tom";
    public void sayHello(){
        System.out.println("hello~ I am "+name);
    }
}
class Worker extends Person{
    @Override
    public void sayHello() {
        System.out.println("你好 我是"+super.name);
    }
}