Java基礎之面向物件的三大特徵

阿新 • • 發佈：2021-10-20

面向物件的三大特徵

封裝：提高程式的安全性 (資料的準確性)
繼承：提高程式碼的複用性 (重複使用性)
多型：提高程式的可擴充套件性和可維護性

學Java，看這一套就夠了

一、封裝

隱藏物件內部的複雜性，只對外公開簡單的介面，便於外界呼叫，提高程式的安全性
隱藏實現的細節，僅僅需要關注具體的功能
方法的抽取，僅僅需要關注方法的功能忽略方法實現的細節
專案的模組化設計層次的劃分

1、對類的屬性進行隱藏

使用private關鍵字修飾類的成員變數

private修飾的成員變數僅僅可以在當前類中直接使用

Public class Person{
  private String name;
  private String gender;
  private int age;
}

2、給每個屬性提供公有的get(獲取)和set(賦值)方法

public class Person {
    private String name;
    private String gender ;
    private int age;
    public void setName(String name){
        this.name = name;
    }
    //定義一個方法 返回當前物件的name屬性值
    public String getName(){
        return name;
    }
    public void setGender(String gender){
        //如果性別是男或者女  那麼 正常賦值
        if(gender.equals("男")|| gender.equals("女")){
            this.gender=gender;
        }else{
            //如果性別不是男也不是女 那麼給一個預設值為 男
            this.gender="男";
        }
    }
    //定義一個方法 返回當前物件的gender屬性
    public String getGender(){
        return gender;
    }
    public void setAge(int age) {
        if (age > 0 && age < 100) {
            this.age = age;
        }
    }
    //定義一個方法  返回當前物件對的age屬性值
    public int getAge(){
        return age;
    }
    public void showInfo(){
        System.out.println(name+gender+age);
    }
}

測試程式碼：

public class TestPerson {
    public static void main(String[] args) {
        //獲得Person物件
        Person p=new Person();
        p.setName("旋渦劉能");
        p.setGender("男");
        p.setAge(56);
        p.showInfo();
        //僅僅需要檢視人的屬性  怎麼辦?
        System.out.println(p.getAge());
        System.out.println(p.getGender());
        System.out.println(p.getName());
    }
}

總結：

屬性全部隱藏物件內部的特點不讓外界知道我們僅僅需要關注物件的功能即可內部的實現使用了哪些成員統統不用考慮
資料的安全性和和規範性更高

二、繼承

java中由已知類建立新類的一種機制，新類擁有已知類的屬性和方法，同時，還可以有自己獨有的屬性和方法

減少相同程式碼的反覆編寫，提高程式碼的複用性，減少編碼量，提高程式的可維護度

繼承是怎麼來的？

是對N多個類的抽像，根據N多個類，抽取出像的部分，歸納為父類，被抽取的類，稱為子類

1、在Java中如何實現繼承？

在java中使用extends (擴充套件)實現繼承，說明子類是父類的擴充套件

新類(子類)extends已知類(父類)

一個父類可以有多個子類，但是一個子類只能有一個直接父類

【例】

1）先準備父類

public class Car {
    String color;
    String brand;
    String type;
    public void start(){
        System.out.println("一輛"+color+"顏色的"+brand+type+"正在啟動");
    }
    public void speedUp(){
        System.out.println("一輛"+color+"顏色的"+brand+type+"正在加速");
    }
    public void speedDown(){
        System.out.println("一輛"+color+"顏色的"+brand+type+"正在減速");
    }
}

2）準備子類

Audi

public class Audi extends Car {
    // 定速巡航
    public void speedKeeping(){
        System.out.println("一輛"+color+"顏色的"+brand+type+"啟動了定速巡航");
    }
}

BMW

public class BMW extends Car {
    //溫度調節
    public void temperatureRegulation(){
        System.out.println("一輛"+color+"顏色的"+brand+type+"啟動了溫度調節");
    }
}

測試程式碼：

public class TestExtends {
    public static void main(String[] args) {
        Audi au =new Audi();
        au.brand="奧迪";
        au.color="黑";
        au.type="TT";
        au.start();
        au.speedUp();
        au.speedKeeping();
        au.speedDown();
      
        BMW b =new BMW();
        b.brand="寶馬";
        b.color="白";
        b.type="X5";
        b.start();
        b.speedUp();
        b.temperatureRegulation();
        b.speedDown();
    }
}

2、super關鍵字

1、當子類中重寫父類中同名的屬性

那麼在子類中父類的同名的屬性被隱藏了

如果在子類中想繼續使用父類隱藏的屬性那麼要使用super關鍵字呼叫父類屬性

2、子類對父類同名方法的重新定義叫做方法的重寫

子類重寫父類方法之後父類的方法就預設隱藏了

如果子類想繼續使用父類中被隱藏的同名方法那麼要使用super關鍵字呼叫

public class Test1 {
    public static void main(String[] args) {
        S s =new S();
        s.showName();
        s.viewName();
    }
}
//父類F
class F{
    String name="父類name屬性的值";
    public void viewName(){
        System.out.println(name);
    }
}
//子類S
class S extends F{
    String name="子類name屬性的值";
    public void showName(){
        System.out.println(name);
        System.out.println(super.name);
    }
    //子類重寫父類的viewName()方法
    public void viewName(){
        System.out.println(name);
        super.viewName();
    }
}

三、多型

一種事物可以有多種表現形態
父類作為方法引數所有的子類物件都可以作為實參
父類作為方法的返回值所有的子類物件都可以返回

子類父類相互轉換：

子類物件可以宣告成父類物件
子類擁父類的屬性和方法
父類不能宣告成子類物件
父類物件可以通過強制轉換宣告成子類物件可以通過編譯但是執行的時候會出現 ClassCastException
當父類物件原本就是由子類物件宣告而成的那麼強制轉換回子類就不會報錯
子類宣告成父類物件時呼叫方法會執行子類的方法
編譯時認為是父類只能呼叫到父類中宣告的方法
執行時認為是子類佔用子類記憶體執行子類方法

public class Test1 {
    public static void main(String[] args) {
       
        F f =new S();
        f.methodA();
        //f.methodB();報錯
        System.out.println(f instanceof  F);
        System.out.println(f instanceof  S);
        
    }
}
class F{
    public void methodA(){
        System.out.println("父類中的方法");
    }
}
class S extends F{
    public void methodA(){
        System.out.println("子類中重寫父類的方法");
    }
    public void methodB(){
        System.out.println("子類中獨有的方法");
    }
}

本文就先寫到這裡了，你弄懂面向物件的三大特徵了嗎？