Java 面向對象的三大特徵

面向對象主要由三大特性：

• 　　封裝
• 　　繼承
• 　　多態

 

1、封裝

一、封裝的概念

　　封裝性是面向對象編程的核心思想

　　指的就是將描述某種實體的數據和基於這些數的操做集合到一塊兒，造成一個封裝體

　　封裝的思想保證了類內部數據結構的完整性，使用戶沒法輕易直接操做類的內部數據，這樣下降了對內部數據的影響，提升了程序的安全性和可維護性。

 

二、封裝的好處

• 　　只能經過規定方法訪問數據
• 　　隱藏類數實現細節
• 　　方便修改實現
• 　　方便加入控制語句　　

 

三、封裝的使用

　　1）、修改屬性的可見性   ——> 設爲private

　　2）、建立共有的 getter / setter方法 ——> 用於屬性的讀寫

　　3）、在getter / setter方法中加入屬性控制語句 ——> 對屬性值的合法性進行判斷

 

public class Demo1 { public String name;        // 公有的
        
    protected int age;        // 受保護的
    
    char sex;                // 默認的
    
    private int num;        // 私有的

    /** * 獲取私有成員num值 * @return
     */
    public int getNum() { return num; } /** * 設置私有成員num的值 * @param num */
    public void setNum(int num) { this.num = num; } }

 

 

四、This關鍵字

this關鍵字主要有三個應用：

• 　　this調用本類中的屬性，也就是類中的成員變量；
• 　　this調用本類中的其餘方法；
• 　　this調用本類中的其餘構造方法，調用時要放在構造方法的首行。

public class Demo2 { public int num; public Demo2(){ this(1);                // this關鍵字調用類中的其餘構造函數
 }
 public Demo2(int a){ this.fun();                // this關鍵字調用類中的其餘方法
 System.out.println(a); } public void fun(){ this.num = 101;            //使用this關鍵字給成員屬性賦值
        System.out.println(this.num); } public static void main(String[] args) { Demo2 demo2 = new Demo2(); } }

 

 

2、繼承

一、繼承的概念和特色

概念：

　　繼承是Java面向對象編程技術的一塊基石，由於它容許建立分等級層次的類。

　　繼承就是子類繼承父類的特徵和行爲，使得子類對象（實例）具備父類的實例域和方法，或類從父 類繼承方法，使得子類具備父類相同的行爲。

特色：　

　　繼承鼓勵類的重用
　　繼承能夠多層繼承
　　一個類只能繼承一個父類
　　父類中private修飾的不能被繼承
　　構造方法不能被繼承

生活中的繼承：

                      

 

二、使用繼承

　　1）、編寫父類

　　　　有公共的屬性和方法

package test; /** * 父類 * @author Administrator * */
public class Father { //父類中的成員屬性
    public String name; public int age; public char sex; /** * 父類中的成員方法 */
    public void say(){ System.out.println("我會說話"); } public void eat(){ System.out.println("我會吃飯"); } }

 

　　2）、編寫子類，繼承父類

　　　　a.子類繼承父類時只能繼承一個父類

　　　　b.繼承的關鍵字   extends

package test; /** * 子類只能繼承一個父類 * 關鍵字 extends * @author Administrator * */
public class Son extends Father { }

 

三、子類訪問父類成員

• 　　訪問父類構造方法 

　　　　　　　　super();　父類無參的構造方法

　　　　　　　　super(name);   父類有參的構造方法

• 　　訪問父類屬性

　　　　　　　　super.name;

• 　　訪問父類方法

　　　　　　　　super.方法名();

 

首先定義一個父類，父類有成員屬性，成員發方法，無參構造方法，有參構造方法:

//首先定義一個父類，父類有成員屬性，成員發方法，無參構造方法，有參構造方法 /** * 父類 * @author Administrator * */
public class Father { //父類中的成員屬性
    public String name; public int age; public char sex; /** * 父類的構造方法 */
    public Father(){ System.out.println("我是無參的構造方法"); } public Father(String name){ this.name = name; System.out.println("我是有參的構造方法,個人名字是："+this.name); } /** * 父類中的成員方法 */
    public void say(){ System.out.println("我會說話"); } public void eat(){ System.out.println("我會吃飯"); } }

 

a.訪問父類構造方法 

public class Son extends Father { /** * 訪問父類構造方法 　　　　　　　　super();　父類無參的構造方法 　　　　　　　　super(name); 父類有參的構造方法 */
    public Son(){ super("**");        //必須注意：訪問父類的構造函數只能在子類的構造函數中訪問，且必須是子類構造函數的第一行
 } public static void main(String[] args) { Son son = new Son(); } }

 

控制檯 打印的結果爲：我是有參的構造方法,個人名字是：**

 

　b.訪問父類屬性

public class Son extends Father { /** * 　訪問父類屬性 　　　　　　　　super.name; //能夠在其餘方法和構造方法中使用 */
    public Son(String name){ super.name = name; System.out.println(super.name); } public void fun(){ System.out.println(super.name); } public static void main(String[] args) { Son son = new Son("xx"); son.fun(); //調用子類中的fun函數
 } }

 

 控制檯 打印的結果爲：

　　　　　　　　　　我是無參的構造方法
　　　　　　　　　　xx
　　　　　　　　　　xx

 

c.訪問父類方法

public class Son extends Father { /** * 　訪問父類方法 　　　　　　　　super.方法名(); //能夠在其餘方法和構造方法中使用 */
    public Son(String name){ super.eat();        //訪問父類中的eat方法 
 } public void fun(){ super.say();        //訪問父類中的say方法
 } public static void main(String[] args) { Son son = new Son("xx"); son.fun(); //調用子類中的fun函數
 } }

 

  控制檯 打印的結果爲：

　　　　　　　　　　我是無參的構造方法
　　　　　　　　　　我會吃飯
　　　　　　　　　　我會說話

 

 總結super關鍵字：

　　super關鍵字；愛訪問父類的成員

　　　　1.super只能出如今子類的方法和構造方法中；

　　　　2.super調用構造方法時，只能是第一句；

 　　　　　3.super不能訪問法父類的private成員；

 

四、繼承的限制和初始化順序

 問：子類能夠繼承父類的全部資源嗎？

 　　不能被繼承的父類成員：　　private成員

　　　　　　　　　　　　　　　子類與父類不在同包，使用默認訪問權限的成員

　　　　　　　　　　　　　　　構造方法

 

 問：多重繼承關係的初始化順序是怎樣的？

 

 

 

 5.方法的重寫

• 　　在子類中能夠根據須要對父類中繼承來的方法進行重寫；
• 　　重寫的方法和被重寫的方法必須具備相同方法名稱、參數列表和返回類型；
• 　　重寫方法不能使用被重寫的方法更嚴格的訪問權限

 

public class Father { /** * 父類中的成員方法 */
    public void say(){ System.out.println("我會說話"); } public void eat(){ System.out.println("我會吃飯"); } }

 

在子類中重寫：

public class Son extends Father { /** * 一個跟父類方法同樣的方法 */
    public void say(){ System.out.println("我會說英語"); } public static void main(String[] args) { Son son = new Son(); son.say(); } }

 

控制檯打印結果：我會說英語

son.say首先會去父類找say方法，若是子類沒有重寫say方法，就會輸出 「我會說話」 ；可是子類裏面也有say方法，就會把父類的say方法重寫，輸出子類中say方法的內容

 

3、多態

一、多態的概念

　　生活中的多態：

　　　　不一樣類型的打印機打印效果不一樣

　　　　　　　　　　黑白打印機　　黑白紙張

　　　　打印機

　　　　　　　　　　彩色打印機　　彩色紙張　　　　

 

　　程序中的多態 ：父類引用，子類對象

　　　　　　　　　 同一種事物，因爲條件不一樣，產生的結果也不一樣

　　　　　　　　　 多態：同一個引用類型，使用不一樣的實例而執行不一樣操做

 

　　將父類對象應用於子類對象的特徵就是面向對象編程中的多態性的體現

　　多態指的就是在應用程序中出現的「 重名 」 現象。多態性容許以統一的風格編寫程序，以處理種類繁多的已存在的類及其相關類。這樣既下降了維護難度，又節省了時間

 

 二、使用多態實現思路

　　編寫父類

　　編寫子類，子類重寫父類方法

　　運行時，使用父類的類型，子類的對象

 

三、實現多態的三個必要條件

• 　　繼承
• 　　重寫
• 　　父類引用指向子類對象 

　　

　　例子：

public class Father { /** * 父類中的成員方法 */
    public void say(){ System.out.println("我會說話"); } }

 

　　

　　重寫：

public class Son extends Father { /** * 一個跟父類方法同樣的方法 */
    public void say(){ System.out.println("我會說英語"); } }

 

 

在Java語言中，多態性主要表如今如下幾個方面：

• 　　　　方法重寫
• 　　抽象類
• 　　接口　　

 

 

4、對象之間的比較

 

在Java語言中，對象之間的比較提供了兩種方法：

　　「  == 」   運算符

　　equals（） 方法

 

區別：

　　「 == 」 運算符所進行的是所引用對象的內存地址是否一致

　　equals（）方法是String類中的方法，其所進行的是兩個對象引用所指的內容是否相同的比較