Java中的继承

1、继承概述

继承的格式：

1. 格式：public class 子类名 extends 父类名
2. 范例：public class Zi extends Fu
3. Fu：父类、基类、超类
4. Zi：子类、派生类

public class Fu {
	public void show() {
		System.out.println("show方法被调用");
	}
}

public class Zi extends Fu{
	public void method() {
		System.out.println("method被调用");
	}
}

public class Demo {
	public static void main(String[] args) {
		Fu f = new Fu();
		f.show();
		Zi z =new Zi();
		z.method();
		z.show();
	}
}

2、继承的好处和弊端

• 好处：
• 提高了代码的复用性（多个类相同的成员可以放到同一个类中）
• 提高了代码的维护性（如果方法的代码需要修改，修改一处即可）
• 弊端：
• 继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时，子类实现也不得不跟着变化，削弱了子类的独立性

3、什么时候使用继承？

• 继承体现关系：is xxx，包含关系
• 假设法：我有两个类A和B，如果他们满足A是B的一种，或者B是A的一种，就说明他们存在继承关系，这个时候就可以使用继承来体现，否则就不能滥用继承
• 举例：苹果和水果、猫和动物、猫和狗（x）

4、继承中变量访问的特点

在子类方法中访问一个变量时：（就近原则）

1. 先在子类局部范围内找
2. 在子类成员范围内找
3. 在父类成员范围内找

public class Fu {
	public int age = 20;
	}

public class Zi extends Fu{
	public int height = 163;
	
	public void show() {
		System.out.println(age);//Zi类中没有，但是继承了父类的
		System.out.println(height);//Zi类中有，就会使用子类中的不会去使用父类的
	}
}

输出结果：
20
163

public class Demo {
	public static void main(String[] args) {
		Zi z =new Zi();
		z.show();
	}
}

5、super关键字

回顾this关键字：在方法中使用this关键字代表使用的是成员变量this，不是局部变量this。

public class Zi extends Fu{
	public int height = 163;
	
	public void show() {
		int height = 199;
		System.out.println(age);//Zi类中没有，但是继承了父类的
		System.out.println(this.height);//这里使用了this关键字，则待变使用的是类中的成员变量height而不是方法中的局部变量height
	}
}

输出结果：
20
163

super关键字：（用法与this相似）
->在方法中使用了super关键字则代表使用的是父类中的成员变量
this：代表本类对象的引用
super：代表父类存储空间的表示->父类对象的引用

关键字	访问成员变量
this	this.成员变量，访问本类成员变量
super	super.成员变量，访问父类成员变量

public class Fu {
	public int age = 20;
	public int height = 170;
	}

public class Zi extends Fu{
	public int height = 163;
	
	public void show() {
		int height = 199;
		System.out.println(age);//Zi类中没有，但是继承了父类的
		System.out.println(this.height);//this代表使用子类中成员变量
		System.out.println(super.height);//super代表使用父类中成员变量
	}
}

public class Demo {
	public static void main(String[] args) {
		Zi z =new Zi();
		z.show();
	}
}

输出结果：
20
163
170

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

子类中所有的构造方法默认都会访问父类中的无参构造方法
为什么？

• 因为子类会继承父类中的数据，可能还会使用父类的数据。所以，子类在初始化之前，一定要先完成父类数据的初始化
• 每一个子类构造方法的第一条语句默认都是super()
• 如果父类中没有无参构造方法时，子类中需要使用super去显式调用有参构造。->一般直接给父类加个无参构造方法

public class Fu {
	
	public Fu() {
		System.out.println("父类中无参构造方法被调用");
	}
	public Fu(int age) {
		System.out.println("父类中有参构造方法被调用");
	}
}

public class Zi extends Fu{
	public Zi() {
		//super(); //super可不写，默认就会去调用父类的无参构造。
		//如果父类中没有无参构造方法时，子类中需要使用super去显式调用有参构造。
		System.out.println("子类中无参构造方法被调用");
	}
	public Zi(int age) {
		//super(); //super可不写，默认就会去调用父类的无参构造
		//如果父类中没有无参构造方法时，子类中需要使用super去显式调用有参构造。
		System.out.println("子类中有参构造方法被调用");
	}
}

public class Demo {
	public static void main(String[] args) {
		Zi z = new Zi();//默认先去访问父类的父类的无参构造方法
		Zi z2 =new Zi(20);//默认先去访问父类的父类的无参构造方法
	}
}

输出结果：
父类中无参构造方法被调用
子类中无参构造方法被调用
父类中无参构造方法被调用
子类中有参构造方法被调用

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

通过子类对象访问一个方法的时：

1. 先在子类成员范围内查找
2. 再在父类成员范围内查找
3. 如果找不到就报错

public class Fu {
	
	public void method() {
		System.out.println("Fu中的method方法被调用");
	}
}

public class Zi extends Fu{
	public void method() {
		super.method();//这里注释的话，不会访问父类的method方法
		System.out.println("Zi中的method方法被调用");
	}
}

public class Demo {
	public static void main(String[] args) {
		Zi z = new Zi();
		z.method();
	}
}

8、super内存图

9、方法重写

方法重写概述：

• 子类中出现了和父类中一模一样的方法声明

方法重写的应用：

• 当子类中需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样既沿袭了父类的功能，又定义了子类特有的内容

案例：手机类和新手机类

//手机类
public class Phone {
	public void call(String name) {
		System.out.println("给"+name+"打电话");
	}
}

//新手机类->重写手机类
public class NewPhone extends Phone {

	@Overirde
	public void call(String name) {
		System.out.println("先打开视频"); //子类特有的内容
		super.call(name); //直接调用父类的方法，完成方法的重写
	}
}

public class PhoneDemo {
	public static void main(String[] args) {
		Phone p = new Phone();
		p.call("luna");
		
		System.out.println("------------------");
		
		NewPhone np = new NewPhone();
		np.call("luna");
	}
}

@Override

• 注解annotation
• 可以帮助我们检查重写方法的方法声明的正确性

方法重写的注意事项：

1. 私有方法private不能被继承（父类的私有成员子类不能继承）
2. 子类的访问权限不能低于父类的访问权限
   （public > protected > default(不写) > private）
3. Java中的类只支持单继承，不支持多继承（即一个子类不能同时继承父类A和父类B）
4. Java中的类支持多层继承（即子类继承于父类，父类继承自超父类，那么子类可以同时拥有父类和超父类的方法）

案例：老师和学生

需求：定义老师类和学生类，然后写代码测试；最后找到老师类和学生类当中的共性内容，抽取一个父类，用继承的方式改写代码，并进行测试。
思路：
1、定义老师类->姓名、年龄、教书()
2、定义学生类->姓名、年龄、学习()
3、定义测试类，写代码测试
4、共性抽取父类，定义人类(姓名、年龄)
5、定义老师类，继承人类，并给出自己特有的方法：教书()
6、定义学生类，继承人类，并给出自己特有的方法：学习()
7、定义测试类，写代码测试

public class People {
	private String name;
	private int age;
	
	public People() {
		//无参构造
	}
	
	public People(String name, int age) {
		//有参构造
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

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

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}	
}

public class Teacher extends People{
	public Teacher() {
		//无参构造
	}
	
	public Teacher(String name,int age) {
		//有参构造
		super(name,age);
	}
	public void teach() {
		System.out.println("老师教书");
	}
}

public class Student extends People{
	
	public Student() {
		
	}
	
	public Student(String name,int age) {
		super(name,age);
	}
	
	public void Study() {
		System.out.println("好好学习，天天向上");
		
	}
}

public class PeopleDemo {
	
	public static void main(String[] args) {
		Teacher t1 = new Teacher();
		t1.setName("陈老师");
		t1.setAge(30);
		System.out.println(t1.getName()+","+t1.getAge());
		t1.teach();
		
		Teacher t2 = new Teacher("刘老师",33);
		System.out.println(t2.getName()+","+t2.getAge());
		t2.teach();
		
		Student s1 = new Student();
		s1.setName("luna");
		s1.setAge(18);
		System.out.println(s1.getName()+","+s1.getAge());
		s1.Study();
		
		Student s2 = new Student("tom",19);
		System.out.println(s2.getName()+","+s2.getAge());
		s2.Study();
		
	}
}

输出结果：
陈老师,30
老师教书
刘老师,33
老师教书
luna,18
好好学习，天天向上
tom,19
好好学习，天天向上

案例：猫和狗

需求：请采用继承的思想实现猫和狗的案例，并在测试类中进行测试
思路：
1、定义动物类Animal
共性：
成员变量：姓名，年龄；构造方法：无参，带参；成员方法：get/set方法
2、定义猫类Cat
cat：
成员变量：姓名，年龄
构造方法：无参，带参
成员方法：get/set方法，抓老鼠()
3、定义狗类Dog
dog:
成员变量：姓名，年龄
构造方法：无参，带参
成员方法：get/set方法，看门()
4、定义测试类AnimalDemo

public class Animal{
	private String name;
	private int age;
	
	public Animal() {
		
	}
	public Animal(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

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

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
	
}

public class Cat extends Animal {
	
	public Cat(){
		
	}

	public Cat(String name, int age) {
		super(name, age);
		// TODO Auto-generated constructor stub
	}
	
	public void catchMouse() {
		System.out.println("Cat can catch mouse");
	}
}

public class Dog extends Animal{
	
	public Dog() {
		
	}

	public Dog(String name, int age) {
		super(name, age);
		// TODO Auto-generated constructor stub
	}
	
	public void doorKeep() {
		System.out.println("dog is the doorkeeper");
	}
}

public class AnimalDemo {
	public static void main(String[] args) {
		Cat c1 = new Cat();
		c1.setName("orange cat");
		c1.setAge(1);
		System.out.println(c1.getName()+","+c1.getAge());
		c1.catchMouse();
		Dog d1 = new Dog();
		d1.setName("black dog");
		d1.setAge(2);
		System.out.println(d1.getName()+","+d1.getAge());
		d1.doorKeep();
	}

}

测试输出结果：
orange cat,1
Cat can catch mouse
black dog,2
dog is the doorkeeper