JAVA之封裝

java有三大特性：封裝，繼承，多態。我們首先來講封裝，那麼什麼是封裝呢？

一：概念

     將類的某些信息隱藏在類內部，不允許外部程序直接訪問，而是通過該類提供的方法來實現對隱藏信息的操作和訪問。

二：爲什麼要用封裝

     a：只能通過規定的方法訪問數據

     b：隱藏類的實例細節，方便修改和實現。

三：封裝的實現步驟

      1：修改屬性的可見性 -->設爲private

      2：創建getter/setter方法 -->用於屬性的讀寫

      3：在getter/setter方法中加入屬性控制語句 -->對屬性值的合法性進行判斷 （可選）

public class Telphone {
	private float cpu;
	private float screen;
	private float mem;
	
	public float getCpu() {
		return cpu;
	}
	public void setCpu(float newCpu) {
		this.cpu = newCpu;
	}
	public float getScreen() {
		return screen;
	}
	public void setScreen(float newScreen) {
		this.screen = newScreen;
	}
	public float getMem() {
		return mem;
	}
	public void setMem(float newMem) {
		this.mem = newMem;
	}
}

public class InitTelphone {

	public static void main(String[] args) {
		Telphone phone=new Telphone();
		phone.setCpu(2.0f);
		phone.setMem(64.0f);
		phone.setScreen(1.4f);
		System.out.println("CPU:"+phone.getCpu());
		System.out.println("Memory:"+phone.getMem());
		System.out.println("Screen:"+phone.getScreen());
	}
}  

  運行結果爲：

   

四： 訪問修飾符   

訪問修飾符	本類	同包	子類	其他
private	√
默認	√	√
protected	√	√	√
public	√	√	√	√

五：內部類

     A：概念

         就是定義在另外一個類裏面的類。內部類有一下作用：

           1：內部類提供了更好的封裝，可以把內部類隱藏在外部類之內，不允許同一個包中的其他類訪問該類

           2：內部類的方法可以直接訪問外部類的所有數據，包括私有的數據

     B：內部類可以分爲：成員內部類，靜態內部類，方法內部類，匿名內部類。

           1：成員內部類

               注意：1):不可以直接使用內部類的成員和方法，要通過內部類的對對象來訪問其成員變量。

                         2):如果外部類和內部類具有相同的成員變量或方法，內部類默認使用自己的成員變量或方法，如果要訪問外部類的 成員變量，可以通過this關鍵字

//外部類HelloWorld
public class HelloWorld{
    //外部類的私有屬性name
    private String name = "swpu";
    //外部類的成員屬性
    int age = 20;
	//成員內部類Inner
	public class Inner {
		String name = "swpu";
                //內部類中的方法
		public void show() { 
			System.out.println("外部類中的name：" +HelloWorld.this.name);//跟內部類重名，所以需要this關鍵字
			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();
	}
}

     運行結果：

   

       2：靜態內部類:由static修飾的內部類，特點爲：

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

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

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

//外部類Telphone
public class Telphone{
  //外部類的靜態屬性name
  private static  String name = "swpu";
	//成員內部類Inner
	public static class Inner {
		String name = "swpu";
                  //內部類中的方法
		public void show() { 
			System.out.println("外部類中的name：" +Telphone.name);
			System.out.println("內部類中的name：" + name);
		}
	}
	//測試成員內部類
	public static void main(String[] args) {
        //創建內部類的對象
	Inner inn =  new Inner()            ;
        //調用內部類對象的show方法
	inn.show();
	}
}

   運行結果爲：

       

3：方法內部類:方法內部類就是定義在外部類的方法中，方法內部類只在該方法的內部可見，即只在該方法內可以使用。 

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