Java基础之常用设计模式

Posted 2022-06-11 in-the-game-of-thrones

一：抽象工厂模式　

　　工厂模式指的是，围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

  1 /**
  2  * 绘画接口
  3  */
  4 public interface Color
  5     //填充颜色
  6     void fill();
  7 
  8 
  9 
 10 
 11 /**
 12  * 形状接口
 13  */
 14 public interface Shape
 15     //绘画形状
 16     void draw();
 17 
 18 
 19 
 20 
 21 public class GreenColor implements Color//Color的实现类
 22     public void fill()
 23         System.out.println("绿色---");
 24     
 25 
 26 public class RedColor implements Color//Color的实现类
 27     public void fill()
 28         System.out.println("红色---");
 29     
 30 
 31 
 32 
 33 
 34 
 35 public class TriangleShape implements Shape//Shape的实现类
 36     public void draw()
 37         System.out.println("三角形---");
 38     
 39 
 40 public class CircleShape implements Shape//Shape的实现类
 41     public void draw()
 42         System.out.println("圆形---");
 43     
 44 
 45 
 46 
 47 
 48 /**
 49  * 抽象工厂，构造两个接口
 50  */
 51 public abstract class AbstractFactory 
 52     public abstract Color getColor(String color) ;//根据颜色字符串得到哪种对象
 53     public abstract Shape getShape(String shape) ;//根据形状字符串得到哪种对象
 54 
 55 
 56 
 57 
 58 public  class ColorFactory extends AbstractFactory//颜色工厂继承抽象工厂
 59     public Color getColor(String color) //根据颜色字符串得到哪种对象
 60         if(null == color)return null;
 61         if ( "red".equalsIgnoreCase(color) )
 62             return new RedColor();//实例化一个RedColor对象
 63         else if ( "green".equalsIgnoreCase(color))
 64             return new GreenColor();//实例化一个GreenColor对象
 65         
 66         return null;
 67     
 68     public Shape getShape(String shape) ;//根据形状字符串得到哪种对象
 69         return null;
 70     
 71 
 72 
 73 
 74 
 75 public  class ShapeFactory extends AbstractFactory//形状工厂继承抽象工厂
 76     public Color getColor(String color) //根据颜色字符串得到哪种对象
 77         return null;
 78     
 79     public Shape getShape(String shape) ;//根据形状字符串得到哪种对象
 80         if(null == shape)return null;
 81         if ( "triangle".equalsIgnoreCase(shape) )
 82             return new CircleShape();//实例化一个CircleShape对象
 83         else if ( "circle".equalsIgnoreCase(shape))
 84             return new TriangleShape ();//实例化一个TriangleShape 对象
 85         
 86         return null;
 87     
 88 
 89 
 90 
 91 
 92 public  class FactoryBuilder//父工厂,构建具体工厂对象
 93     public static AbstractFactory getFactory(String factory)
 94         if ( "colorfactory".equalsIgnoreCase(factory) )
 95             return new ColorFactory();
 96         else if ( "shapefactory".equalsIgnoreCase(factory) )
 97             return new ShapeFactory();
 98         
 99         return null;
100     
101 
102 
103 
104 
105 /**
106  * 抽象工厂模式测试类
107  */
108 public class AbstractFactoryPattern 
109     public static void main (String [] args)
110         //获取颜色工厂
111         AbstractFactory af = FactoryBuilder.getFactory("colorfactory");
112         //创建红色对象
113         Color red = af.getColor("red");
114         //输出信息
115         red.fill();
116         //创建红色对象
117         Color green = af.getColor("green");
118         //输出信息
119         green.fill();
120 
121         System.out.println("分割线---------------------------");
122 
123         AbstractFactory abstractFactory = FactoryBuilder.getFactory("shapefactory");
124         Shape circle = abstractFactory.getShape("CIRCLE");
125         circle.draw();
126         Shape triangle = abstractFactory.getShape("triangle");
127         triangle.draw();
128     
129 

 

二：代理设计模式

　　代理模式指给一个对象提供一个代理对象，并由代理对象控制对原对象的引用。代理可以分为静态代理和动态代理。 
通过代理模式，可以利用代理对象为被代理对象添加额外的功能，以此来拓展被代理对象的功能。可以用于计算某个方法执行时间，在某个方法执行前后记录日志等操作。

 

三：单例设计模式

　　单例模式指的是，一个类只允许创建一个实例化对象，分为懒汉模式与恶汉模式。

　　　　饿汉式：构造方法私有化，外部无法产生新的实例化对象，只能通过static方法取得实例化对象。不存在线程安全的问题。

 1 public class TestSingleton
 2   //构造方法私有化
 3   private TestSingleton()
 4   //类加载时，创建一个实例化对象
 5   private static final TestSingleton testSingleton = new TestSingleton();
 6   //提供一个对外的方法 ， 返回对象实例
 7   public static TestSingleton getTestSingleton()
 8       return testSingleton;    
 9           
10 

 

　　　　懒汉式：需要加上同步锁，同步锁影响了程序执行效率。

　　　　　　1）、双重if判断

 1 public class TestSingleton
 2 
 3   /**
 4    * volatile的作用是作为指令关键字，确保本条指令不会因编译器的优化而省略，
 5    * 且要求每次直接读值。
 6    * volatile让变量每次在使用的时候，都从主存中取。而不是从各个线程的“工作内存”。
 7    *       声明对象变量
 8    *  volatile 禁止指令重排 主要由于new TestSingleton();可能出现问题
 9    */
10   private static volatile TestSingleton testSingleton = null ;
11 
12   //构造方法私有化
13   private TestSingleton()
14 
15   /**
16    * 提供一个对外的方法 ， 返回对象实例 
17    * 双重 if 校验锁 (synchronized) 保证线程安全。
18    */
19   public staticTestSingleton getTestSingleton()
20       //if判断，该对象还未实例化  
21       if ( testSingleton == null )
22           //加锁
23           synchronized (TestSingleton.class)
24               //if判断，该对象还未实例化
25               if ( testSingleton == null )
26                  testSingleton = new TestSingleton();
27               
28           
29       
30       return testSingleton;    //返回实例对象
31           

 

　　　　　　2）、内部类

 1 public class TestSingleton
 2 
 3   //构造器私有化
 4   private TestSingleton()
 5 
 6   //静态内部类，在其中  实例化 私有的 静态的 外部类对象
 7   private static class InternalClass
 8      //实例化外部类对象
 9     private static final TestSingleton TESTSINGLETON = new TestSingleton();
10   
11 
12   //提供对外的方法
13   public static TestSingleton getTestSingleton()
14     return InternalClass.TESTSINGLETON ;
15   
16     

 

四：建造者设计模式

　　建造者模式指的是，将各种产品集中起来管理，用来创建复合对象，所谓复合对象就是指某个类具有不同的属性。

五：适配器设计模式

　　适配器模式是将某个类的接口转换成客户端期望的另一个接口表示，目的是消除由于接口不匹配所造成的的类的兼容性问题。主要分三类：类的适配器模式、对象的适配器模式、接口的适配器模式。

 　　适配器：当A接口中的方法过多，然而实现他的B子类只需要实现其中一两条，于是新建一个C类实现这个接口，C类中实现的方法都为空方法，然后B子类继承该C类，重写需要用到的方法。

 

六：MVC设计模式

　　适配器模式是将某个类的接口转换成客户端期望的另一个接口表示，目的是消除由于接口不匹配所造成的的类的兼容性问题。主要分三类：类的适配器模式、对象的适配器模式、接口的适配器模式。