Java中的继承性

---

继承性是面向对象的第二大主要特性，继承性主要解决的是代码的重用问题，利用继承性可以从已有的类继续派生出新的子类，还可以利用子类扩展出更多的操作。

---

1.继承的实现

继承严格来说就是扩充一个类的已有的功能。在Java中可以通过extends关键字来实现继承的关系，语法如下：

class 子类 extends 父类 {}

继承格式的说明：

• 对于extends来说可以翻译为扩充，但为了方便称为继承。
• 子类又可以称为派生类。
• 父类又可以称为超类（Super Class）。

程序：继承的实现（子类的扩充）

class Person{
	private String name;
	private int age;
	public void setName(String name){
		this.name=name;
	}
	public void setAge(int age){
		this.age=age;
	}
	public String getName(){
		return this.name;
	}
	public int getAge(){
		return this.age;
	}
}
class Student extends Person{            //Student类继承了Person类
	private String school;               //子类扩充属性
	                                     //子类扩充方法
	public void setSchool(String school){
		this.school=school;
	}
	public String getSchool(){
		return this.school;
	}
}
public class TestDemo{
	public static void main(String args[]){
		Student st = new Student();  //实例化子类
		st.setName("柳非");          //父类方法
		st.setAge(18);
		st.setSchool("北京体育大学"); //子类方法
		System.out.println("姓名："+st.getName()+"，年龄："+st.getAge()+"，学校："+st.getSchool);
	}
}
程序执行结果：姓名：柳非，年龄：18，学校：北京体育大学

注意：

• 子类可以直接将父类中的操作继续使用，属于代码的重用。
• 子类可以扩充属于自己的内容。

2.继承的限制

限制一： Java不允许多重继承，但可以多层继承。
在C++语言中有一种概念——多重继承，就是一个子类可以同时继承多个父类，但是在Java中是不被允许的。
示例：错误的继承

class A{}
class B{}
class C extends A,B{}   //一个子类继承了两个父类

示例：多层继承

class A{}
class B extends A{}  //B类继承A类
class C extends B{}  //C类继承B类

注意：继承的层数不要太多（最多3层）
限制二： 子类在继承父类时，严格来讲会继承父类中的所有的操作，但是对于私有操作属于隐式继承，对于非私有操作属于显式继承。

class A{
	private String msg;
	public void setMsg(String msg){
		this.mmsg=msg;
	}
	public String getMsg(){
		return this.msg;
	}
}
class B extends A{
}
public class TestDemo{
	public static void main(String args[]){
		B b = new B();
		b.setMsg="Hello";
		System.out.println(b.getMsg());
	}
}
程序执行结果：Hello

注意：在B类中不能对msg属性进行直接访问，因为在A类中msg属于私有属性，只能利用getter或setter方法间接的进行私有属性的访问。
限制三： 在子类对象构造前一定会默认调用父类构造（默认使用无参构造），用来保证父类对象先实例化，子类对象后实例化。
示例：实例化对象操作

class A{
	public A(){
		System.out.println("A类的构造方法！");
	}
}
class B extends A{
	public B(){
		System.out.println("B类中的构造方法！");
	}
}
public class TestDemo{
	public static void main(String args[]){
		new B();
	}
}
程序执行结果: A类的构造方法
             B类的构造方法

此程序中虽然是实例化子类对象，但是先要执行父类的构造方法，再执行子类构造实例化子类对象，这就相当于在子类中隐含了super（）的语句调用，由于 super（）的主要是调用父类构造方法，所有必须放在子类构造方法的首行。
在上面的程序中父类包含无参构造方法，所以有无super（）是没有区别的，但是对于没有无参构造的父类来说，就必须使用super（）方法，否则会出现编译错误。
示例：父类不提供无参构造

class A{
	public A(String title){
		System.out.println("A="+title);
	}
}
class B extends A{
	public B(String title){
	    super(title);  //明确调用父类构造，否则会出现编译错误
		System.out.println("B类中的构造方法！");
	}
}
public class TestDemo{
	public static void main(String args[]){
		new B("Hello");
	}
}
程序执行结果: A=Hello
             B类的构造方法