深度解析：java必須掌握的知識點——類的重用

類繼承的概念和語法

類繼承的概念

根據已有類來定義新類,新類擁有已有類的全部功能。

Java只支持類的單繼承,每一個子類只能有一一個直接超類（父類）。

超類是全部子類的公共屬性及方法的集合，子類則是超類的特殊化。

繼承機制能夠提升程序的抽象程度，提升代碼的可重用性。

超類和子類
子類對象與超類對象存在「是一個…」或「是一種…」的關係。

子類對象

從外部來看,它應該包括
與超類相同的接口
能夠具備更多的方法和數據成員
其內包含着超類的全部變量和方法
繼承的語法

[ClassModifier] class ClassName extends SuperClassName
{
    //類體
}

類繼承舉例
設有三個類: Person（人）, Employee（員工）,Manager（管理人員）。很明顯：Person是範圍最廣的一個，Employee次之，Manager的範圍最小，其類層次如圖:

有以下代碼：
Preson.java

public class Person {
    public String name;
    public String getName() {
    return name;
    }
}

Employee.java

public class Employee extends Person {
    public int employeeNumber;
    public int getEmployeeNumber() {
        return employeeNumber;
    }
}

Manager.java

public class Manager extends Employee {
    public String responsibilities;
    public String getResponsibilities() {
        return responsibilities;
    }
}

能夠看出Employee（員工）是一種特殊的Person（人），因此Employee繼承於Person類。而Manager（管理人員）是一種特殊的Employee（員工），因此Manager繼承於Employee類。
下面爲測試類：

public class Test {
    public static void main(String args[]){
        Employee li = new Employee();
        li.name = "Li Ming";
        li.employeeNumber = 123456;
        System.out.println(li.getName());
        System.out.println(li.getEmployeeNumber());
        Manager he = new Manager();
        he.name = "He Xia";
        he.employeeNumber = 543469;
        he.responsibilities = "Internet project" ;
        System.out.println(he.getName());
        System.out.println(he.getEmployeeNumber());
        System.out.println(he.getResponsibilities());
    } 
}

類中定義了一個Employee類li,輸出li的名字和編號
一個Manager類he,輸出he的名字，編號和職責。

運行結果：

屬性的隱藏

有如下代碼：

class Parent {
    Number aNumber;
}

class Child extends Parent
    Float aNumber;
}

子類中聲明瞭與超類中相同的成員變量名
從超類繼承的變量將被隱藏
子類擁有了兩個相同名字的變量，一個繼承自超類,另-一個由本身聲明
當子類執行繼承自超類的操做時,處理的是繼承自超類的變量，而當子類執行它本身聲明的方法時，所操做的就是它本身聲明的變量
那麼若是子類想要訪問被隱藏的屬性該怎麼辦？

訪問被隱藏的超類屬性調用從超類繼承的方法,則操做的是從超類繼承的屬性
本類中聲明的方法使用"super.屬性」訪問從超類繼承的屬性
假設有兩個類A1和B1

class A1{ 
   int x= 2;
   public void setx(int i){ 
       x=i;
   }
   void printa(){
       System.out.println(x);
   }
}

class B1 extends A1 { 
   int x=100;
   void printb(){ 
       super.x = super.x +10 ;
       System.out.println("super.x=" +
       super.x+" x=" + x); 
   }
}

以後運行測試代碼：

public class Test {
    public static void main(String args[]){
        A1 a1=new A1();
        a1.setx(4);
        a1.printa();

        B1 b1 = new B1();
        b1.printb();
        b1.printa();

        b1.setx(6); // 將繼承x值設置爲6
        b1.printb(); 
        b1.printa();

        a1.printa();
    } 
}

運行結果：

方法覆蓋

若是子類不需使用從超類繼承來的方法的功能,則能夠聲明本身的同名方法,稱爲方法覆蓋

覆蓋方法的返回類型,方法名稱,參數的個數及類型必須和被覆蓋的方法如出一轍

只需在方法名前面使用不一樣的類名或不一樣類的對象名便可區分覆蓋方
法和被覆蓋方法

覆蓋方法的訪問權限能夠比被覆蓋的寬鬆，可是不能更爲嚴格

方法覆蓋的應用場合

子類中實現與超類相同的功能,但採用不一樣的算法或公式;
在名字相同的方法中,要作比超類更多的事情;
在子類中須要取消從超類繼承的方法。
方法覆蓋的注意事項：

必須覆蓋的方法
派生類必須覆蓋基類中的抽象的方法,不然派生類自身也成爲抽象類.
不能覆蓋的方法
基類中聲明爲final的終結方法基類中聲明爲static的靜態方法
調用被覆蓋的方法
super.overriddenMethodName();

Object類

全部類的直接或間接超類,處在類層次最高點;
包含了全部Java類的公共屬性。

Object類的主要方法

public final Class getClass(）
獲取當前對象所屬的類信息,返回Class對象。
public String toStringO
返回表示當前對象自己有關信息的字符串對象。
public boolean equals(Object obj)
比較兩個對象引用是否指向同一對象，是則返回true ,不然返回false。
protected Object clone()
複製當前對象，並返回這個副本。
public int hashCode(）
返回該對象的哈希代碼值。
protected void finalize() throws Throwable
在對象被回收時執行，一般完成的資源釋放工做。

終結類與終結方法

用final修飾的類和方法;
終結類不能被繼承;
終結方法不能被子類覆蓋。

抽象類

類名前加修飾符abstract ;
可包含常規類能包含的任何成員,包括非抽象方法;
也可包含抽象方法:用abstract修飾，只有方法原型,沒有方法的實現;
沒有具體實例對象的類,不能使用new方法進行實例化,只能用做超類;
只有當子類實現了抽象超類中的全部抽象方法，子類纔不是抽象類，才能產生實例;
若是子類中仍有抽象方法未實現，則子類也只能是抽象類。
抽象類聲明的語法形式

abstract class Number {
}

若是寫new Number()將會編譯錯誤。

抽象方法

聲明的語法形式爲:

public abstract <returnType> <methodName>(..);

僅有方法原型,而沒有方法體;
抽象方法的具體實現由子類在它們各自的類聲明中完成;
只有抽象類能夠包含抽象方法。

抽象方法的優勢

隱藏具體的細節信息,全部的子類使用的都是相同的方法原型，其中包含了調用該方法時須要瞭解的所有信息;
強迫子類完成指定的行爲,規定全部子類的"標準」行爲。

類的組合

組合的語法
將已存在類的對象放到新類中便可
例如，能夠說"廚房( kitchen)裏有一個爐子( cooker )和一一個冰箱( refrigerator )」。因此,可簡單的把對象myCooker和myRefrigerator放在類Kitchen中:

class Cooker{  類的語句}
class Refrigerator{  類的語句}
class Kitchen{
    Cooker myCooker;
    Refrigerator myRefrigerator;
}

例：組合舉例——線段類

一條線段包含兩個端點

public class Point //點類
{
    private int x, y; //coordinate
    public Point(int x, int y){ this.x = x; this.y = y;}
    public int GetX() { return x; }
    public int GetY( { return y; }
}

class Line //線段類
{
    private Point p1,p2; // 兩端點
    Line(Point a, Point b) {
        p1 = new Point(a.GetX(),a.GetY());
        p2 = new Point(b.GetX(),b.GetY());
    }
    public double Length() {
        return Math.sqrt(Math.pow(p2.GetX(-p1.GetX0,2)
        + Math.pow(p2.GetY0)-p1.GetY0.2));
    }
}

一個線段類包含兩個端點，也就是組合了兩個點類。

總結：看完有什麼不懂的歡迎在下方留言評論，記得點個贊哦！