知識點

1.識別符號

java 識別符號可以是 字母、數字、$、_(下劃線)，不可用數字開頭，不能是java 的關鍵字。

2.命名規則

名	規則	例子
包名	全部小寫	multiplicationtable）
類名	每個單詞的首字母大寫	MultiplicationTable
變數名	第一個字母小寫，以後每個單詞的首字母大寫	multiplicationTable
常量	全部使用大寫字母，單詞間用下劃線隔開	MULTIPLICATION_TABLE

3.等等號（==）和equals的區別

==	equals
兩個變數的值是否相等,對於引用型變量表示的是兩個變數在堆中儲存的地址是否相同	兩個變數是否是對同一個物件的引用
即棧中的內容是否相同（棧中存自動變數，即區域性變數）	即堆中的內容是否相同（堆中存物件和靜態（static）變數）
比較的是2個物件的地址	比較的是2個物件的內容

s1=new String("student");
s2="student";
s3="student";
s4=new String(s2);

s1==s2:         false
s1.equals(s2):  true

s1==s4:         false
 
(地址不同)
s1.equals(s4):  true(內容相同)

s2==s3:         true
s2.equals(s3):  true

s3==s4:         false
s3.equals(s4):  true

s2="student";
s3="student";
這兩個是相同的,指向常量池中的"student"。

s1=new String("student");
s4=new String(s1);
這兩個是不同的物件,儘管他們的內容是一樣。

顯然，當equals為true時，==不一定為true（內容equals的，地址不一定==）。

4.switch

當switch裡面沒有break語句時，它會一直判斷下去。

例：下列輸出結果是（ C ）  
int  a = 0  
while ( a < 5 ) {     
switch(a){      
case 0:      
case 3 : a = a + 2;     
case 1 :      
case 2 : a = a + 3;     
default : a = a + 5;     
} 
}  
System.out.print ( a )   

A、 0  
B、 5 
C、 10 
D、 其他    

5.for

for迴圈可以用於迴圈次數不確定的情況，比如：死迴圈

for(;1;)
{
}

6.自動型別轉換

（1）資料型別
*基本資料型別：
boolean, byte, char, short, int, long, float, double, void.
×這些型別的封裝類：
Boolean, Byte, Character, Short, Integer, Long, Float, Double, Void

（2）基本資料型別轉換遵循的原則：
* 資料型別容量大小排序：byte,short,char

7.運算子優先級別

8.區域性變數的作用範圍

區域性變數的作用範圍僅僅在定義它的方法內，或者是在定義它的控制流塊中

9. String 和 StringBuffer

StringBuffer物件比String物件的操作效率要高

String	stringbuffer
用String儲存字串時，如果追加字串，它會在記憶體中重新開闢一塊空間來儲存	用StringBuffer時，它會在原來的基礎上繼續追加字串，不會開闢新的記憶體空間
對String修改時，它都會建立一個新的物件並指向它，建立物件多了，垃圾回收就多了，垃圾回收也涉及到一部分時間	對StringBuffer修改都是對該物件進行修改

StringBuffer的初始化

通常情況下一般使用構造方法進行初始化:

//StringBuffer物件為空物件。
StringBuffer s = new StringBuffer(); 

//StringBuffer物件的內容為字串”abc”。           
StringBuffer s = new StringBuffer(“abc”);

StringBuffer和String屬於不同的型別

不能直接進行強制型別轉換

StringBuffer s = “abc”; //錯誤，賦值型別不匹配
StringBuffer s = (StringBuffer)”abc”;//錯誤，不存在繼承關係，無法進行強轉

StringBuffer物件和String物件之間互轉

• String轉換為StringBuffer：
  String s = “abc”;
StringBuffer sb2 = new StringBuffer(s);

• StringBuffer轉換為String
  StringBuffer sb1 = new StringBuffer(“123”);
String s1 = sb1.toString();

Java 字串常用操作（String類）

• 1.字串查詢
  
  • indexOf（String s）
    返回字元(串)s在指定字串中第一次出現的索引位置，找不到則返回-1。
  • lastIndexOf(String s)
    返回字元(串)s在指定字串中最後一次出現的索引位置，找不到則返回-1。

    String str ="We are students";
    int size1=str.indexOf('a');   //3
    int size2=str.indexOf("a");   //3
    int size3=str.indexOf("ar");  //3
    int size4=str.indexOf("p");   //-1

    //空格也佔一個索引位置

• 2.獲取指定索引位置的字元
  
  • charAt()返回指定索引處的字串。

String str = "hello word";
char mychar1 =  str.charAt(4); //o
char mychar2 =  str.charAt(5); //(不返回任何東西)
char mychar3 =  str.charAt(6); //w
//空格也佔一個索引位置

• 3.獲取子字串
  
  • substring(int beginIndex)返回從指定的索引位置一直到該字串結尾的子串。
  • substring(int beginIndex, int endIndex)返回從指定的開始位置索引到指定的結束位置索引的子字串。（“包頭不包尾”）

String str="I love my husband,who called FengWenhua.";      
String myString1=str.substring(7); //my husband,who called FengWenhua.
String myString2=str.substring(0, 17); //I love my husband

• 4.去除空格
  
  • trim()返回字串的副本，忽略前導空格和尾部空格。

String str="       老公生病了，我吃飯都沒胃口了。       ";

System.out.println("唉~,"+str.trim()+"老公快點好起來！");//唉~,老公生病了，我吃飯都沒胃口了。老公快點好起來！

System.out.println("唉~,"+str+"老公快點好起來！");//唉~,       老公生病了，我吃飯都沒胃口了。       老公快點好起來！

• 5.字串替換
  
  • replace(oldChar,newChar)將指定的字元或字串替換成新的字元或字串

   String str= "address";
   String newstr1 = str.replace("a", "A");      //Address
   String newstr2=str.replace(str, "My Home");  //My Home

• 6.判斷字串的開始與結尾

  • startsWith(String prefix)判斷當前字串物件的字首是否是引數指定的字串
  • endsWith(String suffix)判斷當前字串是否以給定的子字串結束

• 7.判斷字串是否相等

  • equals(String otherstr)兩個字串具有相同的字元和長度時，返回true。equals()方法區分大小寫。

  • equalsIgnoreCase(String otherstr) 忽略大小寫。

• 8.按字典順序比較兩個字串

  • str.compareTo(String otherstr);
  • 該比較基於字串中各個字元的Unicode值，按字典順序將String物件表示的字元序列與引數字串所表示的字元序列進行比較。
  • 此String物件位於引數字串之前，則比較結果為一個負整數；位於引數字串之後，則比較結果為一個正整數；若兩個字串相等，則結果為0.

• 9.字母大小寫轉換

  • toLowerCase()將字串中的所有字元從大寫字母改寫為小寫字母
  • tuUpperCase()將字串中的小寫字母改寫為大寫字母

String str= "aDDreSs";
lower=str.toLowerCase();//address
upper=str.toUpperCase();//ADDRESS

• 10.字串分割
  
  • 使字串按指定的分隔字元或字串對內容進行分割，並將分割後的結果存放在字元陣列中。
  • split(String sign)sign為分割字串的分割符，也可以使用正則表示式。
  • str.split(String sign, in limit)；根據給定的分割符對字串進行拆分，並限定拆分的次數。
  • 對某些特殊字元，如：| , + , * , ^ , $ , / , | , [ , ] , ( , ) , - , . , \等, 因為它們正好是正則的一部分，所以如果用該字元本身來作為切割處的標誌, 這些字元需要進行轉義。
  • 例如: 想用 | 豎線去分割某字元，需要 \ 去轉義。因轉義使用 , 這個 \ 正好是正則表示式的字元，所以還得用一個 \ 。所以需要 \。

String str="[email protected]#hhh";  
String[] a = str.split("@|#");  
System.out.println("結果: "+a[0]+","+a[1]+","+a[2]); //結果: 1234,abc,hhh


String str="[email protected]#hhh";  
String[] a = str.split("@");  
System.out.println("結果: "+a[0]+","+a[1]);//結果: 1234,abc#hhh
String str="[email protected]#[email protected]@lll";  
String[] a = str.split("@",2);  
System.out.println("結果: "+a[0]+","+a[1]); //


String str="[email protected]#[email protected]@lll";  
String[] a = str.split("@",2);  
System.out.println("結果: "+a[0]+","+a[1]+","+a[2]); //報錯

String str="5678|XYZ";  
String[] b = str.split("\\|");  //注意這裡用兩個 \\，而不是一個\  
System.out.println("結果: "+b[0]+","+b[1]);//結果：5678,XYZ

String str="5678|XYZ";  
String[] b = str.split("|");  //注意直接使用|，該字元是正則表示式的一部分，  
String x="結果: ";  
for(int i=0;i<b.length;i++){  
    x=x+b[i]+",";  
}  
System.out.println(x);   //結果: 5,6,7,8,|,X,Y,Z, 

10.陣列的定義和初始化

• 陣列本身是一個物件。

一維陣列

• 定義（以int型陣列為例）

  • 方式一：int[] arr;
  • 方式二：int arr[];

• 陣列的初始化

靜態初始化	動態初始化
在定義的同時指定陣列元素內容	在定義時先通過new 關鍵字開闢指定大小的儲存空間，再為陣列指定內容
方式一：int[] arr={2,5,7,4,6}; 方式二：int[] arr2=new int[]{2,4,6,8,10};	方式一：int[] arr=new int[5];//預設各元素為0 方式二： int[] arr;//宣告陣列 arr=new int[5];//為陣列開闢空間 建議用方式二，提高程式碼執行效率

* 一旦使用new關鍵字那麼肯定在記憶體中為陣列分配了空間，則必然陣列有預設值。陣列是物件資料型別。

//靜態初始化，不指定陣列長度，值寫死。
        //方式一：
        int[] arr1={1,3,5,7,9};            //初始化為給定值。
        //方式二；
        int[] arr2=new int[]{2,4,6,8,10};


        //動態初始化，要制定陣列長度，可以在後來慢慢給它賦值。
        //方式一：
        int[] arr3=new int[5];              //初始化為預設值，int型為0。
        //方式二；
        int[] arr4=null;
        arr4=new int[5];

        //賦值：
        for(int i=0;i<5;i++){
            arr4[i]=2*i+1;
        }

錯誤寫法	解析
int intErrorArray5[] = new int[3]{50,51,52};	錯誤,靜態初始化不能指定元素個數
int intErrorArray6[] = new int[];	錯誤,動態初始化必須指定元素個數
int[] a; a={1,2,3,4,5};	錯誤,陣列常量只能在初始化操作中使用，如int[] a={1,2,3,4,5};
int a[]; a[0]=1; a[1]=2;	錯誤,因為陣列沒有初始化,不能賦值

二維陣列

• 定義
  
  • 方式一：int[][] arr;
  • 方式二：int arr[][];

初始化	分析
int[][] a;	宣告,沒有初始化
int[][] a=new int[2][3];	初始化為預設值,int型為0
int[][] a={{1,2},{2,3},{3,4}}; int[][] a={{1,2},{2,3},{3,4,5}};	//初始化為給定值 //陣列空間不是連續分配的，所以不要求每一維的大小相同
int[][] a=new int[2][]; a[0]=new int[3]; a[1]=new int[4];	//a[0]其實就是一個數組 //每一維的大小可以不一樣;
int[][] a=new int[][]{{1,2},{2,3},{3,4,5}};	同int[][] a={{1,2},{2,3},{3,4,5}};

錯誤寫法	解析
int[] a=new int[5]{{1,2},{2,3},{3,4,5}};	//錯誤,如果提供了陣列初始化操作，則不能定義維表示式
int[][] a=newint[2][]; a[0]={1,2,3,4,5};	//錯誤,陣列常量只能在初始化操作中使用
int[][] a=new int[2][]; a[0][1]=1;	//錯誤,第二維沒有初始化,不能賦值,Java.lang.NullPointerException異常

• 總結:
  
  • 二維就是陣列的陣列,裡面的陣列大小不要求一樣
  • 不管一維還是二維,在使用前(賦值,訪問)必須初始化,可以用new預設初始化,也可以用陣列常量初始化
  • 動態初始化：陣列定義與為陣列分配空間和賦值的操作分開進行；
  • 靜態初始化：在定義數字的同時就為陣列元素分配空間並賦值；
  • 預設初始化：陣列是引用型別，它的元素相當於類的成員變數，因此陣列分配空間後，每個元素也被按照成員變數的規則被隱士初始化。

11.構造方法

• java中的構造方法是用來初始化一個物件的，併為為例項變數賦予合適的初始值。因此構造方法不需要返回型別。　　
• 必須滿足以下語法規則：　　
  
  • 方法名必須與類名相同；　　
  • 不要宣告返回型別；　　
  • 不能被static、final、synchronized、abstract和native修飾；　　
  • 構造方法不能被子類繼承，所以用final和abstract修飾沒有意義。

12.super關鍵字

（1）selectrubric包目錄下的Chinese.java

package selectrubric;
class Person {//前面用public修飾會報錯
Person() {
System.out.println("父類、無參");
}

Person(String name) {
System.out.println("父類、有參： " + name);
}
}


public class Chinese extends Person {//因為建立的是Chinese.java,所以前面要用public class作為標誌
Chinese() {
super(); // 子類呼叫父類無形參的建構函式（子類的建構函式呼叫另一個類的建構函式時，super（）；一定要寫在呼叫的建構函式的第一行）；
System.out.println("子類、無參");
}

Chinese(String name) {
super(name); // 呼叫父類具有相同形參的構造方法；
System.out.println("子類、有參： " + name);
}

Chinese(int age, String name) {// 構造方法的過載！
this(name); // this：呼叫當前具有相同形參的構造方法.並且，當子類沒有刻意用super();呼叫父類的構造方法的時候，系統預設的為它呼叫父類中無參的構造方法；
System.out.println("子類特有： " + age);
}

public static void main(String[] args) {
Chinese chinese = new Chinese();
System.out.println("");
chinese = new Chinese("小丁");
System.out.println("");
chinese = new Chinese(35, "小丁");
}
}

/*
Chinese chinese = new Chinese();
父類、無參
子類、無參

chinese = new Chinese("小丁");
父類、有參： 小丁
子類、有參： 小丁

chinese = new Chinese(35, "小丁");
父類、有參： 小丁
子類、有參： 小丁
子類特有： 35
*/

（2）繼承中的構造方法總結:
* 子類在自己的構造方法中使用super(argument_list)呼叫父類的構造方法。
* super()方法必須寫在子類構造方法的第一行；
* 使用this(argument_list)呼叫當前類的另外的構造方法；
* 如果子類的構造方法中沒有顯式地呼叫父類構造方法，則系統預設呼叫父類中無參的構造方法；
* 如果子類構造方法中既沒有顯式地呼叫基類構造方法，而基類中沒有無參的構造方法，則編譯出錯；

（3）子類可引用父類的某些方法和屬性，通過super.xx來獲取父類的變數(屬性)，通過super.xx()訪問父類的方法。

（4）注意：
* super()和this ()不能共存，否則編譯時會報異常：Constructor call must be the first statement in a constructor。
* 換句話說就是super()和this ()都必須在構造方法的第一行。
* super(有引數/無引數) 用於呼叫父類相應的建構函式。
* this(有引數/無引數) 用於呼叫本類相應的建構函式。

13.異常

• 處理異常常用的兩種方式：
  
  • try…catch(捕獲處理機制)；
  • throws(冒泡處理機制).
• 注意細節：使用try…catch塊捕獲時可以沒有catch塊,但當沒用catch塊的時候必須得有finally塊，即try能與finally單獨使用。

14.介面

概念

• 介面:是一個抽象型別，是抽象方法的集合。一個類通過繼承介面的方式，來繼承介面的抽象方法。

• 介面並不是類，介面和類的編寫方式相似，但它們是不同的概念。類描述物件的屬性和方法。介面則包含類要實現的方法。

• 在 Java 中，介面型別可用來宣告一個變數，他們可以成為一個空指標，或是被繫結在一個以此介面實現的物件。

介面與類相似點

• 一個介面可以有多個方法。* 介面檔案儲存在 .java 結尾的檔案中，檔名使用介面名。* 介面的位元組碼檔案儲存在 .class 結尾的檔案中。* 介面相應的位元組碼檔案必須在與包名稱相匹配的目錄結構中。

介面與類的區別

• 介面不能用於例項化物件。* 介面沒有構造方法。* 介面中所有的方法必須是抽象方法。* 介面不能包含成員變數，除了 static 和 final 變數。* 介面不是被類繼承了，而是要被類實現。* 介面支援多重繼承。

介面特性

• 介面是隱式抽象的，當宣告一個介面的時候，不必使用abstract關鍵字。

• 介面中每一個方法也是隱式抽象的,介面中的方法會被隱式的指定為 public abstract，宣告時同樣不需要abstract關鍵子。（只能是 public abstract，其他修飾符都會報錯）。

• 介面中可以含有變數，但是介面中的變數會被隱式的指定為 public static final 變數（並且只能是 public，用 private 修飾會報編譯錯誤。

• 介面中的方法是不能在介面中實現的，只能由實現介面的類來實現介面中的方法。

• 介面中的方法都是公有的。

抽象類和介面的區別

• 抽象類中的方法可以有方法體（即實現方法的具體功能），介面不行。

• 抽象類中的成員變數可以是各種型別的，而介面中的成員變數只能是 public static final 型別的。

• 介面中不能含有靜態程式碼塊以及靜態方法(用 static 修飾的方法)，而抽象類是可以有靜態程式碼塊和靜態方法。

• 一個類只能繼承一個抽象類，卻可以實現多個介面。

介面的宣告

• 格式：NameOfInterface.java

/* 檔名 : NameOfInterface.java */
import java.lang.*;
//引入包

public interface NameOfInterface
{
   //任何型別 final, static 欄位
   //抽象方法
}

• 例項：Animal.java

/* 檔名 : Animal.java */
interface Animal {
   public void eat();
   public void travel();
}

介面的實現:implements

*實現介面的語法

...implements 介面名稱[, 其他介面, 其他介面..., ...] ...

• 例項:MammalInt.java

/* 檔名 : MammalInt.java */
public class MammalInt implements Animal{

   public void eat(){
      System.out.println("Mammal eats");
   }

   public void travel(){
      System.out.println("Mammal travels");
   } 

   public int noOfLegs(){
      return 0;
   }

   public static void main(String args[]){
      MammalInt m = new MammalInt();
      m.eat();
      m.travel();
   }
}

• 介面無法被例項化，但是可以被實現。一個實現介面的類，必須實現介面內所描述的所有方法，否則就必須宣告為抽象類。

• 類在實現介面的方法時，不能丟擲強制性異常，只能在介面中，或者繼承介面的抽象類中丟擲該強制性異常。

• 類在重寫方法時要保持一致的方法名，並且應該保持相同或者相相容的返回值型別。

• 如果實現介面的類是抽象類，那麼就沒必要實現該介面的方法。

介面的繼承:extends

• 一個介面能繼承另一個介面

• 例項：Sports介面被Hockey和Football介面繼承。

  • Hockey介面自己聲明瞭四個方法，從Sports介面繼承了兩個方法，這樣，實現Hockey介面的類需要實現六個方法。

  • 實現Football介面的類需要實現五個方法，其中兩個來自於Sports介面。

介面的多重繼承

public interface Hockey extends Sports, Event

Sports.java

public interface Sports
{
   public void setHomeTeam(String name);
   public void setVisitingTeam(String name);
}

Football.java

public interface Football extends Sports
{
   public void homeTeamScored(int points);
   public void visitingTeamScored(int points);
   public void endOfQuarter(int quarter);
}

Hockey.java

public interface Hockey extends Sports
{
   public void homeGoalScored();
   public void visitingGoalScored();
   public void endOfPeriod(int period);
   public void overtimePeriod(int ot);
}

標記介面

• 標識介面是沒有任何方法和屬性的介面。
• 簡單來說就是來給某個物件打個標，使物件擁有某個或某些特權。
• 比如：java.awt.event 包中的 MouseListener 介面繼承的 java.util.EventListener 介面定義

package java.util;
public interface EventListener{}

• 標記介面的目的
  
  • 建立一個公共的父介面。使用一個標記介面來建立一組介面的父介面。
  • 向一個類新增資料型別。實現標記介面的類不需要定義任何介面方法，但是該類通過多型性變成一個介面型別。

15.繼承

• 一個類可以繼承多個類：class A extends B，class C extends A，C就同時繼承了B和A兩個類。
• 但不能直接繼承多個類，java是單繼承語言，不支援多繼承：class A extends B,C 這樣寫錯誤。
• 可以用介面來實現多繼承

16.continue

• 沒有標籤的時候，continue的作用是忽略本次迴圈剩下的語句，直接進行本層迴圈的下一次迴圈，而不會結束迴圈。

public class Continue {
    public static void main(String args[])  
    {  
        for(int i=0;i<10;i++)  
        {  

            if(i==3)  
            {  
                System.out.println("遇到continue，本次迴圈剩下的語句“i==3”無法執行。");
                //忽略本次迴圈中continue剩下的語句  
                continue;  
            }  

            System.out.println("i=="+i);  
        }  
    }  
}

/*
i==0
i==1
i==2
遇到continue，直接跳出本次迴圈，本次迴圈剩下的語句“i==3”無法執行。
i==4
i==5
i==6
i==7
i==8
i==9
*/

• 帶標籤的continue語句的作用是跳過標籤所標識迴圈的當次迴圈的剩下語句，重新開始下一次迴圈。

    public static void main(String args[]) {
        // 外層迴圈
        outer: for (int i = 0; i < 5; i++) {
            System.out.println("");
            System.out.println("i==" + i);

            for (int j = 0; j < 3; j++) {
                System.out.println("j==" + j);
                if (j == 1) {
                    // 忽略本次迴圈剩下的語句
                    continue outer;
                }
            }
        }
    }
}


/*
i==0
j==0
j==1

i==1
j==0
j==1

i==2
j==0
j==1

i==3
j==0
j==1

i==4
j==0
j==1
*/


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

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

        for (int i = 0; i < 5; i++) {
            System.out.println("");
            System.out.println("i==" + i);

            for (int j = 0; j < 3; j++) {
                System.out.println("j==" + j);
            }

        }
    }
}


/*
i==0
j==0
j==1
j==2

i==1
j==0
j==1
j==2

i==2
j==0
j==1
j==2

i==3
j==0
j==1
j==2

i==4
j==0
j==1
j==2
*/

17.Object類的方法

Object是所有類的父類，任何類都預設繼承Object。

序號	方法： 說明
1	clone()：保護方法，實現物件的淺複製，只有實現了Cloneable接口才可以呼叫該方法，否則丟擲CloneNotSupportedException異常。
2	getClass()：返回Object 的執行時類

18.String類的方法

方法	說明
regionMatches(boolean b, int firstStart, String other, int otherStart, int length)	從firstStart位置開始取長度為length的字元,1，再從otherStart位置開始取長度為length的字串2，兩字串比較，當b為true時字串不區分大小寫。
trim()	截去字串兩端的空格，但對於中間的空格不處理
split(String str)	將str作為分隔符進行字串分解，分解後的字字串在字串陣列中返回
toCharArray()	將字串轉換為字元陣列
contains(String str)	判斷是否包含指定的字串
getBytes()	將字元儲存在位元組陣列中,與getChars()用法類似。
concat(String str)	concat()是將兩個字串連線在一起。 + 是將任意型別的資料連線成字串。
compareTo(String str)	對字串內容按字典順序進行大小比較，通過返回的整數值指明當前字串與引數字串的大小關係。若當前物件比引數大則返回正整數，反之返回負整數，相等返回0。
compareToIgnoreCase(String str)	對字串內容按字典順序進行大小比較，通過返回的整數值指明當前字串與引數字串的大小關係。若當前物件比引數大則返回正整數，反之返回負整數，相等返回0。
equals(String str)	比較當前字串和引數字串，在兩個字串相等的時候返回true，否則返回false
equalsIgnoreCase(String str)	忽略大小寫
indexOf(int ch/String str)	用於查詢當前字串中字元或子串，返回字元或子串在當前字串中從左邊起首次出現的位置，若沒有出現則返回-1
indexOf(int ch/String str, int fromIndex)	從fromIndex位置向後查詢
lastIndexOf(int ch/String str)	從字串的末尾位置向前查詢
lastIndexOf(int ch/String str, int fromIndex)	從fromIndex位置向前查詢
toLowerCase(); toUpperCase();	字串中字元的大小寫轉換
replaceFirst(String regex, String replacement)	用字元replacement的內容替換當前字串中遇到的第一個和字串regex相匹配的子串，應將新的字串返回。
replaceAll(String regex, String replacement)	用字元replacement的內容替換當前字串中遇到的所有和字串regex相匹配的子串，應將新的字串返回。
statWith(String prefix)	判斷是否以指定的字串開頭
endWith(String suffix)	判斷是否以指定的字串結尾
(以下的方法StringBuffer也有)	···
length()	字串長度
charAt(int Index)	擷取一個字元
getChars(int sourceStart,int sourceEnd,char target[],int targetStart)	擷取多個字元。擷取從位置sourceStart到位置sourceEnd的一段字元，從陣列的target[]的下標值targetStart開始放入陣列target[]中。target.length=sourceEnd-sourceStart。
substring(int beginIndex); substring(int beginIndex, int endIndex);	擷取
replace(char oldChar, char newChar)	字串中字元的替換

public class Continue {
    public static void main(String args[]) {
        String s = "this is a demo of the getChars method.";
        char buf[] = new char[4];
        s.getChars(10, 14, buf, 0);//demo


        for(int i=0;i<buf.length;i++){
            if(i==0){
                System.out.print("["+buf[i]+",");
            }else if(i==buf.length-1){
                System.out.print(buf[i]+"]");
            }else {
                System.out.print(buf[i]+",");
            }
        }


        //[d,e,m,o]
    }
}

//toCharArray()     將字串轉換成字元陣列     
String a = "123";
char buf[] = new char[3];
buf = a.toCharArray();//[1,2,3]

//concat(String str)      字串連線
String str = "aa".concat("bb").concat("cc");
//相當於String str = "aa"+"bb"+"cc";

String str = "asdzxcasd";
String str1 = str.replace('a','g');            //str1 = "gsdzxcgsd"
String str2 = str.replace("asd","fgh");        //str2 = "fghzxcfgh"
String str3 = str.replaceFirst("asd","fgh");   //str3 = "fghzxcasd"
String str4 = str.replaceAll("asd","fgh");     //str4 = "fghzxcfgh"

//trim()
String str = " a sd ";
String str1 = str.trim();
int a = str.length();//a = 6
int b = str1.length();//b = 4

//split()   以指定的符號為標識，拆分字串，並返回陣列。

public class Continue {
    public static void main(String args[]) {
        String str = "asd!qwe|zx#c";
        String[] str1 = str.split("!|#");
        System.out.println("["+str1[0]+","+str1[1]+","+str1[2]+"]    陣列長度："+str1.length);


        String[] str2 = str.split("!|#|\\|");
        System.out.println("["+str2[0]+","+str2[1]+","+str2[2]+","+str2[3]+"]    陣列長度："+str2.length);
    }
}



/*
[asd,qwe|zx,c]    陣列長度：3
[asd,qwe,zx,c]    陣列長度：4

20.StringBuffer類的方法

方法	說明
(1)capacity() (2)StringBuffer( ) (3)StringBuffer( int len ) (4)StringBuffer( String s )	（1）返回整個可分配空間（即字串緩衝區的容量） （2）分配16個字元的緩衝區 （3）分配len個字元的緩衝區 （4）除了按照s的大小分配空間外,再分配16個 字元的緩衝區，比如”abc”的長度是3另外再分配16個字元，所以一共是19。
ensureCapacity(int capacity)	設定緩衝區的大小
setLength(int len)	設定緩衝區的長度
setCharAt(int where,char ch)	用新字元取代指定位置的字元，此方法不返回任何值。
append()	可把任何型別資料的字串表示連線到呼叫的StringBuffer物件的末尾
insert(); StringBuffer insert(int index,String str); StringBuffer insert(int index,char ch); StringBuffer insert(int index,Object obj);	插入字串
reverse()	顛倒StringBuffer物件中的字元
delete(int startIndex,int endIndex); deleteCharAt(int index);	刪除字元
(以下方法String也有)	···
length()	一個StringBuffer當前長度
charAt(int where)	獲得指定位置的字元
getChars(int sourceStart,int sourceEnd,char target[],int targetStart)	擷取多個字元。擷取從位置sourceStart到位置sourceEnd的一段字元，從陣列的target[]的下標值targetStart開始放入陣列target[]中。
substring(int startIndex); substring(int startIndex,int endIndex);	擷取子串
replace(int startIndex,int endIndex,String str)	替換

21.String類與基本型別的轉換

字串轉換為基本型別	基本型別轉換為字串
parseByte(String s) parseShort(String s) parseInt(String s) parseLong(String s parseFloat(String s) parseDouble(String s)	valueOf(char data[]) valueOf(char data[], int offset, int count valueOf(boolean b) valueOf(char c) valueOf(int i) valueOf(long l) valueOf(float f) valueOf(double d)

//字串轉換為基本資料型別       
int a = Integer.parseInt("12");//12
float b = Float.parseFloat("12.34");//12.34
double c = Double.parseDouble("1.124");//1.124

//基本資料型別轉換為字串
String s1 = String.valueOf(20);//20
String s2 = String.valueOf(16.98);//16.98

22.進位制轉換

使用Long類中的方法得到整數之間的各種進位制轉換的方法：
* Long.toBinaryString(long l) // 轉化為二進位制
* Long.toOctalString(long l) // 轉化為八進位制
* Long.toHexString(long l) // 轉化為十六進位制
* Long.toString(long l, int p)//p作為任意進位制

23.過載

• 過載的規則：
  
  • 必須具有不同的引數列表；
  • 可以有不同的返回型別，只要引數列表不同就可以； * 可以有不同的訪問修飾符； * 可以丟擲不同的異常； * 方法能夠在一個類中或者在一個子類中被過載。
• 程式碼

public class HelloWorld
{
 public HelloWorld()
 {

 }

 public static void main(String[] argc)
 {
  HelloWorld w = new HelloWorld();
  System.out.println(w.Multi(2,3));
  System.out.println(w.Multi(2,3,4));
  System.out.println(w.Multi(2.0f,3.0f));

 }



 public int Multi(int x, int y)
 {
  return x*y;
 }

 public int Multi(int x, int y ,int z)
 {
  return x*y*z;
 }


 public float Multi(float x, float y)
 {
  return x*y;
 }

24.實體類

• 實體類(entity)的作用一般是和資料表做對映
• 是一個擁有Set和Get方法的類
• 通常總是和資料庫之類的（所謂持久層資料）聯絡在一起。這種聯絡是藉由框架（如hibernate）來建立的。
• 實體類的名字儘量和資料庫的表的名字對應相同。
• 應該實現java.io.Serializable介面。
• 有個無參的構造方法。
• 有個有參（所有的引數）的構造方法。
• 有屬性和方法，屬性對應資料庫中表的欄位，方法主要有getter和setter方法。
• 有個屬性serialVersionUID。例如：private static final long serialVersionUID = -6125297654796395674L;
• 物件序列化機制（object serialization）:是Java語言內建的一種物件持久化方式，可以很容易的在JVM中的活動物件和位元組陣列（流）之間進行轉換。除了可以很簡單 的實現持久化之外，序列化機制的另外一個重要用途是在遠端方法呼叫中，用來對開發人員遮蔽底層實現細節。
• 屬性一般是private型別，方法為public型別，對於資料庫自動生成的ID欄位對應的屬性的set方法為private。
• 一般格式:（私有屬性，公有方法，getter 和 setter）

public class A{
      private String id;
      public String getId(){
           return this.id;
      }
      public void setId(String id){
           this.id = id;
      }
}

• 在專案中寫實體類一般遵循下面的規範：
  
  • 根據你的設計，定義一組你需要的私有屬性。
  • 根據這些屬性，建立它們的setter和getter方法。
  • 提供帶引數的構造器和無引數的構造器。
  • 重寫父類中的eauals()方法和hashcode()方法。（如果需要涉及到兩個物件之間的比較，這兩個功能很重要。）
  • 實現序列化並賦予其一個版本號。
  • 程式碼

class Student implements Serializable{


/**
 * 版本號
 */
private static final long serialVersionUID = 1L;


//定義的私有屬性
private int id;
private String name;
private int age;
private double score;


//無引數的構造器
public Student(){

}


//有引數的構造器
public Student(int id,String name,int age, double score){
    this.id = id;
    this.name = name;
    this.age = age;
    this.score = score;
}


//建立的setter和getter方法
public int getId() {
    return id;
}
public void setId(int id) {
    this.id = id;
}
public String getName() {
    r