概念：繼承，是指一個類的定義可以基於另外一個已存在的類，即子類繼承父類，從而實現父類的代碼的重用。兩個類的關系：父類一般具有各個子類共性的特征，而子類可以增加一些更具個性的方法。類的繼承具有傳遞性，即子類還可以繼續派生子類，位於上層的類概念更加抽象，位於下層的類的概念更加具體。
1.定義子類：
語法格式
[修飾符] class 子類名 extends 父類名{
子類體
}
修飾符：public private protected default
子類體是子類在繼承父類的內容基礎上添加的新的特有內容，可以包含成員變量、成員方法、類、接口、構造方法等等。
舉個栗子，在一個公司中，雇員是公司聘請的工作人員，經理是管理公司的一種特殊雇員，這類特殊雇員不僅擁有普通雇員的屬性和方法，還有屬於他自己的一些屬性和方法，例如，特殊津貼。
代碼如下
public class EmployeeClass{
private String name; // 名字
private int id; //公司編號
private double salary; //薪水
private String department;// 部門
public EmployeeClass(){}
public EmployeeClass(String name,int id,double salary,String department){
this.name = name;
this.id = id;
this.salary = salary;
this.department = department;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
public String getDepartment() {
return department;
}
public void setDepartment(String department) {
this.department = department;
}
@Override
public String toString() {
return "EmployeeClass [name=" + name + ", id=" + id + ", salary="
+ salary + ", department=" + department + "]";
}
}
這是雇員類的代碼，其中有四個屬性，姓名，編號，工資，部門。
public class ManagerClass extends EmployeeClass{
private double specialsalary;
public ManagerClass(){super();}
public ManagerClass(String name,int id,double salary,String department,double specialsalary){
super(name,id,salary,department);
this.specialsalary = specialsalary;
}
public double getSpecialsalary() {
return specialsalary;
}
public void setSpecialsalary(double specialsalary) {
this.specialsalary = specialsalary;
}
@Override
public String toString() {
return super.toString() + "\nspecialsal:" +specialsalary;
}
}
這是子類，經理類，擁有一個自己的屬性，特殊津貼。
2.子類對父類成員的可訪問特性
子類可以繼承父類的成員，但是對父類成員的訪問卻是由訪問特性控制。
父類與子類在一個包中：不能直接訪問private，但是我們可以通過具有public訪問屬性的成員方法來取得 父類的private成員。
父類與子類不在同一個包中：不能直接訪問private和默認，但是我們可以通過具有public和protected訪問屬性的成員方法來取得 父類的private成員。
3.類成員方法的重載與覆蓋
當子類中定義的新成員變量的名字與父類中某個成員變量名字相同時，子類會把父類中相應成員變量隱藏起來。
當子類中定義的成員方法的名字與父類中某個成員方法的名字相同時屬於成員方法的重載或覆蓋。
(1)成員方法的重載
在前面舉到的雇員與經理栗子中，我們可以在雇員類中定義一個成員方法
public void setInfo(String name,int id,double salary,String department){
this.name = new String(name);
this.id = id;
this.salary = salary;
this.department = new String(department);
}
在經理類中可以定義為：
public void setInfo(String name,int id,double salary,String department,double specialsalary){
super(name,id,salary,department);
this.specialsalary = specialsalary;
}
這就是成員方法的重載
(2)成員方法的覆蓋
通常有兩種形式：
①在子類定義的成員方法中，首先調用父類中被覆蓋的成員方法，再添加一些操作語句。
②在子類定義的成員方法中，不調用父類覆蓋的成員方法，而是重新寫一個語句組。這樣實現了對父類的完全覆蓋。當子類的某項操作與父類對象操作完全不同時，應采取這種方法實現。
栗子：
在object類中有一個判斷兩個對象是否相等的成員方法equals（），其代碼為：
public boolean euqals(Object obj){
return (this == obj);
}
可以看到，這個成員方法是比較兩個對象是否同時引用一個對象。
但是我們現在希望能夠實現一個比較兩個同類型的對象的內容是否相等的功能。所以我們下面設計有了一個復數類，每個復數類由一個實部和虛部組成。設計功能可以比較兩個復數是否相等。代碼如下：
public class ComplexNumber {
private double re;
private double im;
public ComplexNumber(){re = 0.0;im = 0.0;}
public ComplexNumber(double re,double im){
this.re = re;
this.im = im;
}
public double getRe() {
return re;
}
public void setRe(double re) {
this.re = re;
}
public double getIm() {
return im;
}
public void setIm(double im) {
this.im = im;
}
public boolean equals(Object otherObject){
if(this == otherObject) return true;
if(otherObject == null) return false;
if(getClass() != otherObject.getClass()) return false;
ComplexNumber other = (ComplexNumber)otherObject;
if((re == other.re) && (im == other.im)) return true;
else return false;
}
public String toString(){
String str = "";
if(re != 0) str += re;
if(im == 0) return str;
if( im < 0 ) str += im +"i";
else str += " + " + im +"i";
return str;
}
public static void main(String[] args) {
ComplexNumber c1,c2;
c1 = new ComplexNumber(2,3);
c2 = new ComplexNumber(2,-3.4);
if(c1.equals(c2)){
System.out.println("("+c1+") == ( " + c2 +")" );
}
else{
System.out.println("("+c1+") <> ( " + c2 +")" );
}
}
}
結果為(2.0 + 3.0i) <> ( 2.0-3.4i)
