注意事項：

同一個包中不能有一樣的類名的類，不然編譯會出現錯誤。

（二）單例類（Singleton）

1、把構造器用private隱藏。

2、用static建立一個自定義只允許建立一個物件例項的靜態方法（這樣即使還沒建立物件，就可以由類呼叫進行檢查是否已經存在例項了並進行判斷）。

例如：

public class Singleton {
    private static Singleton instance;//使用類變數來快取曾經建立的例項；
    //對構造器用private進行修飾；
private Singleton(){}
    //提供一個靜態方法，用於返回Singleton例項，所以它的返回物件型別就是Singleton；
 
    //該方法加入自定義控制，保證只產生一個物件；
public static Singleton getInstabce(){
        if(instance==null) {
            instance = new Singleton();
}
        return instance;
}
    public static void main(String[] args) {
        //建立物件不同構造器；
        //只通過自定義方法建立物件例項；
        /*Singleton s1=new Singleton();
        Singleton s2=new Singleton();
 
        System.out.println("s1==s2:"+(s1==s2));*/   //這樣創建出來輸出false;
        //getInstance()被定義為靜態方法，在程式載入位元組碼時不用建立例項，可以由類呼叫
Singleton s1= Singleton.getInstabce();
Singleton s2=Singleton.getInstabce();
System.out.println("s1==s2:"+(s1==s2));//輸出true;

(三)匿名內部類及Lambda表示式

1、匿名內部類（實現介面/繼承父類）：

看似直接定義一個介面的物件（實際介面是沒有例項物件的），實際可以認為是在定義另一個實現該介面（父類）的一個類的例項，並對介面中的抽象方法等進行實現。

（1）不能是抽象類（裡面的方法等必須是已實現的）

（2）不能定義構造器，因為沒有匿名內部類的類名。

（3）可以定義初始化塊。可以在初始化塊完成構造器裡面需要完成的任務。

2、Lambda表示式（參考：http://www.cnblogs.com/CarpenterLee/p/6507161.html）：

Lambda表示式中形參列表是對應的介面中抽象方法的形參。

其中一個main函式中可以存在對應多個函式介面的Lambda表示式：

//存在一個或者多個函式介面時的在main()函式的Lambda表示式示例
interface Converter{
    Integer converter(String from);
}
////////////////////////////////
interface Mytest1{
    String test(String a,int b,int c);
}
public class Myinterface {
    public static void main(String []args){

        //Converter converter1=(from)->Integer.valueOf(from);
        //Converter converter1=Integer::valueOf;
        //Converter converter1=from->"you".indexOf(from);
Converter converter1="you"::indexOf;
Integer val=converter1.converter("u");
System.out.println(val);
///////////////////////////////////

      //對應的引數可以要麼全部加上引數型別，要麼全部不加；

        Mytest mt=(String a,int b,int c)->a.substring(b,c);

其中匿名內部類及Lambda表示式的區別：

1、匿名內部類可為任意介面建立例項——不管介面含有多少個抽象方法。

Lambda表示式只能為函式式介面建立例項（裡面只含有唯一一個抽象方法，但是可以有多個預設方法）.

2、匿名內部類可以為普通類、抽象類建立例項，但是，Lambda·表示式只能為函式式介面建立。

3、匿名內部類實現的抽象方法允許呼叫介面中定義的預設方法，但是Lambda表示式不允許這樣呼叫。

二、許可權與修飾符(public、protect、private、final)

1、一般被定義為私有的屬性（private）需要設定其setter()，getter()方法，方便封裝之後被使用。

2、"構造器沒有返回值為什麼不可以用void宣告?"  

答：實際類的構造器是有返回值的，當使用new關鍵字呼叫構造器時，構造器返回該類的例項，可把該例項當做返回值。必須注意，不要在構造器中顯示使用return來返回當前類的物件，因為構造器的返回值是隱式的。

3、final修飾的成員變數必須由程式設計師顯式的指定初始值（系統不會對final成員進行隱式初始化），當該變數被賦予初始值時，就不能再被重新賦值。普通方法不能為final修飾的變數賦值。

（1）final修飾基本型別變數

①final修飾類變數（final static ）:該類變數可以在宣告的時候指定【類初始化時分配預設值（不推薦，最好顯示初始化）】，靜態語句塊中初始化（不能在普通初始化塊初始化，因為類變數在類初始階段就已經被初始化了，之後普通初始化塊就不能再對其賦值）。只在這二者之一初始化。

②final修飾的成員變數（例項變數）：可以在定義時初始化，普通（必須為非靜態）初始化塊初始化（例項變數不能在靜態初始化塊制定初始值，因為靜態初始化塊是靜態成員，不可訪問例項變數），構造器中初始化，只在這三者之一。普通方法不能為final修飾的成員變數賦值。

例如：

public class FinalVariableTest {
    //定義成員變數指定預設值，合法；
final int a=6;
    final String str;//可在構造器、普通初始化塊初始化；
final int c;//可在構造器、普通初始化塊初始化；
final static double d;//靜態初始化塊；
    // final char ch; 若哪兒都沒有初始化是不合法的；
    //普通初始化塊
{
        str="Hello";
//不能重新為a賦值；
        //a=9;
}
//靜態初始化塊
static {
    d=5.6;//為類變數初始賦值；
}
public  FinalVariableTest(){
    c=5;
}
public void changeFinal(){
    //普通方法不能為final修飾的變數賦值；
    //d=2;
    //ch='a';
}
public static void main(String[] args){
    FinalVariableTest ft=new FinalVariableTest();
System.out.println(ft.a);
System.out.println(ft.c);
System.out.println(ft.d);
}
}//輸出為 6 5 5.6

（2）final修飾引用型別變數：只保證引用型別變數所引用的地址不改變，即一直引用同一個物件，但這個物件內部內容可以改變。

三、繼承

1、

四、資料型別

1、Java中有5種成員：初始化塊，成員變數，方法，構造器，內部類（包括介面、列舉）。其中，建立Java物件時，系統總是隱式先呼叫該類的定義的初始化塊，根據初始化塊所在位置從上到下執行，在構造器之前執行。因為它沒有名字，表示，所以無法通過類、物件來呼叫初始化塊，初始化塊只能用static修飾。

2、基本型別與引用型別的區別：

（1）基本型別：它的值就是一個數字，一個字元或一個布林值。

（2）引用型別：是一個物件型別，值是什麼呢？它的值是指向記憶體空間的引用，就是地址，所指向的記憶體中儲存著變數所表示的一個值或一組值。除了在函式傳值的時候是"引用傳遞"，在任何用"＝"向物件變數賦值的時候都是"引用傳遞"。

例如：

int  a；  
 a=250； //宣告變數a的同時，系統給a分配了空間。

引用型別就不是了，只給變數分配了引用空間，資料空間沒有分配，因為誰都不知道資料是什麼，整數，字元？我們看一個錯誤的例子：

MyDate today；

today.day = 4； //發生錯誤，因為today物件的資料空間未分配。

那我們怎麼給它賦值？引用型別變數在聲明後必須通過例項化開闢資料空間，才能對變數所指向的物件進行訪問。舉個例子：

MyDate today；            //將變數分配一個儲存引用的空間

today = new MyDate（）；     //這句話是2步，首先執行new MyDate（），給today變數開闢資料空間，然後再執行賦值操作

//引用變數賦值

MyDate a，b；                    //在記憶體開闢兩個引用空間

a  =  new MyDate（）；     //開闢MyDate物件的資料空間，並把該空間的首地址賦給a

b  =  a；                               //將a儲存空間中的地址寫到b的儲存空間中

如下圖示

3、包裝類

基本型別：byte、short、int、long、char、float、double、boolean

包裝類：Byte、Short、Integer、Long、Character、Float、Double、Boolean

注意：雖然包裝型別的變數是引用資料型別，但包裝類的例項可以與數值型別進行比較，直接去除包裝示例所包裝的數值進行比較，例如：

Integer a=new Integer(6);
//輸出true ;
System.out.println("6的包裝類例項是否大於5.0"+（a>5.0）);

但是和下例相對比：

原因：這與Java的Integer的設計有關，系統把一個-128~127之間的整數自動裝箱成Integer例項，並放入一個名為cache的陣列中快取起來。所以只要是例項-128~127之間的整數就會在同一個空間中，地址相等，超出範圍就重新建立shil

//輸出true
Integer a=2;//通過自動裝箱，允許把基本型別賦值給包裝類例項；
Integer c=2;
System.out.println("比較2個包裝類例項是否相等"+(a==c));
//輸出false
Integer d=128;
Integer e=128;
System.out.println("比較2個包裝類例項是否相等"+(d==e));

但是，因為包裝類的例項實際上是引用型別，只有兩個包裝類引用同一個物件時才會返回ture。例如：

//輸出false
System.out.println("比較2個包裝類例項是否相等"+(new Integer(2)==new Integer(2)));

同下例，因為利用了關鍵字new建立了不同的記憶體空間：

//輸出false
Integer a=new Integer (2);
Integer c=new Integer (2);
System.out.println("比較2個包裝類例項是否相等"+(a==c));

①

Example:

String s1 = "abc";

String s2 = "abc";

System.out.print(s1==s2);

執行結果是：true

因為，String s = "abc"這種形式可以看做我們聲明瞭一個值為”abc”的字串物件引用變數,由於String類是final的，所以事實上，可以看做是聲明瞭一個字串引用常量, 存放在常量池中（棧中）。如果是使用關鍵字new這種形式宣告出的，則是在程式執行期被動態建立，存放在堆中。

String s = “abc”的工作過程可以分為以下幾個步驟：

 (1)定義了一個名為"s"的String型別的引用。

 (2)檢查在常量池中是否存在值為"abc"的字串物件；

 (3)如果不存在，則在常量池（字串池）建立儲存進一個值為"abc"的字串物件。如果已經存在，則跳過這一步工作。

 (4)將物件引用s指向字串池當中的”abc“物件。

String s = new String(”abc“)的步驟則為：

 (1)定義了一個名為"s"的String型別的引用。

 (2)檢查在常量池中是否存在值為"abc"的字串物件；

 (3)如果不存在，則在常量池（字串池）儲存進一個值為"abc"的字串物件。如果已經存在，則跳過這一步工作。

 (4)在堆中建立儲存一個”abc“字串物件。

 (5)將物件引用指向堆中的物件。

這也就是為什麼有道面試題：String s = new String(“xyz”);產生幾個物件？的答案是：一個或兩個的原因。因為如果常量池中原來沒有”xyz”,就是兩個。

②

如果需要把基本型別變數→字串

（1）可將基本型別變數與“”進行連線。例如：

//intstr的值為"5";
String intstr=5+""

（2）利用valueOf()方法把基本型別轉換成字串，例如：

//把float變數轉換成String變數；
String ftstr =String.valueOf(2.34764);
System.out.println(ftstr);

eg: parseInt()，parseFloat().....

5、很多語言都不允許通過獨享訪問類變數，物件只能訪問例項變數，類變數必須通過類來訪問。（其實主要是例項變數和類變數兩大類）

（1）類變數：

①也叫靜態變數，在類中以static關鍵字宣告，但必須在方法構造方法和語句塊之外。

②靜態變數除了被宣告為常量外很少使用。常量是指宣告為public/private，final和static型別的變數，很少單獨使用static宣告變數。

③預設值和例項變數相似。數值型變數預設值是0，布林型預設值是false，引用型別預設值是null。

④可通過例項物件訪問，也可通過類來訪問，即使某個例項是null，null也可以訪問它所屬的類成員.

（2）例項變量：

①“例項變數”，在實體類或資料類中被稱為“屬性”或“欄位”，宣告在一個類中，但在方法、構造方法和語句塊之外。例項變數在物件建立的時候建立，在物件被銷燬的時候銷燬。

②例項變數的值應該至少被一個方法、構造方法或者語句塊引用，使得外部能夠通過這些方式獲取例項變數資訊。

③例項變數對於類中的方法、構造方法或者語句塊是可見的。一般情況下應該把例項變數設為私有。通過使用訪問修飾符可以使例項變數對子類可見。

④例項變數具有預設值。數值型變數的預設值是0，布林型變數的預設值是false，引用型別變數的預設值是null。變數的值可以在宣告時指定，也可以在構造方法中指定。

（3）成員變數：

①類中的屬性，獨立於方法之外，與例項變數重疊，有些類變數也是成員變數。

（4）區域性變數：

①類的方法、構造器中的變數，是被區域性使用的。

例1：

public class Variable{

    static int allClicks=0;//類變數
String str="hello world";//例項變數、成員變數
public void method(){

        int i =0;//區域性變數
int a;//區域性變數
}

}

public class StaticTest {

    private static int staticInt = 2;
    private int random = 2;
    public StaticTest() {
        staticInt++;
random++;
System.out.println("staticInt = "+staticInt+"  random = "+random);
}

    public static void main(String[] args) {
        StaticTest test = new StaticTest();
StaticTest test2 = new StaticTest();
}
}

//執行結果：
//staticInt = 3  random = 3
//staticInt = 4  random = 3//每次建立物件重新呼叫全新的構造器，重新加1

public class Temp {
    static int t; //類變數  
public static void main（String args［］）{
        System.out.println（t）; //列印類變數  
int t = 1; //區域性變數  
System.out.println（t）; //列印區域性變數  
Temp a = new Temp（）; //建立例項  
System.out.println（a.t）; //通過例項訪問例項變數  
}
}      //結果為:0 1 0

四、集合

1、Stream

參考連結：

http://www.cnblogs.com/CarpenterLee/p/6545321.html

http://www.cnblogs.com/CarpenterLee/p/6550212.html

五、IO

1、問題：這個物件不是檔案嗎？為什麼還要呼叫其他方法再次建立檔案。

答:File類例項化，比如 File f=new File("E:/file_ceshi/02.rmvb");只是指向了這個02.rmvb檔案，如果不建立02.rmvb，此檔案是不存在的。因為程式碼只是宣告不是執行，否則會出錯。