继承性

继承性的最大特征是解决代码的重复。

---

一、继承问题的引出

下面先通过一段程序来分析一下，为什么需要继承。

范例：要求定义两个描述人与学生的类

Person.java	Student.java
class Person { private String name; private int 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; } }	class Student { private String name; private int age; private String school;   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 String getSchool() { return school; }   public void setSchool(String school) { this.school = school; } }

以上的程序里面出现了代码的重复，在自然的关系上，学生是属于人的一种类型，并且学生与人相比描述的更加细致，范围更小。

---

二、继承的实现

在Java之中如果要想实现继承使用extends关键字完成，定义时的语法结构如下：

class 子类 extends 父类{}

一定要记住，子类也会被称为派生类，父类也被称为基类（超类）。

范例：实现继承

class Person {
	private String name;
	private int 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;
	}
}

class Student extends Person {// 继承了Person父类
}

public class TestDemo {
	public static void main(String args[]) {
		Student stu = new Student();
		stu.setName("艺兴");// Person类定义
		stu.setAge(27);// Person类定义
		System.out.println("姓名：" + stu.getName() + "，年龄：" + stu.getAge());
	}
}

现在Student类里面没有编写任何方法，但是由于其继承了Person父类，所以可以直接使用Person定义的方法。如果有需要，也可以在Student类里面定义新的扩展方法。

范例：在Student类里面增加新的功能

class Person {
	private String name;
	private int 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;
	}
}

class Student extends Person {// 继承了Person父类
	private String school;

	public String getSchool() {
		return school;
	}

	public void setSchool(String school) {
		this.school = school;
	}
}

public class TestDemo {
	public static void main(String args[]) {
		Student stu = new Student();
		stu.setName("艺兴");// Person类定义
		stu.setAge(27);// Person类定义
		stu.setSchool("音乐学院");
		System.out.println("姓名：" + stu.getName() + "，年龄：" + stu.getAge() + "，学校：" + stu.getSchool());
	}
}

通过以上程序的对比就可以非常清楚的发现继承的优点：

· 子类可以直接将父类的操作继续使用，属于代码重用；

· 子类可以继续扩充属于自己的标准。

三、继承的限制

利用extends关键字在大部分的情况下都可以不用去考虑给出的继承限制（前提：按照标准格式开发），但是事实上由于要限制用户的使用，所以针对于继承也有一些属于自己的要求。

• Java不允许多重继承，但是允许多层继承

在C++语言之中具备一种概念——多继承，即：一个子类可以同时继承多个父类。

范例：错误的继承

class A{}
class B{}
class C extends A,B{}

基本的要求就是希望C类可以同时继承A和B两个类，但是以上的操作是不正确的。那么之所以会存在多继承实际上目的也只有一个：希望一个子类可以同时继承多个父类的操作。那么可以使用多层继承。

class A {}
class B extends A {}
class C extends B {}

相当于C是B的子类，是A的孙子类。在使用多层继承的时候并没有层数的限制，不过从开发的角度认为，不要超过三层的继承关系。

• 子类在继承父类的时候严格来讲会继承父类中的全部操作，但是对于所有的私有操作属于隐式继承，而所有的非私有操作属于显示继承。      隐式继承只能够间接使用。

范例：观察属性

class A {
	private String msg;

	public String getMsg() {
		return msg;
	}

	public void setMsg(String msg) {
		this.msg = msg;
	}

}

class B extends A {

}

public class Demo {
	public static void main(String args[]) {
		B b = new B();
		b.setMsg("Hello");
		System.out.println(b.getMsg());
	}
}

在现在的B类里面一定是存在有msg属性，因为如果不存在，那么setMsg()设置的内容就不可能被保存，即：getMsg()是绝对无法进行内容输出的。

但是在B类里面不能够针对于msg属性进行访问，因为它属于私有的，只能够间接的进行私有属性的访问。

• 在子类对象构造之前一定会默认调用父类的构造（默认使用无参构造），以保证父类的对象先实例化，而后再实例化子类对象。

class A {
	public A() {
		System.out.println("A类的构造方法");
	}
}

class B extends A {
	public B() {
		System.out.println("B类的构造方法");
	}
}

public class Demo {
	public static void main(String args[]) {
		new B();
	}
}

输出结果：
A类的构造方法
B类的构造方法

此时并没有加入任何的操作代码，但是可以发现，在实例化子类对象前，先去实例化了父类对象，以及调用了父类的无参构造方法。

那么此时对于子类构造而言，就相当于隐含了一个“super()”。

class B extends A {
	public B() {
		super();// 父类中有无参构造时，加与不加无区别
		System.out.println("B类的构造方法");
	}
}

如果说此时你的父类中没有无参构造方法了，那么就必须使用super()明确调用父类的有参构造方法。

class A {
	public A(String title) {
		System.out.println("A类的构造方法");
	}
}

class B extends A {
	public B(String title) {
		super(title);// 父类中有无参构造时，加与不加无区别
		System.out.println("B类的构造方法");
	}
}

public class Demo {
	public static void main(String args[]) {
		new B("Hello");
	}
}

通过观察可以发现“super()”主要是由子类调用父类中的构造方法，那么这行语句一定要放在子类构造方法的首行，这一点和this()是类似的。

疑问？既然super()和this()都放在首行，如果现在子类构造没有编写super()的话，会自动使用一个super()调用父类的无参构造，那么如果写上了this()，那么是不是就表示子类无法调用无参构造呢？

通过代码的验证：super()与this()不能够同时出现，不管子类怎么折腾，它都永恒有一个存在的前提：子类对象的构造调用前一定要先执行父类构造，为父类的对象初始化后，才轮到子类对象初始化。