Java自學后的前十章練習題及實時復習

各章重點知識的總結及回顧

Java執行是從 main 方法開始執行的，此方法的完整定義是 public static void main(String[]args) { }

? Java類名的每個單詞的首字母通常要求小寫，

簡述Java實作可移值性的基本原理，

答;Java屬于編譯型和解釋型的編程語言，所有的*.java程式必須編譯為*.class檔案之后才可以在電腦上執行，而執行x.class檔案的電腦并不是一臺真實的電腦，而是利用軟體和硬體模擬出來的一臺虛擬電腦，稱為Java虛擬機，而針對于不同的作業系統平臺，有不同版本的Java虛擬機，即：由Java虛擬機去適應不同的作業系統，即：只要Java虛擬機的支持沒有改變，同一個x.class可以在不同的平臺上運行

簡述Java中path及classpath的作用，

答: PATH：是作業系統的環境屬性，指的是可以執行命令的程式路徑；

CLASSPATH：是所有x.class檔案的執行路徑，java命令執行的時候將利用此路徑加載所需要的x.class檔案，

詳細闡述Java中使用public class或class宣告一個類的區別及注意事項，

? 答:使用public class定義的類，要求檔案名稱和類名稱保持一致，在一個*.java檔案之中只能存在一個public class；

? 使用class定義的類，檔案名稱可以和類名稱不一致，在一個x.java檔案之中可以同時存在多個class定義，編譯之后會產生多個x.class檔案，

請解釋“&”和“&&”的區別？

答:&在進行邏輯運算時表示所有判斷條件都需要判斷，而“&&”為短路與，在前面的判斷回傳false時后面判斷將不再執行，最終的結果就是false，

? &還可以應用在位操作上，

請解釋“|”和“||”的區別？

答:|在進行邏輯運算時表示所有判斷條件都需要判斷，而“|”為短路或，在前面的判斷回傳true時后面判斷將不再執行，最終的結果就是true，

? |還可以應用在位操作上，

基本資料型別不牽扯到記憶體開辟的問題,而參考資料則關系到記憶體

java基本資料型別的大小,方法與默認值整型：

byte：-2^7 ~ 2^7-1，即-128 ~ 127，1位元組，Byte，末尾加B

short：-2^15 ~ 2^15-1，即-32768 ~ 32767，2位元組，Short，末尾加S

有符號int：-2^31 ~ 2^31-1，即-2147483648 ~ 2147483647，4位元組，Integer，

無符號int：0~2^32-1，

long：-2^63 ~ 2^63-1，即-9223372036854774808 ~ 9223372036854774807，8位元組，Long，末尾加L，（也可以不加L）

浮點型：

float：4位元組，Float，末尾加F，（也可以不加F）

double：8位元組，Double，

字符型：

char：2位元組，Character，

布爾型：

boolean：Boolean，

資料型別轉換

范圍小的資料型別可以自動轉為范圍大的資料型別,而范圍大的到小的則需要強行轉換

Java中一些命名規范:*類名的命名要遵循首字母大寫原則，類的名字必須由大寫字母開頭而單詞中的其他字母均為小寫；如果一個類名稱是由多個單詞組成，則每個單詞的首字母均應為大寫例如ModelWhAction；如果類名稱中包含單詞縮寫，則這個所寫詞的每個字母均應大寫，如：XMLExample,還有一點命名技巧就是由于類是設計用來代表物件的，所以在命名類時應盡量選擇名詞　變數的命名要遵循通俗易懂的原則，比如名字就用 name ，而不是用a、b、c這樣的命名，變數命名除了變數名外，實體，包括類、類常量，均采用大小寫混合的方式，第一個單詞的首字母小寫，其后單詞的首字母大寫，變數名不應以下劃線或美元符號開頭，盡管這在語法上是允許的，但是在作業中這樣做會降低代碼的可閱讀性，在作業上這是不規范的.使用駝峰命名法命名多個單詞組成的變數名，

方法的名字的第一個單詞應以小寫字母作為開頭，后面的單詞則用大寫字母開頭，

需要用到的變數命名和方法命名要遵循首字母小寫原則，如果名稱是由多個單詞組成，每個單詞的首字母都要大寫（除首個單詞），

所有命名規則必須遵循以下規則：
 1)、名稱只能由字母、數字、下劃線、$符號組成

 2)、命名時不能以數字開頭

 3)、在命名是絕對不能出現Java關鍵字，
方法多載:方法名稱相同,引數型別或者個數不同, 判斷: 定義多個同命方法時,可以依靠回傳值區別同名方法(x) 2 在進行方法多載時回傳值型別必須相同,否則無法通程序式的編譯.(x)

方法遞回呼叫是指:本方法自身重復執行,在使用遞回呼叫時一定設定好方法的結束條件,否則會出現記憶體溢位問題,造成程式的中斷.

java中的流程控制

1 用戶互動Scanner(java.util.Scanner)

輸入陳述句Scanner:是從jdk 1.5開始追加

主要目的:為了解決輸入流的訪問問題,可以理解為BufferedReader的替代功能類.

基本的語法

Scanner s = new Scanner(System.in);
通過Scanner類的next()與nextLine()方法獲取輸入的字串，在讀取前我們一般需要使用hasNext()與hasNextLine()判讀是否還有輸入的資料
構造Scanner類物件，它附屬于標準輸入流System.in

相關用代碼實作


import java.util.Scanner;
public class JavaIODemo

{
public static void main(String[]args){
Scanner scan = new Scanner(System.in);//創建輸入流物件
System.out.println(“請輸入年齡:”);//提示資訊
if (scan.hasNextInt())//判斷是否整數輸入
{
int age = scan.nextInt();//直接獲取數字
System.out.println(“年齡:”+age);//資料回顯
}else{
System.out.println(“輸入的內容不是數字,程式無法正常運行!!”);//錯誤提示
}
scan.close();//關閉輸入流
}
}


<img src="C:\Users\阿旺\AppData\Roaming\Typora\typora-user-images\image-20201017102831611.png2">對輸入的有效字符之前遇到的空白，next()方法會自動將其去掉
只有輸入有效字符后才將其后面輸入的空白作為分隔符或者結束符
next()不能得到帶有空格的字串 
 x.nextLine():
 
   以Enter為結束符，nextLine（）方法回傳的是輸入回車之前的所有字符
 
可以獲得空白 
 2 順序結構: 
  JAVA的基本結構就是順序結構，除非特別指明，否則就按照順序從上往下執行
 
 順序結構是最簡單的演算法結構，順序結構是任何一個演算法都離不開的一種基本演算法結構
 
 陳述句與陳述句，代碼塊與代碼塊之間按照從上往下的順序執行，由若干個依次執行的處理步驟組成
  
 3 選擇結構 
  
   if單選擇結構
 if(布爾運算式){
 //如果布爾運算式為true將執行的陳述句
 }
 
 if雙選擇結構
 if(布爾運算式){
 //如果布爾運算式的值為true
 }else{
 //如果布爾運算式的值為false
 }
 
 if多選擇結構
 if(布爾運算式 1){ //如果布爾運算式1的值為true執行代碼 }else if(布爾運算式 2){ //如果布爾運算式2的值為true執行代碼 }else if(布爾運算式3 ){ //如果布爾運算式3的值為true執行代碼 }else{ //如果以上比爾運算式都不為true執行代碼 }
 
 嵌套的if結構
 if(布爾運算式 1){ //如果布爾運算式1 的值為true執行代碼 if(布爾運算式 2){ //如果布爾運算式2 的值為true執行代碼 } } 
     
     總結: 
     if陳述句至多有一個else陳述句，else陳述句在所有的else if之后，if陳述句可以有若干個else if陳述句，它們必須在else陳述句之前，一旦其中的一個else if陳述句為true，其它的else if陳述句以及else 陳述句都將跳過執行 
    
 
 switch多選擇結構 
     
     switch 陳述句中的變數型別可以是:byte、short、int、或者char
 從java SE 7開始支持字串String型別
 case標簽必須為字串常量或字面量
 如果不寫break，程式就會繼續往下面的執行，產生case穿透 
     switch(expression){ case value: //陳述句 break;//可選 case value: //陳述句 break;//可選 default://可選 //陳述句 } 
    
  
  
 4 回圈結構 
  
   while回圈
 while(布爾運算式){
 //回圈內容;
 } 
     
     總結; 
     只要布爾運算式為true，回圈就會一直執行下去，當運算式不成立，則跳出回圈
對于while陳述句而言，如果不滿足條件，就無法進入回圈
回圈條件如果一直為true就會造成無限回圈（死回圈），會影響程式性能或者造成程式卡死崩潰!!! 
    
 
 do…while回圈
 do{ //代碼陳述句 }while(布爾運算式);
 
 for回圈
 //初始化//條件判斷//迭代
 for(初始化;布爾運算式;更新){ //代碼陳述句 } 
     
     總結: 
     for回圈是支持迭代的一種通用結構，一種有效、靈活的回圈結構
初始化陳述句可以為空，也可以初始化一個或多個回圈控制變數
如果布爾運算式的值為true，回圈體被執行，false則結束回圈，繼續執行程式后面的陳述句
執行一次回圈后，更新回圈控制變數，再次檢測布爾運算式，回圈執行上面的程序. 
    
  
  
 5 陳述句問題 
  
   break:當程式運行到break陳述句時,立即會離開回圈,執行回圈外的陳述句,如果break陳述句出現在嵌套回圈的內岑回圈,則break陳述句只會逃離當前層回圈.
 
 continue:強制程式跳到回圈的起始處,也就是當程式運行到continue陳述句時,立即會停止運行剩余的回圈主體,而回到回圈的開始處執行.
 
 return:中斷程式的執行.

 
練習::九九乘法表 
public class For99chengfa
{
	public static void main(String[]args){

		//9行  9 次回圈
	  for (int i=1;i<=9 ;i++ )//縱向回圈9次
	  {
		  //System.out.println(i);//i是行號(1~9)
		  //負責輸出一行  (內部for回圈負責將一行上的全部輸出)
		  for (int j=1;j<=i ;j++ )//回圈幾次與行號有關系  即i是行號
		  {
			  System.out.print(j+"*"+i+"="+i*j +" ");//這里不能換行  //這里加了空格
		  }
		  //換行
		  System.out.println();
	  }
	}
}

 
 
Java面向物件的編程 
 
 物件的創建 
 面向程序：當需要實作一個功能時，每個具體的步驟都要親力親為，詳細處理每個細節，（強調程序） 
 面向物件：當需要實作一個功能時，不關心具體的步驟，而是找一個已經具有該功能的的人或物體，通過該人或物體來實作這個功能，（強調物件） 
 面向物件編程(Object Oriented Programing，OOP)的本質：以類的方式組織代碼，以物件的組織（封裝）資料， 
 面向物件的三大基本特征：封裝、繼承和多型， 
 類：是一組相關屬性和行為的集合，可以看成是一類事務的模板，使用事物的屬性特征和行為特征來描述該類事物， 
 屬性：就是該事物的狀態資訊，
行為：就是該事物能夠做什么， 
 物件：是一類事物的具體體現，物件是類的一個實體，必然具備該類事物的屬性和行為， 
 類與物件的關系 
 類是對一類事物的描述，是抽象的，
物件是一類事物的實體，是具體的，
類是物件的模板，物件是類的物體， 
  
  創建物件 
  類名 物件名 = new 類名();
 
  使用物件訪問類中的成員 
  物件名.成員變數名;
物件名.成員方法();
 
  物件的使用格式例子: 
  對應到Java的類當中：

成員變數（屬性）：
    String name; // 姓名
    int age; // 年齡
成員方法（行為）：
    public void eat() {} // 吃飯
    public void sleep() {} // 睡覺
    public void study() {} // 學習

注意事項：
1. 成員變數是直接定義在類當中的，在方法外邊，
2. 成員方法不要寫static關鍵字，
 */
public class Student {

    // 成員變數
    String name; // 姓名
    int age; // 姓名

    // 成員方法
    public void eat() {
        System.out.println("吃飯！");
    }

    public void sleep() {
        System.out.println("睡覺！");
    }

    public void study() {
        System.out.println("學習！");
    }

}
 
  成員變數的默認值: 
   
  面向物件程式記憶體圖: 
  相關代碼: 
  /*
學生類
	學號：int
	姓名：String
	年齡：int
	性別：boolean
	住址：String

變數必須先宣告，再賦值才能訪問，

注意：對于成員變數來說，沒有手動賦值時，系統默認賦值，
賦的值都是默認值，那么默認值是什么？

型別				默認值
---------------------
byte				0
short				0
int				0
long				0L
float				0.0F
double			0.0
boolean			false
char				\u0000
參考資料型別	null

null是一個java關鍵字，全部小寫，表示空，是參考型別的默認值，

分析：對于成員變數來說，是不是應該一個物件有一份，
	李四有李四的學號
	張三有張三的學號
	李四和張三的學號不一樣，所以應該有兩塊不同的記憶體空間，

*/
public class Student{

	// 屬性（描述狀態），在java程式中以“成員變數”的形式存在，

	// 學號
	// 一個物件一份，
	int no; // 這種成員變數又被稱為“實體變數”，

	// 姓名
	String name;

	// 年齡
	int age;

	// 性別
	boolean sex;

	// 住址
	String addr;

}

 
  /*
	物件的創建和使用，
*/
public class StudentTest{

	public static void main(String[] args){

		//區域變數
		//錯誤: 可能尚未初始化變數k
		/*
		int k;
		System.out.println(k);
		*/

		//訪問學生姓名可以直接通過類名嗎？
		// 學生姓名是一個實體變數，實體變數是物件級別的變數，
		// 是不是應該先有物件才能說姓名的事兒，
		// 不能通過“類名”來直接訪問“實體變數”，
		//System.out.println(Student.name);
		
		// i屬于區域變數嗎？當然是，
		// 區域變數存盤在堆疊記憶體當中，（堆疊主要存盤區域變數，）
		//int i = 100;

		// 創建學生物件1
		// s1屬于區域變數嗎？當然是，
		// s1這個區域變數叫做參考
		Student s1 = new Student();
		// 怎么訪問實體變數？
		// 語法：參考.實體變數名
		System.out.println(s1.no);
		System.out.println(s1.name);
		System.out.println(s1.age);
		System.out.println(s1.sex);
		System.out.println(s1.addr);

		System.out.println("-----------------------------");


		// 創建學生物件2
		// s2也是區域變數，
		// s2也叫做參考，
		Student s2 = new Student();
		System.out.println(s2.no);
		System.out.println(s2.name);
		System.out.println(s2.age);
		System.out.println(s2.sex);
		System.out.println(s2.addr);

		// 程式執行到此處我可以修改s1這個學生的學號嗎？
		// 通過“=”賦值的方式將記憶體中實體變數的值修改一下，
		s1.no = 110;
		s1.name = "張三";
		s1.age = 20;
		s1.sex = true;
		s1.addr = "深圳寶安區";

		System.out.println("學號=" + s1.no);
		System.out.println("姓名=" + s1.name);
		System.out.println("年齡=" + s1.age);
		System.out.println("性別=" + s1.sex);
		System.out.println("住址=" + s1.addr);

		// 再次賦值
		s1.addr = "北京大興區";
		System.out.println("住址：" + s1.addr);

	}

	public static void method(){
		// i s1 s2都是main方法中的區域變數，在這里是無法訪問的，
		/*
		System.out.println(i);
		System.out.println(s1);
		System.out.println(s2);
		*/
	}
}
 
  [外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-t7QDQao8-1602919367665)(C:\Users\阿旺\AppData\Roaming\Typora\typora-user-images\image-20201016210913416.png)] 
   
   總結: 
   （1）在類中的位置不同
 成員變數：類中，方法外
 區域變數：方法中或者方法宣告上（形式引數）
 （2）作用范圍不一樣
 成員變數：類中
 區域變數：方法中
 （3）初始值不同
 成員變數：有默認值
 區域變數：沒有默認值，必須定義，賦值，最后使用
 （4）在記憶體中的位置不同
 成員變數：堆記憶體
 區域變數：堆疊記憶體
 （5）生命周期不同
 成員變數：隨著物件的創建而存在，隨著物件的消失
 區域變數：隨著方法的呼叫而存在，隨著方法的呼叫完畢而消失 
   
  構造方法: 
  當一個物件被創建時候，構造方法用來初始化該物件，給物件的成員變數賦初始值，
 （無論是否自定義構造方法，所有類都有構造方法，因為Java自動提供了一個無引數構造方法，一旦自己定義了構造方法，Java自動提供的默認無引數構造方法就會失效，） 
  構造方法的定義格式: 
  修飾符 構造方法名(引數串列){
	//方法體
}
 
  /*
  1 構造方法(Constructor)
  2 構造方法的作用:
      創建物件,并且創建物件的程序中給屬性賦值(初始化)
*/
public class ConstructorTest
{
	public static void main(String[]args){

      User1 u = new User1();
	  System.out.println(u.id);//0   //11
	  System.out.println(u.name);//null   //lihua
       System.out.println(u.age);//0    //13


	   //這時呼叫的是public User1(int),所以沒有手動賦值
	   User1 u2 = new User1(3333);
	   System.out.println(u2.id);//0
	  System.out.println(u2.name);//null
       System.out.println(u2.age);//0
	}
}

/*
  1 id  name  age 都有默認值
  0    null  0
  
  2 思考:實力變數沒有手動賦值的時候,系統會默認會賦值
  那么這個默認賦值操作是在什么時候進行的?
       是在類加載的時候給這些實體變數賦值的嗎還是等物件創建的時候賦值的?
             :::不是,實體變數是在構造方法執行的程序中完成初始化的,完成賦值的	 
			 */
	public class User1
	{
		//3個屬性,三個實體變數(物件變數)
		//用戶id
		int id;  //因為System.out.println(User1.id);錯誤的.需要現物件new,只要物件有了才能訪問id
	    //用戶名
		String name;
		//年齡
		int age;
	
	    //手動定義有引數的構造方法,無引數構造方法將自動消失.  編譯會出錯
		   //解決辦法下面類注釋,或者在手動寫一個無參構造方法
		  public User1(int a){
	}
		  public User1(){
		  //這里實際上有三行代碼,只是不看見
		  //無引數的構造方法體當中雖然什么代碼都沒有寫,但是實際上是這個方法體里面
		  //進行的實體變數默認值初始化
		  //id =0   name = null  age = 0;;;;
	
		  //這就表示不再采用系統的默認值,手動賦值了
		  id = 11;
		  name = "lihua";
		  age = 13;
	  
	  }	
}
 
   
   構造方法的寫法上，方法名與它所在的類名相同，它沒有回傳值，所有不需要回傳值型別，甚至不需要void，使用構造方法后 
   總結: 
   1.如果你不提供構造方法，系統就會給出無引數構造方法
 2.如果你提供了構造方法，系統將不再提供無引數構造方法
 3.構造方法是可以多載的，即可以定義引數，也可以不定義引數 
   
  封裝 
  封裝：禁止直接訪問一個物件中的資料，應通過操作介面來訪問，適當的封裝可以讓代碼更容易理解與維護，也加強了代碼的安全性， 
  1.方法就是一種封裝
 2.關鍵字private也是一種封裝 
  private關鍵字使用格式: 
  private 資料型別 變數名;
 
  1.使用private修飾成員變數
 2.提供getXxx方法/setXxx方法/isXxx方法,可以訪問成員變數，代碼如下： 
  代碼
/*
	Person表示人類：
		每一個人都有年齡這樣的屬性，
		年齡age，int型別，
	
	我這里先不使用封裝機制，分析程式存在什么缺點？
		Person類的age屬性對外暴露，可以在外部程式中隨意訪問，導致了不安全，
	
	怎么解決這個問題？
		封裝，
*/

// 這是沒有封裝的Person，
/*
public class Person{

	// 實體變數(屬性)
	int age; //age屬性是暴露的，在外部程式中可以隨意訪問，導致了不安全，

}
*/

// 嘗試封裝一下
// 不再對外暴露復雜的資料，封裝起來
// 對外只提供簡單的操作入口，
// 優點：第一資料安全了，第二呼叫者也方便了，
public class Person{
	// private 表示私有的，被這個關鍵字修飾之后，該資料只能在本類中訪問，
	// 出了這個類，age屬性就無法訪問了，私有的，
	private int age; // 每一個人年齡值不同，物件級別的屬性，

	// 對外提供簡單的訪問入口(電視機的遙控器就相當于是電視機的訪問入口，簡單明了，)
	// 外部程式只能通過呼叫以下的代碼來完成訪問
	// 思考：你應該對外提供幾個訪問入口?
	// 思考：這些操作入口是否應該是方法呢？
	// 寫一個方法專門來完成讀，(get)
	// 寫一個方法專門來完成寫，(set)
	// get和set方法應該帶有static，還是不應該有static,get和set方法應該定義為實體方法嗎？
	// get讀年齡，set改年齡，這個讀和改都是操作的一個物件的年齡，（沒有物件何來年齡）
	// 封裝的第二步：對外提供公開的set方法和get方法作為操作入口，并且都不帶static，都是實體方法，
	/*
		[修飾符串列] 回傳值型別 方法名(形式引數串列){
		}

		注意：
			java開發規范中有要求，set方法和get方法要滿足以下格式，
				get方法的要求：
					public 回傳值型別 get+屬性名首字母大寫(無參){
						return xxx;
					}
				set方法的要求：
					public void set+屬性名首字母大寫(有1個引數){
						xxx = 引數;
					}
			
			大家盡量按照java規范中要求的格式提供set和get方法，
			如果不按照這個規范格式來，那么你的程式將不是一個通用的程式，

	*/
	// get方法
	public int getAge(){
		return age;
	}

	// set方法
	public void setAge(int nianLing){
		// 能不能在這個位置上設定關卡！！！！
		if(nianLing < 0 || nianLing > 150){
			System.out.println("對不起，年齡值不合法，請重新賦值！");
			return; //直接終止程式的執行，
		}
		//程式能夠執行到這里，說明年齡一定是合法的，
		age = nianLing;
	}

}

//在外部程式中訪問Person這個類中的資料

public class PersonTest
{
	public static void main(String[]args){
		//創建person物件
		Person p1 = new Person();
		//訪問年齡
        //訪問一個物件的屬性 通常包括兩種操作:一種是讀資料,一種是改資料
          //一   讀資料
		  System.out.println(p1.age);//讀(get  獲取)

       //修改資料(set 表示修改/設定)
	  p1.age = 50;
        System.out.println(p1.age);//再次讀取

		//在persontest這個外部程式中目前是可以隨意對age屬性進行操作的
	  p1.age = -100;//改(隨意在這里對person的內部資料進行更改,導致業務不安全)
	  System.out.println("您的年齡值為=" + p1.age);//讀  
	  //程式中給年齡賦值了個負數,不符合業務要求,這就是一個程式bug



	}
}

public class PersonTest2{
	public static void main(String[] args){
		// 創建物件
		Person p1 = new Person();

		// Person的age，徹底在外部不能訪問了，但是這難免有點太安全了，
		// age不能訪問，這個程式就意義不大了，
		
		/*
		// 讀age屬性的值
		System.out.println(p1.age);
		 
		 錯誤: age 在 Person 中是 private 訪問控制
                System.out.println(p1.age);
				

		// 修改age屬性的值
		p1.age = 20;

		// 讀age
		System.out.println(p1.age);
		*/
		
   //通過"類名."可以呼叫set和get方法嗎?  不行
   //只有方法修飾符串列中有static的時候才可以使用"類名."的方式訪問
   //Person.getAge();//錯誤: 無法從靜態背景關系中參考非靜態 方法 getAge()


      //讀呼叫getAge()方法
	  //第一種(不合并)
     /*int nianLing = p1.getAge();
        System.out.println(nianLing);//0
		*/
		//第二種(合并)
	   System.out.println(p1.getAge()); //0

		//改呼叫setAge()方法
		p1.setAge(20);//傳給nianling后再給age再給getAge

		System.out.println(p1.getAge()); //20

		// 你折騰半天了，這不是結果還是沒控制住嗎？？？？？？
		p1.setAge(-100);
		//System.out.println(p1.getAge()); // -100
		System.out.println(p1.getAge()); // 20
	}
}
 
   
   總結: 
   封裝的作用有兩個： 
   第一個作用：保證內部結構的安全， 
   第二個作用：屏蔽復雜，暴露簡單， 
   在代碼級別上，封裝有什么用？ 
   一個類體當中的資料，假設封裝之后，對于代碼的呼叫人員來說， 
   不需要關心代碼的復雜實作，只需要通過一個簡單的入口就可以訪問了， 
   另外，類體中安全級別較高的資料封裝起來，外部人員不能隨意訪問， 
   來保證資料的安全性， 
   
  
 
用非靜態 方法 getAge() 
 
  
    //讀呼叫getAge()方法
 
  //第一種(不合并)
 /*int nianLing = p1.getAge();
 System.out.println(nianLing);//0
 */
 //第二種(合并)
 System.out.println(p1.getAge()); //0 
    //改呼叫setAge()方法
  p1.setAge(20);//傳給nianling后再給age再給getAge

  System.out.println(p1.getAge()); //20

  // 你折騰半天了，這不是結果還是沒控制住嗎？？？？？？
  p1.setAge(-100);
  //System.out.println(p1.getAge()); // -100
  System.out.println(p1.getAge()); // 20
 
  }
 } 
  
> 總結:
>
> 封裝的作用有兩個：
>
> 第一個作用：保證內部結構的安全，
>
> 第二個作用：屏蔽復雜，暴露簡單，
>
>  
>
> 在代碼級別上，封裝有什么用？
>
> 一個類體當中的資料，假設封裝之后，對于代碼的呼叫人員來說，
>
> 不需要關心代碼的復雜實作，只需要通過一個簡單的入口就可以訪問了，
>
> 另外，類體中安全級別較高的資料封裝起來，外部人員不能隨意訪問，
>
> 來保證資料的安全性，







        
      轉載請註明出處，本文鏈接：https://www.uj5u.com/shujuku/179595.html
      標籤：其他 
      上一篇：如何獲得網站上檔案上傳后的路徑
下一篇：Spring系列第八講 自動注入（autowire）詳解，高手在于堅持！

Java自學后的前十章實時復習-cnblog

Java自學后的前十章練習題及實時復習

各章重點知識的總結及回顧

所有命名規則必須遵循以下規則：

java中的流程控制

練習::九九乘法表

Java面向物件的編程

物件的創建

構造方法:

封裝