Java1.7已經出來很長時間了，1.8版本的推出，相比於1.7又增加了很多很多內容，現在又有1.9出來了，所以還是從0開始記錄一下自己對Java的理解吧
    Java的定義我就不提了，自己百度哦，就說自己的理解吧，首先它是經典的面向物件的程式設計語言，現在各種面嚮物件語言層出不窮，之所以Java沒有沒落的原因，我認為是它在不斷的更新自己的內容
    像Java最早誕生的時候有JavaSE，JavaME，JavaEE，但是現在還記得在塞班機上的JavaME的還有多少呢？
    最近這幾年比較火的原因是因為各種企業版本的迭代吧 ，先是SSH，然後SSM，再加上spring4的出現，然後又開始炒起了大資料，emmmmm..廢話有點多了
首先寫一下Java的四大特性吧

1.抽象（abstract）

    說到抽象的話就得提一下四個作用範圍, public, protected, private
    public 宣告的你可以在任何可以引用到的地方進行使用，protected只有其子類可以使用，private是自己玩著用，預設的話同一個package下可以使用。
    我想把抽象和介面都定義為一種概括性吧，抽象使用的是abstract，在類上面使用abstract的話，1.7版本及以下是不能有構造方法的也就是說不能構造的，1.8的時候就允許有構造方法了，舉個例子
    
    實際中的抽象常見的情況就是下面這些吧：


在1.7中我們定義一個NeedShow抽象類，建構函式是不被允許的

public abstract class NeedShow{
    /**
     * 是否執行成功
     */
    protected boolean execute_flag;

    /**
     * 獲取執行是否成功
     * @return 執行成功返回為true 執行失敗返回為false
     */
    public boolean isExecute_flag() {
        return execute_flag;
    }


    /**
     * 設定是否執行成功
     * @param execute_flag 執行成功設定為true 不成功設定為false
     */
    public void setExecute_flag(boolean execute_flag){
        this.execute_flag = execute_flag;
    }
}
 

但是在1.8中我們可以這樣寫是允許的

public abstract class NeedShow{
	/**
     * 是否執行成功
     */
    protected boolean execute_flag;


	/**
     * 獲取執行是否成功
     * @return 執行成功返回為true 執行失敗返回為false
     */
    public boolean isExecute_flag() {
        return execute_flag;
    }


	public NeedShow(boolean flag)
	{
	this.execute_flag=flag
	}
}
 

這樣寫有這樣寫的好處，但是同時其子類也必須override這個構造方法,各有利弊吧


或者你可以考慮將方法抽象了，抽象的方法在其非抽象的子類中是必須實現的，如果其子類是抽象的也可以不實現

public abstract class NeedShow{
	/**
     * 是否執行成功
     */
    protected boolean execute_flag;


	/**
     * 獲取執行是否成功
     * @return 執行成功返回為true 執行失敗返回為false
     */
    public abstract boolean isExecute_flag();


	public NeedShow(boolean flag)
	{
	 this.execute_flag=flag
	}
}

從個人理解的意義上來看介面也是一種抽象吧 1.8 以前的版本是不允許在介面中實現方法的，因此抽象和介面各種相互交織起來產生了各種設計模式不知道介面和抽象類這種具體實現會不會對相應的設計模式也有所改進吧

舉個例子在1.7的時候我們通常宣告一個介面大概是長成這樣的

public interface SendEmailMessage extends SendMessage{

     /**
      * 傳送一個資訊
      * @param str
      * @return
      * @throws Exception 因為不同的傳送介面丟擲的異常不一樣，因此使用的是Exception傳送訊息
      */
     String sendEmailMessage(String str) throws Exception;


     /**
      * 設定傳送給郵箱的資訊
      * @param theEmailMessage 被髮送的資訊
      */
     void setTheEmailMessage(String theEmailMessage);


     /**
      * 獲取傳送給郵箱的資訊
      * @return
      */
     String getTheEmailMessage();


     /**
      * 新增一個郵箱
      * @param email  被新增的郵箱
      */
     void addAnEmailReveiver(String email);
}

但是在1.8的時候呢 我們可以這樣寫：

public interface  Support<T extends NeedShow>{
 
 static int count=0;
    /**
     * 判斷一個數據的型別
     * @param columnType 需要被判斷的型別
     * @param needType 需要的型別
     * @return 如果被判斷的型別包括需要的型別返回值為true 其他情況返回為false
     */
    static boolean JudgeType(String columnType,String needType)
    {
        boolean flag=false;
        needType=needType.toUpperCase();
        if(columnType.contains(needType))
        {
            flag=true;
        }
        return flag;
    }


    default boolean Judge()
    {
      return false;
    }
}

介面直接寫方法，之後的子類沒有實現這個方法的必要了，相對會簡潔一些吧？
當然抽象類本身就可以寫實際實現的方法，何必再使用default來進行宣告呢？


抽象類已經越來越沒有地位了............

2.繼承

   繼承是一種對類功能的加強，如果需要對物件加強的話用介面卡模式哦。
   我認為在Java種，繼承的方式有好多種比如說一個介面繼承另一個介面，一個類繼承另一個類，而一個實體類去實現一個介面，可能說也是一種繼承的體現吧。
   繼承使用的關鍵字是extends 這個關係可以使用在類對類或者介面對介面上
   就像上文中的

public interface SendEmailMessage extends SendMessage{

     /**
      * 傳送一個資訊
      * @param str
      * @return
      * @throws Exception 因為不同的傳送介面丟擲的異常不一樣，因此使用的是Exception傳送訊息
      */
     String sendEmailMessage(String str) throws Exception;


     /**
      * 設定傳送給郵箱的資訊
      * @param theEmailMessage 被髮送的資訊
      */
     void setTheEmailMessage(String theEmailMessage);


     /**
      * 獲取傳送給郵箱的資訊
      * @return
      */
     String getTheEmailMessage();


     /**
      * 新增一個郵箱
      * @param email  被新增的郵箱
      */
     void addAnEmailReveiver(String email);
}

   SendMessage就是一個介面，這樣寫的話一個類實現SendEmailMessage的時候是不是也需要同時實現SendMessage中的方法，就不用在implements後面跟兩個介面了呢?
   上文中寫到的NeedShow就是一個抽象的類，如果需要繼承的話可以這樣寫
   

public  class Information extends NeedShow implements Cloneable,Serializable{
    /*... 省略具體程式碼了  實際上 Cloneable,Serializable這兩個介面中沒有方法的  是兩個標記性質的介面....*/

    /**
     * 獲取執行是否成功
     * @return 執行成功返回為true 執行失敗返回為false
     */
    public boolean isExecute_flag() {
        return execute_flag;
    }
   }

   偷個小懶......上面的程式碼中既有對抽象類的繼承，也有對介面的實現......

3.封裝

   如果說抽象，繼承提供了一種概念性的東西，而封裝的話提供了一種結合吧，外面的使用者只需要知道它提供了什麼，而不需要管它怎麼實現的，
   在使用的時候就可以很方便的將各個模組分工，而且也不需要客戶知道細節，雖然有一種東西叫做反編譯不上程式碼了啊，.......哈哈

4.多型

   這個東西嗎...
   這個東西在程式碼上就是對於繼承或者使用封裝的體現吧。


   在引用上是父類的引用但是實際上的實現是其子類的實現方式


   具體舉個例子吧

  class DML{
    public void update()
    {
        System.out.println("DML UPdate");
    }
}

class Insert extends DML{
    public void update()
    {
        System.out.println("Insert Update");
    }
}

class Update extends DML{
    public void update()
    {
        System.out.println("Update Update");
    }
}

class Delete extends DML{
    public void update()
    {
        System.out.println("delete update");
    }
}

class Main{
    public static void main(String args[])
    {
        DML insertdml=new Insert();
        DML updatedml=new Update();
        DML deletedml=new Delete();
        insertdml.update();
        updatedml.update();
        deletedml.update();
    }
}

這個例子中所有的update方法都重寫了父類的update方法
執行結果如下：
Insert Update
Update Update
delete update




還有一個很類似的東西叫做過載 就是相同的方法名稱，不同的引數長度或是引數型別

修改DML類如下:

修改Main類如下:

class Main{
    public static void main(String args[])
    {
        DML insertdml=new Insert();
        DML updatedml=new Update();
        DML deletedml=new Delete();
        insertdml.update();
        insertdml.update(1);
        insertdml.update(1.1);
        updatedml.update();
        updatedml.update(2);
        updatedml.update(2.1);
        deletedml.update();
        deletedml.update(3);
        deletedml.update(3.1);
    }
}

執行結果如下:
Insert Update
DML update int:1
DML update double:1.1
Update Update
DML update int:2
DML update double:2.1
delete update
DML update int:3
DML update double:3.1

----------------------------------
emm....大概就想到這麼多了 就先寫到這裡了