"大话"设计模式

单列设计模式

• 简单的来说 一个Application 某个类的实例对象只有一个,我们`没有办法new 的时候因为构造方法是被private修饰的 一般通过getInstance()方法获取它的实列对象 getInstance()返回的是一个对象的引用,并不是一个新的实例,废话不多说了 直接上代码!

 public class Singleton {

 private static Singleton singleton;

 private Singleton() {
 }

 public static Singleton getInstance() {
  if (singleton == null) {
   singleton = new Singleton();
  }
  return singleton;
 }
}

上面的是最基本的写法 也叫懒汉式写法(线程不安全的)

public class Singleton {  
    private static Singleton instance;  
    private Singleton (){}  
    public static synchronized Singleton getInstance() {  
    if (instance == null) {  
        instance = new Singleton();  
    }  
    return instance;  
    }  
}

再看看我们的饿汉式的写法吧

public class Singleton {  
    private static Singleton instance = new Singleton();  
    private Singleton (){}  
    public static Singleton getInstance() {  
    return instance;  
    }  
}

静态内部类

public class Singleton {  
    private static class SingletonHolder {  
    private static final Singleton INSTANCE = new Singleton();  
    }  
    private Singleton (){}  
    public static final Singleton getInstance() {  
    return SingletonHolder.INSTANCE;  
    }  
}

枚举

public enum Singleton {  
    INSTANCE;  
    public void whateverMethod() {  
    }  
}

这种方式是Java Bloach提倡的写法 他不仅能够避免线程同步的问题 而且还能防止反序列化重新创建新的对象

双重校验锁

public class Singleton {  
    private volatile static Singleton singleton;  
    private Singleton (){}  
    public static Singleton getSingleton() {  
    if (singleton == null) {  
        synchronized (Singleton.class) {  
        if (singleton == null) {  
            singleton = new Singleton();  
        }  
        }  
    }  
    return singleton;  
    }  
}

观察者设计模式

对象存在一对多的关系 当一个对一个对象发生改变的时候,他所依赖的对象也会发生相应通知和改变 例如:有三个人,小雅(女),小铁箱(男),小木箱(男),小雅长得比较漂亮,平时很风骚,小木箱和小铁箱时刻关注着小雅的举动,有一天小雅说了一句话:我今天老公不在好无聊呀~,这句话被小铁箱和小木箱听到了乐坏了,摩擦摩擦,小铁箱就来到了小雅的家里面,于是进门了———————————-啪啪啪啪,在这里小雅是被观察者,小铁箱和小木箱是观察者,被观察者发送一条Message,让观察者接收,并且观察者做出相应的处理
直接上代码:
小铁箱的代码:

小木箱的代码:

这个借口相当于小木箱和小铁箱的电话号码,小雅发送通知的时候,就会拨打getMessage这个电话,拨打电话就是调用这个接口,

public  interface Person {
   //通知Micro和Kibaco发送的消息
   void getMessage(String msg);
}

然后 我们再过来看看小雅的代码:

public class Beauty {
   List<Person> list=  new ArrayList<Person>();

   public Beauty() {
   }

   public  void  addPerson(Person person){
      list.add(person);
   }

   //遍历给该集合发送给自己的暗恋的人
   public void notifyPerson(){
      for (Person person : list) {
         person.getMessage("今天老公不在,就小女子一人,你们过来吧,你们谁先到,就能先得到我,今晚十一点等你哦~~~");
      }
   }

结果到底是什么样的,我们来测试一把!

public class TestObserver {
   public static void main(String[] args) {
      Kibaco kibaco = new Kibaco();
      Micro micro = new Micro();
      Beauty beauty = new Beauty();

      //小铁箱和小木箱都在小雅那里注册了一下
      beauty.addPerson(kibaco);
      beauty.addPerson(micro);

      //小雅给小铁箱和小木箱发送通知
      beauty.notifyPerson();
   }
}

• 运行结果
  

Perfect!!!

装饰设计模式

对已有的业务逻辑进行封装,使其中增加外的功能,比如我们在Java里面学的IO流就用了装饰设计模式,用户在使用的时候可以任意组装,最终的目的是达到自己目的,例如:我想吃臭豆腐,首先我需要将炸好的豆腐干,我喜欢吃辣椒,在豆腐干外面浇一层辣椒汁,再放一点葱花,最好加一点秘制的排骨汤,美味营养又健康(ps:不知道长沙哪里有好吃的臭豆腐,博主推荐一下黑色经典),那么我们怎么写代码了?首先我们需要一个Tofu类,让所有的配料都继承这个类!!看代码:

• 辣椒汁类

public class chilli extends  Tofu {
      private  Tofu mingredients;

   public chilli( Tofu ingredients) {
      this.mingredients = ingredients;
   }

   @Override
   public String make() {
      return  mingredients.make()+"辣椒汁";
   }

}

• 葱花类

public class leek extends  Tofu {
      private  Tofu mingredients;

   public leek( Tofu ingredients) {
      this.mingredients = ingredients;
   }

   @Override
   public String make() {
      return mingredients.make()+"葱花+";
   }

}

• 排骨汤类

public class ribs extends  Tofu {
      private  Tofu mingredients;

   public ribs(Tofu ingredients) {
      this.mingredients = ingredients;
   }

   @Override
   public String make() {
      return mingredients.make()+"排骨汤+";
   }

}

• 测试类

public class Testdecorate {
   public static void main(String[] args) {
      Tofu tofu =new chilli( new leek(new ribs(new Tofu("豆腐干+"))));
      System.out.println(tofu.make());
   }
}

看到没有一层层包裹,我们从里面往外面看,最里面我new了一个豆腐干,豆腐干外面我浇了一层排骨汤,浇完排骨汤,我再撒了一把葱花,最后再浇了一层辣椒汁,这就是黑色经典臭豆腐的秘制做工,来看看我们的运行结果吧!
- 运行结果

一碗香喷喷的长沙臭豆腐就做好了

适配器模式

将两种完全不同的事务联系起来,就像生活中的变压器,假设一个手机充电需要22v,但是正常的交流电是220v这个时候就需要一个变压器,将220v电压转化成20v的电压,这样变压器就将20v的电压和手机联系起来了

• 手机类

public class Phone {
   public static  final  int V = 220;//正常电压是220v,是一个常量
   private  VoltageAdapter adapter;

   //充电
   public void  charge(){
      adapter.changeTransformer();
   }

   public void setAdapter(VoltageAdapter adapter) {
      this.adapter = adapter;
   }
}

• 变压器类

public class Phone {
   public static  final  int V = 220;//正常电压是220v,是一个常量
   private  VoltageAdapter adapter;

   //充电
   public void  charge(){
      adapter.changeTransformer();
   }

   public void setAdapter(VoltageAdapter adapter) {
      this.adapter = adapter;
   }
}

• 测试类

public class TestAdapter {
   public static void main(String[] args) {
      Phone phone = new Phone();
      VoltageAdapter adapter = new VoltageAdapter();
      phone.setAdapter(adapter);
      phone.charge();
   }
}

• 运行结果

观察者设计模式

• 简单工厂模式

抽象接口

 abstract interface car {
   void run(); //奔跑

   void stop();//停止
}

多个抽象接口的实现类

public class Benz implements car {
   @Override
   public void run() {
      System.out.println("奔驰开始启动了");
   }
   @Override
   public void stop() {
      System.out.println("奔驰熄火停止了-----");
   }
  }

public class BMW implements car {
   @Override
   public void run() {
      System.out.println("宝马开始启动了");
   }

   @Override
   public void stop() {
      System.out.println("宝马熄火停止了-----");
   }
}

一个工厂类

实例化抽象接口

class Factory {
   static car getCarInstance(String type) {
      car c = null;
      if ("Benz".equals(type)) {
         c = new Benz();
      }
      if ("BMW".equals(type)) {
         c = new BMW();
      }
      return c;
   }
}

测试类

public class TestFactory {
   public static void main(String[] args) {
      car car = Factory.getCarInstance("BMW");
      if (car!=null){
         car.run();
         car.stop();
      }else {
         System.out.println("造不了这种汽车-----");
      }
   }
}

• 运行结果
  

抽象产品角色

 public abstract class FactoryMeyhod {
   abstract Moveable create();
}

具体产品角色

public class Broom implements Moveable {
   @Override
   public void run() {
      System.out.println("Broom-----------");
   }
}

public class Plane implements  Moveable {
   @Override
   public void run() {
      System.out.println("Plane-----------");
   }
}

抽象工厂方法

public abstract class FactoryMeyhod {
   abstract Moveable create();
}

测试类

public class TestFactoryMeyhod {
   public static void main(String[] args) {
      FactoryMeyhod broomFactory = new BroomFactory();
      Moveable moveable = broomFactory.create();
      moveable.run();
   }
}

• 运行结果

Broom———–

小木箱的第一篇博客,网上资料很多,感谢”代码也是人”材料借鉴,觉得写得好的话点个赞支持一下呗