java 设计模式 常用21种

1.创造型：抽象工厂

package com.seezoon.创建型.抽象工厂;/** * 抽象工厂 * @author DF *工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序， *必须对工厂类进行修改，这违背了闭包原则，所以，从设计角度考虑，有一定的问题，如何解决？ *就用到抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了， *不需要修改之前的代码 */public class AbstractFactory {public static void main(String[] args) {IFactory factory = new ProductAFactory();IProduct product = factory.produce();product.productMethod();}}interface IFactory {public IProduct produce();}class ProductAFactory implements IFactory{@Overridepublic IProduct produce() {return new ProductA();}}class ProductBFactory implements IFactory{@Overridepublic IProduct produce() {return new ProductB();}}interface IProduct {public void productMethod();}class ProductA implements IProduct {@Overridepublic void productMethod() {System.out.println("ProductA");}}class ProductB implements IProduct {@Overridepublic void productMethod() {System.out.println("ProdectB");}}

2.创造型：单例

package com.seezoon.创建型.单例;import jdk.internal.dynalink.beans.StaticClass;/** * 简单单例模式(严格的单例模式一般情况不适用可自行科普。)  * @author DF *  单例模式（Singleton）          单例对象（Singleton）是一种常用的设计模式。在Java应用中，单例对象能保证在一个JVM中，          该对象只有一个实例存在。这样的模式有几个好处：    1、某些类创建比较频繁，对于一些大型的对象，这是一笔很大的系统开销。    2、省去了new操作符，降低了系统内存的使用频率，减轻GC压力。    3、有些类如交易所的核心交易引擎，控制着交易流程，如果该类可以创建多个的话，系统完全乱了。       （比如一个军队出现了多个司令员同时指挥，肯定会乱成一团），所以只有使用单例模式，才能保证核心交易服务器独立控制整个流程。          Singleton是一种创建型模式，指某个类采用Singleton模式，则在这个类被创建后，只可能产生一个实例供外部访问，并且提供一个全局的访问点。核心知识点如下：(1) 将采用单例设计模式的类的构造方法私有化（采用private修饰）。(2) 在其内部产生该类的实例化对象，并将其封装成private static类型。(3) 定义一个静态方法返回该类的实例。     *//** * 1.单例模式的实现：饱汉式,非线程安全 * 优点是：写起来比较简单，当类SingletonTest被加载的时候，静态变量static的instance未被创建并分配内存空间， * 当getInstance方法第一次被调用时，初始化instance变量，并分配内存，因此在某些特定条件下会节约了内存；缺点是：并发环境下很可能出现多个SingletonTest实例。 * @author HP * */public class Singleton {/* 持有私有静态实例，防止被引用，此处赋值为null，目的是实现延迟加载 */      private static Singleton instance = null;      /* 私有构造方法，防止被实例化 */      private Singleton() {      }      /* 静态工程方法，创建实例 */      public static Singleton getInstance() {          if (instance == null) {              instance = new Singleton();          }          return instance;      }  }/** * 2.单例模式的实现：饿汉式,线程安全 但效率比较低  * 优点是：写起来比较简单，而且不存在多线程同步问题，避免了synchronized所造成的性能问题；缺点是：当类SingletonTest被加载的时候，会初始化static的instance，静态变量被创建并分配内存空间，从这以后，这个static的instance对象便一直占着这段内存（即便你还没有用到这个实例），当类被卸载时，静态变量被摧毁，并释放所占有的内存，因此在某些特定条件下会耗费内存。 *//**public*/ class SingletonTest {      // 定义一个私有的构造方法    private SingletonTest() {      }      // 将自身的实例对象设置为一个属性,并加上Static和final修饰符    private static final SingletonTest instance = new SingletonTest();      // 静态方法返回该类的实例    public static SingletonTest getInstancei() {          return instance;      }    }

3.创建型.：工厂方法.多个工厂方法

package com.seezoon.创建型.工厂方法.多个工厂方法;/** * 多个工厂方法模式 * 是对普通工厂方法模式的改进，在普通工厂方法模式中， * 如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象 * @author DF * */public class MutiFactoryMethod {public static void main(String[] args) {MutiFactory factory = new MutiFactory();IProduct product = factory.produceA();product.productMethod();}}class MutiFactory{public IProduct produceA(){return new ProductA();}public IProduct produceB(){return new ProductB();}}interface IProduct {public void productMethod();}class ProductA implements IProduct {@Overridepublic void productMethod() {System.out.println("ProductA");}}class ProductB implements IProduct {@Overridepublic void productMethod() {System.out.println("ProductB");}}

4.创造型：静态工厂

package com.seezoon.创建型.工厂方法.静态工厂;/** * 静态工厂方法模式 * 将多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可 * @author DF * */public class StaticiFactoryMethod {public static void main(String[] args) {IProduct product = StaticFactory.produceA();product.productMethod();}}class StaticFactory{public static IProduct produceA(){return new ProductA();}public static IProduct produceB(){return new ProductB();}}interface IProduct {public void productMethod();}class ProductA implements IProduct {@Overridepublic void productMethod() {System.out.println("ProductA");}}class ProductB implements IProduct {@Overridepublic void productMethod() {System.out.println("ProductB");}}

5.创造型：普通工厂方法

package com.seezoon.创建型.工厂方法.普通工厂模式;/** * 普通工厂方法比较常用 * @author DF * */public class NormalFactoryMethod {public static void main(String[] args) {Factory factory= new Factory();IProduct product = factory.produce("A");product.productMethod();}}class Factory{/** * 一般可以做成配置 比如xml  * @param product * @return */public IProduct produce(String product){if ("A".equals(product)) {return new ProductA();} else if ("B".equals(product)) {return new ProductB();} else {return null;}}}interface IProduct {public void productMethod();}class ProductA implements IProduct {@Overridepublic void productMethod() {System.out.println("ProductA");}}class ProductB implements IProduct {@Overridepublic void productMethod() {System.out.println("ProductB");}}

6.创造型：建造者

package com.seezoon.创建型.建造者;/** * 建造者模式 * @author DF * 工厂模式关注的是创建单个产品，而建造者模式则关注创建符合对象 */public class Builder { public static void main(String []args){        Director dir = new Director();        dir.getProduct1().showProduct();        dir.getProduct2().showProduct();    }}class Director {    private AbsBuild build = new Build();    public Product getProduct1(){        build.setProd("df",15);        return build.getProduct();    }    public Product getProduct2(){        build.setProd("df",20);        return build.getProduct();    }}abstract class AbsBuild {    public abstract void setProd(String name,int num);    public abstract Product getProduct();}class Build extends AbsBuild {    Product product = new Product();    @Override    public void setProd(String name, int num) {        //To change body of implemented methods use File | Settings | File Templates.        product.setName(name);        product.setNum(num);    }    @Override    public Product getProduct() {        return product;    }}class Product {    private String name;    private int num;    public void showProduct(){        System.out.println("name :"+name);        System.out.println("age:"+num);    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public int getNum() {        return num;    }    public void setNum(int num) {        this.num = num;    }}

7.创造型：原型

package com.seezoon.创建型.原型;import java.io.ByteArrayInputStream;import java.io.ByteArrayOutputStream;import java.io.IOException;import java.io.ObjectInputStream;import java.io.ObjectOutputStream;import java.io.Serializable;/** *  * @author DF *原型模式虽然是创建型的模式，但是与工程模式没有关系，从名字即可看出， *该模式的思想就是将一个对象作为原型，对其进行复制、克隆，产生一个和原对象类似的新对象。 *在Java中，复制对象是通过clone()实现的 */public class Prototype implements Cloneable,Serializable{/** *  */private static final long serialVersionUID = 1L;public void print(){System.out.println("hello Prototype !!!!!");}/** * 该做法为浅复制 * 浅复制：将一个对象复制后，基本数据类型的变量都会重新创建，而引用类型，指向的还是原对象所指向的。 */public Prototype clone() throws CloneNotSupportedException {          Prototype proto = (Prototype) super.clone();          return proto;      }  /** * 深复制 * 深复制：将一个对象复制后，不论是基本数据类型还有引用类型，都是重新创建的。 * 简单来说，就是深复制进行了完全彻底的复制，而浅复制不彻底 * @return * @throws IOException * @throws ClassNotFoundException */    public Prototype deepClone() throws IOException, ClassNotFoundException {            /* 写入当前对象的二进制流 */          ByteArrayOutputStream bos = new ByteArrayOutputStream();          ObjectOutputStream oos = new ObjectOutputStream(bos);          oos.writeObject(this);          /* 读出二进制流产生的新对象 */          ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());          ObjectInputStream ois = new ObjectInputStream(bis);          Prototype prototype = (Prototype) ois.readObject();          ois.close();        bis.close();        oos.close();        bos.close();        return prototype;    }      public static void main(String[] args) throws Exception {    Prototype prototype = new Prototype();    Prototype prototypeClone = prototype.clone();    Prototype prototypeDeepClone = prototype.deepClone();    prototypeClone.print();    prototypeDeepClone.print();}}

8.结构型：代理

package com.seezoon.结构型.代理;/** *  * @author DF *其实每个模式名称就表明了该模式的作用，代理模式就是多一个代理类出来， *替原对象进行一些操作，比如我们在租房子的时候回去找中介，为什么呢？ *因为你对该地区房屋的信息掌握的不够全面，希望找一个更熟悉的人去帮你做，此处的代理就是这个意思。再如我们有的时候打官司， *我们需要请律师，因为律师在法律方面有专长，可以替我们进行操作，表达我们的想法 * * *代理模式的应用场景：如果已有的方法在使用的时候需要对原有的方法进行改进，此时有两种办法：1、修改原有的方法来适应。这样违反了“对扩展开放，对修改关闭”的原则。2、就是采用一个代理类调用原有的方法，且对产生的结果进行控制。这种方法就是代理模式。使用代理模式，可以将功能划分的更加清晰，有助于后期维护！ */public class ProxySample { public static void main(String[] args) {          Sourceable source = new Proxy();          source.method();      }  }interface Sourceable {      public void method();  } class Source implements Sourceable {        @Override      public void method() {          System.out.println("the original method!");      }  }  class Proxy implements Sourceable {        private Source source;      public Proxy(){          super();          this.source = new Source();      }      @Override      public void method() {          before();          source.method();          atfer();      }      private void atfer() {          System.out.println("after proxy!");      }      private void before() {          System.out.println("before proxy!");      }  }  

9.结构型：桥接

package com.seezoon.结构型.桥接;/** *  * @author DF *桥接模式就是把事物和其具体实现分开，使他们可以各自独立的变化。 *桥接的用意是：将抽象化与实现化解耦，使得二者可以独立变化，像我们常用的JDBC桥DriverManager一样， *JDBC进行连接数据库的时候，在各个数据库之间进行切换，基本不需要动太多的代码， *甚至丝毫不用动，原因就是JDBC提供统一接口， *每个数据库提供各自的实现，用一个叫做数据库驱动的程序来桥接就行了 * * * *通过对Bridge类的调用，实现了对接口Sourceable的实现类SourceSub1和SourceSub2的调用 */public class BridgeSample {public static void main(String[] args) {                  Bridge bridge = new MyBridge();                    /*调用第一个对象*/          Sourceable source1 = new SourceSub1();          bridge.setSource(source1);          bridge.method();                    /*调用第二个对象*/          Sourceable source2 = new SourceSub2();          bridge.setSource(source2);          bridge.method();      }  }interface Sourceable {      public void method();  }  class SourceSub1 implements Sourceable {        @Override      public void method() {          System.out.println("this is the first sub!");      }  }  class SourceSub2 implements Sourceable {        @Override      public void method() {          System.out.println("this is the second sub!");      }  }  abstract class Bridge {      private Sourceable source;        public void method(){          source.method();      }            public Sourceable getSource() {          return source;      }        public void setSource(Sourceable source) {          this.source = source;      }  }  class MyBridge extends Bridge {      public void method(){          getSource().method();      }  }  

10.结构型：对象适配器

package com.seezoon.结构型.适配器.对象适配器;/** * 对象适配器 * @author DF *对象的适配器模式：当希望将一个对象转换成满足另一个新接口的对象时，可以创建一个Adapter类，持有原类的一个实例， *在Adapter类的方法中，调用实例的方法就行。 */public class ObjectAdapter {public static void main(String[] args) {Source source = new Source();Adapter adapter = new Adapter(source);adapter.method1();adapter.method2();}}class Source {public void method1() {System.out.println("this is original method!");}}interface Targetable {/* 与原类中的方法相同 */public void method1();/* 新类的方法 */public void method2();}class Adapter implements Targetable {private Source source;public Adapter(Source source) {super();this.source = source;}@Overridepublic void method2() {System.out.println("this is the targetable method!");}@Overridepublic void method1() {source.method1();}}