JAVA物件有三大特性:封裝,繼承,多型.這篇首先介紹封裝

• 什麼是封裝？
• 封裝好處之一 :修改自己的實現程式碼，而不用修改那些呼叫我們程式碼的程式片段。
• 封裝好處之二:更容易理解與維護
• 封裝好處之三:加強了程式碼的安全性

什麼是封裝？

封裝是指一種將抽象性函式介面的實現細節部份包裝、隱藏起來的方法。封裝可以被認為是一個保護屏障，防止該類的程式碼和資料被外部類定義的程式碼隨機訪問。
要訪問該類的程式碼和資料，必須通過嚴格的介面控制。
封裝最主要的功能在於我們能修改自己的實現程式碼，而不用修改那些呼叫我們程式碼的程式片段。
適當的封裝可以讓程式碼更容易理解與維護，也加強了程式碼的安全性。
封裝的優點

1. 良好的封裝能夠減少耦合。

2. 類內部的結構可以自由修改。

3. 可以對成員變數進行更精確的控制。

4. 隱藏資訊，實現細節。
   ---------來自菜鳥教程
   通俗一點來說就是,封裝就是把能實現一個功能的程式碼集中裝在一個方法.然後我們不需要知道它是怎麼寫的,我們直接拿來用就行.不管它裡面怎麼改.只要功能不變,不需要我們提供額外的引數啥的。我們拿來用的就不用管。

那麼提取重要的話,
1,修改自己的實現程式碼，而不用修改那些呼叫我們程式碼的程式片段。
2,更容易理解與維護，也加強了程式碼的安全性。

就這兩句話來說說封裝。 如果你能體會到這兩句話的好處.那麼我相信你肯定能用自己的話來說出封裝是什麼了.

封裝好處之一 :修改自己的實現程式碼，而不用修改那些呼叫我們程式碼的程式片段。

類似這樣的好處,我之前在介紹方法的時候也說過。
比如這個

public class DemoClass {
    public void getOneToOne(){
        System.out.println("1+1=2");
    }
}

然後要呼叫的話是這樣呼叫的。

public static void main(String[] args) {
         DemoClass demoClass = new DemoClass();
        demoClass.getOneToOne();
    }
 

結果輸出 "1+1=2"

如果我要直接的輸出10遍1+1=2 是不是要寫10次System.out.println(“1+1=2”);萬一有一天我要改成2+2=4 那我是不是要修改10遍.
但是如果給它封裝一下.我輸出10遍1+1=2,我要寫10次demoClass.getOneToOne();
但是如果某一天我要修改成2+2=4 我只需要修改DemoClass的getOneToOne方法中的1+1=2 就可以全部一起修改

封裝的好處之一併且也是最主要的功能就體現出來了
封裝最主要的功能在於我們能修改自己的實現程式碼，而不用修改那些呼叫我們程式碼的程式片段。

在這邊的體現就是我只要修改getOneToOne方法中的System.out.println(“1+1=2”); 改成 為 System.out.println(“2+2=4”);
而不用修改呼叫的程式片段,即demoClass.getOneToOne();這個不用改

封裝好處之二:更容易理解與維護

首先,更容易維護這一點意思就是更容易進行修改.其實和好處之一差不多.

那麼更容易理解體現在哪？
比如這段程式碼

public class DemoClass {
    public void getOneToOne(){
        for(int i =1;i<=9;i++){
            for(int j =1;j<=i;j++){
                System.out.print(j+"*"+i+"="+(i*j)+" ");
            }
            System.out.println();
        }
    }
}

如果你沒有見過這段程式碼.我讓你說出它的輸出結果.想必你要花一定時間才能理解出它的意思.

這段程式碼的輸出結果是

1*1=1 
1*2=2 2*2=4 
1*3=3 2*3=6 3*3=9 
1*4=4 2*4=8 3*4=12 4*4=16 
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25 
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36 
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49 
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64 
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81 

沒錯是九九乘法表.

但是你想要讓一個從來沒見過這段程式碼的人在幾秒內就能知道它的意思怎麼做？
答:給方法起一個名字

把getOneToOne這個名字改成九九乘法表.
比如說jiujiuchengfabiao() 就這麼俗氣的拼音
然後這樣執行

 public static void main(String[] args) {
        DemoClass demoClass = new DemoClass();
        demoClass.jiujiuchengfabiao();
    }

唉~~你發現我需不需要理解或知道jiujiuchengfabiao()裡面寫了啥?
不用！方法名告訴了我這個方法它會輸出啥. 幾秒鐘就知道了.
因此封裝把實現功能的程式碼放到一堆,但是它要有一個合理可靠的方法命名才算是好的封裝.不過拼音不建議哈。一般都用單詞

然後假如我換了另外一種寫法來實現這個九九乘法表.對使用者有沒有影響？是不是沒有。你改內部就改內部。我用就是了。

封裝好處之三:加強了程式碼的安全性

也就是說封裝能讓程式碼更安全,體現在哪?
比如這麼一段程式碼

public class Phone {
    private double size = 5.5;
    public double getSize(){
       return this.size;
    }
}

private是什麼意思?就是這個size只能在Phone這個類裡面用.別人拿不到.
關於許可權修飾符.我後面介紹完繼承之後在介紹.這邊就這麼簡單的知道一下private的意思,就是別的類拿不到.

回到這段程式碼.如果我們要得到這個Phone的size怎麼做？

  public static void main(String[] args) {
       Phone phone = new Phone();
        double size = phone.getSize();
    }

這樣就拿到了這個size.
但是如果我們要改它的size呢!!!？
你發現你改不了,你直接寫phone.size = 9.2? 直接報錯,因為它是private它只能在Phone這個類裡面改.

到這加強了程式碼的安全性這句話的意思有沒有一點兒體現了？
你不能隨便亂改我的東西。除非我給你入口。

那如果我就是要改怎麼辦?

跟Phone這個類談談人生讓它給你個入口唄.
然後我談成功了它給了我入口
然後這個Phone類就變成了這樣

public class Phone {
    private double size = 5.5;

    public double getSize() {
        return size;
    }
	
//改變size的入口
    public void setSize(double size) {
        this.size = size;
    }
}

然後這樣寫

public static void main(String[] args) {
       Phone phone = new Phone();
       phone.setSize(9.2);//我要改成9.2
       double size = phone.getSize();
    }

此時你就成功的把size改成9.2了

封裝概念的實現細節部份包裝、隱藏起來的方法。封裝可以被認為是一個保護屏障，防止該類的程式碼和資料被外部類定義的程式碼隨機訪問。
要訪問該類的程式碼和資料，必須通過嚴格的介面控制。

這句話的意思,想必到這你肯定會有一點兒體會到。

封裝到這就介紹完了.

那麼假如讓你說說封裝.你會怎麼用自己的話說呢?體會到了上面寫出的三大好處.你肯定能用自己的話說出一二。而不會說出機械性的那種概念。

下回介紹JAVA三大特性之一:繼承.