Java继承思想（理解+代码）

继承

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

生活中的继承形如：

例如兔子和老虎都会睡觉、吃东西(公共的方法)，只不过吃的东西(即属性)不一样、吃的方式(即方法)也会不同。
如果不使用继承，那么在兔子类、老虎类里我们需要分别定义各自的eat方法以及food属性，这无疑增加重复的代码，导致代码的复用性差。
但是有了继承，我们可以通过子类继承父类的方式，使子类能够拥有父类非private的属性和方法。

继承的好处：

• 提高了代码的复用性。
• 让类和类之间产生了关系，给第三个特征多态提供了前提。

继承的注意点：

• java支持单继承(一个子类只能有一个父类)；Java支持多层继承（A继承B，B继承C，C继承D）；不直接支持多继承(一个子类继承多个父类)，对C++中的多继承机制进行了改良。可以用如下图片表示。
  
• 子类与父类成员变量相同时，如果需要获取父类的成员变量，要用super调用父类。super代表的是一个父类空间。
• 子类方法重写父类方法时，子类权限必须大于等于父类的方法权限。
• 静态方法只能重写静态方法，或者被静态重写。(这个时候主要依赖于类，而不再是对象了)

代码

• 父类(Animal)
  父类属性用到了封装，所以子类如果想使用父类属性只能用父类中的get方法。(super好像不行，待测试)

class Animal{
	//封装
	private String name;
	private String food;
	//初始化构造函数
	public Animal() {};//不带参
	public Animal(String name, String food) {//带参构造函数
		this.setName(name);
		this.setFood(food);
	}
	
	void eat() {
		System.out.println(getName()+" is eating "+getFood());
	}
	
	void sleep() {
		System.out.println(getName()+" is sleeping.");
	}
	
	//静态方法只能重写静态或者被静态重写。
	static void show() {
		System.out.println("叫");
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	public String getFood() {
		return food;
	}
	public void setFood(String food) {
		this.food = food;
	}
}

• 子类（Tiger）
  Tiger类用到了重写，那么什么时候需要重写？
  答：当需要对父类中的某一功能方法进行扩展时，就需要用到重写操作。所以，重写操作一定会保证子类和父类的该方法名字相同、参数的个数与类型相同、返回值也一样，这才是正确的重写操作。

重写和重载的区别也十分重要，菜鸟教程官网的介绍很详细了，这里直接引用。

class Tiger extends Animal{
	public Tiger() {};
	public Tiger(String name, String food) {
		this.setName(name);
		this.setFood(food);	
	}
	//重写老虎的eat()方法,因为我们需要对子类方法进行一个扩展。
	public void eat() {
		System.out.print("We gotta make a hunt firstly! Watch out! ");
		System.out.println(getName()+" killed "+getFood()+" and ate it.");
	}
	//测试super关键字对父类的引用
	public void superTest() {
		super.eat();
	}
}

主函数里测试：

	Tiger tiger1 = new Tiger("tiger1", "chicken");
	tiger1.eat();
	tiger1.superTest();

• 子类（Rabit）
  Rabit类和Tiger类在继承的时候用了两种不同的写法，Rabit类显得更简洁。

class Rabit extends Animal{
	public Rabit() {};
	public Rabit(String name, String food) {
		super(name, food);
	}
}

主函数里测试：

	Animal animal = new Animal("animal", "food");
	animal.eat();
	
	Rabit rabit1 = new Rabit("rabit1", "carrot");
	rabit1.eat();
	
	Rabit rabit2 = new Rabit();
	rabit2.setName("rabit2");
	rabit2.setFood("grass");
	rabit2.eat();

继承中子类、父类构造函数的特点

在子类构造对象时，会发现访问子类构造函数时，父类构造函数也会被访问。
原因：子类的构造函数第一行有一个默认的隐式语句。super()；

public class InheritanceDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		new Zi();
	}
}

class Fu{
	Fu(){
		System.out.println("A, Fu Run");
	}
}

class Zi extends Fu{
	Zi(){
		//子类的构造函数第一行有一个默认的隐式语句。super()
		//super();
		System.out.println("Zi Run");
	}
}

• 那如果执行子类中的带参构造函数，是否会调用父类的不带参构造函数呢？
  运行结果显示，这种情况依然会执行父类的不带参构造函数。

public class InheritanceDemo {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		new Zi(4);
	}
}

class Fu{
	
	Fu(int x){
		System.out.println("Fu Run"+ x);
	}
	Fu(){
		System.out.println("Fu Run");
	}
}

class Zi extends Fu{
	
	Zi(int x){
		//super(4);
		System.out.println("Zi Run"+ x);
	}
	
	Zi(){
		//子类的构造函数第一行有一个默认的隐式语句。super()
		//super();
		System.out.println("Zi Run");
	}
}

• 那如果是执行子类的带参构造函数，如何调用父类中的带参构造函数？
  可以通过super(带参)；来实现

class Zi extends Fu{
	
	Zi(int x){
		super(4);
		System.out.println("Zi Run"+ x);
	}
	
	Zi(){
		//子类的构造函数第一行有一个默认的隐式语句。super();
		//super();
		System.out.println("Zi Run");
	}
}

总结

子类的构造函数(不管是带参的还是不带参的)一旦被调用，都会调用父类的不带参构造函数。但是子类的带参构造函数被调用，不会引起父类的带参构造函数被调用，如果想，可以用super(带参)实现。

---

为什么子类实例化的时候要访问父类中的构造函数呢？

那是因为子类继承了父类，获取到了父类中内容(属性)，所以在使用父类内容之前，要先看父类是如何对自己的内容进行初始化的。

注意：super语句必须要定义在子类构造函数的第一行，因为父类的初始化动作需要先完成。