Java——Object

1.Object萬類之祖

1.1 Object類型的概述

Object類是所有類型的頂層父類，所有類型的直接或者間接的父類；所有的類型中都含有Object類中的所有方法。
隨意定義一個類型,不手動顯式定義其父類，那么這個類的父類就是Object類
public Object() {

}
Object類的構造方法：Object()
- 可以自己創建對象
- 讓子類訪問,所有子類都會直接或者間接的訪問到這個頂層父類的構造方法
- Object類在執行構造方法時，不去訪問自己的父類，因為沒有父類了

1.2 getClass()

返回當前對象的運行時類
- 目前記住其中Class類型中有一個getName，可以返回當前類型的全類名
示例

public class Demo {public static void main(String[] args) {Demo demo = new Demo();System.out.println(demo.getClass().getName());}
}

1.3 hashCode()

根據對象的情況，生成的一個整數，就是哈希碼值。生成數字的方法就是hashCode方法，它是一個特征值。
示例：

public class Demo {public static void main(String[] args) {Demo demo = new Demo();System.out.println(demo.hashCode());demo = new Demo();System.out.println(demo.hashCode());}
}

1.4 toString方法

返回當前對象的字符串表示
對象返回一個地址值的字符串，沒有什么意義
最終操作：不需要手動重寫，可以直接使用快捷鍵生成：Alt+Insert
使用打印語句打印一個對象，其實打印的就是這個對象的toString內容

1.5 equals

用于比較兩個對象是否相等的方法，比較的就是“調用者”和“參數”這兩個對象

boolean equals(Object obj)

在Object類型中，是比較兩個對象的地址值是否相同。

實際生活中，比較兩個對象的內存地址，沒有什么意義。因此在自定義的子類中，都要重寫這個方法。
- 按照自定義的方式比較兩個對象是否相同
重寫原則：
- 一般比較兩個對象中的所有屬性，是否全部相同
- <比如兩個對象的name值相同，那么兩個對象就相同>
代碼實例

public class Simple01 {public static void main(String[] args) {Cat cat1 = new Cat("咪咪");Cat cat2 = new Cat("咪咪");boolean bool = cat1.equals(cat2);System.out.println(bool);// 表示獲取全類名 包 +類名System.out.println(cat1.getClass());}
}class Cat {private String name;public String getName() {return name;}public Cat(String name) {this.name = name;}public void setName(String name) {this.name = name;}@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Cat cat = (Cat) o;return this.getName().equals(cat.getName());}
}

1.6 ==和equals方法的區別

相同點
- ==和equals都是用于比較數據是否相等的方式
不同點：
- 比較內容的不同：
  - ==可以比較任意數據類型，既可以比較基本數據類型，也可以比較引用數據類型
  - equals方法只能比較引用數據類型
- 比較規則不同：
  - ==在比較基本類型的時候，比較的是數據的值；比較引用類型時，比較的是地址值
  - equals方法在重寫之前，比較的是兩個對象的地址值；在重寫之后，比較的屬性值也就是類里面的屬性值的大小。

2.內部類

2.1內部類的概述

定義在內部的類，就是內部類。可以定義在類的內部,可以定義在方法的內部。
根據定義的位置不同，可以分為：

成員內部類
- 普通的成員內部類
- 私有的成員內部類
- 靜態的成員內部類
局部內部類
匿名內部類

2.2普通的成員內部類

定義在成員位置上的類，就是成員內部類
定義格式：
class 內部類類名 {
? ? ?? ??? ??? ?內部類成員
?? ??? ?}
成員內部類的說明：
- 內部類可以直接訪問外部類的所有成員，包括私有成員
- 外部類訪問內部類的成員，必須先創建內部類的對象
- 在外部類以外，創建內部類的對象的格式：
  - 外部類名.內部類名內部類對象名 = new 外部類名().new 內部類名();
代碼實例：

/*** 普通成員內部類*/
public class Simple02 {public static void main(String[] args) {Body.Heart heart = new Body().new Heart();heart.show();}
}//類嵌套類\
class Body {private double height = 1.74;class Heart {int beats = 90;public void show() {System.out.println("身高是" + height + ",心跳每分鐘" + beats);}}}

2.3私有的成員內部類

也是一個成員內部類，在成員內部類前面加上一個private關鍵字
訪問方式說明：
- 在外部類以外，不能直接訪問外部類中的私有成員內部類
- 可以在外部類中，定義一個訪問私有內部類的公有方法，讓外界可以調用公有方法，間接的訪問外部類中的私有成員內部類。
代碼示例:

public class Simple02 {public static void main(String[] args) {Body body = new Body();body.test();}
}//類嵌套類\
class Body {private double height = 1.79;private class Heart {int beats = 90;public void show() {System.out.println("身高是" + height + ",心跳每分鐘" + beats);}}public void test() {Heart hh = new Heart();hh.show();}
}

2.4 靜態的成員內部類

也是一個成員內部類，在成員內部類前面加上一個static關鍵字
訪問特點：
- 靜態內部類中的非靜態成員，需要將所在的內部類對象創建出來之后，才能被調用。
- 靜態內部類中的靜態成員,可以通過外部類名.內部類名的方式直接訪問，而不需要創建外部類的對象
- 總結：一個類是否需要創建對象，不取決于該類本身是否是靜態，而取決于要訪問的成員是否是靜態
- 靜態成員內部類的對象創建格式：
- 外部類名.內部類名內部類對象名 = new 外部類名.內部類名();
- 代碼實例
- ```
public class Simple03 {public static void main(String[] args) {// 方式一：外部類名.內部類名 內部類對象名 = new 外部類名.內部類名();Body2.Liver liver = new Body2.Liver();liver.show();// 方式二：外部類名.內部類名的方式直接訪問System.out.println(Body2.Liver.FUNC);}}class Body2 {private double weight = 180;static class Liver {String color = "black";static final String FUNC = "解毒";void show() {System.out.println("肝都變成" + color + "色了，少整點吧！");}}
}
```

2.5局部內部類

定義在方法中的內部類

說明：

問題：屬于方法中的局部變量，外界都沒有辦法訪問到
解決方式:在方法內部定義調用方式
代碼示例：

public class Simple3 {public static void main(String[] args) {new Body2().methodTest();}}class Body2 {void methodTest () {class SeaFood {void eat () {System.out.println("喝酒不能吃海鮮");}}new SeaFood().eat();}}

2.6 匿名內部類【常用】

沒有名字的內部類
匿名內部類的使用前提：
- 匿名類：繼承一個類
- 匿名類：實現一個接口
格式：
new 父類類名或者接口名() {
? ? ?? ?父類方法的重寫或者是接口內容的實現
}
本質：創建了一個類的子類對象、接口的實現類對象
示例代碼

public class Simple04 {public static void main(String[] args) {// 父 new 子Games games = new MyGames();games.play("LOL");// 匿名內部類new Games() {@Overridepublic void play(String name) {System.out.println("會玩" + name);}}.play("王者榮耀");// 拉姆達表達式Games games1 = (name) -> System.out.println("會玩" + name);games1.play("三國殺");}
}interface Games {void play(String name);
}class MyGames implements Games {@Overridepublic void play(String name) {System.out.println("會玩" + name);}
}

3.String

3.1概述

String就是字符串類型，屬于java.lang包，不需要導包
所有的字符串常量"Hello World","abc"都屬于String類型的對象
字符串字面值屬于常量，存儲在方法區的常量池中。
String類型是一個常量，在創建之后就無法更改（是一個不可變的字符序列）。
不可變的原因是String類型只提供了構造方法，沒有提供set方法，因此只能在創建對象的時候，初始化成員變量，將來對象創建完成之后，無法通過方法來修改。
代碼示例:

public class Simple05 {public static void main(String[] args) {String str2 = "abc";System.out.println(str2);//abcstr2 = "xyz";System.out.println(str2);//xyz}
}

3.2 String類型的構造方法

String()：創建一個空字符串
String(String original)：創建參數字符串的一個副本（字符串是在常量池中，構造方法創建的字符串是在堆內存中）
String(byte[] arr)：將一個字節數組轉成一個字符串,將我們不認識的字節數組，轉成了我們認識的字符串，過程叫做【解碼】查詢的是當前平臺默認的編碼表
String(byte[] arr, int offset, int length)：將字節數組的一部分轉成字符串
String(char[] arr)：將字符數組轉成字符串
- 既不是編碼，也不是解碼，只不過是把字符串成了串
String(char[] arr, int offset, int length)：將字符數組的一部分轉成字符串
代碼示例：

public class Simple06 {public static void main(String[] args) {//test1_空參構造();//test2_原始字符串轉換();//test3_字節數組轉字符串();test4_字符數組轉成字符串();}private static void test4_字符數組轉成字符串() {char[] arr = {'a', 'b', 'X', 'Y'};String str1 = new String(arr);System.out.println(str1);//abXY  只是組成字符串而已//將字符 數組的一部分轉成字符串，String str2 = new String(arr, 1, 2);System.out.println(str2);//bX}private static void test3_字節數組轉字符串() {//將整個字節數組轉成了字符串byte[] bytes = {99, 111, 100, 105, 110, 103, 45, 102, 117, 116, 117, 114, 101};String s = new String(bytes);System.out.println(s);/*將字節數組的一部分轉成字符串，* 其中offset是從哪個索引開始，length表示要將多少個字節是轉成字符串*/byte[] arr = {99, 111, 100, 105, 110, 103, 45, 102, 117, 116, 117, 114, 101};String str2 = new String(arr, 1, 4);System.out.println(str2);}private static void test2_原始字符串轉換() {String str = new String("abc");//這個對象，在堆內存中//"abc"常量，在方法區的常量池//new String("abc")這個對象，在堆內存中//str指向了堆內存中的對象System.out.println(str);//abcSystem.out.println(str == "abc");//falseSystem.out.println("abc" == "abc");//true}public static void test1_空參構造() {String str = new String();System.out.println(str);}
}

3.3 String類型的判斷功能

equals(Object obj)：判斷調用者和參數對象描述的字符串內容是否相同
equalsIgnoreCase(String otherStr)：忽略大小寫判斷兩個字符串內容是否相同
contains(String str)：判斷調用者是否包含了str這個子串
startsWith(String prefix)：判斷調用者是否以prefix開頭
endsWith(String suffix)：判斷調用者是否以suffix結尾
isEmpty()：判斷調用者是否是空串
代碼示例

public class Simple07 {public static void main(String[] args) {
//        test1_equals();
//        test2_equalsIgnoreCase();
//        test3_包含();
//        test4_5_判斷開始和結束();
//        test6_判斷為空();}private static void test6_判斷為空() {String str = "abc";System.out.println(str.isEmpty());//false  字符串不為null}private static void test4_5_判斷開始和結束() {String str = "abcdefg";System.out.println(str.startsWith("abc"));//trueSystem.out.println(str.startsWith("abd"));//fasleSystem.out.println(str.startsWith("cde"));//falseSystem.out.println(str.endsWith("efg"));//true}private static void test3_包含() {String str1 = "abcdefg";System.out.println(str1.contains("abc"));//trueSystem.out.println(str1.contains("efg"));//trueSystem.out.println(str1.contains("cde"));//trueSystem.out.println(str1.contains("ace"));//false 必須是連續的}private static void test2_equalsIgnoreCase() {String str1 = "abcDEF";String str2 = "abcdef";System.out.println(str1.equals(str2));//false 字符串不相等//忽略大小寫判斷兩個字符串內容是否相同System.out.println(str1.equalsIgnoreCase(str2));//true}private static void test1_equals() {String str1 = new String("abc");//在堆中String str2 = new String("abc");System.out.println(str1 == str2);//false 兩個對象地址不一樣 new了兩次System.out.println(str1.equals(str2));//true  指向同一個對象}
}

3.4 String類型的獲取功能

length()：獲取字符串字符的個數
charAt(index)：返回調用者字符串中索引為index的字符（和length方法結合之后可以遍歷字符串）
substring(int beginIndex)：獲取一個字符串，內容是從當前字符串的beginIndex索引開始，一直到最后一個字符機截止
substring(int beginIndex, int endIndex)：獲取一個指定索引范圍的子串
- 注意事項：1、包含頭不包含尾，返回的結果中，不包含endIndex索引指向的字符；2、所有的方法都無法修改字符串對象本身，一般都是返回一個新的字符串對象
indexOf家族：
- indexOf(int ch)：返回ch字符在當前調用者字符串中，第一次出現的索引
- indexOf(int ch, int fromIndex)：從fromIndex索引開始尋找，找到ch字符在當前字符串中第一次出現的索引
- indexOf(String str)：返回的是str這個字符串在調用者字符串中第一次出現的索引
- indexOf(String str, int fromIndex)：從fromIndex索引開始尋找，找到str字符串在當前字符串中第一次出現的索引（注意：無論從哪個位置開始找，所有字符的索引都不會變化）
lastIndexOf家族：
- 和IndexOf基本一樣，只不過是從后往前找，所有字符和字符串的索引也都不會發生變化
示例代碼

public class Simple08 {public static void main(String[] args) {test1_length();test2_charAt();test3_字符串遍歷();test4_獲取子串();test5_indexOf();test6_lastIndexOf();}private static void test6_lastIndexOf() {String str = "abcdabcd";System.out.println(str.lastIndexOf('c'));System.out.println(str.lastIndexOf('c', 5));System.out.println(str.lastIndexOf("cd"));System.out.println(str.lastIndexOf("cd", 5));}private static void test5_indexOf() {String str = "abcdabcd";//返回第一個c出現的索引System.out.println(str.indexOf('c'));System.out.println(str.indexOf('c', 3));System.out.println(str.indexOf("cd"));//2System.out.println(str.indexOf("cd", 3));}private static void test4_獲取子串() {String str = "abcdefg";String result = str.substring(3);//str本身不會變化，因為字符串對象是一個不可變的字符序列System.out.println(str);//substring可以返回一個新的字符串對象System.out.println(result);//通過兩個參數的substring獲取子串System.out.println(str.substring(2, 5));}private static void test3_字符串遍歷() {String str = "abcdefg";//遍歷字符串for (int i = 0; i < str.length(); i++) {System.out.println(str.charAt(i));}}private static void test2_charAt() {String str = "abcdefg";char c = str.charAt(3);System.out.println(c);}private static void test1_length() {String str = "abcdefg";System.out.println(str.length());}
}

3.5 String類型的轉換功能

byte[] getBytes()：將當前字符串，轉成字節數組(編碼)
char[] toCharArray()：將當前的字符串，轉成字符數組
toUpperCase()：將當前的字符串，轉成全大寫形式
toLowerCase()：將當前的字符串，轉成全小寫形式
concat(String str)：將當前調用者，和參數str進行拼接，返回拼接后的長字符串（不常用，因為更多使用的是運算符+）
valueOf家族：可以將任意數據類型的數據，轉換成字符串 (靜態方法)
代碼示例：

public class Simple09 {public static void main(String[] args) {test1_getBytes();test2_toCharArray();test3_upperAndLower();test4_concat();test5_valueOf();}private static void test5_valueOf(){//可以將任意數據類型的數據，轉換成字符串System.out.println(String.valueOf(false));System.out.println(String.valueOf('x'));System.out.println(String.valueOf(new char[] {'a', 'b'}));System.out.println(String.valueOf(100));Object obj = null;System.out.println(String.valueOf(obj));}private static void test4_concat() {String str = "abc";String result = str.concat("xyz");System.out.println(result);System.out.println(str + "xyz");//將當前調用者，和參數str進行拼接，返回拼接后的長字符串（不常用，因為更多使用的是運算符+）}private static void test3_upperAndLower() {String str = "aBCdEfG";String upper = str.toUpperCase();//：將當前的字符串，轉成全大寫形式System.out.println(str);System.out.println(upper);String lower = str.toLowerCase();//：將當前的字符串，轉成全小寫形式System.out.println(lower);}private static void test2_toCharArray() {String str = "abcdefg";char[] arr = str.toCharArray();//將當前的字符串，轉成字符數組for (int i = 0; i < arr.length; i++) {System.out.print(arr[i] + "\t");}System.out.println();}private static void test1_getBytes() {String str = "abc";byte[] arr = str.getBytes();//將當前字符串，轉成字節數組(編碼)for (int i = 0; i < arr.length; i++) {System.out.println(arr[i]);}}
}

3.6 String類型的其他方法

replace(String oldStr, String newStr)：將調用者中的老串替換成新串
trim()：去掉字符串左右兩邊的空格、制表符

split：

split(String regex, int limit)：字符串按照某個字符串進行分割，返回字符串數組，且限制返回元素個數。
split()：不限制返回元素個數。
String str = "Hello,World!com.coding-future";
? ? ? ?String[] s = str.split("[,!.-]");
? ? ? ?System.out.println(Arrays.toString(s));
? ?}
format
String str = ?String.format("我是%s人，我愛%s","中國","中國");
代碼示例

public class Simple10 {public static void main(String[] args) {test2_trim();test1_replace();}//去掉字符串左右兩邊的空格、制表符private static void test2_trim() {String str = "  I love java,  java is good ";String result = str.trim();System.out.println(str);System.out.println(result);}//將調用者中的老串替換成新串private static void test1_replace() {String str = "I love java, java is good";String result = str.replace("java", "study");System.out.println(str);System.out.println(result);}
}

4. StringBuffer && StringBuilder

4.1概述

內存理解:

public class Simple11 {public static void main(String[] args) {String[] strArr = {"java", "javascript", "html", "css", "nodejs"};String s1 = "我會的技能有：";for (String s : strArr) {s1 += s;s1 += ",";}System.out.println(s1);}
}

StringBuilder是一個可變的字符序列，因為在類中提供了修改私有成員變量的方法
- 常用的方法是append和insert，就是在StringBuilder對象本身上，進行修改操作
String類型和StringBuilder的關系：都是用于描述字符串
- String是不可變的字符序列，沒有提供修改私有成員的方法；StringBuilder是可變的字符序列，因為提供了修改成員變量的方法；
- String長度本身也不可以變化，StringBuilder長度可以變化，可以認為StringBuilder就像一個可以伸縮的容器，用于存儲字符

4.2構造方法

構造方法作用：創建當前對象、將其他類型的數據，轉換成當前類型
StringBuilder的構造方法：
- StringBuilder()：創建一個生成器，初始容量為16個字符
- StringBuilder(int capacity)：創建一個生成器，初始容量為capacity大小
- StringBuilder(String str)：創建一個生成器，初始值就是str這些字符，初始大小是str+16
獲取容積的方法：
- capacity()：獲取當前生成器的容器大小
- length()：獲取當前生成器中的字符個數
代碼示例

public class Simple12 {public static void main(String[] args) {StringBuilder sb1 = new StringBuilder();System.out.println(sb1.capacity());//16StringBuilder sb2 = new StringBuilder(10);System.out.println(sb2.capacity());//10StringBuilder sb3 = new StringBuilder("Hello");System.out.println(sb3.capacity());//21System.out.println(sb3.length());//字符個數是5}
}

4.3添加功能

append(任意類型)：可以將任意數據類型，轉成字符，添加到生成器中
insert(int index, 任意數據類型)：可以將任意數據類型，添加到指定的位置
- index的范圍是0~當前緩沖區的大小
- 插入數據之后，數據本身的索引就是參數中指定的index
實例代碼

private static void test1insert() {StringBuilder sb1 = new StringBuilder();//"1"sb1.insert(0, "a");System.out.println(sb1);//1sb1.insert(0, "b");System.out.println(sb1);//basb1.insert(1, "xyz");System.out.println(sb1);//bxyza}

4.4刪除功能

deleteCharAt(int index) ：刪除指定索引的字符
delete(int start, int end)：刪除指定范圍的字符，被刪除的部分包含頭不包含尾
實例代碼

public class Simple13 {public static void main(String[] args) {//test1_deleteCharAt();test2_delete();}private static void test2_delete() {StringBuilder sb1 = new StringBuilder("abcdef");//刪除cdsb1.delete(2, 4);System.out.println(sb1);//abef}private static void test1_deleteCharAt() {StringBuilder sb1 = new StringBuilder("abcdefg");sb1.deleteCharAt(2);System.out.println(sb1);//abdefg  刪除指定索引的字符sb1.deleteCharAt(6);//String索引越界異常System.out.println(sb1);}
}

4.5替換和反轉功能

replace(int start, int end ,String str)：
- 將字符串緩沖區中的從start開始到end-1這部分內容，替換成str
reverse()：將原有字符序列進行反轉
示例代碼

public class Simple14 {public static void main(String[] args) {test1_replace();test2_reverse();}private static void test2_reverse() {StringBuilder sb1 = new StringBuilder("abcdefg");sb1.reverse();System.out.println(sb1);}private static void test1_replace() {StringBuilder sb1 = new StringBuilder("abcdefg");sb1.replace(2, 5, "qq");System.out.println(sb1);}
}

4.6.StringBuffer和StringBuilder的區別

共同點：
- 都是字符串的緩沖區，都是字符串的生成器，都是可變的字符序列
不同點：
- 出現版本不同：
  - StringBuffer在jdk1.0出現的
  - StringBuilder在jdk1.5出現的
- 線程安全性不同：
  - StringBuffer是線程安全的，在多線程環境下仍然保證數據安全
  - StringBuilder是線程不安全，在多線程環境下無法保證數據安全
- 效率不同：
  - StringBuffer效率低
  - StringBuilder效率高

5.包裝類

5.1概述

class Test {String str = "50";int a = (int) str; //此方式是否可以將str轉成int類型int age = null; // 是否可以這樣操作？
}

基本數據類型有八種，都是非常簡單的數據類型
在這些類型中，只能表示簡單的數據，不能包含一些操作數據的方法，沒有辦法存儲描述這些數據的內容。需要準備一個引用數據類型，能將基本數據類型進行包裝，提供一些操作基本類型的方法，定義一些描述數據的數據。
基本類型的包裝類：
- byte Byte
  short Short
  int Integer類型
  long Long
  float Float
  double Double
  char Character
  boolean Boolean
各種包裝類型的方法、特點基本相同，只要學習一個Integer類型，其他的也觸類旁通。
Integer類型的對象中，維護了一個私有的成員變量，是一個int類型的字段（成員變量、屬性），用于表示這個Integer對象要表示的數字。
提供了在int、Integer、String類型之間相互轉換的方法

byte Byte
short Short
int Integer類型
long Long
float Float
double Double
char Character
boolean Boolean

5.2 Integer的構造方法

Integer(int i)：將一個基本類型的int數，轉換成Integer類型的對象使用i給Integer對象中的成員變量賦值
Integer(String s)：將一個字符串類型的數字，轉換成Integer類型的對象轉換的作用
示例代碼

public class Simple15 {public static void main(String[] args) {//將一個基本類型的int數，轉換成Integer類型的對象使用i給Integer對象中的成員變量賦值Integer it = new Integer(100);System.out.println(it);//將一個字符串類型的數字，轉換成Integer類型的對象轉換的作用Integer it1 = new Integer("100");System.out.println(it1 + 10);}
}

5.3 Integer、int、String類型互相轉換的總結

Integer轉換成int類型
- intValue()
int轉換成Integer類型
- 構造方法Integer(int i)
Integer到String的轉換
- toString方法即可
String到Integer的轉換
- Integer.valueOf(String str)
int轉換成String類型：
- Integer.toString(int i)

String轉換成int類型

Integer.parseInt(String str)

public class Simple16 {public static void main(String[] args) {Integer it2 = 10;int i = it2.intValue(); // i 沒有操作方法Integer it3 = new Integer(20);System.out.println(it3);// it3有操作方法String s = it3.toString();System.out.println(s);// 字符串Integer it4 = Integer.valueOf(s);System.out.println(it4); // IntegerString s1 = Integer.toString(i);System.out.println(s1);// 字符串int i1 = Integer.parseInt(s1);System.out.println(i1);// int 類型}
}

5.4 自動裝箱和拆箱

裝箱和拆箱：
- 裝箱：將基本數據類型，封裝成包裝類型的對象(引用類型)，這個過程就是裝箱，使用構造方法即可
- 拆箱：從包裝類型的對象中，將其包裝的基本類型的數據取出，這個過程就是拆箱，使用intValue方法即可
自動裝箱和拆箱
- 自動裝箱：可以直接使用基本類型的數據，給引用類型的變量賦值
- 自動拆箱：可以直接使用包裝類對象，給基本類型的變量賦值:包裝類對象直接進行算數運算
示例代碼

public class Simple17 {public static void main(String[] args) {Integer it = 100;//自動裝箱，100基本數據類型給integer包裝類型賦值int i = it;//自動拆箱，System.out.println(it + 1);//自動拆箱  變成基本類型 然后運算Integer inte = 100; // 先裝箱inte = inte + 1;//先自動拆箱，計算，最后自動裝箱}private static void test1_裝箱和拆箱() {int i = 100;Integer it = new Integer(i);//裝箱int j = it.intValue();//拆箱}
}

6. 包(package)

包：用于分類存放類文件(.class)的文件夾，在out/production目錄下存放.class
作用：
- 包幫助管理大型軟件系統:將功能相近的類劃分到同一個包中。比如:MVC的設計模式
- 包可以包含類和子包，劃分項目層次，便于管理
- 使用package聲明類或接口所屬的包,聲明在源文件的首行
- 解決類命名沖突的問題,同一個包下,不能命名相同的類和接口,不同的包下,可以命名同名的類和接口。
- 每"."一次,就代表一層文件目錄。
命名：域名倒著寫：com.xxxx.www（全球唯一）
包的聲明：使用package的關鍵字，聲明當前的類是屬于指定的包的。
效果：
- 編譯的這個類，就會進入到一個指定的文件夾中。
- 當前的類，名稱也發生了變化，類名變成了【包名 + 類名】
簡化：

每次使用其他包的類的時候，都需要寫很長一串全類名，所以非常麻煩，需要簡化. 使用import語句進行簡化，在類的聲明上，寫一個import語句，將這個類的全類名導入進來，在該類中，就可以直接使用這個類的簡寫形式了。
注意事項：
- 在源文件中使用import顯式的導入指定包下的類或接口
- 聲明在包的聲明和類的聲明之間。
- 如果導入的類或接口是java.lang包下的，或者是當前包下的，則可以省略此import語句。 System, String...
- 如果需要導入多個類或接口，那么就并列顯式多個import語句即可
- 可以使用java.util.*的方式，一次性導入util包下所有的類或接口,不建議使用import *，使用import到類名。