java 设计模式常用21种

ゞ浴缸里的玫瑰 2022-05-28 12:54 236阅读 0赞

#                                   java 设计模式 常用21种 #

1.创造型：抽象工厂

\[java\]  [view plain][]  [copy][view plain]

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][view plain]

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][view plain]

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][view plain]

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][view plain]

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][view plain]

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][view plain]

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][view plain]

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][view plain]

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][view plain]

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. \}  
51.

[view plain]: https://blog.csdn.net/Rundy_Deng/article/details/76552095#