十九、封裝

1、封裝：將類的某些信息隱藏在類內部，不允許外部程序直接訪問，而是通過該類提供的方法來實現對隱藏信息的操作和訪問。
優點：只能通過規定的方法訪問數據
隱藏類的實例細節，方便修改和實現
2、步驟。
修改屬性的可見性：設爲private
常見getter/setter方法，用於屬性的讀寫
在getter/setter方法中加入屬性控制語句，對屬性值的合法性進行判斷

public class Phone{
    //屬性，成員變量，有什麼
 private    float screen;
   private float cpu;
  private  float mem;

public float getScreen(){
    return screen;
}
public void setScreen(float newScreen){
    screen=newScreen;
}
}


在mian()
Phone p=new Phone();
p.setScreen(6.0f);
System.out.println(p.getScreen());

3、使用包管理java中的類

包的作用：管理java文件，解決同名文件衝突

定義包：package 包名（全小寫字母）
注意：必須放在JAVA 源代碼的第一行
包名間可以使用“.”號隔開
比如：com.view.Class
系統中的包：
java.(功能).(類)
java.lang.(類)包含java語言基礎的類
java.util.(類)包含java語言中各類工具類
java.io.(類)包含輸入、輸出相關功能的類

使用包：import 包名

4、java中的訪問修飾符

5、this關鍵字
代表當前對象
this.屬性操作當前對象的屬性
this.方法操作當前對象的方法

封裝對象的屬性的時候，經常會使用this關鍵字

   private float screen;
        public float getScreen() {
            return screen;
        }

        public void setScreen(float screen) {
            this.screen = screen;//把參數賦給屬性
            this.sendMassage();//調用方法
        }



  public void sendMassage(){
            System.out.println("sendMessage");
        }

6、Java 中的內部類
內部類（ Inner Class ）就是定義在另外一個類裏面的類。與之對應，包含內部類的類被稱爲外部類。
內部類的主要作用如下：

內部類提供了更好的封裝，可以把內部類隱藏在外部類之內，不允許同一個包中的其他類訪問該類
內部類的方法可以直接訪問外部類的所有數據，包括私有的數據
內部類所實現的功能使用外部類同樣可以實現，只是有時使用內部類更方便

內部類可分爲以下幾種：

成員內部類
靜態內部類
方法內部類
匿名內部類

//外部類HelloWorld
public class HelloWorld {

    // 內部類Inner，類Inner在類HelloWorld的內部
    public class Inner {

        // 內部類的方法
        public void show() {
            System.out.println("welcome to imooc!");
        }
    }

    public static void main(String[] args) {

        // 創建外部類對象
        HelloWorld hello = new HelloWorld();
        // 創建內部類對象
        Inner i = hello.new Inner();
        // 調用內部類對象的方法
        i.show();
    }
}

（1）成員內部類
內部類中最常見的就是成員內部類，也稱爲普通內部類。

1、 Inner 類定義在 Outer 類的內部，相當於 Outer 類的一個成員變量的位置，Inner 類可以使用任意訪問控制符，如 public 、 protected 、 private 等

2、 Inner 類中定義的 test() 方法可以直接訪問 Outer 類中的數據，而不受訪問控制符的影響，如直接訪問 Outer 類中的私有屬性a

3、定義了成員內部類後，必須使用外部類對象來創建內部類對象，而不能直接去 new 一個內部類對象
即：內部類對象名 = 外部類對象.new 內部類( );

4、編譯上面的程序後，會發現產生了兩個 .class 文件
Outer$Inner.class和Outer.class
其中，第二個是外部類的 .class 文件，第一個是內部類的 .class 文件，即成員內部類的 .class 文件總是這樣：外部類名$內部類名.class

注意：（1）外部類是不能直接使用內部類的成員和方法

可先創建內部類的對象，然後通過內部類的對象來訪問其成員變量和方法。
（2）如果外部類和內部類具有相同的成員變量或方法，內部類默認訪問自己的成員變量或方法，如果要訪問外部類的成員變量，可以使用 this 關鍵字。

//外部類HelloWorld
public class HelloWorld{

    //外部類的私有屬性name
    private String name = "love";

    //外部類的成員屬性
    int age = 20;
    //成員內部類Inner
    public class Inner {
        String name = "愛";
        //內部類中的方法
        public void show() { 
            System.out.println("外部類中的name：" + HelloWorld.this.name);
            System.out.println("內部類中的name：" +  name  );
            System.out.println("外部類中的age：" + age);//沒有訪問修飾符控制
        }
    }
    //測試成員內部類
    public static void main(String[] args) {

        //創建外部類的對象
        HelloWorld o = new HelloWorld (); 

        //創建內部類的對象
        Inner inn = o.new Inner();             ;

        //調用內部類對象的show方法
        inn.show();
    }
}

運行結果：外部類中的name：love
內部類中的name：愛
外部類中的age：20

（2）靜態內部類
靜態內部類是 static 修飾的內部類，這種內部類的特點是：

1、靜態內部類不能直接訪問外部類的非靜態成員，但可以通過 new 外部類().成員 的方式訪問

2、如果外部類的靜態成員與內部類的成員名稱相同，可通過“類名.靜態成員”訪問外部類的靜態成員；如果外部類的靜態成員與內部類的成員名稱不相同，則可通過“成員名”直接調用外部類的靜態成員

3、創建靜態內部類的對象時，不需要外部類的對象，可以直接創建 內部類對象名= new 內部類();

public class Test1 {   
        // 外部類中的靜態變量score
        private static int score = 84;

        // 創建靜態內部類
        public      static    class SInner {
            // 內部類中的變量score
            int score = 91; 
            public void show() {
                System.out.println("訪問外部類中的score：" +  Test1.score           );
                System.out.println("訪問內部類中的score：" + score);
                System.out.println("訪問內部類中的score：" + new Test1().score);
                **new Test1().sendMassage();**
            }
        }
       private  void sendMassage(){
            System.out.println("sendMessage");
        }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        // 直接創建內部類的對象
        SInner si=new SInner();
        // 調用show方法
        si.show();
    }
    }

運行結果：訪問外部類中的score：84
訪問內部類中的score：91
訪問內部類中的score：84
sendMessage

（3）方法內部類
方法內部類就是內部類定義在外部類的方法中，方法內部類只在該方法的內部可見，即只在該方法內可以使用。
由於方法內部類不能在外部類的方法以外的地方使用，因此方法內部類不能使用訪問控制符和 static 修飾符。

        // 外部類中的靜態變量score
        //外部類
        public class Test1 {   
            private String name = "愛";          
            // 外部類中的show方法
            public void show() { 
                // 定義方法內部類
                class MInner {
                    int score = 83;
                    public int getScore() {                     
                        return score + 10;
                    }
                }               
                // 創建方法內部類的對象
                MInner mi=new MInner();             
                // 調用內部類的方法             
                mi.getScore();              
                System.out.println("姓名：" + name + "\n加分後的成績：" + mi.getScore());
            }           
            // 測試方法內部類
            public static void main(String[] args) {                
                // 創建外部類的對象
                Test1 mo=new Test1();               
                // 調用外部類的方法
                mo.show();
            }
        }

前端使用 Konva 實現可視化設計器（13）- 折線 - 最優路徑應用【思路篇】

java開發第一部分，一、環境變量配置

五、java中的關鍵字

六、Java標識符

四、程序的移植

七、變量

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結