第一篇：黑馬程序員java培訓就業班筆記：day06總結

Day06總結： 上午

1、二維數組 格式：

Int[][] arr=new int[2][3];[2]代表1維數組的個數； [3]代表1維數組有三個元素； 內存圖：

分析：

通過對內存圖分布可知，首先在棧內存中加載main函數，開辟空間，定義一個變量arr，在堆內存中通過New創建一個數組實體int[2]，并分配其地址值為0x0045,數組元素值進行默認初始化為Null;然后把地址值賦值給棧內存中的arr.在堆內存中開辟兩塊空間，分別用來存放二維數組中的數組元素，分配其地址值分別為0x0056、0x0089,然后對將地址值傳給二維數組中的元素，所以說對內存中二維數組存儲的是一維數組的地址值。最后變量通過二維數組的地址0x0045指向二維數組。

注意：二維數組中必須指定長度、以及實體沒有對二維數組進行初始化時默認為null;

2、對二維數組的遍歷（大圈套小圈思想）For(int x=0;x

3、面向對象的理解：

特點：

1、面向對象就是更符合人們思考習慣的一種思想。

2、從面向過程的執行者，轉變成了面向對象的指揮者

3、面向對象將復雜的事情簡單化了。

其實面向對象是一種思想，是面向過程而言，將復雜的事情變的更簡單了。通過把大象放到冰箱里這個列子來理解面向對象的概念

面向過程：把冰箱門打開、存儲大象、關閉冰箱；強調的過程注重行為； 面向對象：冰箱.打開、冰箱.存儲、冰箱.關閉；強調的是冰箱這個對象。

面試題：你怎么理解面向對象？

首先說面向對象的特點：它是一種思想，它讓復雜的問題簡單化，它把執行者變成了指揮者。

然后舉例子來說明，最牛的就是結合實際場景來說：其實面試官你就是在用面向對象的思想在思考問題，為什么這么說？因為公司業務蒸蒸日上，需要招更多的人來完成項目，所以才在這里招聘人員，你需要找一些具備專業編程經驗的人，來幫公司完成工作，那么我就是那個對象，因為我具備專業編程能力，你就是那個指揮者，指揮我來做事，至于我怎么去完成編程任務，你是不需要去知道，你只要結果了就可以了，這其實就是把你之前的工作簡化了，你不必再事必躬親了。這就是面向對象思想的體現。

同時可以結合去飯店吃飯，在家做事等等列子來說明面向對象的思想。

擴展：OOP:面向對象編程。

OOA面向對象分析。

OOD:面向設計。還有面向接口、面向框架、面向對象的語言：C++、JAVA、C#

4、在實現功能，先找java當中是不是提供好了相關的對象，沒有對象自己造一個對象。比如說公司招聘人員找不到人的時，這時公司就需要自己在公司內部培養人，也就是自己造對象。

5、類和對象關系：

a)類到底是什么？

類就是對現實生活中事物的描述，描述中包含了該類事物的共性內容。Class Car(){ Int num;String color;Void run(){} } 在類中定義的變量和函數都稱為類中的成員。成員：

成員變量---屬性 成員函數---行為

b)什么是對象？

對象就是該類事物實實在在存在的個體。

Eg：現實生活中的對象：張

三、李四

想要描述：提取對象中的共性內容，對具體的抽象。

描述時：這些對象的共性有姓名年齡性別學習java的功能。對象也可以理解為其實就是個容器，用來存儲更多的數據，存儲的都是每一個對象特有的數據，而類就是這些數據所屬的屬性。

用java語言來描述一個小汽車

描述事物：無非就是描述事物的屬性和行為 屬性：輪胎數、顏色 行為：運行 Eg: Class Car { String color=“red”;Int num=4;Run(){ System.out.println(color+“"+num);} } Class CarDemo { Public static void main(String[] args){ Car c=new Car();C.color=”bule“;C.num=5;C.run();m

Car c1=new Car();C1.num=8;C1.color=”green“;C1.run();} } 重點：分析上述代碼在內存中的分布：

復習的時候寫內存分析：

6、成員變量和局部變量的區別：

1、源代碼中定義位置不同：

成員變量：定義在類中，在整個類中有效。局部變量：定義在函數中，在局部范圍內有效。簡單一句話：作用范圍不一樣，成員變量作用于整個類中，局部變量作用于函數中，或者語句中。

2、在內存中的位置和事件不同：

生命周期不同：

成員變量：隨著對象的創建的而出現在堆內存中，隨著對象被回收而消失。

局部變量：隨著變量所屬局部區域的運行，而出現在棧內存中，隨著所屬區域運行結束而釋放。

3、變量使用的初始化：

成員變量：因為堆內存中都有默認初始化值，對于引用型變量默認值就是null;局部變量：因為在棧內存中都沒有默認初始化值，必須手動初始化后才可以參與運算。

7、匿名對象：

即沒有名字的對象，簡化書寫用的。基本使用：

1、當對對象的方法只調用一次時，可以用匿名對象來完成

這樣寫比較簡化，如果對一個對象進行這個成員的調用，必須給這個對象起個名字

2、可以將匿名對象作為實際參數進行傳遞。一旦對對對進行多個成員操作時。必須要對對象起個名字。

Eg: Main(){ Show(new Car（）)} Public static void show(Car c)

{ C.num=3； C.color=”back";C.run();}

8、面向對象三個特征：

封裝：

是指隱藏對象的屬性和實現細節，僅對外提供公共訪問方式，凡是面向對象必須有封裝性。

特點： 將變化隔離 便于使用 提高復用性 提高安全性

原則：

1、將不需要對外提供的內容都隱藏起來。

2、把屬性都隱藏，提供公共方法對其訪問。在代碼中的體現：

1、將成員變量都私有化，并通過共有的方法對其進行訪問，這兩個方法是:setXxxgetXxx

2、只要不準備對外提供的全部都封裝起來，3、私有僅僅是封裝的一種表現形式，函數是最小的封裝體。方法需要私有嗎？

Public static void selectSort(){ Swap();} Private void swap()//此處私有是因為位置置換不用提供給用戶。{ } 代碼實現： Class Person { Private int age;//為了不讓其他程序直接訪問age屬性，避免錯誤的數據，可以使用一個關鍵字來完成private私有，它是一個權限修飾符。

Public void setAge()//對外提供函數是可以控制你輸入的參數。//一個成員變量通常對應的兩個方法、{ If(a>130||a<0){ Age=a;

Speak();} Else System.out.println();} Public void getAge(){ Return age;}

Void speak(){ Sop();} } Class PersonDemo { Public static void main(String[] args){ Person p=new Person();P.age=-20;//錯誤數據是因為對象直接訪問age屬性造成的。P.speak();} } 總結：之所以對外提供訪問方式，就是因為可以在訪問方式中加入邏輯判斷等語句 對訪問的數據進行操作，提高代碼的健壯性。凡是set開頭的返回值類型是void，get開頭的跟它的返回值類型一致。

第二篇：黑馬程序員java培訓就業班筆記：day05總結

Day05 上午：

1、數組的靜態初始化

多種定義格式：

Int[] arr=new int[]//標準格式，可以明確數組的數據類型，和數組名，但是不知道數組的長度

Int arr[]=new int[] Int[] arr=new int[]{2,1,3,4,5,}//通過大括號可以標示出數組中的內容，此處最好別寫長度，因為容易出錯，因為即初始化實體，又初始化實體中的元素。

Int[] arr={2,1,3,4,5};//可以明確數組的數據類型，和數組名，也可以知道數組中的內容。

2、arr.length:方便獲取數組中的元素個數的方式。

3、操作數組的最基礎的思想以及核心思想：

a)最基礎的思想：就是遍歷。什么是遍歷。

Eg：int[] arr = new int[3];int[] arr = {4,8,9,2,6,9};//明確了數組的類型和長度，并明確了數組中元素的內容。

// int[] arr1 = new int[]{4,8,9};//方便獲取數組中的元素個數的方式，可以使用數組實體一個屬性。length System.out.println(“len:”+arr.length);

for(int x=0;x

if(x%2==1)

System.out.println(“arr[”+x+“]=”+arr[x]);//arr[0] = 4;}

這就是遍歷的思想，獲取數組中的元素，通常會用到遍歷。

b)核心思想：就是操作數組中元素的角標，角標即索引，因為存數據的最終目的就是取出數據使用，就是操作角標，操作動作：

1、給數組角標上的元素賦值，2、獲取角標上元素的值，存儲都得用角標

4、數組中常見的操作：

a)獲取最值：

思路：

1、首先我們要定義一個功能完成獲取數組中最大值的動作；

2、定義個函數來實現這一功能；明確結果，整數數組中的最大值，int,明確是否有未知內容參與運算，參數列表中有一個參數，數組類型int[]，一定要注意這里是數組類型，不是int型；

3、如何實現功能細節呢？

1、對數組中的元素進行比較，將比較后比較大的值進行記錄，并參與下一次比較，當數組中的元素都比較完成后，最大值就已經被記錄下來了。

2、每次比較的較大的值不確定，定義一個變量進行記錄，該變量如何初始化呢？只要初始化為數組中的人一個元素即可。

3、應該讓數組中的元素自動和該變量記錄的元素進行比較，所以可以使用遍

歷，獲取數組中的每一個元素。

4、當遍歷到元素比較變量中的記錄的元素大，用該變量記錄住更大的元素。

5、遍歷結束后，變量存儲就是數組中的最大值。實現代碼：eg：

Public static int getMax(int arr){ /.定變量記錄較大的值；

Int max=arr[0];//初始化數組中的任意個元素； //對數組進行遍歷比較

For(int x=1;xmax)

Max=arr[x];} Return max;} 同樣有另外一種方式獲取最大值 Public static int getMax(int[] arr){ Int maxIndex=0;//初始化為數組中一個元素的角標 For(int x=1;xarr[maxIndex])

maxIndex=x;} Return arr[maxIndex];} b)排序：

1、選擇排序：

首先通過數組中元素的比較方式來分析：

用數組中第一個角標的元素與數組中第二個角標的元素進行比較，發現9比6大，進行位置置換，此處應該定義一個三方變量，用來記錄住置換過程的元素值，然后再用第一個角標的元素與下一個角標元素進行比較，按照全面的原則進行置換位置，如果前者小于后者，則不置換位置，一次比較，當第一輪結束之后第一個角標出能取的該數組中最小的元素的值，然后再用第一個角標的元素開始和下一個角標的元素進行比較，同理，當第二輪結束后，第二個角標處獲取了該數組中的第二小的值。所以我們發現當依次這樣比較下去，就可以對數組中的元素進行排序，當比較到arr.length-1元素時，發現只剩下這一個元素，沒有其他元素和它進行比較了。思路：

1、首先定義一個功能函數對數組進行排序，2、明確結果，沒有返回值，因為它只是對數組進行排序的一個動作，明確是否有未知內容參與運算，有，數組類型int[] arr 實現代碼：

Public static void selectSort(int[] arr){ For(int x=0;x

if(arr[x]>arr[y]){

Int temp=arr[x];Arr[x]=arr[y];Arr[y]=temp;} } }

}

優化后的選擇排序：

從上面的排序圖中我們可以知道，對數組中元素進行置換位置的次數過多，也就是對堆內存的操作頻繁，降低了性能，下面我們可以通過這種方式對性能優化。

思路：

在棧內存中我們定義兩個變量，分別用來記錄較小的元素的值和較小元素的角標，然后對其進行初始化，至于初始化的值只要是數組中的任意元素即可，然后拿數組中的元素與它進行比較，如果發現拿去比較的元素比變量中記錄的數值要小，那么就進行位置置換，并記錄下較小的元素的角標，依次把數組中的元素遍歷完，就可以獲取數組中的最小元素的值和角標，然后我們拿初始化的值和獲取的最小的元素進行位置的置換，這樣以來當我們獲取了數組中的元素的最小的時候，堆內存中的只用操作一次位置即可，這樣的就提高性能。實現代碼：

Public static void selectSort_2（int[] arr）{ For(int x=0;xarr[y])

Num=arr[y];Index=y;} If(index!=x){ int temp = arr[x];arr[x] = arr[index];arr[index] = temp;

} } } 注意：復習的時候添加注釋

2、冒泡排序：

首先通過排序方式來分析其步驟：

通過排序方式，可以知道是用數組中的元素挨個比較，如果前面的元素的值比它下一個角標的元素大，則進行位置置換，然后再用第二個角標的元素與下一個角標的元素進行比較，同樣如果下一個角標的元素比它小，則進行位置置換，這樣當比較到arr.length-1個元素時已經沒有 和它進行的比較的元素了，當第一輪比較結束后，我們可以知道最后一個角標的元素為該數組中的最大值，按照同樣的原理進行下一次比較，依次獲取了比較大的元素的值。

實現代碼：

Public static void bubbleSort(int[] arr){ For(int x=0;x

If(arr[y]>arr[y+1]){

//位置置換 } } } }

c)折半查找：

首先分析數組元素的查找方式：

首先要明確數組時有序的。

首先定義三個變量min、mid、max分來用來記錄最小角標、中間角標、最大角標，中間角標的獲取為(min+max)/2;獲取中間角標之后，就可以獲取中間角標對應的元素arr[mid];用我們所需要查找的key與中間角標運算進行比較，如果key>arr[mid];那么此時min的位置就是mid的下一個角標，min=mid+1;然后再次獲取中間角標的元素，mid=(min+max)/2,同時也獲取了中間角標對應的數組元素，arr[mid],然后同理，拿key與中間角標的元素進行比較.同樣的原則，依次比較，直到key==arr[mid]的時候獲取key.如果當出現了min>max或者時候則說明我們要查找的key在該數組中布存在，return-1；

實現代碼：

Public static void binarySearch(int[] arr int key){ Int min,mid,max;Min=0;Max=arr.length-1;Mid=(min+max)>>1//相當于/2，右移的效率比它要高 While(arr[mid]!=key){ If(key>arr[mid])Min=mid+1;Else if（key

Min=mid-1;If(max>1;}

Return mid;} 注意：復習的添加代碼注釋

總結：折半查找也稱二分查找，這種查找可以提高效率，但是被查找的數組的額元素必須是有序的。不能對無序的數組進行排序后再用折半查找，因為這時候數組中元素的角標已經發生變化了。

5、查表法思想：

a)什么時候使用查表法？

當元素很多，而且這些元素與數組有對應關系，而且這些數字都有角標的規律的時候。

擴展：什么時候使用數組？

當同一類型的元素較多時，就使用數組這個容器對數據進行存儲。b)查表法思想的代碼體現：

0 1 2 3 4 5 6 7 10 11 12 13 14 15 '0', '1', '2', '3', '4','5', '6',' 7', '8', '9','A',' B', 'C' ,'D', 'E' ,'F' 我們發現十六進制中一共有16個元素，而且每通過&15獲取的數字都再15之內，都有對應的十六進制元素，而且元素對應的數字正好有規律，而且符合了數組這種容器的特點角標，那么可以將十六進制的元素都存儲到數組中，將每次&15的結果作為角標去查這個數組，就可以獲取到十六進制的對應的元素。這就是查表思想。

代碼體現：

Public static void searchList(int num){ //定義一個十六進制的元素表

Char[] arr={'0', '1', '2', '3', '4','5', '6',' 7', '8', '9','A',' B', 'C' ,'D', 'E' ,'F'};//定義一個char類型元素的數組，用于存儲每次獲取到的十六進制值。Char[] chs=new char[8];Int pos=chs.length;While(num!=0){ Int temp=num&15;Chs[--pos]=arr[temp];Num=num>>>4;} For(int x=pos;x

通過上面我們可以知道那么是否可以定義這樣的一個功能函數呢？用來對十進制、二進制、八進制、十六進制進行轉換？

思路：

1、明確結果，沒有返回值，只是對給定的數據轉換的功能。

2、明確是否有未知內容參與運算，有，是什么？求的數值num,十六進制是&15，八進制是&7，二進制是&1，那么&的這個是不確定的，我們定義為變量 base,當這個數值通過&上這些數據后，要取出后面的數值，我們通過右移來實現，但是各個進制的不一樣右移的位置數也是不一樣的，十六進制是無條件右移四位，八進制是無條件右移三位，二進制是無條件右移1位，所以這個數也是不確定的，定義變量 offset 實現代碼：

//十進制--二進制

public static void toBin(int num){ trans(num,1,1);} //十進制--八進制

public static void toOctal(int num){ trans(num,7,3);} //十進制--十六進制

public static void toHex(int num){ trans(num,15,4);} Public static void trans(int num,int base,int offset){ If(num==0){ Sop(0);;Return;} //定義一個十六進制的元素表

Char[] arr={0', '1', '2', '3', '4', '5', '6', ' 7', '8', '9', 'A',' B', 'C' ,' D', 'E' ,'F'};Char[] chs=new char[32];Int pos=chs.length;While(num!=0){ Int temp=num&base;Chs[--pos]=arr[temp];Num=num>>>offset;} For(ingt x=pos;x

System.outr.println(chs[x]);} } 注意：復習的添加代碼注釋。

這一章節自己還不是很熟悉，能理解，但是不能獨立寫出代碼，在以后的幾天內要每天都要一遍，并自己獨立寫出代碼，做到思想理解透徹。先要產生一天的宏觀思想。復習方法：

首先總結當天學習的方法。遇到不會的先放到一邊。每天晚上睡著覺之前要回憶一遍。

第三篇：黑馬程序員java培訓就業班筆記：day10總結

Day10總結：

1、多態的特點：

1、成員變量：

當在子父類中出現了相同的非私有成員變量時，在多態調用中的特點：

在編譯時：參考引用型變量所屬類中是否有調用的成員變量，如果有編譯通過，如果沒有編譯失敗。

在運行時：參考引用型變量所屬的類中的成員。

簡單一句話：對于成員變量無論是編譯還是運行都參考引用型變量所屬類中的成員變量。

也就是說：成員變量看等號左邊。

2、成員函數：

當子父類中出現一模一樣的函數時，在多態調用中的特點：

在編譯時：參考引用型變量的所屬的類中是否有調用的成員函數。在運行時：參考的是對象所屬的類中是否有調用的成員函數。

原因是：編譯時期應該參考父類，運行時期應該參考子類。因為成員函數上有一個特點覆蓋。

簡單一句話：對于成員函數，編譯看左邊，運行看右邊。

3、靜態函數：

在編譯時期：參考引用型變量所屬的類中是否調用的靜態函數，如果有編譯通過，如果沒有編譯失敗。

在運行時期：參考的還是引用型變量所屬的類中的靜態函數。簡單一句話：對于靜態函數，無論是編譯還是運行都看左邊

總結：對于多態成員而言，無論編譯還是運行都看左邊，只有成員非靜態函數，編譯看左邊，運行看右邊，因為覆蓋的特性。

2、多態的應用： 代碼實現：

Object：所有類的父類，該類中的方法所有對象都具備。代碼實現：

Class Demo extends Object { Private int num;Demo(int num){ This.num=num;} 通常都會按照對象自身的特點對對象進行比較，比如：現在要比較兩個Demo對象中null值是否相同。} Public boolean compare(Demo b){ Return this.num=d.num;

} 發現Demo繼承Oject已經具備了比較對象的方法，所以沒有必要再定義新的方法compare了，直接使用equals就可以了，可是Object equals比較的是地址值，不是我們所需的，那就保留的父類的功能聲明，建立自身的比較內容，這就是覆蓋。Public boolean equals(Object obj){ If(!(Object instanceof Deno))Return false;Demo d=(Demo)obj;向下轉型。

Return this.num=d.num;此處體現了多態的特性。} Public String toString(){ Return “demo:”+num;} Class ObjectDemo { Public static void main(String[] args){ Demo d1=new Demo(4);Demo d2=new Demo(4);Sop(d1.toString());Sop(d1);Sop(c1.getName());Sop(d1.compare(d2));} }

4、內部類：

將一個類定義在另外一個類的里面的類稱為內部類 當一個類要直接訪問另外一個類的成員時，可以將這個類定義到另一個類里面，稱為另一個類的內部類。

內部類訪問的規則：

1、內部類可以直接訪問外部類中的成員。

2、外部類需要創建內部類對象才可以訪問內部類中的成員。

在描述事物時，事物中還有具體的事物時，而且這個內部事物在訪問著外部的事物時。這時對這個內部事物的描述，就可以用內部類完成。

內部類出于外部類的成員位置上是可以被成員修飾符所修飾的。Public

Private：將內部類私有化時，只能對外提供方法，對內部類的控制。

Static：當內部類中定義了靜態的成員時，該內部類必須靜態的，否則編譯失敗。代碼體現： Class Outer { Static int num=4;Static class Inner //內部類，為什么要定義內部類？

當一個類要直接訪問另一個類中的成員時。可以將這個類定義到另一類里面。{ Static void show(){ Sop(“show run”+num);} Public void method(){ Inner in=new Inner();In.,show();} } } Class InnerClassDemo { Public static void main(String[] args){ //Outer out=new Outer();

//out.method();

//System.out.println(“Hello World!”);

//當訪問一個外部類的內部類時，先由外部類對象再有內部類對象。

//Outer.Inner in=new Outer().new Inner();//要指明內部類所處的外部類

//in.show();

//內部類靜態化，要調用的非靜態的方法show();

//Outer.Inner in=new Outer.Inner();

//in.show();

//如果show方法也是靜態的，要調用靜態的方法show();

Outer.Inner.show();} }

5、匿名內部類：沒名字的內部類。

就是內部類的簡化寫法。

前提：內部類可以繼承或者實現一個外部類。代碼實現： 格式：

New 父類名or 接口名(){子類的具體內容} Abstract class AbdsDemo { Abstract void show1();Abstract void show2();} Class Outer { Int num=4;New AbsDemo(){ Void show()//匿名內部類 { Sop(“num===”+num);} }.show();} Public void method2(){ AbsDemo a=new AbsDemo();{ Public void show1();Public void show2();};A.show1();A.show2();//要想調用兩個方法，怎么做？起個名稱即可

當里面有多個方法的時候建議不要寫匿名內部類。

}

-----------------------------interface Inter {

void show();} class Outer {

//補足代碼。最好用匿名內部類

static Inter method()//為什么是Inter類型

{

return new Inter()

{

public void show()

{

System.out.println(“show run”);

}

};

} }

class InnerClassTest

{

public static void main(String[] args)

{

Outer.method().show();

/*

Outer.method():Outer類中有一個method方法，而且這個方法是靜態的。

Outer.method().show

會返回一個對象，而且這個對象還可以調用show方法

說明這個對象肯定是Inter類型。

*/

} }

------------------------------

6、異常：

是在運行時期發生的不正常情況

Java發現不正常的情況都包含著一些常見信息，并 將這些信息進行了對象的封裝。異常這種機制，其實就是java按照面向對象的思想將出現的問題封裝成了對象。在進行問題分析時，發現問題有很多種，但是不斷向上抽取，最終問題可以歸納為兩種，一種是可以針對處理的一種是通常不進行處理的。

在java中的體現一個是Exception ,一個是Error,后者一般針對處理。

無論是異常還是錯誤，他們都有名稱信息等共性的內容。

可以繼續抽取形成一個父類：throwable可拋出。Throwable

|---Error |---Exception 異常和錯誤都有一個特點：其子類的名稱的后綴名都是父類名。

該體系具備一個特殊的特性叫做可拋性，該體系中的類可以被關鍵字throws拋出。

該體系中的類產生的對象可以被Throw拋出，簡單說該體系可以被Throws 和throw操作。

Throw 和throws的區別：

Throws：定義在函數上，用于聲明函數的可能出現的問題，后面跟異常類，可以跟多個，用逗號隔開、Throw:定義在函數內，用于拋出異常對象因為程序的跳轉，后面跟的是異常對象。

If判斷和異常處理的區別：

If判斷是將正常代碼和異常代碼寫在一起。閱讀性極差，異常處理將問題代碼和異常處理代碼分離。代碼實現： Class Demo { 功能的定義著在定義工呢過時，發現該功能容易因為未知內容的不確定性的出現的問題。為了讓調用者明確，有可能有問題，需要在函數上對問題進行聲明。

需要一關鍵字throw異常名。

Int div（int a,int b）throws Exception//拋出異常是為聲明異常問題，讓調用者去處理。{ If(b==0)Throw new ArithmeticException(“除數為零、違反規則”);

Return a/b;} } 對異常的針對性處理方式： Try { 需要被檢測的代碼； } Cathch（異常類 變量）{ 異常處理代碼 } Finaly { 一定會被執行的代碼。}

自定義異常：

Java將常見的問題都封裝成了對象。

對于自定義項目中出現的問題，java并未給出對應的描述，這時我們就需要按照面向對象的思想自己完成對問題的描述和封裝。

自定義異常：

需求：在我的程序中，進行除法運算，除數不可以為負數也不可以為0;對0這種情況，java中有對應的描述，ArithmeticException 對于負數，java中沒有。只有我們自己定義，定義一個類來對異常進行描述。

Class FuShuException extends Exception { Private int num;FuShuException(){} FuShuException(String message,int num){ Super(message);This.,num=num;} Public int getNum(){ Return num;} } Class Demo { Int div(int a,int b)throws FuShuException { If(b<0)Throw new FuShuException(“除數不可以為負數”);函數內拋出異常，函數上一定要標示。函數內拋出是什么？函數上就標示什么？ 對方拋出什么異常，我就處理什么異常。Return a/b;} }

Class ExceptionDemo2 { Public static void main(String[] aths){ Demo d=new Demo()； Try

{ Int num=d.div(4,-1);Sop(“num=”+num);} Cathc(FuShuException e){ Sop();e.printStackTrace();} Sop(“over”);} }

自定義應用： 異常分兩種：

1、編譯被檢測的異常：Exception 這種異常通常都需要進行針對性的處理。

2、運行時發生的異常：RuntimeException 對于運行時異常一般是不編寫針對性的處理方式，如果該異常發生就讓程序停止，對程序進行修正。因為這種的出現往往已經無法讓程序繼續運算了。

class Demo {

int div(int a,int b)throws ArithmeticException

{

if(b==0)

throw new ArithmeticException(“除數為零”);

return a/b;

} } class ExceptionDemo3

{

public static void main(String[] args)

{

getIndex(null,4);

}

public static int getIndex(int[] arr,int key)

{

if(arr==null)//進行健壯性判斷。

throw new NullPointerException(“沒有具體的數組”);

for(int x=0;x

{

if(arr[x]==key)

return x;

}

return-1;

}

public static int getElement(int[] arr,int index)

{

if(arr==null)

throw new NullPointerException(“沒有具體的數組實例”);

if(index<0||index>=arr.length)

throw new ArrayIndexOutOfBoundsException(“角標越界”);

return arr[index];

} }-------------------異常練習：

/* 需求：

畢老師用電腦上課。按照面向對象思想來描述。名詞提煉法

上課過程中出現的問題：

1、電腦藍屏了。

2、電腦冒煙了。

*/ class LanPinException extends Exception {

LanPinException(String message)

{

super(message);

} } class MaoYanException extends Exception {

MaoYanException(String message)

{

super(message);

}

} class NoPlanException extends Exception {

NoPlanException(String message)

{

super(message);

} } class Computer {

private int state=2;

public void run()throws LanPinException,MaoYanException

{

if(state==1)

throw new LanPinException(“電腦藍屏了”);

if(state==2)

throw new MaoYanException(“電腦冒煙了”);

System.out.println(“電腦運行”);

}

public void reset()

{

System.out.println(“電腦重啟”);

state=0;

} } class Teacher {

private String name;

private Computer cmpt;

Teacher(String name)

{

cmpt=new Computer();

this.name=name;

}

public void prelect()throws NoPlanException//此處冒煙是電腦發生的，能再老師講課的功能出現這樣的異常么？所以拋出的對象不對，老師只能耽誤了講課的進度，所以此時是否應該定義一個關于講課進度的類來封裝這個問題。

{

try

{

cmpt.run();

System.out.println(name+“畢老師講課”);

}

catch(LanPinException e)

{

System.out.println(e.getMessage());

cmpt.reset();

prelect();

}

catch(MaoYanException e)//這個功能我處理不了，因為冒煙不會了，這時候需要拋出。

{

test();

//throw e;//因為處理不了，繼續往外拋。此時在講課方法上要聲明。此處也不能拋出這個異常。因為冒煙是電腦運行時的，不是老師講課的。

throw new NoPlanException(“課時無法繼續進行”);

}

}

public void test()

{

System.out.println(“練習”);

} } class ExceptionTest {

public static void main(String[] args)

{

Teacher t=new Teacher(“畢老師”);

try

{

t.prelect();

}

catch(NoPlanException e)

{

System.out.println(“換人”);

}

} } //到底什么是拋什么處理？

/*

自己能解決的就處理，處理不了就拋。

比如著火了，小火的時候自己可以處理，比如滅火器等

當火勢大了，就處理不了，只能交給消防隊，自己要跑。

*/

第四篇：黑馬程序員java培訓就業班筆記：day09總結

Day09總結： 上午：

1、final關鍵字：

Eg:代碼實現：

Class Fu { Final void method(){

//code...訪問低層代碼

} } Class Zi extends Fu { Void method()

{

Sop(“haha”);} } 以上代碼體現出繼承的弊端，因為父類的method的方法訪問了系統的低層代碼。當子類對其覆寫，就不會去訪問父類的meth的方法，直接用自己的method這樣就出現了代碼的不嚴謹性，所以此時需要用final關鍵字進行修飾。注意為什么不把類加final修飾，因為可能該類中會出現很多功能。有些是不需要被覆寫的。有些是被調用的。所以只能根據自己所需對相應的成員進行修飾。

2、Final的特點：

1、final是一個修飾符，可以修飾類、方法、變量(成員變量、局部變量)

2、Final修飾的類不可以被繼承。

3、Final修飾的方法不可以被覆蓋。

4、Final修飾的變量是一個常量，只能被賦值一次。是為了增強閱讀性，只要數據是固定的，就將這個數據用一個名稱來表示，并用final修飾。常量名稱都是大寫字母，多個單詞組成時用下劃線來分隔。

代碼體現：

Eg:

Class Zi { Static final int num=90;//必須對變量進行初始化，不知道要最終化哪個值，所以必須對它進行初始化。加靜態也是一樣的，同樣的道理，并且被初始化，此時靜態和final沒有必然的聯系。當變量被final修飾時，說明變量已經是一個常量值，此時不能被修飾，可以用static來修飾。

Public stati double PI=3.14;Void method(){

Final int x=4;

X=8;

Sop(num);//既然是在操作一個固定的值。為什么不把4直接寫在此處，如果這樣做的的話，閱讀性極差，你根本就不知道它所代表什么？為了增強閱讀性，此時數據是不變化的，所以我們需要給它起個名字，并且用final來修飾。這樣的話它也是固定的不變的。

注意：被final修飾的數值只能被覆寫一次，并且修飾的常量名全部大寫，多個單詞組成時用下劃線進行分隔。Eg:final int PERSON_AGE=4;} }

3、抽象類：

特點：

1、沒有方法體的方法，稱為抽象方法，必須存放在抽象方法類中，抽象方法和抽象類必須用abstract關鍵字來修飾，2、抽象類不可以被實例化，為什么？因為調用抽象方法沒有意義？為什么？因為它連方法體都不存在？

3、抽象類必須由其子類將抽象類中的抽象方法都覆蓋后，其子類才可以被實例化，否則該子類還是抽象類。Eg: Abstract class Demo { Abstract void show();} Class SubDemo extends Demo

Void show(){} //此時把父類中抽象方法覆蓋，此時才能被實例化。} 比如水果，它就是抽象的，不具體它包含各種各樣的水果，每種水果有它自己的體現。

抽象類涉及的問題？

1、抽象類中是否可以定義非抽象的方法？

可以 首先抽象類是一個類，類是用來描述事物，只不過描述事物過程中有些信息不具體，抽象類和一般類異同點：

相同：抽象類和一般類都用于描述事物，都可以定義成員。不同：抽象類中可以定義抽象成員函數，（抽象要么修飾類要么修飾函數）而一般類不可以。

抽象類不可以實例化，一般類可以實例化。

2、抽象類中是否有構造函數？

有，而且抽象類雖然自身不可以被實例化，但是其子類覆蓋了所有的抽象方法后，是可以實例化的。所以抽象類的構造函數是用于給其子類對象進行實例化。

3、抽象類通常都是一個父類？

是、因為需要子類去覆蓋父類中的抽象方法。代碼體現：

Abstract class Demo{ Abstract voif show1();Abstract void show2();} Abstract class SubDemo extends Demo { Void show1();} Class Test extends SubDmeo { Void show2();}

4、抽象類中可不可以不定義抽象方法？

可以；看上去沒有什么意義，其實有點意義，就是不讓這個類創建對象，為什么不讓創建？ 代碼體現：

interface InterTest//這是一個測試接口，有4種測試方式。

{ void test1();void test2();void test3();void test4();

} abstract class InterTestImpl implements InterTest//用這個類進行所有的空實現。但是創建對象是毫無意義的。所以用抽象。

{

public void test1(){}

public void test2(){}

public void test3(){}

public void test4(){} }

class Test2 extends InterTestImpl

{ public void test2(){}

}

class Test3 extends InterTestImpl

{ public void test3(){}

}

/*

class InterTestImpl implements InterTest

{

public void test2()//

{

sop(“testimpl test2”);

}

public void test1(){}//這樣做實現太麻煩。代碼重復。如何改進？

public void test3(){}

public void test4(){}

}

*/

5、抽象關鍵字 不可以和那些關鍵字共存？

Final：修飾了類是一個最終類，不可以被繼承，然后abstract修飾的類必須是父類，需要被繼承、沖突、非法的修飾符組合，abstract 和final Static:抽象方法被static修飾，就具備了可以被類名直接調用的的特點，但是抽象方法被調用沒有意思。

Priavte：因為抽象方法被私有，無法被覆蓋。

代碼體現： 雇員實例：

需求：公司中程序員有姓名、工號、薪水、工作內容。

項目經理除了姓名、工號、薪水、還有獎金、工作內容

進行數據建模

做問題領域的分析就是找出問題領域的對象。

分析: 在這個問題領域中有兩個對象： 程序員：

屬性：姓名，工號，薪水

行為：工作內容 項目經理：

屬性：姓名、工號、薪水、獎金

行為：工作內容。

這時候不能用項目經理去繼承程序員。因為職能不同，但是有共性，只能抽取。

就有了員工：

屬性：姓名，工號，薪水

行為：工作內容

*/ abstract class Employee

{ private String name;private String id;private double pay;Employee(String name,String id,double pay){

this.name=name;

this.id=id;

this.pay=pay;} public abstract void work();//工作內容是無法知道的。} class Programmer extends Employee { Programmer(String name,String id,double pay){

super(name,id,pay);} public void work(){

System.out.println(“code”);}

}

class Manager extends Employee { private double bonus;Manager(String name,String id,double pay){

super(name,id,pay);

this.bonus=bonus;} public void work(){

System.out.println(“manage”);} }

4、接口：

格式：interface{} 表現特點：

1、里面的方法都是抽象的。

2、接口中的成員都有固定的修飾符，最常見的成員：全局常量抽象方法。只是最常見，不代表只有它們沒有其他的，全局常量，共有的不需要對象，直接用接口調用的，不可變的。

表現形式：Public static final

抽象方法：public abstract

3、接口的成員都是public的。

4、接口是不可以創建對象的。就相當于是抽象的特殊表達形式。（但是有區別和抽象類）

5、類與類之間是繼承關系，類與接口之間是實現關系。

6、接口的出現可以多實現，避免了單繼承的局限性。

7、一個類在繼承一個類的同時，還可以實現多個接口、8、接口與接口之間是繼承關系，而且可以多繼承，以為接口的方法都沒有主體。思想特點：

1、對外暴露的規則。

外設要介入計算機中，因為計算機外面提供了接口，這就是規則。

2、程序的功能擴展

3、降低了耦合性

4、用來多實現

結合電腦主板的思想進行闡述，它是個規則。對外提供的規則 它提高了我們功能的擴展性，降低了耦合性。主板和聲卡：主板使用規則，聲卡實現規則。

與抽象類的區別：抽象類有單繼承的局限性，接口沒有

5、java對多繼承記住改良，以多現實接口的方式來體現。差別：多繼承因為父類中有相功能時，會造成不確定性。為什么可以實現多實現？

因為繼承中父類的方法有方法體？這才是造成不確定性的根本原因，而此處是沒有方法體的。

代碼體現：

interface A {

//int show();//這樣是不可以的。無法覆蓋。

void show();} interface B {

// void method();

void show();//當有重復的方法時。但是此時子類復寫它是可以的，為什么？

//因為繼承中父類的方法有方法體。這才是造成不確定性的根本原

因。而

//此處是沒有方法體的。

} class C extends D implements A,B//多實現。此時c必須覆蓋兩個方法

{

public void show(){}

//public void method(){}

} //一個類在繼承一個的類的時候還可實現多實現

class D

{

public void function();} //接口之間是可以繼承，而且支持多繼承。

interface InterA {

void showA();} interface InterB {

void showB();} interface InterC extends InterA,InterB//為什么此處可以實現多繼承，因為方法沒有主體。

{

void showC();}

class InterfaceDemo2

{

public static void main(String[] args)

{

C c=new C();

c.show();

System.out.println(“Hello World!”);

}

}

6、抽象類和接口之間的區別：

共性：它們都是不斷抽取出來的抽象非概念

區別：

1、抽象類只能被單繼承、接口可以被多實現，避免了單繼承的局限性。

2、抽象類中可以定義抽象方法，和非抽象方法，它可以用于定義體系的基本共性的內容。接口中只能定義抽象方法，它主要用于對象的功能的擴展。

3、抽象類是繼承關系，是is a關系，接口是實現關系是like a關系。

4、抽象類中的成員修飾符都是自定義的，接口中的修飾符都是固定的。記住：不要把接口狹義的理解為interface,應該理解廣義些，就是對外提供的規則，凡是對外暴露的都可以是接口。

實現代碼：

1、abstract class 犬

{ public abstract void 吃飯();

public abstract void 吼叫();

}

interface 搜爆

{ public void 搜爆();

}

class 搜爆犬 extends 犬 implements 搜爆//這是即具備了犬的基本特性，又具備了搜爆功能。

{ public void 搜爆(){} public void 吃飯(){}

public void 吼叫(){}

}

class 搜爆貓 extends 貓 implements 搜爆

{ public void 搜爆(){}

}

記住： 類里面都是定義的一些基礎內容，接口里面都是定義一些特性內容，這樣的方便了對其進行擴展。

//抽煙的學生，抽煙是額外功能。

2、abstract class Student

{ abstract void study();

}

interface Smoking

{ void smoke();

}

class SomkeStudent extends Student implements Smoking

{ public void study(){}

public void smoke(){}

}

//煙民。學生煙民 問題領域不同，對象的屬性和行為也不同。

abstract class Somker

{

abstract void smoke();

}

interface Study

{ void study();

}

class StudentSmoker extends Smoker implements Study

{ public void smoke(){} public void study(){}

}

7、多態：重點掌握

定義：某一類事物的多種存在形態。代碼實現：

class 動物

{}

class 貓 extends 動物

{

}

貓 x=new 貓();

動物 y=new 貓();//父類的引用變量指向了其子類的對象。

多態在代碼中的體現，父類或者接口的引用指向了自己的子類對象。

實現代碼：

class Animal

{ abstract void eat();

}

class Dog extends Animal

{ void eat(){

sop(“啃骨頭”);} void lookHome()

{

sop(“看家”);}

}

class Cat extends Animal

{ void eat(){

sop(“吃魚”);} void catchMouse(){

sop(“抓老鼠”);}

}

class Pig extends Animal

{ void eat(){

sop(“豬飼料”);} void gongdi(){

sop(“拱地”);}

} class DuoTaiDemo { public static void main(String[] args){

//Cat c=new Cat();

//c.eat();

//Cat c1=new Cat();

//c1.eat();

//method(c);

//method(c1);

重要知識點：----開發都用！

Animal a=new Cat();//此處貓對象類型自動向上提升---向上轉型，當指向使用體系基本功能時，可以向上轉型操作。

為什么體現多態性？

首先貓是一個實體，是一個貓類型，因為有了繼承，是動物中的一種，把這個實體稱之為動物也可以，所以它具備了兩種形態，貓和動物。這便是體現了多態性。

//一旦向上轉型，貓就不是貓了，已經是動物類型了。

a.catchMouse();//編譯失敗。

但是現在想執行貓的抓老鼠的功能怎么辦？

向下轉型：

Cat c=(Cat)a;//向下轉型。當使用子類對象中的特有內容時，才做向下轉型。

c.eat();

c.catchMouse();//此時是可以實現貓的抓老鼠的功能的。

總結：在多態轉型中，至始至終只有子類對象做著類型的變化。

method(new Cat());

} public static void method(Animal a)//Animal a=new Cat();{

重點知識點：instanceof

if(a instanceof Cat)//對象instanceof 類型 判斷具體對象是否是指定的類型。

{

Cat c=(Cat)a;//編譯通過，但是不能運行，此時類型轉換異常classCastException;

//此時為了程序的嚴謹性，需要對傳入的的對象進行判斷。

c.catchMouse();

}

else if(a instanceof Dog)

{

Dog d=(Dog)a;

d.lookHome();

}

a.eat();

總結：

instanceof是一個關鍵字，用于判斷對象的類型。什么時候用？

當進行向下轉型時，先判斷該對象是否符合被轉成的子類型。

} }

8、重點理解：

1、多態的好處：提高了代碼的擴展性，有了多態，前期設計好的內容可以使用后期出現的子類內容，對于指揮對象做事情這件事情，如果對象很多，指揮起來很麻煩，抽取對象的共性類型，對該類型的事物進行指揮就會變的很簡單。

2、多態的前提：

1、必須要有關系：繼承、實現。

2、必須有覆蓋的操作。

3、多態的弊端：前期的程序雖然可以使用后期出現的子類內容，但是只能使用子類覆蓋父類中的內容，不能使用子類中的特有內容。

第五篇：黑馬程序員java培訓就業班筆記：day14(多線程、String類)總結

Day14總結：

1、wait和sleep的區別：（面試題）

1、sleep指定時間，wait可以指定時間，也可以不用指定時間。

2、wait方法必須定義在同步中，sleep方法不一定。

3、在同步中wait sleep對于執行權和鎖的處理不同： i.Sleep釋放CPU執行權，但是沒有釋放鎖。ii.Wait釋放執行權、釋放鎖。實現代碼： Public void run(){ Synchronized(this){ Code…sleep(10);//此線程進入凍結狀態，釋放了執行權，并沒有釋放鎖。

Wait();//等待狀態下，釋放執行權、釋放鎖，因為它需要被對象喚醒，所以要釋放鎖

} } Public void method(){ Synchronized(this){

notifyAll();//喚醒上面所有的線程。但是此時t0、t1并沒有執行，因為鎖還在此線程中，只有當它執行完畢之后，釋放鎖。它們獲取鎖之后才有機會執行。

} }

2、停止線程：

1、Stop方法已經過時，為什么？因為該方法具有不固定的安全性。

如何停止線程？ 只有一種方法：

線程執行的代碼結束，線程會自動終止。

1、run方法中通常有循環，所以只要循環結束即可。所以只要控制循環條件。最簡單的方式就是定義標記。

2、如果run中有同步可以讓線程出現凍結狀態的方法，比如wait那么線程就不會去讀取標記。這時必須讓線程恢復到運行狀態才可以有機會讀取到標記，所以通過正常的恢復方法比如notify、sleep時間到，但是如果沒有辦法正常恢復，就必須使用強制手段，interrupt方法，強制將線程的凍結狀態清除，讓線程恢復運行。其實就是讓線程重新獲取讀取標記、結束。但是別忘了強制動作會產生異常要處理。實現代碼：

StopThreadDemo.java

class StopThread implements Runnable

{ private boolean flag=true;//定義標記控制住循環。public synchronized void run(){ while(flag)//開始true、此時定義標記控制循環。

{

try

{

wait();//當存在同步時，wait方法不會讓線程去讀取標記。此時主線程結束了，但是這兩個線程卻在這里等待了。并沒有結束。

}

catch(InterruptedException e)

{

System.out.println(Thread.currentThread().getName()+“....Exception”);

setFlag();//如果發生了強制中斷，只要把狀態切斷到假。

}

System.out.println(Thread.currentThread().getName()+“...”);} } public void setFlag(){ flag=false;} }

class StopThreadDemo { public static void main(String[] args){ StopThread st=new StopThread();Thread t1=new Thread(st);Thread t2=new Thread(st);t1.start();t2.setDaemon(true);//標記成了守護線程。

t2.start();

for(int x=0;;x++){

if(x==50)

{

st.setFlag();

t1.interrupt();//t1將它的凍結狀態強制結束。

t2.interrupt();//中斷方法。其實不是中斷線程。而且還拋出了異常。

//其實會將凍結中的線程強行恢復到運行狀態，就會讀到標記。這就是中斷線程。并不是結束線程。一定要注意要區分。

//

break;

}

System.out.println(Thread.currentThread().getName()+“....”);}

System.out.println(“Hello World!”);} }

3、守護線程：setDaemon();線程標記，守護線程，當正在運行的線程是守護線程時，JVM自動退出，該方法在開啟之前調用，也就是說在start方法之前調用。

線程分兩種：

前臺線程：自己創建的線程都是前臺線程。

后臺線程：一旦調用了此方法為守護線程之后的線程都是守護線程。

區別：都是線程，啟動后都再搶奪CPU的執行權，這里是沒有區別的，最大的區別就是如果線程結束了，正在運行的后臺線程也隨著結束，簡單的說后臺線程是以來前臺線程而執行的。

4、線程細節：

1、join：當A線程執行到B線程時，那么A線程就會等待，等B執行完畢，A才會執行。

代碼實現：

D1.join();d1加入，說明了主線程必須先釋放執行權給它，等到d1結束之后主線程才恢復執行狀態，所以輸出結果是等d1全部都執行完畢之后，才有其他線程的交替執行。

記住：誰把執行權給了誰，就只和給的對象的執行權有關，等它結束之后，就會重新獲取執行

記住：主線程是因為誰放棄了執行權，就只和那個線程有關系權，與其他線程無關。

2、優先級：代表搶奪資源的頻率。有兩種方法：getPriority setPriority來獲取優先級和設置優先級，只有十個數字可以使用1-10這十個數字，同時線程中提供了幾個特殊的方法： 線程類中提供了MAX_PRIORITY MIN_PRIORTY NORM_PRIORTY。

3、yield:結束該線程，釋放執行權。

4、toString();獲取線程詳細信息，包括線程組、線程名、所屬線程。實現代碼：ThreadMethodDemo.java

5、string類：

1、字符串的特點：

1、java中用String類來描述字符串。

2、字符串是一個特殊的對象，一旦初始化就不可以被改變，因為是常量。面試題1： String s=“abc”;String s1=new Strng(“abc”);是否相同？

前者“abc”是一個對象。后者是兩個對象，new string（）代表一個對象，“abc”也代表一個對象。

Sop(s1==s2);==比較的是數據。false Sop(s1.equals(s2));比較的是內存的地址值，equals覆寫了Object類中的equals方法。True

面試題2: String a=“abcd”;//在緩沖池創建了一個abcd的字符串。String a1=“ab”;//a1和a2都是變量，無法確定。

String a2=“cd”;String b=a1+a2;//b是要重新進行分配的。

String c=“ab”+“cd”;//兩個都是常量值，用連接符連接在一起還是字符創。abcd System.out.println(“a==b：”+(a==b));//false System.out.println(“a==c：”+(a==c));//true

2、常見操作方法：

1、獲取：

a)獲取長度：

Int length();數組長度是個屬性，字符串是個方法 b)獲取字符串中的字符：

charAt(int index);返回值是一個字符。

c)一個字符或者一個字符串在一個字符串中的位置

Int indexof(int ch)Int indexof(int ch,int fromIndex)Int indexof(ch,fromIndex)Int indexof(srting,fromindex)Int lastIndexof(ch);注意：這些獲取索引位的方法，如果沒有查找的內容，返回-1，所以這個方法。

d)獲取部分字符串：

String substring(begin,end)

2、判斷：

a)是否包含指定的字符串

Boolean contains(String)

b)是否是以指定的字符串開頭

Boolean startsWith(String)c)是否是以指定的字符串結尾

Boolean endwith(String)d)忽略大小寫判斷字符串

Boolean equalsIgnoreCase(string)

3、轉換：

a)將字符串轉成大小寫

String toLowerCase();String toUpperCase();b)將字符串轉成數組

Byte[] getBytes();Char[] getChar();c)將字符串轉成字符串數組

String[] d)將字符串中的內容進行替換

String replace(oldch1,new ch2)String replace(string1,string2)e)去除字符串兩端的空白

Trim();如何查閱API文檔的小技巧，先查找返回值類型，縮小查找范圍。實現代碼：

ublic static void main(String[] args){

// stringMethod4();

String str = “

ab c

”;

System.out.println(“-”+str.trim()+“-”);

String s = String.valueOf(4);

System.out.println(4+“");

System.out.println(”ab“+”cd“);

System.out.println(”ab“.concat(”cd“));

}

private static void stringMethod4(){

String str = ”lisi.wangwu.zhaoliu“;

} String[] strs = str.split(”.“);for(int i = 0;i < strs.length;i++){ System.out.println(strs[i]);}

str = ”hello“;

String s = str.replace('a', 'k');

System.out.println(”s=“+s);System.out.println(str);private static void stringMethod3(){

String str = ”aBCd“;

String s = str.toLowerCase();System.out.println(s);String s1 = str.toUpperCase();System.out.println(s1);

System.out.println(str);

char[] arr = str.toCharArray();

for(int x = 0;x

System.out.println(arr[x]);} } private static void stringMethod2(){

String str = ”ThreadDemo.java“;

System.out.println(”contains(Demo):“+str.contains(”Demo“));System.out.println(”starsWith(Thread):“+str.startsWith(”Thread“));System.out.println(”endsWith(.java):“+str.endsWith(”.java“));System.out.println(”isEmpty:“+str.isEmpty());str = ”abc“;說

System.out.println(str.equalsIgnoreCase(”abC“));}

private static void stringMethod(){

String str = ”abcdaef“;System.out.println(”length;“+str.length());

System.out.println(”charAt(2):“+str.charAt(2));

System.out.println(”indexOf(a):“+str.indexOf('a',2));

System.out.println(”lastIndexOf(a):“+str.lastIndexOf('k'));

System.out.println(”substring(1,3):"+str.substring(0,str.length()));}