JavaSE（七）继承

继承

1.1.继承基本使用

• 继承的使用用来解决 代码冗余问题

• 子类 使用关键字extends 去继承父类（子承父业）；只有通过 IS-A测试 什么什么是一个什么什么时才能使用继承 不能乱用；

• 子类（派生类 后代类）一旦继承父类（基类）之后， 子类自动拥有父类的一切成员（成员变量，方法），但是子类只能访问可访问的；

• 有了继承关系后，构造方法的执行有顺序了，在子类构造方法中 必须要先执行父类的某一个构造方法 ；只是执行父类的构造方法而已 并没有什么父类对象产生；

  • 子类构造方法中 如果没有显示添加有关父类的构造方法的调用 ，编译器默认添加父类无参构造的调用；

• Java只支持单继承，子类只能有一个父类；

• 继承体系中Object类 是所有类型的根基类，所有的类都是Object的子类型；所有类型的对象都能调用Object中的方法

  • 当类型声明后面没有显示添加extends ,编译器默认添加 extends Object

父类 员工类

//父类
public class Employee {
    private int id;
    private String name;
    private char gender;
    private double salary;
​
    public Employee() {
        System.out.println("父类无参构造执行了");
    }
​
    public Employee(int id, String name, char gender, double salary) {
        this.id = id;
        this.name = name;
        this.gender = gender;
        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 char getGender() {
        return gender;
    }
​
    public void setGender(char gender) {
        this.gender = gender;
    }
​
    public double getSalary() {
        return salary;
    }
​
    public void setSalary(double salary) {
        this.salary = salary;
    }
}

子类1 SE

//通过 IS-A测试 什么什么是一个什么什么
// SE是子类 继承 Employee父类；子类自动拥有父类的一切成员
public class SE extends Employee {
    //子类特有的属性
    private int hot;
​
    /*在子类构造方法中 必须要先去执行父类的某一个 构造方法
     ****子类构造方法中 如果没有显示添加有关父类的构造方法的调用 ，编译器默认添加父类无参构造的调用；
     */
    public SE() {
        //调用父类的无参构造方法，只能出现在代码首行
        super();
        System.out.println("子类无参构造执行了");
    }
​
    public SE(int id, String name, char gender, double salary, int hot) {
        super(id, name, gender, salary);
        this.hot = hot;
    }
​
    public int getHot() {
        return hot;
    }
​
    public void setHot(int hot) {
        this.hot = hot;
    }
}

子类2 PM

public class PM extends Employee {
    private String exp;
    private double bonus;
​
    public PM() {
    }
​
    public PM(int id, String name, char gender, double salary, String exp, double bonus) {
        super(id, name, gender, salary);
        this.exp = exp;
        this.bonus = bonus;
    }
​
​
    public String getExp() {
        return exp;
    }
​
    public void setExp(String exp) {
        this.exp = exp;
    }
​
    public double getBonus() {
        return bonus;
    }
​
    public void setBonus(double bonus) {
        this.bonus = bonus;
    }
}

1.2. super关键字

• super 和this类似；this指代当前对象，super指代父类型

• super使用场景

  • 子类构造方法中通过super( ) ；调用父类的构造方法

  • 当子类成员和父类成员（成员变量，方法）重名了，必须使用super区分要访问的是父类成员

父类

public class Father {
    private int age;
    public String name;
​
    public Father() {
    }
​
    public Father(int age, String name) {
        this.age = age;
        this.name = name;
    }
​
    public void read() {
        System.out.println("阅读红楼梦");
    }
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) {
        this.age = age;
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
}

子类

public class Son extends Father {
    private String name;
​
    public Son() {
    }
​
    public Son(int age, String name) {
        super(age, name);
    }
​
    /**
     * Override注解 为了帮助检查是否符合重写的语法
     */
    @Override
    public void read() {
        //子类成员变量和父类成员变量重名了,使用super去区分要访问的是父类成员
        super.read();
        System.out.println("阅读西游记");
    }
​
    public void study() {
        //子类成员变量和父类成员变量重名了,使用super去区分要访问的是父类成员
        System.out.println(super.name + "在学习");
    }
}

1.3.方法的重写

• 子类对继承的方法如果不满意，就重写

• 子类重写的方法和被重写的方法 要有相同的方法声明

• 重写 是发生 继承关系基础下的，一定是有了继承之后 才会有重写

方法重写和方法重载的区别

1. 方法重载 是同一个类体中，方法名相同 形参列表不同

2. 方法重写 有了继承关系后，子类重写父类的方法

1.4.权限修饰符

• 权限修饰符 4个 修饰class，成员变量，方法

• 一般使用public和缺省去修饰class

• 权限 能在哪些地方访问所被修饰的成员

修饰符	本类	同一个包	子类	任意地方
private	Y
缺省（不写 包级权限）	Y	Y
protected	Y	Y	Y
public	Y	Y	Y	Y

父类

package com.edu.www.day0419.exer6;
​
public class Animal {
    private int age;
​
    /**
     * 私有 独有
     */
    public void eat() {
    }
​
    public void run() {
        eat();
    }
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) {
        this.age = age;
    }
}

子类

package com.edu.www.day0419.exer6.exer66;
import com.edu.www.day0419.exer6.Animal;
​
public class Monkey extends Animal {
    public void jump() {
        eat();
    }
}
​

1.5. package和import

• package包机制：为了解决类名冲突的问题； 起名字 公司域名的倒写；必须在源文件的首行

• import 表示引入导入一个类型； 后面是类的全路径（包名+类名）

  • 同一个包下面的类型 不需要引用；如果不在同一个包下面 必须要引入才能使用这个类型

  • 如果是位于java.lang这个包下面的类 都不需要显示import都是自动引入进来的；

//包机制：为了解决类名冲突的问题；
//起名字 公司域名的倒写；必须在源文件的首行
package com.edu.www.day0419.exer6.exer66;
​
// import 表示引入导入一个类型； 后面是类的全路径（包名+类名）
import com.edu.www.day0419.exer6.Animal;
import java.util.Scanner;
//同一个包下面的类型 不需要引用；如果不在同一个包下面 必须要引入才能使用这个类型
//如果是位于java.lang这个包下面的类 都不需要显示import都是自动引入进来的；
public class Test2 {
    public static void main(String[] args) {
        Monkey monkey;
        Animal animal;
        String str;
        Math math;
        Scanner sc;
    }
}