Java中的设计模式：如何优雅地解决常见问题？

 来自：www.jdnaicha.com

在Java编程中，设计模式是解决问题的最佳实践，它们是在软件设计中针对常见问题的优秀解决方案。使用设计模式可以提高代码的可读性、可维护性和可扩展性。本文将探讨Java中几种常见的设计模式，以及它们如何优雅地解决一些常见问题。

一、单例模式

单例模式是一种创建型设计模式，它确保一个类仅有一个实例，并提供一个全局访问点。这种模式常用于管理全局唯一的资源，如配置文件、数据库连接等。

在Java中实现单例模式，可以使用懒汉式、饿汉式、双重检查锁定等方式。以下是懒汉式的实现示例：

java
public class Singleton {  
    private static Singleton instance;  
  
    private Singleton() {  
        // 私有构造函数，防止外部类通过new Singleton()创建对象  
    }  
  
    public static synchronized Singleton getInstance() {  
        if (instance == null) {  
            instance = new Singleton();  
        }  
        return instance;  
    }  
}
二、工厂模式

工厂模式是一种创建型设计模式，它提供了一种封装对象创建过程的机制。工厂模式分为简单工厂、工厂方法和抽象工厂三种。

简单工厂模式通过一个工厂类根据传入的参数来决定创建哪种对象。以下是一个简单工厂模式的示例：

java
public interface Shape {  
    void draw();  
}  
  
public class Circle implements Shape {  
    @Override  
    public void draw() {  
        System.out.println("Inside Circle::draw() method.");  
    }  
}  
  
public class Rectangle implements Shape {  
    @Override  
    public void draw() {  
        System.out.println("Inside Rectangle::draw() method.");  
    }  
}  
  
public class ShapeFactory {  
    // 使用getShape方法获取形状类型的对象  
    public Shape getShape(String shapeType){  
        if(shapeType == null){  
            return null;  
        }          
        if(shapeType.equalsIgnoreCase("CIRCLE")){  
            return new Circle();  
        } else if(shapeType.equalsIgnoreCase("RECTANGLE")){  
            return new Rectangle();  
        }  
  
        return null;  
    }  
}
工厂方法模式将对象的创建过程委托给子类决定。抽象工厂模式则提供了一种创建相关或依赖对象的家族的方式，而无需指定它们的具体类。

三、观察者模式

观察者模式是一种行为型设计模式，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。当主题对象状态发生改变时，它的所有依赖者（观察者）都会收到通知并自动更新。

Java中的java.util.Observable和java.util.Observer类是实现观察者模式的基础。以下是一个简单的观察者模式示例：

java
import java.util.*;  
  
public interface Subject {  
    void registerObserver(Observer o);  
    void removeObserver(Observer o);  
    void notifyObservers();  
    void setStateChanged();  
    boolean wasStateChanged();  
}  
  
public class ConcreteSubject implements Subject {  
    private boolean changed = false;  
    private Vector<Observer> obs;  
  
    public ConcreteSubject() {  
        obs = new Vector<Observer>();  
    }  
  
    @Override  
    public void registerObserver(Observer o) {  
        if (!obs.contains(o)) {  
            obs.add(o);  
        }  
    }  
  
    @Override  
    public void removeObserver(Observer o) {  
        int i = obs.indexOf(o);  
        if (i >= 0) {  
            obs.remove(i);  
        }  
    }  
  
    @Override  
    public void notifyObservers() {  
        for (Observer observer : obs) {  
            observer.update(this);  
        }  
    }  
  
    @Override  
    public void setStateChanged() {  
        changed = true;  
    }  
  
    @Override  
    public boolean wasStateChanged() {  
        return changed;  
    }  
}  
  
public interface Observer {  
    void update(Subject subject);  
}  
  
public class ConcreteObserver implements Observer {  
    private String name;  
    private Subject subject;  
  
    public ConcreteObserver(Subject subject, String name) {  
        this.subject = subject;  
        this.name = name;  
    }  
  
    @Override  
    public void update(Subject subject) {  
        if (subject.wasStateChanged()) {  
            System.out.println("Observed " + subject.getClass().getName()  
                    + ": " + name);  
            subject.setStateChanged();  
        }  
    }  
}

 来自：www.tcjmbj.cn