（1）Java的四大特性

    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....大概就想到这么多了 就先写到这里了