最常用的几种设计模式

工厂模式

这种类型的设计模式属于创建型模式，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。
意图： 定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。

单例模式

这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。
意图： 保证一个类仅有一个实例，并提供一个访问它的全局访问点。
主要解决： 一个全局使用的类频繁地创建与销毁。
何时使用： 当您想控制实例数目，节省系统资源的时候。
如何解决： 判断系统是否已经有这个单例，如果有则返回，如果没有则创建。构造函数是私有的。

适配器模式

作为两个不兼容的接口之间的桥梁。这种类型的设计模式属于结构型模式，它结合了两个独立接口的功能。这种模式涉及到一个单一的类，该类负责加入独立的或不兼容的接口功能。
主要解决： 主要解决在软件系统中，常常要将一些"现存的对象"放到新的环境中，而新环境要求的接口是现对象不能满足的。

代码实现：

//  媒体播放器接口
public interface MediaPlayer {
   public void play(String audioType, String fileName);
}
// 更高级的媒体播放器接口
public interface AdvancedMediaPlayer { 
   public void playVlc(String fileName);
   public void playMp4(String fileName);
}
// VIC播放器 （实现高级媒体播放器接口）
public class VlcPlayer implements AdvancedMediaPlayer{
   @Override
   public void playVlc(String fileName) {
      System.out.println("Playing vlc file. Name: "+ fileName);      
   }
   @Override
   public void playMp4(String fileName) {
      //什么也不做
   }
}
// MP4播放器 （实现媒体播放器接口）
public class Mp4Player implements AdvancedMediaPlayer{
   @Override
   public void playVlc(String fileName) {
      //什么也不做
   }
   @Override
   public void playMp4(String fileName) {
      System.out.println("Playing mp4 file. Name: "+ fileName);      
   }
}
 // 普通媒体播放器接口的适配器类。
public class MediaAdapter implements MediaPlayer {
   AdvancedMediaPlayer advancedMusicPlayer;
   public MediaAdapter(String audioType){
      if(audioType.equalsIgnoreCase("vlc") ){
         advancedMusicPlayer = new VlcPlayer();       
      } else if (audioType.equalsIgnoreCase("mp4")){
         advancedMusicPlayer = new Mp4Player();
      }  
   }
   @Override
   public void play(String audioType, String fileName) {
      if(audioType.equalsIgnoreCase("vlc")){
         advancedMusicPlayer.playVlc(fileName);
      }else if(audioType.equalsIgnoreCase("mp4")){
         advancedMusicPlayer.playMp4(fileName);
      }
   }
}

装饰者模式

对已有的业务员逻辑进一步的封装，时期增加额外的功能，如IO流就是用了装饰者模式，用户在使用的时候，可以任意组装，达到自己想要的结果。
代码实现：

//形状接口
public interface Shape {
   void draw();
}
//矩形类（实现形状接口）
public class Rectangle implements Shape {
 
   @Override
   public void draw() {
      System.out.println("Shape: Rectangle");
   }
}
//圆形类（实现形状接口）
public class Circle implements Shape {
 
   @Override
   public void draw() {
      System.out.println("Shape: Circle");
   }
}
//形状类的抽象装饰类
public abstract class ShapeDecorator implements Shape {
   protected Shape decoratedShape;
   public ShapeDecorator(Shape decoratedShape){
      this.decoratedShape = decoratedShape;
   }
   public void draw(){
      decoratedShape.draw();
   }  
}
//扩展抽象装饰类
public class RedShapeDecorator extends ShapeDecorator {
   public RedShapeDecorator(Shape decoratedShape) {
      super(decoratedShape);     
   }
   @Override
   public void draw() {
      decoratedShape.draw();         
      setRedBorder(decoratedShape);
   }
   private void setRedBorder(Shape decoratedShape){
      System.out.println("Border Color: Red");
   }
}
public class DecoratorPatternDemo {
   public static void main(String[] args) {
 
      Shape circle = new Circle();
      ShapeDecorator redCircle = new RedShapeDecorator(new Circle());
      ShapeDecorator redRectangle = new RedShapeDecorator(new Rectangle());
      System.out.println("Circle with normal border");
      circle.draw();
      System.out.println("\nCircle of red border");
      redCircle.draw();
      System.out.println("\nRectangle of red border");
      redRectangle.draw();
   }
}

输出结果：
Circle with normal border
Shape: Circle

Circle of red border
Shape: Circle
Border Color: Red

Rectangle of red border
Shape: Rectangle
Border Color: Red

代理模式

在代理模式中，一个类代表另一个类的功能，这种类型的设计模式属于结构型模式，在代理模式中，创建具有现有对象的对象，以便向外界提供功能接口。
意图： 为其他对象提供一种代理以控制对这个对象的访问。
何时使用： 想在访问一个类时做一些控制。
如何解决： 增加中间层。
关键代码： 实现与被代理类组合。
代码实现：

//图片接口
public interface Image {
   void display();
}
//红图片类（实现红图片接口）
public class RealImage implements Image {
   private String fileName;
   public RealImage(String fileName){
      this.fileName = fileName;
      loadFromDisk(fileName);
   }
   @Override
   public void display() {
      System.out.println("Displaying " + fileName);
   }
   private void loadFromDisk(String fileName){
      System.out.println("Loading " + fileName);
   }
}
//图片接口代理类（实现图片接口）
public class ProxyImage implements Image{
   private RealImage realImage;
   private String fileName;
   public ProxyImage(String fileName){
      this.fileName = fileName;
   }
   @Override
   public void display() {
      if(realImage == null){
         realImage = new RealImage(fileName);
      }
      realImage.display();
   }
}
//测试
public class ProxyPatternDemo {
   public static void main(String[] args) {
      Image image = new ProxyImage("wang.jpg");
      // 图片将从磁盘加载
      image.display(); 
      // 图片不需要从磁盘加载（已经创建过image对象）
      image.display();  
   }
}

输出结果：
Loading wang.jpg
Displaying wang.jpg
Displaying wang.jpg