java 设计模式 常用21种

                                  java 设计模式 常用21种

1.创造型：抽象工厂

[java]  view plain  copy

1. package com.seezoon.创建型.抽象工厂;  
2.   
3. /** 
4.  * 抽象工厂 
5.  * @author DF 
6.  *工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序， 
7.  *必须对工厂类进行修改，这违背了闭包原则，所以，从设计角度考虑，有一定的问题，如何解决？ 
8.  *就用到抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了， 
9.  *不需要修改之前的代码 
10.  */  
11. public class AbstractFactory {  
12.     public static void main(String[] args) {  
13.         IFactory factory = new ProductAFactory();  
14.         IProduct product = factory.produce();  
15.         product.productMethod();  
16.     }  
17. }  
18. interface IFactory {  
19.     public IProduct produce();  
20. }  
21. class ProductAFactory implements IFactory{  
22.     @Override  
23.     public IProduct produce() {  
24.         return new ProductA();  
25.     }  
26. }  
27. class ProductBFactory implements IFactory{  
28.     @Override  
29.     public IProduct produce() {  
30.         return new ProductB();  
31.     }  
32. }  
33. interface IProduct {  
34.     public void productMethod();  
35. }  
36.   
37. class ProductA implements IProduct {  
38.     @Override  
39.     public void productMethod() {  
40.         System.out.println("ProductA");  
41.     }  
42. }  
43.   
44. class ProductB implements IProduct {  
45.   
46.     @Override  
47.     public void productMethod() {  
48.         System.out.println("ProdectB");  
49.     }  
50. }  

2.创造型：单例

[java]  view plain  copy

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

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

[java]  view plain  copy

1. package com.seezoon.创建型.工厂方法.多个工厂方法;  
2.   
3.   
4. /** 
5.  * 多个工厂方法模式 
6.  * 是对普通工厂方法模式的改进，在普通工厂方法模式中， 
7.  * 如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象 
8.  * @author DF 
9.  * 
10.  */  
11. public class MutiFactoryMethod {  
12.     public static void main(String[] args) {  
13.         MutiFactory factory = new MutiFactory();  
14.         IProduct product = factory.produceA();  
15.         product.productMethod();  
16.     }  
17. }  
18. class MutiFactory{  
19.     public IProduct produceA(){  
20.         return new ProductA();  
21.     }  
22.     public IProduct produceB(){  
23.         return new ProductB();  
24.     }  
25. }  
26.   
27. interface IProduct {  
28.     public void productMethod();  
29. }  
30.   
31. class ProductA implements IProduct {  
32.     @Override  
33.     public void productMethod() {  
34.         System.out.println("ProductA");  
35.     }  
36. }  
37.   
38. class ProductB implements IProduct {  
39.     @Override  
40.     public void productMethod() {  
41.         System.out.println("ProductB");  
42.     }  
43. }  

4.创造型：静态工厂

[java]  view plain  copy

1. package com.seezoon.创建型.工厂方法.静态工厂;  
2.   
3.   
4. /** 
5.  * 静态工厂方法模式 
6.  * 将多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可 
7.  * @author DF 
8.  * 
9.  */  
10. public class StaticiFactoryMethod {  
11.     public static void main(String[] args) {  
12.         IProduct product = StaticFactory.produceA();  
13.         product.productMethod();  
14.     }  
15. }  
16. class StaticFactory{  
17.     public static IProduct produceA(){  
18.         return new ProductA();  
19.     }  
20.     public static IProduct produceB(){  
21.         return new ProductB();  
22.     }  
23. }  
24. interface IProduct {  
25.     public void productMethod();  
26. }  
27.   
28. class ProductA implements IProduct {  
29.     @Override  
30.     public void productMethod() {  
31.         System.out.println("ProductA");  
32.     }  
33. }  
34.   
35. class ProductB implements IProduct {  
36.     @Override  
37.     public void productMethod() {  
38.         System.out.println("ProductB");  
39.     }  
40. }  

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

[java]  view plain  copy

1. package com.seezoon.创建型.工厂方法.普通工厂模式;  
2.   
3. /** 
4.  * 普通工厂方法比较常用 
5.  * @author DF 
6.  * 
7.  */  
8. public class NormalFactoryMethod {  
9.   
10.       
11.     public static void main(String[] args) {  
12.         Factory factory= new Factory();  
13.         IProduct product = factory.produce("A");  
14.         product.productMethod();  
15.     }  
16. }  
17. class Factory{  
18.     /** 
19.      * 一般可以做成配置 比如xml  
20.      * @param product 
21.      * @return 
22.      */  
23.     public IProduct produce(String product){  
24.         if ("A".equals(product)) {  
25.             return new ProductA();  
26.         } else if ("B".equals(product)) {  
27.             return new ProductB();  
28.         } else {  
29.             return null;  
30.         }  
31.     }  
32. }  
33. interface IProduct {  
34.     public void productMethod();  
35. }  
36.   
37. class ProductA implements IProduct {  
38.     @Override  
39.     public void productMethod() {  
40.         System.out.println("ProductA");  
41.     }  
42. }  
43.   
44. class ProductB implements IProduct {  
45.     @Override  
46.     public void productMethod() {  
47.         System.out.println("ProductB");  
48.     }  
49. }  

6.创造型：建造者

[java]  view plain  copy

1. package com.seezoon.创建型.建造者;  
2.   
3.   
4. /** 
5.  * 建造者模式 
6.  * @author DF 
7.  * 工厂模式关注的是创建单个产品，而建造者模式则关注创建符合对象 
8.  */  
9. public class Builder {  
10.      public static void main(String []args){  
11.             Director dir = new Director();  
12.             dir.getProduct1().showProduct();  
13.             dir.getProduct2().showProduct();  
14.         }  
15. }  
16. class Director {  
17.     private AbsBuild build = new Build();  
18.     public Product getProduct1(){  
19.         build.setProd("df",15);  
20.         return build.getProduct();  
21.     }  
22.     public Product getProduct2(){  
23.         build.setProd("df",20);  
24.         return build.getProduct();  
25.     }  
26. }  
27.   
28.   
29. abstract class AbsBuild {  
30.     public abstract void setProd(String name,int num);  
31.     public abstract Product getProduct();  
32. }  
33. class Build extends AbsBuild {  
34.     Product product = new Product();  
35.     @Override  
36.     public void setProd(String name, int num) {  
37.         //To change body of implemented methods use File | Settings | File Templates.  
38.         product.setName(name);  
39.         product.setNum(num);  
40.     }  
41.   
42.     @Override  
43.     public Product getProduct() {  
44.         return product;  
45.     }  
46. }  
47.   
48. class Product {  
49.     private String name;  
50.     private int num;  
51.   
52.     public void showProduct(){  
53.         System.out.println("name :"+name);  
54.         System.out.println("age:"+num);  
55.     }  
56.   
57.     public String getName() {  
58.         return name;  
59.     }  
60.   
61.     public void setName(String name) {  
62.         this.name = name;  
63.     }  
64.   
65.     public int getNum() {  
66.         return num;  
67.     }  
68.   
69.     public void setNum(int num) {  
70.         this.num = num;  
71.     }  
72. }  

7.创造型：原型

[java]  view plain  copy

1. package com.seezoon.创建型.原型;  
2.   
3. import java.io.ByteArrayInputStream;  
4. import java.io.ByteArrayOutputStream;  
5. import java.io.IOException;  
6. import java.io.ObjectInputStream;  
7. import java.io.ObjectOutputStream;  
8. import java.io.Serializable;  
9.   
10. /** 
11.  *  
12.  * @author DF 
13.  *原型模式虽然是创建型的模式，但是与工程模式没有关系，从名字即可看出， 
14.  *该模式的思想就是将一个对象作为原型，对其进行复制、克隆，产生一个和原对象类似的新对象。 
15.  *在Java中，复制对象是通过clone()实现的 
16.  */  
17. public class Prototype implements Cloneable,Serializable{  
18.     /** 
19.      *  
20.      */  
21.     private static final long serialVersionUID = 1L;  
22.     public void print(){  
23.         System.out.println("hello Prototype !!!!!");  
24.     }  
25.     /** 
26.      * 该做法为浅复制 
27.      * 浅复制：将一个对象复制后，基本数据类型的变量都会重新创建，而引用类型，指向的还是原对象所指向的。 
28.      */  
29.     public Prototype clone() throws CloneNotSupportedException {    
30.         Prototype proto = (Prototype) super.clone();    
31.         return proto;    
32.     }    
33.     /** 
34.      * 深复制 
35.      * 深复制：将一个对象复制后，不论是基本数据类型还有引用类型，都是重新创建的。 
36.      * 简单来说，就是深复制进行了完全彻底的复制，而浅复制不彻底 
37.      * @return 
38.      * @throws IOException 
39.      * @throws ClassNotFoundException 
40.      */  
41.     public Prototype deepClone() throws IOException, ClassNotFoundException {    
42.     
43.         /* 写入当前对象的二进制流 */    
44.         ByteArrayOutputStream bos = new ByteArrayOutputStream();    
45.         ObjectOutputStream oos = new ObjectOutputStream(bos);    
46.         oos.writeObject(this);    
47.         /* 读出二进制流产生的新对象 */    
48.         ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());    
49.         ObjectInputStream ois = new ObjectInputStream(bis);    
50.         Prototype prototype = (Prototype) ois.readObject();    
51.         ois.close();  
52.         bis.close();  
53.         oos.close();  
54.         bos.close();  
55.         return prototype;  
56.     }    
57.     public static void main(String[] args) throws Exception {  
58.         Prototype prototype = new Prototype();  
59.         Prototype prototypeClone = prototype.clone();  
60.         Prototype prototypeDeepClone = prototype.deepClone();  
61.         prototypeClone.print();  
62.         prototypeDeepClone.print();  
63.     }  
64. }  

8.结构型：代理

[java]  view plain  copy

1. package com.seezoon.结构型.代理;  
2.   
3. /** 
4.  *  
5.  * @author DF 
6.  *其实每个模式名称就表明了该模式的作用，代理模式就是多一个代理类出来， 
7.  *替原对象进行一些操作，比如我们在租房子的时候回去找中介，为什么呢？ 
8.  *因为你对该地区房屋的信息掌握的不够全面，希望找一个更熟悉的人去帮你做，此处的代理就是这个意思。再如我们有的时候打官司， 
9.  *我们需要请律师，因为律师在法律方面有专长，可以替我们进行操作，表达我们的想法 
10.  * 
11.  * 
12.  *代理模式的应用场景： 
13.     如果已有的方法在使用的时候需要对原有的方法进行改进，此时有两种办法： 
14.     1、修改原有的方法来适应。这样违反了“对扩展开放，对修改关闭”的原则。 
15.     2、就是采用一个代理类调用原有的方法，且对产生的结果进行控制。这种方法就是代理模式。 
16.     使用代理模式，可以将功能划分的更加清晰，有助于后期维护！ 
17.  */  
18. public class ProxySample {  
19.      public static void main(String[] args) {    
20.             Sourceable source = new Proxy();    
21.             source.method();    
22.         }    
23. }  
24. interface Sourceable {    
25.     public void method();    
26. }   
27. class Source implements Sourceable {    
28.         
29.     @Override    
30.     public void method() {    
31.         System.out.println("the original method!");    
32.     }    
33. }    
34. class Proxy implements Sourceable {    
35.         
36.     private Source source;    
37.     public Proxy(){    
38.         super();    
39.         this.source = new Source();    
40.     }    
41.     @Override    
42.     public void method() {    
43.         before();    
44.         source.method();    
45.         atfer();    
46.     }    
47.     private void atfer() {    
48.         System.out.println("after proxy!");    
49.     }    
50.     private void before() {    
51.         System.out.println("before proxy!");    
52.     }    
53. }    

9.结构型：桥接

[java]  view plain  copy

1. package com.seezoon.结构型.桥接;  
2.   
3. /** 
4.  *  
5.  * @author DF 
6.  *桥接模式就是把事物和其具体实现分开，使他们可以各自独立的变化。 
7.  *桥接的用意是：将抽象化与实现化解耦，使得二者可以独立变化，像我们常用的JDBC桥DriverManager一样， 
8.  *JDBC进行连接数据库的时候，在各个数据库之间进行切换，基本不需要动太多的代码， 
9.  *甚至丝毫不用动，原因就是JDBC提供统一接口， 
10.  *每个数据库提供各自的实现，用一个叫做数据库驱动的程序来桥接就行了 
11.  * 
12.  * 
13.  * 
14.  *通过对Bridge类的调用，实现了对接口Sourceable的实现类SourceSub1和SourceSub2的调用 
15.  */  
16. public class BridgeSample {  
17.     public static void main(String[] args) {    
18.           
19.         Bridge bridge = new MyBridge();    
20.             
21.         /*调用第一个对象*/    
22.         Sourceable source1 = new SourceSub1();    
23.         bridge.setSource(source1);    
24.         bridge.method();    
25.             
26.         /*调用第二个对象*/    
27.         Sourceable source2 = new SourceSub2();    
28.         bridge.setSource(source2);    
29.         bridge.method();    
30.     }    
31. }  
32. interface Sourceable {    
33.     public void method();    
34. }    
35. class SourceSub1 implements Sourceable {    
36.         
37.     @Override    
38.     public void method() {    
39.         System.out.println("this is the first sub!");    
40.     }    
41. }    
42. class SourceSub2 implements Sourceable {    
43.         
44.     @Override    
45.     public void method() {    
46.         System.out.println("this is the second sub!");    
47.     }    
48. }    
49. abstract class Bridge {    
50.     private Sourceable source;    
51.     
52.     public void method(){    
53.         source.method();    
54.     }    
55.         
56.     public Sourceable getSource() {    
57.         return source;    
58.     }    
59.     
60.     public void setSource(Sourceable source) {    
61.         this.source = source;    
62.     }    
63. }    
64. class MyBridge extends Bridge {    
65.     public void method(){    
66.         getSource().method();    
67.     }    
68. }    

10.结构型：对象适配器

[java]  view plain  copy

1. package com.seezoon.结构型.适配器.对象适配器;  
2.   
3. /** 
4.  * 对象适配器 
5.  * @author DF 
6.  *对象的适配器模式：当希望将一个对象转换成满足另一个新接口的对象时，可以创建一个Adapter类，持有原类的一个实例， 
7.  *在Adapter类的方法中，调用实例的方法就行。 
8.  */  
9. public class ObjectAdapter {  
10.     public static void main(String[] args) {  
11.         Source source = new Source();  
12.         Adapter adapter = new Adapter(source);  
13.         adapter.method1();  
14.         adapter.method2();  
15.     }  
16. }  
17.   
18. class Source {  
19.     public void method1() {  
20.         System.out.println("this is original method!");  
21.     }  
22. }  
23.   
24. interface Targetable {  
25.     /* 与原类中的方法相同 */  
26.     public void method1();  
27.   
28.     /* 新类的方法 */  
29.     public void method2();  
30. }  
31.   
32. class Adapter implements Targetable {  
33.   
34.     private Source source;  
35.   
36.     public Adapter(Source source) {  
37.         super();  
38.         this.source = source;  
39.     }  
40.   
41.     @Override  
42.     public void method2() {  
43.         System.out.println("this is the targetable method!");  
44.     }  
45.   
46.     @Override  
47.     public void method1() {  
48.         source.method1();  
49.     }  
50. }