1.Java語言是面向物件的程式設計語言，java程式的基本組成單元是類，類有屬性和方法，每一個應用程式都必須包含一個main()方法，含有main()方法的類稱為主類。
注意：程式碼的所有標點符號都為英文字元，不要再中文輸入法下輸入標點符號。檔名必須和類名First同名，即First.java。還要注意大小寫，java是區分大小寫的。一個java應用程式由若干個類組成，package為包的關鍵字。Import關鍵字匯入包。

2.類的屬性：稱為類的全域性變數(成員變數)，方法中的屬性稱為(區域性變數)。全域性宣告在類中，區域性宣告在方法體中。

3.main()是類體中的主方法，範圍一對括號。public(許可權修飾符)，static(靜態修飾符)，void(返回值修飾符)main方法必須public static void main(String [] args){}: String [] args是字串型別的陣列，他是main方法的引數。

4.基本資料型別8種： byte，short，int,long,float,double,char,boolean.
引用資料型別：類（class），介面（interface），陣列（Array【】）；

5.整數型別： 整數型別用來儲存整數數值，沒有小數部分！！！。可正可負。Java中整數有3中表示形式：十，八，十六進位制；不能以0作為十進位制的開頭（0除外）; 八進位制必須以0開頭； 十六進位制必須以0X或者0x開頭；
**記憶體空間：**byte：8位-128-127（2的7次冪）；short：16位-32768-32767（2的15次冪）； int ：32位； long：64位； long num=21457842L；不加L也對；

6.浮點型別表示有小數部分的數字。單精度浮點型（float）32位； 雙精度浮點型（double）64位；Float f=13.24f; double d1=456.23d; double d2=4561233.4562;

7.char型：字元型別：儲存單個字元，佔用16位（兩個位元組）記憶體空間；單引號表示；a unicode 97；unicode編碼採用無符號編碼，可以儲存65536個字元（0x0000-0xffff）; char word=’d’; int p=(int)word;

8.轉義字元：是一種特殊的字元變數，它以“\”開頭， \ddd：1-3位八進位制資料，\132；\uxxxx：四位十六進位制\u0052； \’：單引號； \反斜槓； \t:垂直製表符，將游標移到下一個製表符位置。 \r:回車； \n：換行； \b:退格； \f:換頁

9.布林型別又稱邏輯型別：；識別符號：字母，下劃線，美元符號，第一個字元不可為數字，不可違java保留關鍵字。變數名： 有效識別符號，不可關鍵字，不可重複，有意義。

10.系統區（OS），程式區（Program），資料區（Data）；

11.當定義final變數屬於成員變數時，必須在定義時就設定它的初值，否則產生編譯錯誤。Static final double PI=3.14；變數被定義出來後只暫存在記憶體中，等到程式執行到某一點，該變數就會被釋放掉，有生命週期。靜態變數，例項變數：靜態變數的有效範圍可以跨類，甚至可以達到整個應用程式之內。直接以： 類名.靜態變數；的方式呼叫。
注意：區域性變數可與成員變數的名字相同，此時成員變數被隱藏。

static int times = 3;
public static void main(String[] args) {
        int times = 4;
        System.out.println(times)；}

12.X=y=z;可以不建議使用；自增，自減是單目運算子，操作源是一個整形或浮點型變數。 6個比較運算子：><==>=<=!=; 邏輯運算子：與或非，除了！是一元運算子，其他都是二元運算子。三元運算子： boolean b=2<5?true:false;

13.運算子優先順序：單目優先雙目，（）最高，之後一次算數，位，關係，邏輯，三元，賦值。

14.型別轉換：是一個值轉換為另一個型別的過程。重點：低精度向高精度資料型別轉換，永遠不會溢位，並且總能成功，而把高精度資料型別向地資料型別轉換則必然會有資訊丟失，有可能失敗。

15.當：char，byte，short之間運算結果預設為int。當把高精度的變數的值賦給低精度的變數時，必須使用顯示型別轉換運算。（又稱強制型別轉換）。可能精度損失。

16.當把整數賦給byte，short，int，long時，不可超出範圍，否則必須進行強制轉型，例：byte b=（byte）129；

17.註釋：提高程式的可讀性，可維護性，好的編碼規範可以使程式更易閱讀和理解。單行註釋：// ； 多行註釋： /* / ； 多行註釋可以巢狀單行註釋；多行不可巢狀多行。文件註釋：/* */ ; javadoc文件內容； 可讀性第一，效率第二。

18.每條語句要單獨佔一行，一條命令要已分號結束； java中關鍵字和關鍵字中間多個空格，被視為一個空格。

19.複合語句：由開括號：{}；複合語句已整個塊為單位，能夠用到任何在一個單獨語句可以用到的地方，複合語句可以巢狀複合語句。複合語句為區域性變數創造了一個作用域，變數作用域之外使用會出錯。

20.If（內值必須為boolean的）；有時候為了程式設計需要if，else後面括號內可以沒有語句。範圍小寫上面。

21.switch：多選一，必須是整型，字元型，字串型別。表示式可以是：byte，short，int，char，string，列舉。常量值1-n必須是整形，字元型，字串型，default是可選的，如果他不存在，且switch語句中表達式的值不與任何case的常量值相同，switch不做任何處理。同一個switch，case的常量值必須互不相同。Case後的值絕不能是實數，case1.1不合法；

22.While（）條件判斷語句:重點：while（x==5）；這是程式會認為要執行一條空語句，進入無限迴圈。Do｛｝while（）；語句後有分號；

23.Java5新增Foreach語法:迴圈巢狀：外層控制行數，內層控制列數；無限迴圈：for（；；）；可以break跳出；任何foreach語句都可以改寫為for語句版本。Foreach並不是一個關鍵字。

24.break是中斷迴圈；標籤名：標籤名： 迴圈體｛break 標籤名；｝結束外層迴圈。

25.continue是執行下一次迴圈；不是立即跳出迴圈體，而是跳過本次迴圈，回到迴圈的條件測試部分，從新開始迴圈。 標籤名： 迴圈體｛continue 標籤名；｝；continue也支援標籤。

26.String：不可變字串，低層用char門存放，string是final的，一旦被賦值，不可改變。 String s= new String（char []a）; String (char [] a,offset,length); char a [] ={};//可以為空，中括號;
char [] b={’s’,’t’,’u’,’d’,’e’,’n’,’t’}; String str=new String(b,2,4);//從0開始，第二個取四個

27.String str1,str2; str1=”dsf”;str2=”dsf” 引用相同的字串常量，因此具有相同的實體。“+”運算子可以連線多個字串，併產生一個String物件。

28.Java中一句相連的字串不能分開在兩行中寫，例如:System.out.println(“iki
ke”);錯誤的；但是可以用“+”連線。只要“+”運算子的一個運算元是字串，編譯器就會將另一個運算元轉換成字串形式。

29.str.length();獲取長度方法。包含其中的空格。
str.indexOf(str);String str=”we are hero”;int size=str.indexOf(“a”);size=3;indexOf()返回引數字串a在指定字串中首次出現的位置，沒有檢索到a返回值為-1；
Str.indexOf(substr ,int fromindex);from是起始位置； 字串下標：0-length-1；
Str.lastIndexOf（str）:返回指定字串最後一次出現的索引位置；str.lastIndexOf(str, fromindex):起始位向前查詢；
查詢空字串，lastIndexOf返回的結果與呼叫該字串length（）方法返回結果相同。
Str.charAt(int index)方法將指定索引處的字元返回。
subString():方法被兩種不同的方法過載，來滿足不同的需求。
SubString(int begin):該方法返回的是從指定位置索引開始擷取至尾。
SubString(int begin，int end)：包含左邊，不包含右邊。
trim()方法：返回字串的副本，忽略前導和尾部空格。
Str.replaceAll(“ ”,””);去除字串中所有的空白內容Replace（old，new）：替換方法old重複多次都替換
Str.startsWith(String prefix):判斷當前字串以什麼字元開始。
Str.endsWith(String prefix):判斷當前字串以什麼字元結束。

30.重點：“==”比較運算子比較的是兩個字串的地址是否相同，不 new String，則地址相同。

31.Equals()方法:相同的字元和長度；1.只能處理引用型別變數。2.在Object類中，發現equals仍然比較地址，因為String,包裝類，file類，Date類，重寫了Object類的equals方法，比較兩個物件的實體是否相同。 EqualsIgnoreCase（）方法：忽略大小寫比較，返回boolean。

32.compareTO()方法：按照字典順序比較兩個字串，Unicode值，如果字典順序此String物件位於字串之前，比較結果返回一個負數，之後為正數，相等結果為零。 b compareTo a：1； b compareTo c:-1;

33.toLowerCase():String轉換為小寫， str.toUpperCase():轉換為大寫。
concat（str）：連線當前字串。
split(String sign):根據給定的分隔符對字串進行分割。split（String sign，int limit）:根據給定分隔符對字串進行拆分，並限定拆分次數。String str=”192.168.0.1”;//按照“.”進行分割，使用轉義字元“\.”
String [] firstArray=str.split(“\.”);//切割兩次String [] secondArray=str.split(“\.”,2);

34.String類的靜態format()方法用於建立格式化的字串。Str.format(String format,Object…args);
Format是格式字串，args格式字串中由格式說明符引用的引數，此引數可變，可以為0； Format（local 1，String format，Object。。Args）：1為null，則不進行本地化。 Format（）通過給定的特殊轉換符作為引數對日期和時間進行格式化。

35.字串生成器：J2SE5.0新增了可變的字元序列String-builder；大大提高了頻繁增加字串的效率；

類名  String  StringBuilder   StringBuffer
執行緒安全性   不安全 不安全 安全
執行效率    低   中   高
物件型別    字串常量   字串變數   字串變數

36.+號連線與動態字串的時間差異：

String str="";
    long starTime =System.currentTimeMillis();//起始時間
    for(int i=0;i<10000;i++){
        str=str+i;
    }
    long endTime =System.currentTimeMillis();//結束時間
    long time=endTime-starTime;//消耗時間

    StringBuilder builder=new StringBuilder("");
    starTime =System.currentTimeMillis();//起始時間
    for(int i=0;i<10000;i++){
        builder.append(i);
    }
    starTime =System.currentTimeMillis();//結束時間
    time=endTime-starTime;//對比兩個時間

37.StringBuilder：最後輸出字串，可使用toString方法；StringBuilder方法如下：
append()：該方法用於向字串生成器中追加內容。
insert(int offset,arg):向字串生成器中指定位置插入資料內容。Offset必須大於等於零，小於等於次序列長度。
delete(int start,int end):移除此序列的子字串中的字元，從start開始，end-1結束。左包括，右不包括。
CharAt（int index）:返回指定index位置的字元； equals（）；比較相等；
regionMatches（int firstStart,String other,int otherStart,int length）:判斷當前字串從firstStart開始的子串與另一個字串Other從OtherStart開始length的長度是否equals。

38.陣列：使用new關鍵字分配陣列時，必須指定陣列元素的型別和個數。使用new關鍵字為陣列分配記憶體時，整數陣列中元素初始值為0；float，double初始值為0.0；對於char，預設為空格。對於boolean預設為false。引用資料型別預設為null。動態初始化：int [] a=new int [] {1,2,4}; 賦值宣告分開進行 靜態初始化：int [] a={34,3423,342,}賦值宣告一起進行。

39.棧：存放區域性變數，物件的引用。 **堆：**new出來的東西放在裡面。

40.二維陣列初始化：

type arrayname [] []={value1,value2.....};
int[][]s=new int[1][];//前面必須有。後面可以沒有。
int a[][] = new int[3][4];// 預設值為0，定義二維陣列
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                System.out.print(a[i][j]);
            }
            System.out.println("輸出空格");
        }

41.Arrays類：中的靜態方法fill（）來對陣列中的元素進行替換。 fill（int [] a, int value）:value分配給每個元素；

    int arr []=new int [5];Arrays.fill(arr, 8);

Arrays.fill(int [] a,int fromIndex,int toIndex,int value):左包括，右不包括。
Arrays.sort(arr):對陣列實現排序；（升序）；
Arrays.copyOf(arr,int newlength):複製陣列；

int arr []=new int [5];int newarr []=Arrays.copyOf(arr, 5);

Newlength：新陣列的長度，大於原陣列用0填充。Char用空格（記住）填充。小於就擷取。
Arrays.copyOfRange(arr,int formIndex,int toIndex):formIndex:0-length,toIndex可以大於arr。

42.Arrays類的binarySearch()方法：可以使用二分法來搜尋指定陣列，獲得指定物件。返回搜尋元素的索引值。
binarySearch(Object[],Object key):如果key包含在陣列中返回索引值的索引，否則返回-1或“-”(插入點)

int arr[] =new int []{4,25,10};Arrays.sort(arr);int index=Arrays.binarySearch(arr, 0,1,8);

System.out.println(index);元素8在索引0-1的位置。由於指定範圍內並不存在元素8，index的值是插入點“-”，排序後，他在元素25的前面，25的索引值是2，所以index=-2；
必須在進行此呼叫之前對陣列進行排序（sort）方法；

int arr[] =new int []{1,8,9,4,5};Arrays.sort(arr);int index=Arrays.binarySearch(arr,4);

System.out.println(index);該方法在指定範圍neutral檢索某一元素。返回值1是對陣列a排序之後4的索引位置；

43.氣泡排序：基本思想是對比相鄰的元素值。也就是交換兩元素位置。由雙層迴圈實現的，外層迴圈用於控制排序輪數，一般為要排序的陣列長度減1次。

    public void sort(int [] array){//氣泡排序
        for(int i=1;i<array.length;i++){
            for(int j=0;j<array.length;j++){
                if(array[j]>array[j+1]){
                    int temp=array[j];//第一個元素值儲存在臨時變數中
                    array[j]=array[j+1];//第二個元素值儲存在第一個元素單元中
                    array[j+1]=temp;//把臨時變數放進第二個元素中
        }}}}

44.直接選擇排序：基本思想：將指定排序位置與其他陣列元素分別對比，滿足條件就交換元素值。與氣泡排序相比直接排序交換次數少，速度快。

public class BubbleSort {
    int index;
public void sort(int[] array) {// 直接選擇排序
        for (int i = 1; i < array.length; i++) {
            index = 0;
            for (int j = 1; j < array.length - i; j++) {
                if (array[j] > array[index]) {
                    index = j;
                }
            }
            // 交換在位置array.length-i和index（最大值）上的兩個元素
            int temp = array[array.length - i];
            array[array.length - i] = array[index];
            array[index] = temp;
        }
}
public static void main(String[] args) {    // index=1; 錯誤那不進主方法，但普通方法可以用。
}
}

45.反轉排序：

public void sort(int [] array){
    int temp;
    int len=array.length;
    for(int i=0;i<len/2;i++){
        temp=array[i];
        array[i]=array[len-1-i];
        array[len-1-i]=temp;
    }
}

46.面向物件概述：面向物件的開發思想。類：實際上就是封裝物件屬性和行為的載體，而物件則是類抽象出來的一個例項，類就是同一類事物的總稱，如將現實世界中的一個事物抽象成物件，類就是這類物件的總稱。同屬性和行為的一類實體被稱為類。

47.封裝：將類的屬性私有化，提供公共的方法呼叫。封裝是面向物件程式設計的核心思想。採用封裝的思想保證了類內部資料結構的完整性。為使用者提供物件屬性和行為的介面，通過介面使用類，無需瞭解類的構成。

48.繼承：類之間的關係叫做關聯；單繼承：一個類只可繼承一個父類。子類繼承父類後，父類中的屬性和方法子類獲取，當父類私有屬性和方法後，子類同時獲得，但由於封裝型，子類無法直接使用。子類的例項都是父類的例項，但不能說父類例項都是子類的例項。

49.多型：將父類物件應用於子類的特徵就是多型。向下轉型使用強轉符號（）；日後的維護和調整隻需要維護父類即可，降低了維護難度，節約了時間。多型的實現並不是依賴於具體類，而是依賴於抽象類和介面。
a instanceof A:如果a是A的例項，那麼它也一定是A的父類的例項。判斷是否為他的例項。

50.類：java中物件的屬性也稱為成員變數。不設初值有預設值。

51.Java中許可權修飾符主要包括：private，public，protected。一個原始檔中最多隻有一個public類，別的類個數不限。如果原始檔只包含了一個public類，則檔案要按照該類名命名。

修飾符     同類  同包  子類  任何地方
private     y           
default     y   y       
protected   y   y   y   
public      y   y   y   y

52.區域性變數：方法執行時建立，結束時刪除，區域性變數在使用時必須進行賦值或初始化，否則編譯出錯。有效範圍叫做作用域，在互不巢狀的作用域中可以同時宣告兩個名稱和型別相同的區域性變數。獨立互不干擾。

53.This關鍵字：呼叫類的成員變數和成員方法。1。可以用來修飾屬性方法構造器。2.this理解為當前物件或當前正在建立的物件。This.Name；this.Show();
**重點：**this（形參）的方式呼叫本類中其他過載的制定構造器。要求構造器內部宣告在首行，有n個構造器，最多n-1個構造器可以用this（）；

54.方法的過載：同一個類中，方法名相同，方法的引數列表不同。

55.類的構造方法：是一個與類同名的方法，物件的建立就是通過構造方法完成的。構造方法沒有返回值，名稱與本類名稱相同。目的：給物件初始化值。在構造方法中可以為成員變數賦值，當這樣例項化一個本類物件時，相應的成員變數也被初始化。

public class AnyThing {
    public AnyThing() {
        this("呼叫有參的構造器");
        System.out.println("這是無參的構造器");
    }
public AnyThing(String str) {
        System.out.println("這是有參的構造器");
    }
public static void main(String[] args) {
new AnyThing();
    }}

56.靜態變數：static修飾的變數，常量，方法被稱為靜態變數常量方法。使用：類名。靜態成員；物件。靜態成員

57.各區域執行順序：靜態程式碼塊–>非靜態程式碼塊–>構造方法–>成員方法；

58.Java中規定不能將方法體內的區域性變數宣告為static的。Static塊執行一次。

59.主方法是類的入口點，它定義了程式從何處開始；主方法是靜態的，主方法中直接呼叫其他方法，則該方法也必須是靜態的，主方法沒有返回值。主方法的形參為陣列。Args【0】–args【n】分別代表代表程式的第一個是引數到第n個引數，可以使用args.Length獲取引數的個數。

60.在java中物件和例項事實上可以通用。

61.被JVM視為垃圾的兩種：物件引用超出範圍，物件賦值為null；

62.垃圾回收機制：基本完善，垃圾回收機制只回收那些new操作符建立的物件，物件不new在記憶體中獲取一塊記憶體地址，這種物件不可能被垃圾回收機制所識別。記住：finalize（）方法；這個方法是Object類中的，他被宣告為protected，使用者可以自己定義這個方法。
有一點需要明確，垃圾回收機制finalize方法不保證一定會發生，如java虛擬機器記憶體損耗待盡時，不執行垃圾回收機制。
Java提供了System.gc()方法強制啟動垃圾回收機制。

63.Java.lang包中Integer類，Long類，Short類等封裝類分別將對應基本型別封裝成為一個類。都是Number的子類。

64.Integer：有兩種構造方法。：Integer num=new Integer(7); Integer num=new Integer(“45”)；
Integer:常用方法： byteValue():返回值byte；
compareTo(i): int 數字上比較兩個Integer物件。相等返0；前者小於i返回負值，大於i返回正值；
Equals(): boolean相等否； intValue():int; shortValue():short; toString(): String;
valueOf(str):Integer; parseInt(Str): int;
Integer的toString：轉換為十進位制字串。 toBinaryString():二進位制； toHexString():十六進位制；
toOctalString():八進位制；

65.Boolean(boolean value)：對於Boolean來講，當形參為true返回true，除此之外返回false。
BooleanValue():boolean; equals(Object obj):boolean; parseBoolean(String s):booean;
toString():String; ValueOf(String s):boolean;

66.Byte: byteValue():byte; compareTo(Byte another Byte):int ; doubleValue():double;
intValue():int ; parseByte(String s):byte; toString():String; valueOf(String str):byte;
Equals():boolaen;

67.Character:character(char value):char; compareTo(character other):int 等0，前-1，後1；
Equals(Object obj): boolean; toUpperCase(char):大寫： toLowerCase(char):小寫；
toString():string; charValue():char; isUpperCase(char):boolean是否大寫;isLowerCase(char);

68.Double(double);Double(str); byteValue():byte; compareTo():int; equals():boolean; intValue()**int; **isNaN():boolean:物件是非數字（NaN）值，返回true，否則返回false； toString（）；
ValueOf():Double; doubleValue():double; longValue():long;
Double類提供了一下常量：MAX_EXPONRNT:int，有限double變數可能具有最大指數。MIN_EXPONENT;標準化最小；NEGATIVE_INFINITY:double;負無窮大；POSITIVE_INFINITY：double正無窮大；

69.抽象類Number：是BigDecimal;BigInteger,Byte,Double,Float,Integer,Long,Short;
doubleValue():返回雙精度； floatValue():返回單精度；各種類的value；

70.與時間有關的類：1.System類下的currentTimeMillis();2.Date類：java.uti.Date；3.SimpleDateFormat類；java.text.SimpleDateFormat格式時間， 解析：文字-》日期：prase()方法；數字格式化：java.text.DecimalFormat格式化數字，DecimalFormat類;

71.Math類：常量：Math.PI;Math.E;三角函式；
1.指數函式：exp(a)：e的a次方； log( double a):取自然對數，Ina的數值； log10(double a):取底數為10的對數；Sqrt（double a）: 求平方根； cbrt(double a):a的立方根； pow（a，b）:a的b次方；
2.取整函式：ceil(double a):向上取整； floor（double a）：向下去整；rint（double a）：返回引數最接近整數，同為整數同樣接近，取偶數。Round（fload a）：加上0.5返回最近的整數；
取最大值：max(double a,double b):取最大； mix(double a,double b):取最小；Abs（）：取絕對值；

72.Math.random()方法：產生隨機數字，0-1的double；可以為0； （char）(‘a’+Math.random()*(‘z’-’a’+1));
偽隨機數，演算法。

73.static:修飾屬性(類變數)；屬性，方法，程式碼塊(初始化塊)，內部類。1.由類建立的所有物件都公用一個屬性。2.當其中一個物件對此屬性進行修改時，會導致其他物件對此屬性一個呼叫（非靜態static修飾的屬性，個個物件各自擁有一套副本。）類變數隨著類的載入而載入，而且獨一份。靜態變數可以直接通過類。類變數的形式呼叫。類的載入早於物件，可以物件。類變數，但是類。例項變數不可以。類變數存在於靜態域中。

74.static：修飾方法，隨著類的載入而載入，在記憶體中也是獨一份的，可以通過類。類方法的方式呼叫。內部可以呼叫靜態的屬性方法，而不能呼叫非靜態的，

75**static程式碼塊**：靜態塊中，裡面可以有輸出語句，隨著類的載入而載入，只被載入一次。靜態程式碼塊早於非靜態程式碼塊。只能執行靜態的結構（屬性和方法）；

76.類的第四個成員：程式碼塊（初始化塊）；一個類可以有多個程式碼塊按順序執行，每建立一個物件，非靜態程式碼塊載入一次。

77.Super關鍵字：呼叫父類中指定操作；訪問父類屬性，呼叫父類成員，子類構造呼叫父類構造。
Super():呼叫父類構造方法； super.doSomeThing():呼叫父類成員方法；繼承不只有擴充套件，還有重寫；
重寫（覆蓋）：特殊的重寫叫重構：子類與父類的成員方法返回值，方法名稱，引數型別個數順序完全相同。
重寫：子類不能降低父類的修飾許可權； 重寫的前提：繼承的基礎上，子類獲取父類的結構後，可以對父類的同名方法進行重構，方法的返回值型別，方法名，形參列表相同。子類許可權不小於父類，子類異常不大於父類。子類重寫父類方法可以修改返回值型別。

78.Super修飾構造器：子類中使用“super（形參列表）”必須宣告在首行。This(形參)和Super(形參)只能出現一個。寫一個類要一個空構造器。

79.例項化子類物件是首先要例項化父類物件，在例項化子類物件，這呼叫的是無參構造，有參構造要用super。呼叫構造方法的順序，頂級父類，上一級父類，子類。
重點：如果使用finalize()方法對物件進行清理，確保子類 的finalize（）方法最後一個動作是呼叫父類的finalize方法，以保證當垃圾回收物件佔用記憶體時，物件的所有部分都能被正常回收。

80.Object類：在java中所有的類都直接或者間接的繼承了java.lang.Object類；Object類的getClass(),notify(),notifyAll(),wait()等方法不能被重寫，定義為final型別。
getClass():他會返回物件執行時的Class例項，然後使用getName()：方法獲得類的名稱； getClass().getName();
toString():方法返回字串形式，返回一個String例項。重寫toStirng呼叫的就是自己的，不重寫就是Object的。
重點：String類；File類；Date類包裝類；已經實現了toString()的重寫。
Public String toString(){//重寫toString方法；
return “在”+getClass().getName()+”類中重寫toString()方法” ；｝

81.“==”比較的兩個物件的引用是否相等，equals()比較兩個物件的實際內容。
Equals():預設實現使用‘==’運算子比較兩個物件的引用地址，不是內容，真正比較需要重寫equals；

82.物件型別的轉換：主要包括向上轉型，向下轉型操作。把子類物件賦值給父類物件型別的變數，上轉。
上轉例子：Person p=new Man();
向下轉型：Person p=new Man(); Man() man=(Man)p; 將父類物件強制轉化為子類物件，顯示型別轉換；

83.Instanceof: 如果父類不是子類物件的例項，會發生ClassCastException；下轉之前要判斷父類物件是否為子類物件的例項。用instanceof：操作符判斷一個類是否實現了某個介面，一個例項是否屬於某一個類。
Person p=new Person();//例項化一個父類物件。
If(p instanceof Man){ Man man=(Man) p };//判斷父類物件是否為子類例項，向下轉型。返回boolean型；

84.方法的過載：就是在同一個類中允許同時存在一個以上的同名方法，只要這些方法引數個數型別順序不同即可。
返回值型別可以不同；

85.Public static int add(int…a){//定義不定長引數看作int[]a;
Int s=0; for(int i-0;i

package practice1;

public class OuterClass {
    // 在外部類中例項化內部類的物件。
    InnerClass in = new InnerClass();

    // 在外部類方法中呼叫內部類方法
    public void ouf() {
        in.inf();
    }

    class InnerClass {
        public InnerClass() {
            // 不寫預設構造器，系統也會提供。一個預設構造器
        }

        public void inf() {
            // 內部類成員的方法；
        }

        int y = 0;// 定義內部類成員變數
    }

    public InnerClass doit() {
        // 外部類方法返回值為內部類引用
        in.y = 4;// 外部類不可以直接訪問內部類成員
        // 返回內部類引用
        return new InnerClass();

    }

    public static void main(String[] args) {
        //內部類的物件例項化操作必須在外部類或者外部類的非靜態方法中實現。
OuterClass out=new OuterClass();
OuterClass.InnerClass in=out.doit();
OuterClass.InnerClass in2=out.new InnerClass();//這個記住。
    }
}

1.建立非靜態的內部類的物件：必須先建立外部類的物件，通過外部類的物件的呼叫內部類的構造器。
2.建立靜態內部類的物件，可以直接通過外部類呼叫靜態內部類構造器。

97.外部類建立內部類物件與與其他類建立物件引用時相同。內部類可以訪問外部類成員，但內部類成員只有在內部類的範圍內可知，不能被外部類使用。內部類物件與外部類物件關係非常緊密，內外可以互動使用彼此類中定義的變數。如果在外部類和靜態方法之外例項化內部類物件，需要使用外部類。內部類的形式指定該物件的型別。

98.在主方法中例項化內部類物件，必須在new操作符之前提供一個外部類的引用。
Public static void main(String args []){ OuterClass out=new OuterClass(); OuterClass.innerClass in=out.doit();
OuterClass.innerClass in2-out.new innerClass();//例項化內部類物件。使用外部類物件建立內部類物件。}

99.內部類物件會依賴與外部類物件，除非已經存在一個外部類物件，否則類中不會出現內部類物件。

100.如果將一個許可權修飾為private的內部類上轉為其父類物件，或轉為一個介面，在程式中可以完全隱藏內部類的具體實現過程。可以在外部提供一個介面，在介面中宣告一個方法，如果在該介面中的內部類中實現該介面的方法，就可以定義多個內部類以不同的方式實現介面中的同一個方法，而在一般的類中是不能多次實現介面中同一方法。

public class TheSameName {
    private int x;

    private class Inner {
        private int x = 9;

        public void doit(int x) {
            x++;// 呼叫的是形參x
            this.x++;// 呼叫內部類的變數x
            TheSameName.this.x++;// 呼叫外部類的變數x

        }}}//內部類與外部類的成員重名的情況，可以使用this關鍵字處理。就是用外部類名稱後跟一個點操作符和this關鍵字便可以獲取外部類的一個引用。

101.區域性內部類：內部類不僅可以在類中進行定義，也可以在類的區域性位置定義，如在類的方法或任意的作用域中均可以定義內部類。

interface OutInterface2 {//定義一個介面
}
public class OuterClass3 {
public OutInterface2 doit(final String x) {//doit()方法引數為final型別
    class InnerClass2 implements OutInterface2() {//定義一個內部類
        InnerClass2(String s){
            s=x;
            System.out.println(s);
        }
    }
return new InnerClass2("doit");}}

內部類被定義在了doit（）方法內，內部類InnerClass2是doit（）方法的一部分，並非OuterClass3類中的一部分，所以在doit（）方法外部不能訪問該內部類，但是該內部類可以訪問當前程式碼塊的常量以及此外部類的所有成員。

102.如果方法體中使用區域性變數，該區域性變數需被設定為final型別變數。換句話說，在方法體中定義的內部類只能訪問方法中final型別的區域性變數，這是因為在方法定義的區域性變數相當於一個常量，他的生命週期超出方法執行的生命週期，由於該區域性變數被設定為final，所以不能再內部類中改變該區域性變數的值。

class OuterClass4{
    public OutInterface2 doit() {
        return new OutInterface2() {//宣告匿名內部類
            private int i=0;
            public int getValue() {
                return i;
            }
        };
    }
}

Doit寫的有些莫名其妙，但這種寫法被java編譯器認可，在doit方法內部首先返回一個OutInterface2的引用，然後在return語句中插入一個定義內部類的程式碼，由於這個類沒有名稱，所以這裡將該內部類稱為匿名內部類。實質上：這種內部類的作用就是建立一個實現於OutInterface2介面的匿名類的物件。
Return new A(){ ….//內部類體 }； return後面的；分號別忘了；
由於匿名內部類沒有名稱，所以匿名內部類使用預設構造器來生成OutInterface2物件。最後的分號是代表建立OutInterface2引用表示式的標識。

103.匿名內部類編譯以後，會產生以“外部類名$序號”為名稱 .class檔案，序號以1-n排序，分別代表這1-n個匿名內部類。

104.靜態內部類：在內部類之前增加修飾符static，可以宣告static成員，但是非靜態內部類不可以宣告靜態成員。靜態內部類最大的特點就是不可以使用外部類的非靜態成員，所以靜態內部類在開發中比較少見。

105.內部類的繼承：在某個類繼承內部類時，必須硬性給予這個類一個帶引數的構造器，並且該構造器方法的引數為需要內部類的引用，同時在構造方法體中使用a.super();,這樣才為繼承提供了必要的物件引用。

106.異常處理：error：錯誤，程式中不作處理； exception：異常，要求在程式設計時，就考慮對異常的處理。
Int result=3/0；異常：java.lang.ArithmeticException;(算數異常)；0永遠不可以作為除數；

107.當某一個方法發生錯誤時，這個方法會建立一個物件，並且把它傳遞給正在執行的系統。這個物件就是異常物件。通過異常處理機制，可以將非正常情況下的處理程式碼與程式的主邏輯分開，即在程式設計同時在其他地方處理異常。

108.為了保證程式有效地執行，需要對發生的異常進行相對的處理。如果某個方法丟擲異常，既可以在當前方法中進行捕捉，也可以將異常向上丟擲，由方法呼叫者來處理。
Int age=Integer.parseInt(“20L”); NumberFormatException（數字轉換異常）；

109.Java語言捕獲異常結構由try，catch，finally三部分組成。Try{}存放可能發生異常的java語句；catch程式塊在try之後，用來激發被捕獲的語句。Finally語句塊是異常處理結構的最後執行部分，try如何退處必須執行。

110.Try{}:內宣告的變數，類似區域性變數，出了try{}語句，無法被呼叫。 finally:語句是可選的,一定執行程式碼塊。
Catch語句內部是對異常的處理：getMessage(); printStackTrace();
可以有多個catch語句，從上往下執行，滿足某個catch語句後，跳出多條catch語句。
如果異常處理了，那麼其後的程式碼繼續執行，try-catch可以相互巢狀；
當try語句塊中的語句發生異常時，程式就會跳轉到catch程式碼塊中執行。Try後不在執行，catch後抓住一次。
注意：Exception是try程式碼塊傳遞給catch程式碼塊的變數型別，e是變數名。Catch程式碼中語句“e.getMessage”用於輸出錯誤性質。異常處理有三個函式：1.getMessage()函式：輸出錯誤性質；2.toString()函式：給出異常的型別與性質； 3.printStackTrace()函式：指出異常的型別，性質，棧層次及出現在程式中的位置。

111.完整的異常處理一定要包含finally語句，無論程式中有無異常，並且無論之間的try-catch是否順利完成，都執行finally語句。
以下四種情況finally語句不會執行：1.在finally語句塊中發生了異常； 2.在前面的程式碼中使用了System.exit();退出程式； 3.程式所在的執行緒死亡。 4.關閉CPU；

112.常見異常類：1.ClassCastException：型別轉換異常； 2.ClassNotFoundException：未找到相應類異常；
3.ArithmeticException:算術異常； 4.ArrayIndexOutOfBoundsException:陣列下標越界異常；
5.ArrayStoreException：陣列包含不相容數值丟擲異常； 6.SQLException：操作資料庫異常；
7.NullPointerException：空指標異常； 8.NoSuchFieldException：欄位未找到異常；
9.NoSuchMethodException：欄位未找到異常； 10.NumberFormatException：字串轉換為數字異常；
11.NegativeArraySizeException：陣列元素個數為負數丟擲的異常；
12.StringIndexOutOfBoundsException：字串索引超出範圍丟擲的異常；
13.IOException：輸入輸出異常； 14.IllegalAccessException：不允許訪問某類異常；
15.InstantiationException：當應用程式檢視使用Class類中的newInstance（）方法建立一個類的例項時，而指定的類物件無法被例項化時，輸出該異常。
16.EOFException：檔案已結束異常； 17.FileNotFoundException：檔案未找到異常；

113.Java提供的異常處理的抓拋模型；自定義異常類繼承現有的異常類。提供一個序列號，提供幾個過載的構造器。

114.自定義異常：使用者只需要繼承Exception類即可自定義異常類；

public class MyException extends Exception{//建立自定義異常，繼承Exception類
public MyException(String ErrorMessage) {//構造方法
    super(ErrorMessage);//父類構造方法。}}

public class Tran {
//定義方法，丟擲異常
    static int avg(int number1,int number2) throws MyException{
        if(number1<0||number2<0) {
            throw new MyException("不可以使用負數");
        }
        if(number1>100||number2>100) {
            throw new MyException("數值過大");
        }
        return (number1+number2)/2;
    }
    public static void main(String[] args) {
        try {
            int result=avg(102,150);
            System.out.println(result);
        } catch (MyException e) {
            // TODO Auto-generated catch block
            System.out.println(e);}}}

115.在方法中丟擲異常：使用throws關鍵字丟擲異常；多個異常可以用逗號分隔。

public class Shoot {
static void pop() throws NegativeArraySizeException{
    int [] arr=new int[-3];

}
public static void main(String [] args) {
    try {
        pop();
    }catch(NegativeArraySizeException e) {
        System.out.println("pop()方法丟擲的異常");
    }//此方法內部出現異常的時候，會丟擲一個異常類物件，拋給方法的呼叫者。}}

116.子類重寫父類方法，其丟擲的異常型別只能是被重寫的方法異常類的子類或異常型別一樣。
Throws關鍵字將異常拋給上一級後，如果不想處理，可以繼續向上丟擲，但最終還是要處理。
丟擲的異常型別若是RuntimeException，可以不顯示處理，若是Exception，必須顯示處理。

117.Throw關鍵字用於方法體中，並且丟擲一個異常物件。程式在執行到throw語句時立即終止，他後面的語句不執行。Throw通常用來丟擲使用者自定義異常。

118.Exception是所有異常的父類，如果將catch（Exception e）放在前面，後面的異常程式碼塊將永不執行，也就沒有什麼意義了，所以catch語句的順序不可調換。

119.執行時異常：RuntimeException異常時程式執行過程中產生的異常。Java類庫的每個包中都定義了異常類，所有這些類都是Throwable類的子類。Throwable類派生了兩個子類，非別是Exception和Error類。Error是java執行系統中的內部錯誤以及資源耗盡的錯誤，這類錯誤比較嚴重。Exception類為非致命類，可以通過捕捉處理使程式繼續執行。Exception類又根據錯誤發生的原因分為RuntimeException和非RuntimeException異常。以下幾個為常見的執行時異常。
NullPointerException：空指標異常； ArrayIndexOutOfBoundsException：陣列下標越界異常；
ArithmeticException：算數異常； ArrayStoreException：陣列中包含不相容的值丟擲的異常；
IllegalArgumentException：非法引數異常； SecurityException：安全性異常；
NegativeArraySizeException：陣列長度為負異常；

120.集合類：java.util提供了一些集合類，容器。陣列也是容器，陣列長度固定，集合長度可變；陣列用於存放基本型別資料，集合存放引用型別資料。
常用的集合：List集合；Set集合；Map集合；

121.List與Set繼承了Collection介面，各介面還提供了不同的實現類。
Java.lang.Object:{一.Collection: 1.set:{hashSet,TreeSet; 2.List:{ArrayList,LinnkedList;
二.Map:{hashMap,TreeMap;
Collection介面是層次結構中的跟介面。構成Collection的單位稱為元素。Collection介面通常不能直接使用。
Collection常用方法： add(E e) :將指定物件新增到該集合中。
AddAll(Collection col): 判斷集合中是否包含指定obj元素，所有元素新增進當前集合。
remove(Object o) :將指定物件從集合中刪除；
isEmpty(): 返回boolean值，用於判斷當前集合是否為空。
iterator() : 返回在此Collection的元素上進行迭代的迭代器。用於遍歷集合中的物件。
size(): 返回int型值，獲取該集合中元素的個數。
Contain(Object obj):判斷集合中是否包含指定obj元素，若包含，返回true。
toArray():方法可返回集合返回成陣列。

122.Collection介面中的物件iterator()方法可返回在此Collection進行迭代的迭代器。

   import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class List112 {
public static void main(String[] args) {
    Collection<String> list=new ArrayList<>();//例項化集合類物件
    list.add("a");//向集合新增資料
    list.add("b");
    list.add("c");
    Iterator<String> it=list.iterator();//建立迭代器
    while(it.hasNext()){//判斷是否有下一個元素
        String str=(String)it.next();//或去集合中的元素
        System.out.println(str);
    }
    }
}

123.List集合：元素有序，可重複。
List集合：包括List介面以及List介面的所有實現類。可重複，順序為插入順序。索引訪問。
List介面繼承了Collection介面，因此包含Collection中的所有方法。
常用方法： get(int index):獲得指定索引元素位置。 set(int index,Object obj):指定位置修改
刪除：remove(int index); 得到： get(int index) ； 新增：add(int index,Object obj);
長度：size();

124.ArrayList()類:可變陣列，可儲存所有元素，包括null，快速隨機訪問。缺點：插入刪除慢。
LinkedList()類:採用連結串列結構儲存物件。 優點：便於向集合中插入刪除物件。隨即查詢慢。

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class List112 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();// 建立集合物件
        List<String> list1 = new LinkedList();
list.add("1");// 向集合新增元素
        list.add("2");
        list.add("3");
        int i = (int) (Math.random() * list.size());// 獲得0-2之間的隨機元素
        list.get(i);
        // for(String s:list){//不可
        // System.out.println();;
        // }
        list.remove(i);
        list.get(i);
        for (int i1 = 0; i1 < list.size(); i1++) {
            System.out.println(list.get(i));//遍歷
        }}}

125.Set：儲存元素無序，不可重複的。1.無序性：無序性！=隨機性，指元素是底層。不可以重複，新增相同元素時新增不進去。說明：要求新增Set中元素所在的類，一定要重寫equals（）和hsashcode（）方法。 Set：重用的方法都是collection下定義。
Set集合由Set介面和Set介面的實現類組成。Set集合繼承了Collection介面，包含他的所有方法。
如果一個Set中的可變元素改變了自身狀態導致Object.equals(Object)=true;

126.Set介面常用的實現類有HsahSet類與TreeSet類也是主要實現類：
HashSet類：實現Set介面，雜湊表支援，它不保證Set的迭代順序，特別是它不保證該順序恆久不變。此類允許使用nul元素。
TreeSet類：不僅實現了Set介面，還實現了java.Util.SortedSet,因此TreeSet類實現的Set集合在遍歷集合時按自然順序遞增排序，也可以按照指定比較器遞增排序。

127.TreeSet增加方法如下：first():返回當前第一個（最低）元素
last（）：返回當前最後一個（最高）元素
Comparator（）：返回對此Set中的元素進行排序的比較器，如果此Set使用自然排序，則返回null。
headSet（E toElement）：返回一個新的Set集合是toElement（不包