Java中几种常用设计模式

  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 }

 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 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   }        

 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 }