Java之父：James Gosling，高司令
1995年推出JDK1.0
JDK8.0
A：JavaSE，Java Platform Standard Edition(Java平臺標準版)
B：JavaEE，Java Platform Enterprise Edition(Java平臺企業版)，企業級開發
C：JavaME，Java Platform Micro Edition(Java平臺微小版)
將原始檔一行一行解釋，一行一行執行。不同的操作系統具備不同的直譯器。
執行效率低。跨平臺。
將原始檔編譯成機器碼檔案，一次編譯。多次執行。
執行效率高。不可跨平臺。
安裝JDK–>版本是8.0版本 設定環境變數
1、單行註釋
2、多行註釋
3、文件註釋
1、組成：數位，字母，_,$，組成
2、數位不能開頭
3、區分大小寫
4、長度
5、不能是java中的關鍵字和保留字。
見名知意
1.先宣告，再賦值
2.宣告和賦值寫一起
3.多個變數統一宣告，就是寫在一起宣告：同種型別
1、變數必須先定義，才能 纔能使用
2、變數名不能衝突，同一個作用域內。
3、目前所學的變數：先初始化，再使用。
byte，位元組，1個位元組，8bit，-128~127
short，短整形，2個位元組，16bit
int，預設型別，4個位元組，32bit
long，長整形，8個位元組，64bit
在宣告long型別的時候，數值後加L或l。建議L。
float型別：4個位元組，32bit，定義變數的時候，數值後加f，或F
double型別：8個位元組，64bit，預設型別
boolean型別：取值只有兩個，true(對，真)，false(錯，假)，
char，表示單個的字元，使用單引號引起來的，但本質上是個數值，因爲對應的字元編碼值。
1、將有特殊作用的字元，轉爲普通的字元，不再起作用
2、還可以將一些普通的字元，轉爲有特殊含義的作用
\n,\t
String，用於表示一個字元序列。使用雙引號引起來的都是字串的內容
A：兩種型別相容
B：目標型別的取值範圍 大於 源型別取值範圍
強制轉換：
A：兩種型別相容
B：目標型別的取值範圍 小於 源型別的取值範圍
取值範圍：
byte–>short–>int–>long–>float–>double
char-int
算術運算子：+，-，*，/,%，++，–
賦值運算子：=，+=，-=，*=，/=,%=
關係運算符：也叫比較運算子，比較兩個數值的關係的。計算結果是boolean型別
邏輯運算子：運算元是boolean型別，計算結果也是boolean型別。
三元運算子：根據條件獲取一個結果。 語法：X ？ Y：Z
[外連圖片轉存失敗,源站可能有防盜鏈機制 機製,建議將圖片儲存下來直接上傳(img-Mk1EYTV0-1597135689170)(C:\Users\Administrator\Desktop\javaSE\day4\課堂筆記\img\自動型別提升.png)]
//step1：匯入Scanenr這個掃描器
imprt java.util.Scanner;
//step2：建立Scanner掃描器
Scanner sc = new Scanner(System.in);
//step3：使用sc呼叫對應的方法，來讀取鍵盤的輸入
int num1 = sc.nextInt();//讀取一個int型別的數據
double num2 = sc.nextDouble();//讀取一個double型別的數據
String str = sc.next();//讀取一個String型別的數據
char c = sc.next().charAt(0);//讀取一個char型別的字串
程式的流程結構：
A：順序結構：預設的，從上向下，逐行的執行。
B：選擇結構：條件滿足，某些程式碼纔會執行。
C：回圈結構：條件滿足，某些程式碼會反覆 反復多次的執行。直到條件不滿足。
if(條件：boolean){
//條件成立，執行此處的程式碼
}
if(條件：boolean){
//條件成立，執行此處的程式碼
}else{
//條件不成立，執行此處的程式碼
}
if(條件1){
條件1滿足，執行此處的程式碼
}else if(條件2){
條件1不滿足，條件2滿足，執行此處的程式碼
}else if(條件3){
條件1、2都不滿足，條件3滿足，執行此處的程式碼。
}。。。
else{
}
if(外層條件){
if(內層條件){
}else{
}
}else{
}
switch(變數/表達式){
case 數值1：分支1；break；
case 數值2：分支2；break；
case 數值3：分支3；break；
default：最後一個分支；
}
1、case後的數值，不能重複。
2、case是無序的，先寫後寫都可以，關鍵是是否能夠匹配上switch作用的變數。
3、switch作用的變數型別：short，byte，char，int，String。
4、default語句是可選的。
5、某個case匹配上後，如果該分支中沒有break，那麼後續的case都不再匹配，直接執行。一直到遇到break位置。
區域性變數：定義在函數裏面的變數。
在一個變數的作用範圍內，任何的地方都可以直接使用該變數。不能定義相同名字的其他變數。區域性變數必須要賦值才能 纔能直接使用
條件滿足，某些程式碼會被反覆 反復多次的執行。條件不成立了，回圈結束。0-n次。
1、初始化部分：對回圈變數進行初始賦值。
2、回圈條件部分：判斷回圈變數是否滿足回圈條件。
3、回圈體部分：要回圈執行的具體的程式碼。
4、更新回圈變數部分：修改回圈變數的值。
while( 回圈條件判斷 ){
//回圈體
//(回圈中變數的變化)
}
//執行流程：while回圈的特點：先判斷條件，再執行程式碼。
//CTRl+c終止回圈死回圈
do{
//回圈體
//(回圈變數的變化)
}while( 回圈條件 );
//執行流程：先執行一次再判斷
for(表達式1:回圈變數的初始化 ; 表達式2:回圈的條件 ; 表達式3：回圈變數的變化 ){
//回圈體；
}
//執行流程：表達式一次判斷
break：詞義：打破，打碎，破壞
用法一：switch-case語句中，break用於防止switch穿透。
用法二：回圈語句：while，do-while，for。強制結束了回圈語句，無論回圈條件是否滿足。
continue：詞義：繼續
用法：結束當前這次回圈，回圈下次會繼續執行。
多種回圈，指的就是回圈的巢狀。
特點：外層回圈執行1次。記憶體回圈要完整的執行一遍。
printf(" 佔位符 \n",型別的變數);//格式化列印：print+format
%d，整數佔位符
%s，字串佔位符
%f，浮點佔位符
%.2f,%.3f
%c，字元佔位符
Java中的方法，類似於其他語言的函數，一段用來完成特定功能的程式碼。這段程式碼可以被多次呼叫並執行。
函數：function
方法：method
step1：方法宣告，只是做一個方法宣告，裏面寫清楚方法的程式碼。但是這些程式碼並不執行。
step2：方法的呼叫，呼叫幾次，方法中的程式碼就執行幾次。
1.宣告一個方法的語法：
2.宣告方法的語法格式：
[修飾符1，修飾符2…] 返回值型別 方法名(形式參數){
方法體;//方法中的程式碼
}
public static void 函數名稱（）{
//函數主體
}
//定義函數的位置：與main函數並列
//函數呼叫，通過函數名稱進行呼叫
返回值只能返回一個
return語句：
return語句有兩個作用
1、將一個方法的結果返回給呼叫處。
2、結束該方法的執行。
遞回：英文單詞：Recursion
遞回演算法：
就是一組相同數據型別的數據。記憶體上是開闢的連續的記憶體空間。
方式一：數據型別[] 陣列名 = new 數據型別[長度];
A：先宣告，再建立(分配記憶體空間)
B：宣告並建立
C：宣告，建立，並賦值
數據型別[] 陣列名 = {數值1,數值2,數值3,數值4.。。。};
D：宣告，建立，並賦值
數據型別[] 陣列名 = new 數據型別[]{數值1,數值2,數值3,數值4.。。。}
遍歷：依次存取，從第一個元素，存取到最後一個元素。
1、使用回圈來遍歷陣列
for(int i = 0;i < arr.length; i++){
arr[i] = i;//賦值
System.out.println(arr[i]);//獲取數值
}
for(數據型別 變數名 : 陣列名){
System.out.println(變數名);
}
工作原理：
for(int e :arr){
System.out.println(e);
}
陣列的預設值，就是陣列建立後，裏面儲存的預設的數據。
陣列中是有預設值的
整數：0
小數：0.0
字元：\u0000
布爾：false
其他：null
陣列是參照型別：傳遞的是地址。就是參數也會指向這塊記憶體。當方法結束的時候，參數就銷燬了。
class Test5ArrayMethod
{
//設計一個方法，用於列印陣列
public static void printArray(int[] arr){//int[] arr = a;a的地址給了arr，那麼arr和
// a指向同一塊記憶體的陣列
for(int e : arr){
System.out.print(e +"\t");
}
System.out.println();
}
public static void main(String[] args)
{
int[] a = {1,2,3,4,5};
//設計一個方法，用於列印陣列
printArray(a);//將a的地址，傳遞給arr
System.out.println("Hello World!");
}
}
//設計一個方法，用於建立一個數組， 並賦值。陣列要返回給呼叫處
public static int[] createArray(int len){
int[] arr = new int[len];
for(int i = 0;i <arr.length;i++){
arr[i] = i * 2;
}
return arr;
}
Bubble Sort 原理：比較相鄰的兩個數，將較大的數，向後移動。
class Test7BubbleSort
{
public static void main(String[] args)
{
int[] arr = {15,23,8,10,7};
for(int i= 1; i<arr.length;i++){//控制輪數：
//i=1,2,3,4
/*
i=1, j<4
i=2, j<3
i=3, j<2
*/
for(int j = 0;j < arr.length - i;j++){
if(arr[j] > arr[j+1]){
//交換
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
for(int i = 0;i<arr.length;i++){
System.out.println(arr[i]);
}
}
}
思路(升序)：每次找個基準值，定一個變數k表示比較小的值的下標。每輪比較完，都在基準值上放一個比較小數。
int[] a = {15,23,8,10,7};
for(int i= 0;i <a.length - 1;i++){//控制輪數，趟數
int k = i;
for(int j = k + 1;j<a.length;j++){
if(arr[k] > arr[j]){
k = j;
}
}
//交換
if(k != i){
int temp = arr[k];
arr[k] = arr[i];
arr[i] = temp;
}
}
JDK提供好的類：
A：Scanner，讀取鍵盤
B：String，字串
C：Math，數學的
D：Arrays，提供陣列的常規操作的
E：System，
就是將一個數組的數據，複製到另一個數值中。
方法一：通過回圈，依次複製，將原陣列的數據，一個一個，複製到目標陣列中
方法二：Arrays類裡方法：copyOf(原陣列，新陣列的長度)–>返回值是新陣列
方法三：System類裡的方法：arraycopy(原陣列，原陣列位置，新陣列，新陣列位置，拷貝的個數)
int[][]i={{}{}{}};
/*
class ClassName{//類名首字母大寫
//屬性描述：外部特徵
//行爲描述：能夠幹啥
}
*/
package com.qf.demo01;
public class Test1Person {
public static void main(String[] args) {
//step1：建立Person類的物件
//語法：類名 物件名 = new 類名();
Person p1 = new Person();
System.out.println(p1);//列印p1的值，p1是參照型別，列印都是p1指向的物件的地址。
System.out.println(p1.name);
System.out.println(p1.age);
System.out.println(p1.sex);
/*
* com.qf.demo01.Person@15db9742
* 包名.類名@編碼值 ---->理解爲p1的記憶體地址。
*
* java中的數據型別：
* 基本型別：byte，short，char，int，long，bolean，float，double
* 參照型別：
* 陣列，類類型別
*
*/
//step2：通過物件存取屬性，語法是.
//給物件的屬性，進行賦值
p1.name = "王二狗";//給p1這個物件的name屬性進行賦值
p1.age = 18;
p1.sex = '男';
//獲取物件的屬性值
System.out.println("姓名："+p1.name);
System.out.println("年齡："+p1.age);
System.out.println("性別："+p1.sex);
//step3：通過物件，存取成員方法--->理解爲就是物件呼叫成員方法
p1.eat();
p1.sleep();
p1.daDouDou();
}
}
如何判定多個方法是否是過載的？衡量標準，要同時滿足以下三條：
A：必須同一個類中。
B：方法名稱必須一致。
C：參數列表必須不同。（順序，個數，型別）
構造方法：是一個很特殊的方法。
普通方法：一段具有特殊功能的程式碼。而且可以被多次呼叫執行。
語法規則：
public 類名(){
}
public 類名(參數列表){
將參數的數值，賦值給屬性即可。
}
//分爲有參和無參夠構造
| 序號 | 對比點 | 構造方法 | 普通方法 |
|---|---|---|---|
| 1 | 返回值 | 沒有，也不能寫void | 必須寫返回值型別，沒有就寫void |
| 2 | 方法名 | 必須和類名一致 | 見名知意 |
| 3 | 參數列表 | —— | —— |
| 4 | 修飾符 | 最多隻能存取許可權：public | 存取許可權public，還有其他，比如static |
| 5 | 呼叫 | 必須使用new關鍵字 | 沒有static，類中的成員方法。物件.方法 有static，直接方法名。 |
| 6 | 作用 | 專門用於建立物件，並且可以初始化屬性的值。 | 實現特定的功能 |
| 7 | 執行 | 每當建立一個物件，就會呼叫一次，執行1次 | 通過方法名，呼叫幾次就執行幾次。 |
this的用法一：表示當前物件。
this的用法二：this()指代當前類的構造方法。
匿名物件，就是隻有=右側，沒有=左側。
new 構造方法(必要的參數);
修飾符：public，private，static，final，abstract。。。
使用了private存取許可權修飾符，限制了只能在類中使用。那麼對於外部的物件，如何給屬性進行操作？賦值，取值。
使用setter方法，給屬性進行賦值。
使用getter方法，獲取屬性值
繼承指的是兩個類的關係。如果一個類(子類)，繼承了另外一個類(父類別)。那麼子類就可以直接使用父類別的非私有化的成員(屬性，和方法)。
1、實現程式碼的重用和擴充套件。
2、模擬現實世界的關係。
關鍵字：extends，詞義：擴充套件的。描述兩個類的關係：子類，父類別。
1、兩個類存在了繼承關係。
子類可以使用父類別的屬性和方法
但是父類別不能使用子類的屬性和方法。
2、Java語言的繼承是侷限性：單繼承。
一個子類，只能有一個父類別。
Java語言，不允許多繼承，但是可以多層繼承。
一個父類別，爺爺類，太爺爺，祖爺爺。。祖宗。。
一個父類別是可以有多個子類的。
呼叫子類的構造方法中，先呼叫父類別的構造方法。預設父類別的無參構造方法。
用法一：表示父類別的構造方法。super()，表示父類別的構造方法。同this()相類似。
1、繼承結構中。
2、方法的宣告，必須和父類別的一致。
方法名必須和父類別一致
參數列表必須和父類別一致
返回值必須和父類別一致
3、存取許可權，不能比父類別更加嚴格。
4、子類重寫的方法，不能拋出比父類別更大更多的異常。
private：私有的。本類中。
protected：受保護的。本類，同包下，不同包(子類使用)
public，沒有限制的。
預設的：(default)：注意，啥修飾符都不寫，就是預設的。本類。同包下可以存取。
一個父類別兩個兒子 2個子類都可以重寫父類別的方法
向上轉型：一個子類物件看成了父類別型別。那麼就失去了子類新增。
Animal a2 = new Cat();//
表示抽象的意思。
abstract class Animal{
public abstract void run();//只有宣告， 沒有實現，那麼就是抽象方法。
}
public static void main(String[] args){
//對於抽象類，不能建立物件
//Animal a = new Animal();
//a.run();
}
//最大目的強制子類重寫方法
//抽象類不能有物件
詞義：「最終的，最後的」。可不可以把final理解成最後的，誰都不能更改。
1、final修飾變數（成員變數和區域性變數），則爲常數，只能賦值這一次
2、final修飾方法，則該方法不能被子類重寫
3、final修飾類，則類不能被繼承
靜態的屬性：屬於類，僅一份。所有的物件共用。
靜態的方法：屬於類，由類直接呼叫，方法裡不能存取物件的內容（屬性，方法），以及this和super關鍵字。
繼承中，子類可以繼承父類別的靜態方法，但是不能重寫。
3、修飾程式碼塊
4、修飾內部類
區域性程式碼塊
構造程式碼塊
靜態程式碼塊 加static
同步程式碼塊 多執行緒
{
}
介面就是一種能力和約定。一種協定，一種規則。
A：介面中，包含靜態常數，預設的(預設)修飾符：public static final
B：介面中，包含抽象方法，預設的(預設)修飾符：public abstract
//1.定義一個介面
interface 介面名{
//靜態常數
//抽象方法
}
//2.需要實現類來實現介面：類比子類繼承抽象類。
class 實現類 implements 介面名{
//重寫介面中的抽象方法
}
//3.建立實現類的物件
介面型別的參照 = new 實現類的物件
1、介面可以多實現：一個實現類可以同時實現多個介面
2丶介面可以多繼承
3、一個類如果實現介面了，還能繼承其他的父類別嗎？可以的
4、如果一個類沒有實現介面中的所有的方法，那麼它是抽象的
A：降低了程式的耦合性。程式碼的關聯程度。
介面中只做功能的宣告，沒有具體的實現。
面向介面程式設計：關心功能有哪些
B：定義的都是規則，對外暴露的功能是一致。
C：介面可以多繼承，以及多實現，使用更靈活。
首有個介面A，和它 實現類。然後在另一個類B中，持有A的參照，那麼在B類中可以呼叫介面A的方法。這就是一種回撥。
1、繼承關係
2、實現關係
3、依賴關係
public class Pet{}
public class Girl{
public void play(Pet pet){
}
}
4、關聯關係
public class Book{}
public class Person{
Book book;
}
特殊的關聯關係：聚合，組合。。。
匿名內部類：沒有名字的內部的類。
interface A{
public void test();
}
//A a = new 實現類物件；
A a = new A(){//從此處開始，就是匿名的呢不累
public void test();
};//到此處結束
a.test();
一般匿名內部類適合：使用一次，建立一次物件。
Object類是所有類的基礎類別。所以只要是Java中的類的物件，預設都可以執行Object類中的方法。
//在方法中this，就指代了c1物件
public boolean equals(Object obj) {//Object obj = c2;
return (this == obj);
}
c1.equals(c2);//false
子類重寫：重寫的規則
應該比較物件的各個屬性值即可，如果都相同，那麼認爲是相同的物件，最終返回true，否則返回false。
c1.equals(c2);
/*
分析：
this-->c1
obj-->c2，向上轉型
Cat c2 = new Cat();
c1.equals(c2);//Object obj = c2;
*/
//step1：先比較地址：c1和c2 的地址：this == obj，如果地址相等，直接返回true。
//step2：判斷，obj == null？ obj--->Cat
//step3：比較對應的屬性是否相等
this.各種屬性和
obj--->向下轉型：c2.各種屬性
| 序號 | 基本數據型別 | 對應的包裝類 |
|---|---|---|
| 1 | byte | java.lang.Byte |
| 2 | short | java.lang.Short |
| 3 | int | java.lang.Integer |
| 4 | long | java.lang.Long |
| 5 | float | java.lang.Float |
| 6 | double | java.lang.Double |
| 7 | char | java.lang.Character |
| 8 | boolean | java.lang.Boolean |
new StringBuffer();//預設的緩衝區大小16個字元
new StringBuffer(int capacity);//也可以自己指定容量大小
new StringBuffer(String s);//StringBuffer物件建立好，並且裏面還儲存了字串
//在String基礎上增加的add新增 delete刪除 reverse修改
StringBuilder類提供的方法，和StringBuffer功能相同。
它們的區別：
StringBuffer是執行緒安全的，效率比StringBuilder低一些。JDK1.0
StringBuilder執行緒不安全。效率比StringBuffer高一些。JDK1.5
Math類：和數學相關：PI，abs()，ceil()，floor()，round()，random()。。
亂數
大小數。精準的計算。double，float
Date類中的很多獲取日期，時間等等的方法， 都被Calendar類所提供替代。
/*
* SimpleDateFormat類：
* Date-->String：日期格式化？就是將一個日期Date物件，按照指定的字串格式去顯示。
* format(),根據模板，將date日期，轉爲String字串型別
* 1.建立SimpleDateFormat物件。可以通過構造方法指定模板(格式)："yyyy-MM-dd"
* 如果沒有指定模板，使用系統預設：20-4-16 上午11:09
* 2.sdf.format(date)-->String
*
*
* String-->Date：解析？就是將一個文字字串，解析成一個Date物件。
* parse()，根據模板，將字串解析爲對應的日期物件，異常。
* 1.同上
* 2.sdf.parse(String)-->date
*/
Calendar類是抽象的。GregorianCalendar子類。
獲取日期時間，也可以設定日期時間。
//step1：建立Calendar類的物件。
Calendar calendar = new GregorianCalendar();//方式一
Calendar rightNow = Calendar.getInstance();//方式二
//step2：
//獲取類
calender.get(YEAR,MONTH,DAY_OF_MONTH,DAY_OF_WEEK,HOUE,MINUTE....);
//設定
calendar.set();
動態儲存多個物件。
物件：集閤中所儲存的數據，僅限於物件。
集合框架的最大的父介面：規定的都是集合容器最基本的功能。
爲Collection介面的子介面，也是一種容器。但是有自己的獨特的儲存特點。
遍歷一個List介面中的所有元素：
作爲List介面的實現類，將介面中的方法全部實現。
底層：陣列的結構來實現的。也會有人叫動態陣列。
理解爲ArrayList相當於一個可變長度的陣列，存取遍歷效率較高。增加，刪除元素，效率較低。
作爲List介面的實現類，將介面中的方法全部實現。同時還實現了Deque雙端佇列中的方法。
queue：佇列。排隊，佇列
deque：雙端佇列，全名：double-ended queue
模擬棧的結構：後進先出(LIFO)，棧頂元素，
push()，壓棧，入棧，pop(),彈棧，出棧
模擬佇列的結構：先進先出(FIFO)，隊頭元素
offer(),poll()
Set詞義：數學中集合的概念。也是Collection的子介面。
底層是由雜湊表實現。它不保證迭代的順序。特別是不保證順序一直不變。
真正判斷元素是否是重複，是否是相同的：看equals()。
Object類：equals()–>boolean，判斷物件是否相等。
子類是否重寫：
String，Integer，Date，。。。。
HashSet集合去重的流程**：
step1：先獲取物件的hashCode，物件的雜湊值不同，直接儲存到HashSet容器中。
step2：如果雜湊值相同，呼叫equals()比較。
true：認爲是相同的元素，不儲存
false：不同的元素，儲存
原則：hashCode()和equals()的原則：
重寫的規則：
hashCode()
物件相同，屬性值相同。雜湊碼必須相同。
物件不同，屬性值不同。雜湊碼儘量不同。
equals()
物件相同：屬性值相同。必須true。
物件不同：屬性值不同。必須false。
也要去除重複的元素。可以給儲存的元素進行整理排序。
預設的規則：Comparable介面，定義排序的規則。
interface Comparable{
int compareTo(T obj);//排序的規則
}
回憶：HashSet儲存特點？1、無序。2、去重
HashSet儲存數據，記錄儲存的順序。
儲存原理同HashSet相同，但是外層套了一個鏈表結構。用於記錄儲存的順序。
僅有唯一的一個方法：compareTo()–>此方法用於排序，返回值int型別型別
預設的TreeSet集合，使用的是Comparable介面，來給物件進行排序。以及去重。
int compare(T o1, T o2)
比較其兩個參數的順序。
比較的兩個物件：o1和o2
map每次操作的元素是成對的。兩個：key(鍵)，value(值)。
map中儲存的元素，鍵值對。其中鍵不能重複。值可以重複。鍵和值，必須是一一對應的。
put(key,value)；向map中新增鍵值對，鍵不能重複。如果鍵重複了，那麼value會被覆蓋的。
HashMap集合——>key如何去重？原理同HashSet相同。
HashSet集合——>如何去重？step1：hashCode()，step2：equals()
對比TreeSet和TreeMap
1、都要求物件具有可比性。
TreeSet來講：裏面所儲存的元素，能夠進行比較大小。
TreeMap來講，所儲存 key，能夠進行比較大小。
2、區別於HashSet和HashMap，要給排序。從小到大排序。
Comparable介面：預設的
Comparator介面：自定義
Entry可以認爲是一個鍵值對物件。理解爲：將鍵值對看成一個整體的物件。包含了Key，Value。
Map中操作的是一對物件。key和value。存在一個對映關係。對應的。
對於map集合，無法直接迭代獲取裏面的元素。
記錄了儲存的順序。去重的原理和HashMap相同。
HashTable的父類別是：Dictionary
HashMap的父類別是：AbstractMap
HashTable是舊的類，執行緒安全，效率低
對於null的處理：
集合儲存物件的，Properties儲存屬性資訊。
將屬性集合Properties中的數據——>file檔案中
List<String> list = new ArrayList();
list.add(String);//儲存String型別
class 類名<T>{
//T這個型別，當建立物件的時候決定好。
}
//3.<M>，靜態方法上自己獨立宣告泛型，不能使用類的。
public static <M> M test(M m){
System.out.println(m);
return m;
}
List<?>，List
靜態屬性：private static T member；//錯誤的
建立T的範例：T t = new T();//錯誤
自定義異常，不能使用泛型
class MyException extends Exception
Collections：集合的工具類，包含了集合的常用方法。
Iterator i1=new Iterator();
while(i1.hasNext()){
System.out.println(i1.next())
}
概念：在程式執行的時候，程式碼中產生的不正常事件，導致程式無法正常的執行。
Throwable類：可拋出的。
Exception：異常
1.受檢異常----必須處理，程式才能 纔能執行。
2.非受檢異常，又叫執行時異常-----程式碼中的邏輯問題導致的異常。
子類異常不能大於父類別異常
try{
//try語句塊中，有可能產生異常的程式碼，嘗試着執行
}catch(異常型別1 e){
//對例外處理
}catch(異常型別2 e){
//
}...
finally{
//此處的操作是可選的，
這裏的程式碼，一定會被執行的。。
}
public void test()throws 異常型別1,異常型別2...{
}
throws：用於一個方法的對外宣告：用於表示該方法不處理異常，交由呼叫處進行處理。
throw：用於程式碼中主動拋出一個異常物件：設計一個方法的功能的時候，根據邏輯分析，可以主動拋出一個異常物件。
程式碼級別上，主動拋出一個異常物件，提示呼叫者：產生問題啦。。
以下是String這個類的原始碼：
public char charAt(int index) {
if ((index < 0) || (index >= value.length)) {
throw new StringIndexOutOfBoundsException(index);
}
return value[index];
}
自己定義一個類，用於表示某種異常。需要繼承Exception或其子類即可。
class MyException extends Exception{
//提供有參構造方法。。
public MyException(String msg){
super(msg);//呼叫父類別的有參構造：提供異常的資訊
}
public MyException(){
super();//父類別的無參構造，沒有提供異常的資訊
}
}
程式中主動拋出一個異常物件：
/*
* 設計一個方法，用於檢驗年齡，年齡不合法，拋出一個異常
*/
public static void checkAge(int age) throws MyException{
if(age < 0){
// return;
throw new MyException("年齡不能爲負數。。");
}
System.out.println("年齡輸入正確，請繼續。。。");
}