JAVA常用设计模式

很多人在学习设计模式，感觉定义很抽象，包括我，这也难怪JAVA本来就是一种抽象的思想，所以写了这篇博客，加入我自己的理解，难免会有一些不合理的地方，希望大家批评指正。
首先说说设计模式是什么吧。简单的来说，设计模式是一个经验的总结，与具体的语言无关，相当于一个模型，可以被不同的语言反复使用，本文以JAVA语言为基础。

一、要明白具体的设计模式，我们就需要知道设计模式做了什么，具体原则是什么

 1. 单一职责：简单的说，就是每个类需要做的事情尽量少，最好是一件
 2. 开闭原则：把经常变得东西抽象成一个模板，变化的部分只提供一个方法，具体的细节由子类实现，即别人想添加功能，只需要添加一个子类，而无需修改源码的实现。
 3. 里氏替换：这个我们应该很熟悉，就是一种继承的理念，即继承父类的子类们中，应该具有一些共同的行为特征和属性，比如不能定义一个Person类，让Pig继承。
 4. 依赖注入原则：也是一种分离思想，即子类对象依赖于抽象类，而不是依赖具体实现类
 5. 接口分离原则：一个接口的功能要满足单一原则，因为接口的实现，必须重写接口的方法，所以接口的抽象方法不宜过多。
 6. 迪米特原则：对象与对象之间的关系要少，比如一个对象尽量不要去调用另一个对象的方法。
 7. 总结，虽然是用自己的话在表述，但自己也不知道自己在写什么。

二、接下来，我想介绍一些常用的设计模式

█ 简单工厂设计模式：类的创建由工厂类去实现，比如我需要实现一个水果工厂，别人需要什么水果，我就提供什么

第一步：创建工厂类

public class FruitFactory {

    public static Fruit createFruit(String fruitType)
    {
        if("apple".equals(fruitType)){
            return new Apple();
        }else if("banana".equals(fruitType))
        {
            return new Banana();
        }else{
            return null;
        }
    }
}

第二步：水果接口

public abstract class Fruit {
    public abstract void taste();
}

第三步：创建需要添加的具体水果
 1. 造苹果

public class Apple extends Fruit {

    @Override
    public void taste() {
        // TODO Auto-generated method stub
      System.out.println("苹果味道有点酸!");
    }
}

2. 造香蕉

public class Banana extends Fruit {

    @Override
    public void taste() {
        // TODO Auto-generated method stub
      System.out.println("香蕉味道很甜!");
    }
}

第四步：具体实现造水果

public class FruitDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Fruit fruit = FruitFactory.createFruit("apple");//要苹果？造一个!
        fruit.taste();
        a = AnimalFactory.createAnimal("banana");//要香蕉？造一个!
        fruit.taste();
    }
}

 第五步：总结

从上面的代码，得知，水果工厂内只有apple和banana，但如果客户需要橘子，怎么办？这还不简单？so easy。

public class FruitFactory {

    public static Fruit createFruit(String fruitType)
    {
        if("apple".equals(fruitType)){
            return new Apple();
        }else if("banana".equals(fruitType))
        {
            return new Banana();
        }else if("orange".equals(fruitType))
        {
            return new Orange();
        else{
            return null;
        }
    }
}

 但还需要橙子，梨子，桃子呢？所以缺点总结如下
       1. 有新的需求，工厂类就必须不断修改，麻烦！所以出现了工厂类。下面介绍工厂类。

█ 工厂模式：在简单工厂类的基础上，添加了小工厂，就好像有一个水果工厂，还添加一个子工厂，专门造苹果，另一个子工厂专门造香蕉，这样，新的需求只需添加一个需求类实现水果工厂接口即可，废话不多说，看代码。

  第一步：创建大工厂类接口

public interface Factory {
    public abstract Fruit createFruit();
}

第二步：创建水果类

public abstract class Fruit {
    public abstract void taste();
}

第三步：创建具体水果的小工厂类，实现大工厂接口
 1. 苹果工厂

public class AppleFactory implements Factory {

    @Override
    public Fruit createFruit() {
        // TODO Auto-generated method stub
        return new Apple();
    }
}

2. 香蕉工厂

public class BananaFactory implements Factory {

    @Override
    public Fruit createFruit() {
        // TODO Auto-generated method stub
        return new Banana();
    }
}

第四步：造水果,继承水果类


 1. 造苹果

public class Apple extends Fruit {
    @Override
    public void taste() {
        // TODO Auto-generated method stub
        System.out.println("苹果味道有点酸!");
    }

}

1. 造香蕉

public class Banana extends Fruit {

    @Override
    public void taste() {
        // TODO Auto-generated method stub
      System.out.println("香蕉味道很甜!");
    }
}

第五步：测试类

public class FruitDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //苹果
         Factory factory = new AppleFactory();
         Fruit fruit = factory.creatFruit();
         System.out.println(fruit.taste);

         //香蕉
         factory = new BananaFactory();
         Fruit fruit = factory.creatFruit();
         System.out.println(fruit.taste);
    }
}

第六步：总结   

优点：每增加一个需求，只需增加一个具体类，和具体类的工厂类，而无需改动原有的代码。
缺点：工作量较大，看着都累。

█ 单例设计模式：简单的来说，就是不允许外部创建对象，而是直接使用，那么如何实现不让外界创建对象，而且还可以使用对象呢？
- 将被使用类的构造方法私有化，即private修饰
- 在类的成员位置创建对象
- 创建公有方法getObject，让外界能够使用

• 单例设计模式——-饿汉式：就是立即创建对象

public class Fruit {

     private Fruit()
     {
     //构造方法使用private修饰
     }
     //创建Fruit对象
     static Fruit fruit = new Fruit();
     //通过公有属性方法返回对象给外界
     public static Fruit getFruit()
     {
         return fruit;
     }
}

测试

public class FruitDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Fruit.fruit = null;
        Fruit fruit = Fruit.getFruit();
    }
}

• 单例设计模式——-懒汉式：不立即创建对象，而是延后到被调用时

public class Fruit {

     private Fruit()
     {
     //构造方法使用private修饰
     }
     //创建Fruit对象
     static Fruit fruit = null;
     //通过公有属性方法返回对象给外界
     public static Fruit getFruit()
     {
         if(fruit == null)
         {
         fruit = new Fruit();
         }
         return fruit;
     }
}

测试

public class FruitDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Fruit.fruit = null;
        Fruit fruit = Fruit.getFruit();
    }
}

• 单例设计模式——总结
  在实际应用中会选择饿汉式，因为懒汉式存在安全隐患，在多线程时，多个线程同时获取该对象时，会出现对象具体的创建混乱。解决办法如下：同步方法。

public class Fruit {

     private Fruit()
     {
     //构造方法使用private修饰
     }
     //创建Fruit对象
     static Fruit fruit = null;
     //通过公有属性方法返回对象给外界，注意添加synchronized，实现线程的同步
     public synchronized static Fruit getFruit()
     {
         if(fruit == null)
         {
         fruit = new Fruit();
         }
         return fruit;
     }
}

█ 模版设计模式：定义一个算法的骨架，这个骨架就是一个模版，具体的算法实现推迟到子类中，比如我们计算算法运行的效率，我们就可以把计算效率提取成一个模版，而具体的算法我们可以到子类中实现，而无需改动模版。

 第一步：定义一个模版 

public abstract class Pattern {
    public long getTime(){
        long startTime = System.currentTimeMillis();
        methodPattern();//只需实现这个抽象方法来实现具体的算法即可
        long endTime = System.currentTimeMillis();      
        return endTime-startTime;
    }
    public abstract void methodPattern();
}

第二步：实现具体的算法,这里选择快速排序，其他的就不一一举例

public class ForTest extends Pattern {

    //排序
        public static void Sort(int[] arr,int low,int high)
        {
            if(low < high)
            {
                int position = getPositionSort(arr,low,high);
                Sort(arr,low,position-1);
                Sort(arr,position+1,high);
            }
        }
        private static int getPositionSort(int[] arr, int low, int high) {
            // TODO Auto-generated method stub
            int temp = arr[low];
            while(low < high)
            {
                while(low < high && arr[high]>temp)
                    high--;
                arr[low] = arr[high];
                while(low < high && arr[low] < temp)
                    low++;
                arr[high] = arr[low];
            }
            arr[low] = temp;
            return low;
        }
        //主要是这个构造方法的重写
    @Override
    public void methodPattern() {
        // TODO Auto-generated method stub
        int arr[] = {12,3,2,30,10};

        Sort(arr,0,arr.length-1);
        for(int s_arr:arr)
        {
            System.out.print(s_arr+" ");
        }
    }
}