【JAVA入门】Day09 - 继承

【JAVA入门】Day09 - 继承

---

---

        对象代表什么，就得封装对应的数据，并提供数据对应的行为。
        但是，当几个不同的对象拥有相同的行为时，重复定义这些行为会显得代码非常冗余。以学生类和老师类为例子，学生和老师都会“吃喝拉撒”，这些重复的行为没有必要定义在各自的类中，而是可以抽象为一个笼统的“人”类，在它里面进行定义。

一、继承的定义

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

public class Student extends Person {}

         Student 称为子类（派生类），Person 称为父类（基类或超类）。
        使用继承有诸多好处：

• 使用继承可以把多个子类中重复的代码抽取父类中，提高了代码的复用性。
• 子类可以在父类的基础上，增加其他的功能，使得子类更强大。
           什么时候用继承：
           当类与类之间，存在相同（共性）的内容，并满足子类是父类中的一种，就可以考虑使用继承来优化代码。

二、继承的特点

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

• 只支持单继承：一个子类只能继承一个父类。
• 不支持多继承：子类不能同时继承多个父类。
• 支持多层继承：子类 A 继承父类 B，父类 B 可以继承父类 C。子类 A 直接继承于父类 B，间接继承于父类 C。

         其中，多层继承是有一个源头的：每一个类都直接或间接继承于一个叫 Object 的父类。

【例】多层继承。

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

public class Cat extends Animal {
	public void catchMouse() {
		System.out.println("猫在抓老鼠");
	}
}
public class Dog extends Animal {
	public void lookHome() {
		System.out.println("狗在看家");
	}
}

public class Ragdoll extends Cat {
}

public class LiHua extends Cat {
}

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

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

public class Test {
	public static void main(String[] args) {
		//创建对象并调用方法
	
		//1.创建布偶猫的对象
		Ragdoll rd = new Ragdoll();
		rd.eat();
		rd.drink();
		rd.catchMouse();

		//2.创建哈士奇的对象
		Husky hsk = new Husky();
		hsk.eat();
		hsk.drink();
		hsk.breakHome();
	}
}

• 还有一个非常重要的点：如果你的类中有 private 修饰的成员，那么其子类便无法访问了。所谓私有，是指只能在本类中访问。

三、继承的内容分析

         子类到底能继承父类中的哪些内容？我们需要结合内存来进行分析。

• 首先父类的构造方法，子类一定不能继承，子类有它自己的构造方法。
• 成员变量，父类拥有的成员变量，子类也可以继承下来，但是虽然继承了，但是如果父类拥有的成员变量是 private 修饰的私有成员，是无法访问的。
• 成员方法，父类拥有的成员方法。如果，成员方法是非私有的，那么子类就可以继承下来并且访问；但是，一旦成员方法用 private 修饰，即私有，那么子类是不能继承该方法的。

3.1 构造方法是否可以被继承

         构造方法是不可以被子类继承的。

3.2 成员变量是否可以被继承

         不论父类中的成员变量是私有的还是非私有的，子类都可以把它们继承下来。
         但是，父类中的私有成员变量在子类中，无法被直接调用。如果想要访问这些变量，可以在父类中写下相应的 public 的 get 和 set 函数，继承到子类中调用之。

3.3 成员方法是否可以被继承

         成员方法是否能被继承，关键看其是否能被添加进虚方法表中。如果父类的一个成员方法是 private 的，那他就不能添加进虚方法表，就不可以被子类继承；如果这个成员方法是非私有的，就可以添加进虚方法表，就可以被子类继承。
         所谓虚方法表，其实就是父类将自己可以被继承的方法写进表中，然后将表交给子类，子类根据这个表进行自己的实例化（这个其实是多态的内容，后面会着重讲）。

四、继承中成员的访问特点

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

public class Fu {
	String name = "Fu";
}
public class Zi extends Fu {
	String name = "Zi";
	public void ziShow() {
		System.out.println(name);  //Zi
	}
}

         继承中对成员变量的访问，采用的是就近原则。上面的代码中，父类中的 name 值为 “Fu”，它被子类继承，而子类中也定义了一个 name 变量，值为 “Zi”，此时根据就近原则，sout 输出的内容是 “Zi”。
         在寻找变量时，JVM 会根据就近原则，从近往远处找，直到找到第一个同名变量为止。

public class Fu {
	String name = "Fu";
}
public class Zi extends Fu {
	public void ziShow() {
		System.out.println(name);  //Fu
	}
}

         如何规避这个同名变量的问题？我们可以采用 this 和 super 关键字的方法。

public class Fu {
	String name = "Fu";
}
public class Zi extends Fu {
	String name = "Zi";
	public void ziShow() {
		String name = "ziShow";
		System.out.println(name);	//ziShow
		System.out.println(this.name);	//Zi
		System.out.println(super.name);	//Fu
	}
}

         上面的代码中，name 指的就是 ziShow() 中的局部变量 name；this.name 指的是当前类（Zi）中的成员变量 name；super.name 指的是当前类的父类（Fu）中的成员变量 name。
         继承中成员变量会根据这些关键字，从不同位置开始往上找，什么都不加，就是从局部位置往上找；加 this，就是从本类成员位置开始往上找；加 super，就是从父类成员位置开始往上找。

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

         成员方法的直接调用也遵循一个就近原则，谁离我近，我就用谁。想要直接访问父类的方法，也可以使用 super 关键字。
         下面的代码中，我们写了一个 Person 类和一个 Student 类，用 Student 类继承 Person 类，并用一个 Test 测试类来测试（注意看：只有 Test 类用 public 修饰了，这是因为它是程序的入口，main 方法的所在，文件的名称也必须和它相同，一个 .java 文件中只能有一个 public 修饰的 class）。

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();
		drink();
	}
}

        根据就近原则，这里的 eat() 和 drink() 都会优先从本类中找，但是本类中没有这两个方法，于是又去父类中找，在父类中找到这两个方法，所以调用之。
        如果将代码改成如下所示：

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(){
		//现在本类中找，结果没找到，还去父类找
		this.eat();
		this.drink();

		//直接在父类中找
		super.eat();
		super.drink();
	}
}

        这样写也是一样的，最终还是会去父类中调这两个方法。
        如果子类中也有两个同名方法，还是参考就近原则，输出情况如下：

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 eat() {
		System.out.println("吃意大利面");
	}

	public void drink() {
		System.out.println("喝红茶");
	}
	public void lunch(){
		//直接在本类中找，找到了，因此直接用
		eat();		//吃意大利面
		drink();	//喝红茶

		//直接在父类中找，找到了，用的是父类的
		super.eat();	//吃饭
		super.drink();	//喝水
	}
}

4.3 方法的重写

        刚才这种在子类中写同名方法覆盖父类方法的方式，叫做方法的重写。当父类的方法不能满足子类现在的需求时，需要进行方法重写。
        在继承体系中，子类出现了和父类中一模一样的方法声明，我们就称子类这个方法是重写的方法。
        在重写后的方法上方，我们还需要一个重写注解——@Override。

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

        方法的重写过程发生在继承时：父类将自己内部非private、非static、非final的方法填入一个虚方法表中交给子类继承，然后子类会在父类的基础上再添加自己类中的虚方法，如果此时存在重写，则会覆盖父类中同名的虚方法。因此，方法重写的本质是——覆盖虚方法表。

        方法重写有以下注意事项和要求：

• 重写方法的名称、形参列表必须与父类中的一致。
• 子类重写父类方法时，访问权限子类必须大于等于父类（空着不写 < protected < public）。
• 子类重写父类方法时，返回值类型子类必须小于等于父类。
• 建议：重写的方法尽量和父类保持一致。
• 私有方法不能被重写（虚方法表中根本没有私有方法）。
• 子类也不能重写父类的静态方法（因为根本没有继承下来）。
• 只有被添加到虚方法表中的方法才能被重写。

public class Test {
	public static void main(String[] args) {
		Husky hsk = new Husky();
		hsk.eat();
		hsk.drink();
		hsk.breakHome();
		SharPei sp = new SharPei();
		sp.eat();
		sp.drink();
		sp.lookHome();
		ChineseDog cd = new ChineseDog();
		cd.eat();
		cd.drink();
		cd.lookHome();
	}
}

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

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

class SharPei extends Dog {
	@Override
	public void eat() {
		super.eat();	//调用父类中的方法，输出“吃狗粮”
		System.out.println("吃骨头");
	}
}

class ChineseDog extends Dog {
	@Override
	public void eat() {
		System.out.println("吃剩饭");
	}
}

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

        父类中的构造方法不会被子类继承。
        子类当中的所有构造方法都会默认先访问父类中的无参构造，再执行自己。这是因为父类中的成员变量要继承到子类，子类在初始化时，有可能会使用到父类中的数据，如果父类没有完成初始化，子类就无法使用父类中的数据。
        因此，子类在初始化之前，一定要调用父类的构造方法先完成父类数据空间的初始化。
        事实上，子类构造方法的第一行语句默认是：super()，即使你不写它也存在且缺省，且必须在第一行。

public class Fu {
	String name;
	int age;
	public Fu() {}
	public Fu(String name, int age) {
		this.name = name;
		this.age = age;
	}
}

public class Zi extends Fu {
	//super();
	public Zi() { }
}

        因此，我们如果想直接给子类继承的父类成员变量进行初始化，可以利用 super() 方法，直接调用父类的有参构造方法，在父类中完成这些成员变量的初始化。

public class Person {
    String name;
    int age;
    public Person() {
        System.out.println("父类的无参构造");
    }

    public Person(String name, int age) {
        System.out.println("父类的有参构造");
        this.name = name;
        this.age = age;
    }
}

public class Student extends Person {
    public Student() {
        super();
        System.out.println("子类的无参构造");
    }
    public Student(String name, int age) {
        super(name, age);  //调用父类的有参构造初始化成员变量
    }
}

public class Test {
    public static void main(String[] args) {
        Student s = new Student("zhangsan", 23);
        System.out.println(s.name + ", " + s.age);
    }
}

4.5 this、super 的使用总结

• this：理解为一个变量，表示当前方法调用者的地址值。this 在内存中存储的形式本质就是一个局部变量，其值为当前方法调用者的地址的值。
• super：代表父类的存储空间。
• this 和 super 主要有以下几种用途：

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

        其中，this 调用的是本类的，super 调用的是父类的。
        利用 this 调用本类构造方法，可以起到给一些数据默认值的特效。

public class Student {
	String name;
	int age;
	String school;
	public Student() {
		this(null, 0, "实验一小");
	}

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

        如上代码所示，如果直接使用无参构造的方法生成对象 Student s = new Student()，就会直接再次调用本类的有参构造，从而实现默认姓名为 null，默认年龄为0，默认学校为“实验一小”的效果。

【练习】带有继承结构的标准 Javabean 类。
1.经理
成员变量：工号，姓名，工资，管理奖金。
成员方法：工作（管理其他人），吃饭（米饭）。
2.厨师
成员变量：工号，姓名，工资
成员方法：工作（炒菜），吃饭（米饭）。

public class Employee {
	private String id;
	private String name;
	private double salary;

	public Employee() {
	}

	public Employee(String id,String name,double salary) {
		this.id = id;
		this.name = name;
		this.salary = salary;
	}
	
	public void setId(String id) {
		this.id = id;
	}
	
	public String getId() {
		return id;
	}

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

	public String getName() {
		return name;
	}

	public void setSalary(double salary) {
		this.salary = salary;
	}

	public double getSalary() {
		return salary;
	}

	//工作
	public void work() {
		System.out.println("员工在工作");
	}

	//吃饭
	public void eat() {
		System.out.println("员工在吃米饭");
	}
}

public class Manager extends Employee {
	private double bonus;

	public Manager() {}

	public Manager(String id, String name, double salary, double bonus) {
		super(id, name, salary);
		this.bonus = bonus;
	}

	public void setBonus(double bonus) {
		this.bonus = bonus;
	}
	
	public double getBonus() {
		return bonus;
	}

	@Override
	public void work() {
		System.out.println("经理在管理其他人");
	}

}

public class Cook extends Employee {
    public Cook() {
    }

    public Cook(String 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("111", "张三", 8000, 3000);
        System.out.println(m.getId() + ", " + m.getName() + "," +
                 m.getSalary() + ", " + m.getBonus());
        m.work();
        m.eat();

        Cook c = new Cook();
        c.setId("222");
        c.setName("王五");
        c.setSalary(8000);
        System.out.println(c.getId() + ", " + c.getName() + ", " + c.getSalary());
        c.work();
        c.eat();
    }
}