Java中有哪些常用设计模式？如何应用这些设计模式？

Java是一门十分流行的编程语言，在软件开发中，设计模式是十分重要的概念之一。本文将会介绍Java中常用的设计模式和如何应用它们来提高软件开发效率。

一、常用的设计模式

1. 单例模式（Singleton Pattern）

单例模式是指一个类只允许创建一个对象实例。在Java中，可以通过私有化构造函数并使用静态方法来实现单例模式。需要注意的是，多线程环境下需要进行加锁处理。

1. 工厂模式（Factory Pattern）

工厂模式是指通过一个工厂类来创建其他对象。在Java中，可以使用简单工厂、工厂方法和抽象工厂等方式来实现。

1. 抽象工厂（Abstract Factory Pattern）

抽象工厂是指一个工厂类可以创建多个产品族，每个产品族包含多个产品等级结构。这种设计模式能够提供接口的通用性，并且可以在不修改代码的情况下增加新产品。

1. 代理模式（Proxy Pattern）

代理模式是指为其他对象提供一种代理以控制对这个对象的访问。在Java中，可以使用静态代理或动态代理来实现。

1. 观察者模式（Observer Pattern）

观察者模式是指当一个对象状态改变时，其所依赖的对象会自动收到通知并更新。在Java中，可以通过实现Observer接口和Observable类来实现。

1. 装饰器模式（Decorator Pattern）

装饰器模式是指在运行时扩展一个对象的功能，而不改变其结构。在Java中，可以通过继承和接口实现来达到这一目的。

1. 适配器模式（Adapter Pattern）

适配器模式是指将一个类的接口转换为客户希望的另一个接口。在Java中，可以通过类适配器、对象适配器和接口适配器等方式来实现。

1. 策略模式（Strategy Pattern）

策略模式是指定义一系列算法并将其封装起来，在不同情况下使用不同的算法来完成相同的任务。在Java中，可以使用接口和抽象类来定义算法族，并使用委托来完成相应任务。

1. 模板方法模式（Template Method Pattern）

模板方法模式是指定义一个操作中的算法骨架，将一些步骤延迟到子类中实现。在Java中，可以使用抽象类和钩子函数等方式来实现。

1. 建造者模式（Builder Pattern）

建造者模式是指分离一个复杂对象的构建过程，并使其能够按照顺序构造出完整对象。在Java中，可以通过包含多个构造器参数的Builder类来实现。

二、如何应用设计模式

在实际软件开发过程中，应用设计模式可以增强代码的可读性和可维护性。以下是一些实际应用场景：

1. 单例模式

当需要保证一个类只有一个对象时，可以使用单例模式。例如，数据库连接对象和配置文件等。

1. 工厂模式

当需要根据不同条件创建不同对象时，可以使用工厂模式。例如，在游戏中创建不同类型的武器或者地图。

1. 抽象工厂

当需要创建复杂对象的多个组成部分时，可以使用抽象工厂。例如，在电脑制造过程中需要创建显示器、CPU、内存等组件。

1. 代理模式

当需要对一个对象进行限制或控制访问时，可以使用代理模式。例如，在网络访问中限制访问某些网站或者在数据库操作中添加权限验证。

1. 观察者模式

当需要将一些状态更新通知到其他相关对象时，可以使用观察者模式。例如，在GUI编程中用户输入和鼠标事件等。

1. 装饰器模式

当需要给一个对象添加额外的功能而不改变其结构时，可以使用装饰器模式。例如，在IO流操作中为输出流添加加密或压缩功能。

1. 适配器模式

当需要将两个接口进行连接时，可以使用适配器模式。例如，在Java的AWT和Swing中将旧版的接口转换为新版的接口。

1. 策略模式

当需要在不同条件下使用不同算法时，可以使用策略模式。例如，在排序过程中可以根据不同数据类型选择不同算法。

1. 模板方法模式

当需要定义一个算法的骨架但是具体实现由子类决定时，可以使用模板方法模式。例如，在游戏开发过程中定义游戏界面的绘制算法骨架，由具体子类实现。

1. 建造者模式

当需要按照顺序构造一个复杂对象时，可以使用建造者模式。例如，在汽车生产过程中，按照顺序构建引擎、底盘、车身等部分然后组装为一辆汽车。

三、学习代码示例

以下代码示例展示了单例模式和工厂模式的应用：

1. 单例模式示例：

public class Singleton {
    private static Singleton instance;
    
    private Singleton() {
        // 私有化构造函数
    }
    
    public static synchronized Singleton getInstance() { // 多线程下加锁保证只有一个实例
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

1. 工厂模式示例：

public interface Shape {
    void draw();
}

public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Circle.draw()");
    }
}

public class Square implements Shape {
    @Override
    public void draw() {
        System.out.println("Square.draw()");
    }
}

public class ShapeFactory {
    public static final int CIRCLE = 0;
    public static final int SQUARE = 1;

    public Shape createShape(int shapeType) { // 工厂方法根据不同参数创建不同对象
        switch (shapeType) {
            case CIRCLE:
                return new Circle();
            case SQUARE:
                return new Square();
            default:
                throw new IllegalArgumentException("Invalid shape type:" + shapeType);
        }
    }
}

1. 抽象工厂模式示例：

public interface Color {
    void fill();
}

public class Red implements Color {
    @Override
    public void fill() {
        System.out.println("Fill with red color");
    }
}

public class Green implements Color {
    @Override
    public void fill() {
        System.out.println("Fill with green color");
    }
}

public interface AbstractFactory {
    Shape createShape();
    Color createColor();
}

public class ShapeFactory implements AbstractFactory {
    @Override
    public Shape createShape() {
        return new Circle();
    }

    @Override
    public Color createColor() {
        return new Red();
    }
}

public class RoundedShapeFactory implements AbstractFactory {
    @Override
    public Shape createShape() {
        return new RoundedRectangle();
    }

    @Override
    public Color createColor() {
        return new Green();
    }
}

1. 代理模式示例：

public interface ImageInterface {
     void display();
}

public class RealImage implements ImageInterface {

     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 ImageInterface {

     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();
     }
}

1. 观察者模式示例：

import java.util.ArrayList;
import java.util.List;

public class Subject {
    private List<Observer> observers = new ArrayList<Observer>();
    private int state;

    public int getState() {
        return state;
    }

    public void setState(int state) {
        this.state = state;
        notifyObservers();
    }

    public void attach(Observer observer) {
        observers.add(observer);
    }

    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update();
        }
    }
}

public class BinaryObserver extends Observer {

   public BinaryObserver(Subject subject){
      this.subject = subject;
      this.subject.attach(this);
   }

   @Override
   public void update() {
      System.out.println("Binary String: " + Integer.toBinaryString(subject.getState()));
   }
}

public class OctalObserver extends Observer {

   public OctalObserver(Subject subject){
      this.subject = subject;
      this.subject.attach(this);
   }

   @Override
   public void update() {
     System.out.println("Octal String: " + Integer.toOctalString(subject.getState()));
   }
}

public class HexaObserver extends Observer{

   public HexaObserver(Subject subject){
      this.subject = subject;
      this.subject.attach(this);
   }

   @Override
   public void update() {
      System.out.println("Hex String: " + Integer.toHexString(subject.getState()).toUpperCase());
  }
}

1. 装饰器模式示例：

public interface Shape {
     void draw();
}

public class Rectangle implements Shape {

     @Override
     public void draw() {
        System.out.println("Shape: Rectangle");
     }
}

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();           
        setColor(decoratedShape);
     }

     private void setColor(Shape decoratedShape){
        System.out.println("Border Color: Red");
     }
}

1. 适配器模式示例：

public interface MediaPlayer {
   void play(String audioType, String fileName);
}

public interface AdvancedMediaPlayer {    
   void playVlc(String fileName);
   void playMp4(String fileName);
}

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) {
      //do nothing
   }
}

public class Mp4Player implements AdvancedMediaPlayer{

    @Override
    public void playVlc(String fileName) {
       //do nothing
    }

    @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);
       }
    }
}

public class AudioPlayer implements MediaPlayer {
   MediaAdapter mediaAdapter; 

   @Override
   public void play(String audioType, String fileName) {    

      if(audioType.equalsIgnoreCase("mp3")){
         System.out.println("Playing mp3 file. Name: " + fileName);            
      } 
      
      else if(audioType.equalsIgnoreCase("vlc") || audioType.equalsIgnoreCase("mp4")){
         mediaAdapter = new MediaAdapter(audioType);
         mediaAdapter.play(audioType, fileName);
      }
      
      else{
         System.out.println("Invalid media. " + audioType + " format not supported");
      }
   }   
}

1. 策略模式示例：

public interface Strategy {
   int doOperation(int num1, int num2);
}

public class OperationAdd implements Strategy{
   
   @Override
   public int doOperation(int num1, int num2) {
      return num1 + num2;
   }
}

public class OperationSubtract implements Strategy{
   
   @Override
   public int doOperation(int num1, int num2) {
      return num1 - num2;
   }
}

public class OperationMultiply implements Strategy{

   @Override
   public int doOperation(int num1, int num2) {
      return num1 * num2;
   }
}

public class Context {
    private Strategy strategy;

    public Context(Strategy strategy){
       this.strategy = strategy;
    }

    public int executeStrategy(int num1, int num2){
       return strategy.doOperation(num1, num2);
    }
}

1. 模板方法模式示例：

public abstract class Game {

     abstract void initialize();
     abstract void startPlay();
     abstract void endPlay();

     // 模板方法
     public final void play(){

        // 初始化游戏
        initialize();

        // 开始游戏
        startPlay();

        // 结束游戏
        endPlay();
     }
}

public class Cricket extends Game {

    @Override
    void endPlay() {
        System.out.println("Cricket Game Finished!");
    }

    @Override
    void initialize() {
        System.out.println("Cricket Game Initialized! Start playing.");
    }

    @Override
    void startPlay() {
        System.out.println("Cricket Game Started. Enjoy the game!");
    }
}

public class Football extends Game {

    @Override
    void endPlay() {
        System.out.println("Football Game Finished!");
    }

    @Override
    void initialize() {
       System.out.println("Football Game Initialized! Start playing.");
    }

   @Override
   void startPlay() {
       System.out.println("Football Game Started. Enjoy the game!");
   }
}

1. 建造者模式示例：

public class Burger {

     private String meat;
     private String sauce;
     private List<String> toppings = new ArrayList<String>();

     public void setMeat(String meat) {
         this.meat = meat;
     }

     public void setSauce(String sauce) {
         this.sauce = sauce;
     }

     public void addTopping(String topping) {
         toppings.add(topping);
     }
}

public interface Item {
     String name();
     Packing packing();
     float price();    
}

public interface Packing {
     String pack();
}

public abstract class Burger implements Item {

   @Override
   public Packing packing() {
      return new Wrapper();
   }

   @Override
   public abstract float price();
}

public abstract class ColdDrink implements Item {

    @Override    
    public Packing packing() {
           return new Bottle();
    }

    @Override    
    public abstract float price();
}

public class VegBurger extends Burger {
     @Override
     public float price() {
         return 25.0f;
     }

     @Override
     public String name() {
        return "Veg Burger";
     }
}

public class ChickenBurger extends Burger {
   @Override
   public float price() {
      return 50.5f;
   }

   @Override
   public String name() {
      return "Chicken Burger";
   }
}

public class Coke extends ColdDrink {

    @Override    
    public float price() {
           return 30.0f;
    }

    @Override    
    public String name() {
           return "Coke";
    }
}

public class Pepsi extends ColdDrink {

    @Override
    public float price() {
       return 35.0f;
    }

    @Override
    public String name() {
       return "Pepsi";
    }
}

以上是常用的十种设计模式示例代码。