Java面向對象編程的三大特征

前言:

封裝、繼承和多態是面向對象編程的三大特征。

1.封裝

1.1.封裝概念

封裝就是把抽象出的數據(屬性)和對數據的操作(方法)封裝在一起,數據被保護在內部,程序的其他部分隻有通過被授權的操作(方法)才能對數據進行操作。

如:我們通過遙控器對電視機的操作就屬於典型的封裝。

1.2.封裝的好處

隱藏實現的細節:

一個操作具體的實現過程往往很復雜,通過封裝用戶和調用者可以直接使用提供的方法進行操作,不用關心其實現細節。

可以對數據進行驗證,保證其安全合理;

進行封裝後,私有化類的成員變量,類中的實例變量不能直接進行查看和修改,用戶需要通過提供的getter和setter方法才能操作,在方法中可以對用戶輸入的數據進行驗證,從而控制數據的范圍。

1.3.封裝的實現步驟

  • 將屬性進行私有化private (不能直接修改屬性)
  • 提供公共的setter方法,用於對屬性判斷並賦值
  • 提供公共的getter方法,用於獲取屬性的值
class person{
    private String name;//私有化,不能直接操作
    private int age;

    //通過getter方法得到數據信息
    public String getName(){

        return name;
    }

    public int getAge(){
        return age;
    }

    //通過setter方法設置屬性

    public void setName(String name){
        this.name = name;
    }
    public void setAge(int age){
        if (age < 1 || age > 150){//對數據進行驗證,保證其在合理的范圍內
            System.out.println("年齡需要在1~150之內~");

        }
        this.age = age;
    }
}

2.繼承

2.1.繼承概念

繼承可以提高代碼的復用性,讓編程更加靠近人類思維。當多個類存在相同的屬性(變量)和方法時,可以從這些類中抽象出父類,在父類中定義相同的屬性和方法,所有的子類不需要重新定義這些屬性和方法,隻需要通過extends關鍵字來聲明繼承父類即可。

在子類中也可以重寫父類的方法,這樣子類在調用該方法時執行的是重寫後的方法

public class test {
    public static void main(String[] args) {
        cat cat = new cat();
        cat.speak();
    }
}

class Animal {//父類
    public void speak(){
        System.out.println("動物會叫~");
    }
}

class cat extends Animal{//子類
    @Override
    public void speak() {//重寫父類的speak()方法
        System.out.println("喵喵~");
    }
}

2.2.繼承的好處

  • 代碼的復用性提高瞭
  • 代碼的擴展性和維護性提高瞭

2.3.子類對象實例化過程

3.多態

3.1.多態基本介紹

一個方法或者對象具有多種形態(多態是建立在封裝和繼承的基礎之上的);父類的引用指向子類的對象;允許不同類的對象對同一消息作出響應。不同對象調用相同方法即使參數也相同,最終表現行為是不一樣的。

3.2.多態的具體體現

方法的多態

重寫和重載

  • 重載在方法調用之前,編譯器就確定瞭要調用的具體的方法,稱為靜態綁定
  • 對於多態而言,隻有等到方法調用的那一刻解釋運行器才會確定要調用的具體方法,稱為動態綁定
public class test {
    public static void main(String[] args) {
        A a = new A();
        //通過不同的參數來調用a的sum()方法,就是調用的不同方法,體現方法的多態
        System.out.println(a.sum(1,2));
        System.out.println(a.sum(1,2,3));
        B b = new B();
        //根據不同的對象調用say()方法,會調用不同的方法
        a.say();
        b.say();
    }
}
class A {
    public int sum(int num1,int num2){
        return num1 + num2;
    }
    public int sum(int num1,int num2,int num3){//sum()方法的重載
        return num1 + num2 + num3;
    }
    public void say(){
        System.out.println("這是A的say()方法~");
    }
}

class B extends A{//子類
    @Override

    public void say(){//重寫父類的say()方法
        System.out.println("這是B的say()方法~");

    }
}

3.3.對象的多態(多態的核心)

  • 一個對象的編譯類型運行類型可以不一致
  • 在編譯期隻能調用父類中聲明的方法,運行期實際執行的是子類中重寫的方法
  • 編譯類型是定義對象時就確定的,不能改變
  • 運行類型是可以變化的
Animal animal = new Dog();
//編譯類型是Animal,而運行類型是Dog(向上轉型)
animal = new Cat();
//編譯類型還是Animal,運行類型變成瞭Cat

對象的多態在使用時需註意:

  • 前提:兩個對象存在繼承關系
  • 本質:父類的引用指向瞭子類的對象
  • 虛擬方法調用:向上轉型後調用子父類同名同參數的方法時,實際執行的是子類重寫父類的方法,此時父類的方法叫做虛擬方法
  • 向上轉型後內存中實際是加載瞭子類特有的屬性和方法的,但是由於變量聲明為父類類型,導致編譯時隻能調用父類中聲明的屬性和方法,不能使用子類的特有成員(可以使用強制轉換進行向下轉型)

動態綁定機制 :

  • 當調用對象方法的時候,該方法會和該對象的運行類型綁定
  • 當調用對象屬性的時候,沒有綁定,哪裡聲明,哪裡使用(看編譯類型)

3.4.對象的多態的應用

多態數組

數組的定義類型為父類類型,裡面保存的實際類型為子類類型

class Person{}
class student extends{}
class teacher extends{}
class text{
    public static void main(String[] args){
        Person[] persons = new Person[3];
        person[1] = new Person();
        //編譯類型為父類Person,運行類型為子類
        person[2] = new studet();
        person[3] = new teacher(); 
    } 
}

多態參數

方法定義的形參類型為父類1類型,實參類型允許為子類類型

class Employee{}
class Worker extends Employee{}
class Manager extends Employee{}
class master{
    public static void salary(Employee e){}
}
class text{
    public static void main(String[] args){
        Worker worker = new Worker();
        Manager manager = new Manager();
        //形參為父類,可傳入子類的對象
        master.salary(worker);
        master.salary(manager);
    }
}

到此這篇關於Java面向對象編程的三大特征的文章就介紹到這瞭,更多相關Java面向對象特征內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet!

推薦閱讀: