Java 继承（上）

特点：

• 利于代码复用；
• 缩短开发周期；

体现的是：

• 一种类与类之间的关系
• 使用已存在的类（父类\基类）的定义作为基础建立新类（子类\派生类）
• 新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类

两个类要形成继承的关系，不仅仅需要具有相似的属性和方法，还需一定的逻辑意义，即满足“ A is a B”的关系就可以形成继承关系，如猫和狗都是动物，所以猫和狗都可以继承动物类；学生和老师都是人，所以可以继承人类；货车和卡车都是汽车，所以可以继承汽车类；不满足“A is a B”的关系的两个类，是无法形成继承关系。如汽车有名称name 和 出厂日期 age 的属性、猫也有名字 name 和 出生日期 age的属性，虽然它们都有 name 和 age 两个共性，但是它们在逻辑上无法提取出公共的父类，即两者都需满足“A is a B”的关系，所以它们之间无法形成继承关系。

继承的实现 使用 extends 关键字
编写父类:

class Animal {
     //公共的属性和方法
}

编写子类，继承父类：

class Dog extends Animal {
    //子类可以定义与父类重名的属性
    //子类特有的属性和方法
}

class Cat extends Animal {

}

Ps:

• Java 的继承只能是单继承，即只有继承一个父类。类比于一个孩子只能有一个亲爹。
• 子类可以无偿地访问父类的非私有成员；
• 父类不可以访问子类特有成员，即使子类特有成员是公有的。

代码演练

（1）父类：

package com.animal;

public class Animal {
    private String name;//昵称
    private int month;//月份
    private String species;//品种

    public Animal() {

    }

    public String getName() {
        return name;
    }

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

    public int getMonth() {
        return month;
    }

    public void setMonth(int month) {
        this.month = month;
    }

    public String getSpecies() {
        return species;
    }

    public void setSpecies(String species) {
        this.species = species;
    }

    //吃东西
    public void eat(){
        System.out.println(this.getName()+"吃东西");
    }
}

（2）子类

• 猫类：

  package com.animal;
  
  public class Cat extends Animal{
      private double weight;
      public Cat() {
  
      }
  
      public double getWeight() {
          return weight;
      }
  
      public void setWeight(double weight) {
          this.weight = weight;
      }
  
      public void run(){
          System.out.println(this.getName()+"是一种"+this.getSpecies()+"，它在快乐地奔跑");
      }
  }
  

• 狗类

  package com.animal;
  
  public class Dog extends Animal{
      private String sex;
      public Dog() {
  
      }
  
      public String getSex() {
          return sex;
      }
  
      public void setSex(String sex) {
          this.sex = sex;
      }
  
      public void sleep() {
          System.out.println(this.getName()+"现在"+this.getMonth()+"个月大，它在睡觉～～～");
      }
  }
  

（3）测试类

package com.test;

import com.animal.Animal;
import com.animal.Cat;
import com.animal.Dog;

public class Test {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.setName("花花");
        cat.setSpecies("中华田园猫");
        cat.eat();
        cat.run();

        System.out.println("============");

        Dog dog = new Dog();
        dog.setName("妞妞");
        dog.setMonth(1);
        dog.eat();
        dog.sleep();

        System.out.println("==================");
        //父类不可以访问子类特有成员，即使子类特有成员是公有的。
        Animal animal = new Animal();
//        animal.run();
//        animal.sleep();
    }
}

运行结果如下：

花花吃东西

花花是一种中华田园猫，它在快乐地奔跑

============

妞妞吃东西
妞妞现在1个月大，它在睡觉～～～

方法重写

（1）方法重写与方法重载的区别

• 方法重载：
  • 同一个类中；
  • 方法名相同、参数列表不同（参数顺序、个数、类型）；
  • 方法返回值、访问修饰符任意；
  • 与方法的参数名无关
• 方法重写：
  • 有继承关系的子类中；
  • 方法名相同、参数列表相同（参数类型、顺序、个数），方法返回值可以允许是子类类型。
  • 方法的访问修饰符，访问范围 要大于或等于父类的访问范围
  • 方法的参数名无关

（2）示例代码（在上面代码的基础之上新增：子类Dog类重写父类的 eat 方法）：

• 子类 Dog 类：

  package com.animal;
  
  public class Dog extends Animal{
      private String sex;
      public Dog() {
  
      }
  
      public String getSex() {
          return sex;
      }
  
      public void setSex(String sex) {
          this.sex = sex;
      }
  
      public void sleep() {
          System.out.println(this.getName()+"现在"+this.getMonth()+"个月大，它在睡觉～～～");
      }
  
      //子类重写父类吃东西方法
      @Override
      public void eat() {
          System.out.println(this.getName()+"最近没有食欲~~~");
      }
  }
  

• 测试类运行结果如下：

  花花吃东西

  花花是一种中华田园猫，它在快乐地奔跑

  ============

  妞妞最近没有食欲~~~

  妞妞现在1个月大，它在睡觉～～～

  ==================

访问修饰符

• 公有的：public
  • 允许在任意位置进行访问
• 私有的：private
  • 只允许在本类中进行访问
• 受保护的：protected
  • 允许在当前类、同包子类/非子类、跨包子类调用；
  • 跨包非子类不允许
• 默认
  • 允许在当前类、同包子类/非子类
  • 跨包子类/非子类不允许

super 关键字

• 父类对象的引用。
• 允许调用父类允许被子类派生的任意成员（属性或方法）
• 访问父类的构造方法。
  • 子类的构造过程中，必须调用其父类的构造方法；
  • 如果子类的构造方法中没有显式标注，则系统默认调用父类无参的构造方法；
  • 如果子类构造方法中既没有显式标注，且父类中没有无参的构造方法，则编绎出错；
  • 使用 super 调用父类指定构造方法，必须在子类的构造方法的第一行。

继承后的初始化顺序

• 在满足继承条件的情况下，子类对象的初始化顺序：在执行程序的时候，会先完成类的加载
• 在类加载的过程中，会优先加载父类的静态成员；
• 然后加载子类的静态成员；
• 在进行子类实例化的过程中，会先完成父类对象的加载
• 最后才会完成子类对象的加载

Ps：

• 访问修饰符不影响成员加载顺序，跟书写位置有关。
• 子类的带参构造默认调用的是父类的无参构造。
• 在子类的构造方法中，可以通过 super( ) 调用父类的其他构造方法。并且该语句super( ) 必须放在构造方法的第一行。
• 父类的构造不允许被继承、不允许被重写，但是会影响子类的实例化过程。

this 和 super 的区别

• this ：当前对象的引用；super ：父类对象的引用；
• 可以通过 this 调用当前对象允许被访问的属性和方法；通过 super 可以调用父类允许被访问的属性和方法；
• this 和 super关键字都不能在静态方法中使用；
• 在构造方法中使用：this 调用的是同一个类中的构造方法；而 super 调用的是父类的构造方法。
  • super 和 this 在同一个构造方法中不能同时使用。如果在同一个构造方法中使用，编译器会报错，因为它们会同时抢占构造方法第一行的位置。