Java面向对象之三大特性—继承（从0到1 详解，附有代码案列）

十二.继承

12.1 继承概述

• java中提供一个关键字extends，用这个关键字，可以让一个类和另外一个类建立起继承关系。

• 继承是Java中实现代码重用的重要手段之一，Java中只支持单根继承，即一个类只能有一个直接父类。

• 继承的格式：

  public class 子类 extends 父类{ }
  public class Student extends Person{}
  Student 称为子类（派生类），Person称为父类（基类或超类）
    
   子类可以得到父类的属性和行为，子类可以使用
   子类可以在父类的基础上新增其他功能，子类更强强大
  

使用继承好处：

• 可以把多个子类中的重复代码抽取到父类中，提高代码复用性；
• 子类可以在父类的基础上，增加其他功能，使子类更强大。

当类与类之间，存在相同(共性)的内容，并满足子类是父类中的一种，就可以考虑考虑使用继承，来优化代码

12.2 继承的特点

• java只支持单继承，不支持多继承，但支持多层继承。

  单继承：一个子类只能继承一个父类。

  不支持多继承：子类不能同时继承多个父类。

  多层继承：子类A继承父类B，父类B可以继承父类C（孙-儿-爷）

• Java中所有的类都直接或间接的继承于Object

• 子类只能访问父类中非私有的成员

• 权限修饰private：子类无法访问

单根继承

• 子类可以调用父类的属性和方法
• 父类调用不到子类独有的属性和方法
• 子类构造方法默认调用父类无参构造（第一行默认调用）

12.2.1 Test

现有四种动物：布偶猫、中国狸花猫、哈士奇、泰迪

暂时不考虑属性，只考虑行为，请按照继承思想特点进行继承体系设计。

四种动物的行为：

• 布偶猫：吃饭、喝水，抓老鼠

• 中国狸花猫：吃饭、喝水、抓老鼠

• 哈士奇：吃饭、喝水、看家、拆家

• 泰迪；吃饭、喝水、看家、蹭一蹭

//父类Animal

//Animal
public class Animal {
    public void eat(){
        System.out.println("吃饭ing...");
    }
    public void drink(){
        System.out.println("喝水ing...");
    }
}

子类Cat，继承父类Animal

public class Cat extends Animal{
    public void catchMouse(){
        System.out.println("抓老鼠...");
    }
}

子类Dog，继承父类Animal

public class Dog extends Animal {
    public void lookHome(){
        System.out.println("看家...");
    }
}

子类Husky（哈士奇），继承父类Animal

public class Husky extends Dog{
    public void breakHome(){
        System.out.println("拆家...");
    }
}

子类LiHua（狸花猫），继承父类Animal

public class LiHua extends Cat{}

子类Ragdoll（布偶猫），继承父类Animal

public class Ragdoll extends Cat {}

子类Teddy（泰迪），继承父类Animal

public class Teddy extends Dog{
    public void touch(){
        System.out.println("蹭一蹭...");
    }
}

测试类

public class Test {
    public static void main(String[] args) {
        // 创建对象并调用方法

        // 创建布偶猫对象
        Ragdoll ragdoll = new Ragdoll();
        ragdoll.catchMouse();
        ragdoll.eat();
        System.out.println("-----------------------------");
        // 创建狸花猫对象
        LiHua liHua = new LiHua();
        liHua.catchMouse();
        liHua.eat();
        liHua.drink();
        System.out.println("-----------------------------");
      // 创建哈士奇对象
        Husky husky = new Husky();
        husky.eat();
        husky.drink();
        husky.breakHome();
        husky.lookHome();
        System.out.println("--------------------------");
      // 创建泰迪对象
        Teddy teddy = new Teddy();
        teddy.lookHome();
        teddy.drink();
        teddy.eat();
        teddy.touch();
    }
}

12.3 子类的继承

子类能继承父类中的哪些内容？

父类中有	子类能否继承
构造方法	非私有—>不能		private—>不能
成员变量	非私有—>能		private—>能,但是子类不能直接用
成员方法	非私有(虚方法表)—>能		private—>不能

• 父类的构造方法子类不能继承

  假如子类继承了父类的构造方法，则违反了构造方法的命名规则。

• 父类的成员变量子类能继承，但是如果子类继承的是父类私有成员变量时子类不能直接使用

• 如果父类的成员的方法能添加到虚方法表中，则子类能继承

子类继承父类的什么？

• 继承public和protected修饰的属性和方法，不管子类和父类是否在同一个包里
• 继承默认权限修饰符修饰的属性和方法，但子类和父类必须在同一个包里

12.4 继承内存图

在方法区中，当加载完子类的字节码文件时，父类的字节码文件也进行加载

• 子类继承父类的非私有成员变量，当创建对象z时会在堆中开辟一块空间，这个空间里分两块内容，一块存储子类的成员变量，另一块存储继承父类的成员变量；当对象z访问成员变量时先从子类中开始访问，依次是父类中的，如下图：

• 子类继承父类的私有成员变量

  当父类的私有变量被子类继承时，通过子类的对象直接给父类的私有成员变量赋值会报错，所以子类继承的是父类私有成员变量时不能直接使用

• 父类的成员方法不能被子类继承

  在成员方法中，只有父类中的虚方法才能被子类继承

  虚方法：非private、 非static 、 非final

12.5 继承中 特性

12.5.1 继承中：成员变量的访问特点

• 就近原则：谁离我近，我就用谁

• 先局部位置找在,再本类(子类)成员位置找,最后父类成员位置找，逐级往上。

• this:直接在本类(子类)成员位置开始往上找

• super:直接从父类成员位置往上找

public class Fu {
		String name = "Fu";
}

public class  zi extends Fu{
    String name = "zi";
    public void ziShow(){
        String name = "ziShow";
     
//name先匹配ziShow()方法里的name,再匹配naem="zi",最后匹配name="Fu";
        System.out.println(name);
    }

}

如果出现成员变量重名，如下代码所示：

• ​ name:从局部位置开始往上找

• ​ this.name:直接在本类成员位置开始往上找

• ​ super.name:从父类成员位置往上找

  System.out.println(name);//ziShow;从局部位置开始往上找
  System.out.println(this.name);//Zi;直接在本类的成员变量里找
  System.out.println(super.name);//Fu 直接在父类成员位置中找

public class Test {
    public static void main(String[] args) {
        Zi zi  = new Zi();
        zi.ziShow();// ziShow   Zi    Fu
    }
}
// 父类
class Fu{
    String name = "Fu";
}
// 子类 ，子类并继承父类
class Zi extends  Fu{
  String name = "Zi";
  public void ziShow(){
     String name = "ziShow";
     System.out.println(name);//ziShow
    //name:从局部位置开始往上找
    //this.name:直接在本来成员位置开始往上找
    //super.name:从父类成员位置往上找
     System.out.println(this.name);//Zi;直接在本类的成员变量里找
     System.out.println(super.name);//Fu 直接在父类中找
    }
}

public class Test {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show();
    }
}
class Fu {
    String name = "Fu";
    String hobby = "喝茶";
}
class Zi extends Fu {
    String name = "Zi";
    String game = "吃鸡";
}
public void show() {
    //如何打印Zi
    //System.out.println(name);//Zi
    //System.out.println(this.name);//Zi
    //如何打印Fu
    //System.out.println(super.name);//Fu
    //如何打印喝茶
    //System.out.println(hobby);//喝茶
    //System.out.println(this.hobby);//喝茶
    //System.out.println(super.hobby);//喝茶
    //如何打印吃鸡
    System.out.println(game);
    System.out.println(this.game);
}

12.5.2继承中：成员方法的访问特点

• 就近原则：

• super调用，直接访问父类

• this调用，直接在本类（子类）中找

public class Test {
    public static void main(String[] args) {
        Student s = new Student();
        s.lunch();//吃米饭... 喝开水...  吃米饭...
    }
}
//父类
class Person{
    public void eat(){
        System.out.println("吃米饭...");
    }
    public void drink(){
        System.out.println("喝开水...");
    }
}
//子类，子类并继承父类
class Student extends Person{
    public void lunch(){
        //eat(); 相当于this.eat();
        //drink();相当于this.drink();
        //方法的直接调用有个隐藏的this
        //先在本类中查看eat()/drink()方法，如果有就会调用；没有则调用从父类中继承下来的
        this.eat();
        drink();
        // 直接从父类中调用
        super.eat();
    }
}

12.5.3继承中：构造方法的访问特点

• 子类不能继承父类的构造方法，但可以通过super调用

• 子类中所有的构造方法默认先访问父类中的无参构造,再执行自己

  ​ 子类在初始化时,可能会用到父类中的数据，如果父类没有完成初始化，子类将无法使用父类的数据。

  ​ 子类初始化之前，一定要调用父类构造方法先完成父类数据空间的初始化。

子类怎么调用父类构造方法？

• 子类构造方法的第一行语句默认是:super( ),不写也存在，且必须是在第一行，用来调用父类的无参构造。
• 如果想调用父类的有参构造给成员变量进行赋值，必须手动写 super (x x)进行调用并赋值。

继承条件下的构造方法：

• 子类构造方法没有通过super显式调用父类的有参构造方法，也没通过this显式调用自身其他构造方法，系统会默认调用父类的无参构造方法

• 子类构造方法通过super显式调用父类的有参构造方法

  执行父类相应构造方法，而不执行父类无参构造方法

• 子类构造方法通过this显式调用自身的其他构造方法，在相应构造方法中应用以上两条规则

用代码理解，实列1：

//父类
public class Person {
    String name;
    int age;
    public Person(){
        System.out.println("父类的无参构造...");
    }
    public Person(String name,int age){
        this.name = name;
        this.age = age;
        System.out.println("父类有参构造...");
    }
}
==================================================
  //子类
public class Student extends Person{
    public Student (){
        super();//不写也有；访问父类的无参构造
        System.out.println("子类的无参构造...");
    }
    public Student(String name ,int age){
      //调用父类有参构造，进行赋值
        super(name,age);
        System.out.println("子类有参构造...");
    }
}
============================================
  public class Test {
    public static void main(String[] args) {
       Student stu = new Student();
        // 输出：父类的无参构造...   
				//      子类的无参构造...

        Student stu = new Student("孔",18);
        System.out.println(student1.name+","+student1.age);
        //输出：父类有参构造...
        //     子类有参构造...
        //     孔,18
    }
}

用代码理解实列2：

//父类
public class Person {
    String name;
    int age;
    public Person(){
        System.out.println("父类的无参构造...");
    }
    public Person(String name,int age){
        this.name = name;
        this.age = age;
        System.out.println("父类有参构造...");
    }
}
==================================================
  //子类
public class Student extends Person{
    public Student (){
        super();//不写也有；访问父类的无参构造
        System.out.println("子类的无参构造...");
    }
    public Student(String name ,int age){
        //调用父类有参构造，进行赋值
        //super(name,age);
       super();//此行访问父类的无参构造
      //此处不写super,将会调用父类的空参构造，然后再执行自己
      System.out.println("子类有参构造...");
    }
}
================================
  public class Test02 {
    public static void main(String[] args) {
       Student stu = new Student();
        // 输出：父类的无参构造...   
				//      子类的无参构造...

        Student stu = new Student("孔",18);
        System.out.println(student1.name+","+student1.age);
        //输出：父类无参构造...
        //     子类有参构造...
        //     null,0
    }
}

12.5.4 this/super 使用总结

super关键字

• super不能访问父类的private成员

• 构造方法：super()必须在子类构造方法的第一行

• 调用属性：super.属性名，子类调用父类属性（属性不能是private）

• 调用方法：super.方法名(),子类调用父类的方法（方法不能是private）

通俗的讲：

• this:理解为一个变量，表示当前方法调用者的地址值

• super:代表父类存储空间

关键字	访问成员变量	访问成员方法	访问构造方法
this	this.成员变量；	this.成员方法(…)	this(…)
	访问本类成员变量	访问本类成员方法	访问本类构造方法
super	super.成员变量	super.成员方法(…)	super(…)
	访问父类成员变量	访问父类成员方法	访问父类构造方法

this.成员方法(…)/super.成员方法(…):

//父类Person
public class Person {
    public void talk(){
        System.out.println("talking");
    }
}
=============================================
//子类
public class User extends Person {
    public void eat(){
        super.talk();//访问父类的成员方法
        System.out.println("eating。。。");
        drink("你好");// 相当于this.drink，调用本类的成员方法
    }
    public String drink(String a){
        System.out.println("user喝水");
        System.out.println(a);
        return a;
    }
}
========================================================
  public class UserTest {
    public static void main(String[] args) {
        User user = new User();
        user.eat();//talking eating。。。 user喝水  你好
    }
}

this(x x)/super(…)访问构造方法：

public class Student {
    String name;
    String school;
    public Student(){
        // 调用本类其他构造方法
      // 给school设置默认值
        this(null,"清华大学");//此处调用了本类的有参构造
    }
    public Student(String name,String school){
        this.name = name;
        this.school =school;
    }
}
=====================================================
  public class StudentTest {
    public static void main(String[] args) {
        Student stu = new Student();
        System.out.println(stu.school);//清华大学
    }
}

12.5.5 Test

带有继承结构的标准JavaBean类

1. 经理

   成员变量：工号、姓名、工资、管理奖金

   成员方法：工作（管理其他人）、吃饭（吃米饭）

2. 厨师

   成员变量：工号、姓名、工资

   成员方法：工作（炒菜）、吃饭（吃米饭）

//父类Employee
public class Employee {
    private int id;
    private String name;
    private double salary;//工资

    public Employee() {}
    public Employee(int id, String name, double salary) {
        this.id = id;
        this.name = name;
        this.salary = salary;
    }

    public int getId() {return id;}
    public void setId(int id) { this.id = id;}

    public String getName() { return name; }
    public void setName(String name) { this.name = name;}
  
    public double getSalary() {return salary;}
    public void setSalary(double salary) {this.salary =salary;}
  
    public void work(){
        System.out.println("员工正在工作ing...");
    }
    public void eat(){
        System.out.println("吃米饭");
    }
}
===========================================
//子类Manager
public class Manager extends Employee{
    //管理奖金
    private double bouns;
  
    public Manager() { }
    //带全部参数的构造，父类+子类
    public Manager(int id, String name, double salary, double bouns) {
        super(id, name, salary);
        this.bouns = bouns;
    }

    public double getBouns() { return bouns;}
    public void setBouns(double bouns) {this.bouns = bouns;}
    
    @Override
    public void work() {
        System.out.println("管理其他人...");
    }
}
===========================================
//子类Cooker
  public class Cooker extends Employee{
    public Cooker() {}
    public Cooker(int id, String name, double salary) {
        super(id, name, salary);
    }
    
    @Override
    public void work() {
        System.out.println("炒菜");
    }
}

// 测试类
public class Test {
    public static void main(String[] args) {
        // 创建对象并赋值,调用有参构造
        Manager m = new Manager(1,"孔",15000,5000);
        m.work();
        m.eat();
        System.out.println(m.getId()+","+m.getName()+
                ","+m.getSalary()+","+m.getBouns());
      //管理其他人...
     //吃米饭
     //1,孔,15000.0,5000.0

        System.out.println("===========");
        //调用无参构造
        Cooker c = new Cooker();
        c.setId(2);
        c.setName("大聪明");
        c.setSalary(1000);
        c.work();
        c.eat();
        System.out.println(m.getId()+","+m.getName()+
                ","+m.getSalary()+","+m.getBouns());
//炒菜
//吃米饭
//2,大聪明,1000.0
    }
}

12.6 方法重写

12.6.0认识方法重写

• 概述：当父类的方法不能满足子类现在的需求时，需要进行方法重写

• 书写格式说明：在继承体系中，子类出现了和父类一摸一样的方法声明，则称子类的这个方法是重写的方法。

• 构造方法不能够被重写

@Override重写注解

• @Override放在重写后的方法上，校验子类重写时语法是否正确
• 加上注解后如有红色波浪线，表示语法错误。

public class Test {
    public static void main(String[] args) {
       OverStudent s = new OverStudent();
        s.lunch();
    }
}
//父类Person
class Person{
    public void eat(){
        System.out.println("吃米饭...");
    }
    public void drink(){
        System.out.println("喝开水...");
    }
}
//子类OverStudent，子类继承了父类
class OverStudent extends Person{
    public void lunch(){
        this.eat();//吃意大利面
        this.drink();//喝凉水
        super.eat();//吃米饭
        super.drink();//喝开水
    }
    @Override
    //方法重写
    public void eat(){
        System.out.println("吃意大利面");
    }
    @Override
    //方法重写
    public void drink(){
        System.out.println("喝凉水");
    }

}

12.6.1 方法重写本质

子类覆盖了从父类当中继承下来虚方法表里的方法。换句话说，如果方法加载不进去虚方法表中则重写不了。

12.6.2方法重写注意事项

1. 在子类与父类之间
2. 方法名相同
3. 参数个数和类型相同
4. 返回值类型相同或是其子类
5. 访问修饰符不能严于父类

12.6.3 Test

按照继承体系设计

哈士奇：吃饭(吃狗粮) 喝水、看家、拆家

沙皮狗：吃饭(吃狗粮、吃骨头) 喝水、看家

田园犬：吃饭(吃剩饭) 喝水、看家

//父类Dog
public class Dog {
    public void eat(){
        System.out.println("吃饭狗粮...");
    }
    public void drink(){
        System.out.println("喝水ing...");
    }
    public void lookHome(){
        System.out.println("看家...");
    }
}

//子类ChinessDog
public class ChinessDog extends Dog{
    @Override
    public void eat(){
        System.out.println("吃剩饭...");
    }
}
===============================================
//子类Husky
public class Husky extends Dog{
    public void breakHome(){
        System.out.println("拆家...");
    }
}
============================================
//子类SharPei
public class SharPei extends Dog{
    @Override
    public void eat(){
        super.eat();//吃狗粮
        System.out.println("吃骨头...");
    }
}

//测试类DogTest
public class DogTest {
    public static void main(String[] args) {
        Husky husky = new Husky();
        husky.breakHome();
        husky.eat();//吃饭狗粮...
        husky.drink();
        System.out.println("===========");
        SharPei sharPei = new SharPei();
        sharPei.eat();//吃饭狗粮...吃骨头...
        sharPei.lookHome();//看家...
        sharPei.drink();//喝水ing...
        System.out.println("===============");
        ChinessDog chinessDog = new ChinessDog();
        chinessDog.eat();//吃剩饭...
        chinessDog.drink();//喝水ing...
        chinessDog.lookHome();//看家...
    }
}

12.7 Object

object类是超类（基类）

Java中所有的类都直接或者间接继承Object

重写equals方法