基础几个设计模式

Java中设计模式总结

第一种：工厂方法模式(工厂模式)

01：普通工厂模式

概念：就是建立一个工厂类，对实现了同一接口的一些类进行实例的创建

1.建立共通接口

public interface Sends {

      public String send();

}

2.创建实现类

public class EmailSend implements Sends{

      @Override

      public String send() {

         return "emailSend执行..........";

      }

}

第二个实现类：

public class SmsSend implements Sends{

      @Override

      public String send() {

         return "sms Send执行..........";

      }

}

3.创建工厂类

public class SendFactory {

   public Sends sendsMethed(String type){

      if("email".equals(type)){

        return new EmailSend();

      }else if("sms".equals(type)){

        return new SmsSend();

      }else{

        return null;

      }

   }

}

4.创建测试类

public class Test {

   public static void main(String[] args) {

      SendFactoryfactory=new SendFactory();

      Sendssend=factory.sendsMethed("email");

      System.out.println(send.send());

   }

}

缺点：如果传递字符串错误，将不能正确创建对象。

02：多个工厂方法模式

概念：是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象

 

1.其他不变，修改工厂类如下：

public class SendFactory {

   public Sends emailMethod(){

      return new EmailSend();

   }

   public Sends smsMethod(){

      return new SmsSend();

   }

}

2.修改测试类

public class Test {

   public static void main(String[] args) {

      SendFactoryfactory=new SendFactory();

      Sendssend=factory.emailMethod();

      System.out.println(send.send());

   }

}

缺点：需要创建工厂类实例

03：静态工厂方法模式

概念：将上面的多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可。

1.修改工厂类：

public class SendFactory {

   public static Sends emailMethod(){

      return new EmailSend();

   }

   public static Sends smsMethod(){

      returnnew SmsSend();

   }

}

2.修改测试类：

public class Test {

   public static void main(String[] args) {

      Sendssend=SendFactory.emailMethod();

      System.out.println(send.send());

   }

}

第二种：抽象工厂模式

概念：创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。

1.建立共通接口

public interface Sends {

      public String send();

}

2.创建实现类

public class EmailSend implements Sends{

      @Override

      public String send() {

         return "emailSend执行..........";

      }

}

第二个实现类：

public class SmsSend implements Sends{

      @Override

      public String send() {

         return "sms Send执行..........";

      }

}

3.创建接口

public interface Provider {

   public Sends produce();

}

4.创建多个工厂类，并且实现接口

public class EmailFactory implements Provider{

   @Override

   public Sends produce() {

      return new EmailSend();

   }

}

第二个工厂类

public class SmsFactory implements Provider{

   @Override

   public Sends produce() {

      return new SmsSend();

   }

}

5.测试类

public class Test {

   public static void main(String[] args) {

      Providerprovider= new EmailFactory();

      Sendssend=provider.produce();

      System.out.println(send.send());

   }

}

优点：新添功能，直接添加新的实现类，实现Sends接口，然后创建一个工厂类实现Provider接口就ok了，无需改动现有代码。扩展性较好。

第三种：单例模式

概念：是一种常用的设计模式。在Java应用中，单例对象能保证在一个JVM中，该对象只有一个实例存在

1、某些类创建比较频繁，对于一些大型的对象，这是一笔很大的系统开销。

2、省去了new操作符，降低了系统内存的使用频率，减轻GC压力。

3、有些类如交易所的核心交易引擎，控制着交易流程，如果该类可以创建多个的话，系统完全乱了。（比如一个军队出现了多个司令员同时指挥，肯定会乱成一团），所以只有使用单例模式，才能保证核心交易服务器独立控制整个流程。

第四种：建造者模式

概念：将各种产品集中起来进行管理，用来创建复合对象，所谓复合对象就是指某个类具有不同的属性，其实建造者模式就是前面抽象工厂模式和最后的Test结合起来得到的。

1、2步同上一样。

3.创建工厂

public class Builder {

   private static List<Sends> list=new ArrayList<Sends>();

   public void emailMethod(int count){

      for (int i = 0; i < count; i++) {

        list.add(new EmailSend());

      }

   }

   public void smsMethod(int count){

      for (int i = 0; i < count; i++) {

        list.add(new SmsSend());

      }

   }

   public static List<Sends> getList() {

      return list;

   }

   public static void setList(List<Sends> list) {

      Builder.list = list;

   }

}

4.创建测试类

public class Test {

   public static void main(String[] args) {

      Builderbuilder=new Builder();

      builder.emailMethod(5);

      Listlist=Builder.getList();

      System.out.println(list.size()+":zzz");

   }

}