Java物件導向程式設計的三大特徵

2022-07-25 14:04:04

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物件導向特徵內容請搜尋it145.com以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援it145.com！