#暑期创作大赛#

Java 的继承举例与详解

类的继承是将现有类作为父类派生出新的子类；通过类的继承可以实现以最少的代码快 速创建新类的目的，即可以提高代码复用率。

1. 类的继承

继承是面向对象程序设计的三大特征之一（封装、继承、多态），被继承的类称为父类 或超类，由继承而得到的类称为子类。

一个父类可以有多个子类，但一个子类只能拥有一个父类，这有点像层次结构。

子类可以自动拥有其父类允许被继承的所有成员，同时子类可以重写或添加自己独有的 成员变量和成员方法。

Java中，所有类都是java.lang.Object的直接或间接子类。

2. 子类的创建

在定义一个类时，如果该类要继承某类，需要用 extends 关键字标识出来，语法格式 如下：

class ChildClass extends ParentClass{… …}

其中，ChildClass继承ParentClass，即 ChildClass是ParentClass的子类，ParentClass 是ChildClass的父类。

继承有一个特点，子类的对象也是其父类的对象，反之则不然。举例来说，老虎类是动 物类的子类，那么老虎类的对象假设为东北虎，可以说东北虎是动物，但不能说动物是东北 虎，逻辑上有错误。

 package ch08; class Person{ //从这里看不出该类是不是父类  
	 private String name;  
	 private int age;  
	 public Person(){   
		 System.out.println("调用了个人类的构造方法Person()");  
	 }  
	 public void setNameAge(String name, int age){ 
 	 	this.name=name;   this.age=age;  
 	 } 
 	public void show(){   
 		System.out.println("姓名："+name+"  年龄："+age);  
 	} 
 } 
 class Student extends Person{ 
 //从这里可以看出：父类为Person，子类为Student  private String department; 
 	public Student()  {  
 		System.out.println("调用了学生类的构造方法Student()"); 
 	}  
 	public void setDepartment(String dep){   
		 department=dep;   System.out.println("我是"+department +"的学生"); 
 	} 
 } 
 public class Demo{  
 	public static void main(String[] args){      
 		Student stu=new Student();      
 		stu.setNameAge("张小三",21); //子类调用父类方法      
 		stu.show(); //子类调用父类方法      
 		stu.setDepartment("计算机系");  //子类调用自己的方法  
     } 
 }  

结论：

（1）在同一包中，父类的非私有（private）成员可以继承给子类；在不同的包中，子 类只能继承父类的受保护（protected）和共有的（public）成员。

（2）在执行子类的构造方法之前，先执行父类的无参构造方法，因为父类的无参构造 方法可能要初始化一些成员。

（3）构造方法不能被继承，但子类可以调用父类的构造方法。

3.调用父类中特定的构造方法

使用super()语句调用父类特定的构造方法。
示例：

package ch08; 
class Person{  
	private String name;   
	private int age;   
	public Person(){   
		System.out.println("调用了Person类的无参构造方法");  
	}  
	public Person(String name, int age){
 		System.out.println("调用了Person类的有参构造方法");      
		this.name=name;     
		this.age=age;  
	}  
	public void show(){   
		System.out.println("姓名："+name+"  年龄："+age);  
	} 
} 
class Student extends Person{  
	private String department;  
	public Student(){  
 		System.out.println("调用了学生类的无参构造方法Student()");  
 	} 
	public Student (String name,int age,String dep){  
		super();  
		//super(name,age);  //调用父类特定的构造方法    
		department=dep;   
		System.out.println("我是"+department +"的学生");  
		System.out.println("调用了学生类的有参构造方法Student(String name,int age,String dep) ");  
	} 
} 
public class Demo{ 
	public static void main(String[] args){  
		Student stu1=new Student(); 
		Student stu2=new Student("李小四",23, "信息系");
		stu1.show();   stu2.show(); 
	 }
} 

结论：

（1）子类调用父类特定的构造方法，使用super([参数列表])语句，并且必须将其放在 子类构造方法的第一行；

（2）如果子类的构造方法中没有 super()语句，且父类存在有参的构造方法，则父类 必须提供无参的构造方法，否则编译错误；

（3）关于super()和this()： ? super()语句是子类调用父类的构造方法；this()是在类的内部，一个构造方法 中调用另一个构造方法。 ? super()和this()必须放在构造方法中的第一行。

4.在子类中访问父类的成员

在子类中访问父类的成员可以用super直接访问父类允许访问的成员，
语法格式如下：
super.成员变量;
super.成员方法();
在这里，可以把super是看作是父类的对象。
示例：

 package ch08; 
 class Person{  
 	protected String name; 
	protected int age;  
	public Person() {}  
 	public Person(String name, int age){   
 		this.name=name;   
 		this.age=age;  
 	} 
 	protected void show(){   
 		System.out.println("姓名："+name+"  年龄："+age);  
 	} 
 } 
 class Student extends Person{  
 	private String department;  
 	int age=20; 
	public Student (String xm,String dep){   
 		name=xm;   
 		department=dep;   
 		super.age=25;   
 		System.out.println("子类 Student中的成员变量age="+age);   
 		super.show();   
 		System.out.println("系别："+ department );  
 	} 
 } 
public class Demo{  
	public static void main(String[] args){   
		Student stu=new Student("李小四","信息系");  
	} 
}  

回忆：protected访问修饰符 被 protected 修饰的成员变量或成员方法，只能被该类自身、其子类（可以在不同包 中），或同一包中的其他类访问。

5. 用父类的对象访问子类的成员

这类对象称为“上转型对象”或“上转对象”，即将子类对象赋值给父类对象（父类对 象指向子类对象），语法格式如下：

ParentClass pc = new ChildClass(); //而非：ParentClass pc = new ParentClass ();

示例：

package ch08; 
class Person{  
	protected String name;  
	protected int age;  
	public Person(String name, int age){   
		this.name=name;   this.age=age;  
	}  
	protected void show(){   
		System.out.println("姓名："+name+"  年龄："+age);  
	} 
} 
class Student extends Person{  
	private String department;  
	public Student (String name,int age,String dep){   
		super(name,age);   
		department=dep;  
	}  
	protected void show(){   
		System.out.println("系别："+ department);  
	}  
	public void subShow(){   
		System.out.println("我在子类中");  
	} 
} 
public class Demo{  
	public static void main(String[] args){   
		//以下一行父类对象指向子类对象   
		Person per=new Student("王永涛",24, "电子");   
		per.show();   
		//per.subShow();  
	} 
}  

结论：
（1）父类对象访问子类成员，仅限于上转对象的情况，并且只能访问覆盖类型的方法；
（2）普通的父类对象不能访问子类的成员；相反，子类的对象可以访问父类允许访问 的成员。