學習Java中的設計模式

Java是一種常用的編程語言，設計模式方面也是非常重要的一個話題。設計模式是程序員經驗的積累，是針對常見問題的可重用的解決方案。使用設計模式可以減少代碼的複雜度，提高代碼的可維護性和重用性。本文將會介紹幾個常用的設計模式以及如何在Java中應用這些設計模式。

一、單例模式

單例模式是一種常用的設計模式，用於確保類只有一個實例存在。單例模式在多線程和並發處理時尤為重要，可以保證程序中一個類只有一個實例，並且所有對象共享該實例。

Java中實現單例模式一般有兩種方法，第一種方法是使用雙重檢查鎖定：

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

第二種方法是使用枚舉類型：

public enum Singleton {
    INSTANCE;
    public void doSomething(){
        // todo
    }
}

二、工廠模式

工廠模式是一種常用的設計模式，用於消除對象之間的依賴，實現對象的鬆散耦合。在工廠模式中，對象的創建和使用被分離開來。使用工廠模式可以降低代碼的複雜度，並且更容易實現代碼的可維護性和重用性。

Java中實現工廠模式一般有三種方法：簡單工廠模式、工廠方法模式和抽象工廠模式。

簡單工廠模式：

public interface Car {
    void run();
}
public class BMW implements Car {
    @Override
    public void run() {
        System.out.println("BMW is running");
    }
}
public class Audi implements Car {
    @Override
    public void run() {
        System.out.println("Audi is running");
    }
}
public class CarFactory {
    public static Car createCar(String type){
        switch (type){
            case "BMW":
                return new BMW();
            case "Audi":
                return new Audi();
            default:
                throw new IllegalArgumentException("Invalid car type:"+type);
        }
    }
}

工廠方法模式：

public interface Car {
    void run();
}
public class BMW implements Car {
    @Override
    public void run() {
        System.out.println("BMW is running");
    }
}
public class Audi implements Car {
    @Override
    public void run() {
        System.out.println("Audi is running");
    }
}
public interface CarFactory {
    Car createCar();
}
public class BMWFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new BMW();
    }
}
public class AudiFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new Audi();
    }
}

抽象工廠模式：

public interface Car {
    void run();
}
public class BMW implements Car {
    @Override
    public void run() {
        System.out.println("BMW is running");
    }
}
public class Audi implements Car {
    @Override
    public void run() {
        System.out.println("Audi is running");
    }
}
public interface CarFactory {
    Car createSportsCar();
    Car createSUV();
}
public class BMWFactory implements CarFactory {
    @Override
    public Car createSportsCar() {
        return new BMW();
    }
    @Override
    public Car createSUV() {
        return new BMW();
    }
}
public class AudiFactory implements CarFactory {
    @Override
    public Car createSportsCar() {
        return new Audi();
    }
    @Override
    public Car createSUV() {
        return new Audi();
    }
}

三、觀察者模式

觀察者模式也是一種常用的設計模式，用於建立對象之間的一對多依賴關係。在觀察者模式中，某個對象的狀態發生改變時，所有依賴它的對象都將得到通知並自動更新。

Java中實現觀察者模式一般包含以下兩個部分：Subject和Observer。Subject負責管理所有的Observer，當Subject的狀態發生改變時，它會通知所有的Observer進行更新。

public interface Subject {
    void attach(Observer observer);
    void detach(Observer observer);
    void notifyObservers();
}
public interface Observer {
    void update(Subject subject);
}
public class ConcreteSubject implements Subject {
    private List observers = new ArrayList();
    private int state;
    public void setState(int state){
        this.state = state;
        notifyObservers();
    }
    public int getState(){
        return state;
    }
    @Override
    public void attach(Observer observer) {
        observers.add(observer);
    }
    @Override
    public void detach(Observer observer) {
        observers.remove(observer);
    }
    @Override
    public void notifyObservers() {
        for(Observer observer:observers){
            observer.update(this);
        }
    }
}
public class ConcreteObserver implements Observer {
    private String name;
    public ConcreteObserver(String name){
        this.name = name;
    }
    @Override
    public void update(Subject subject) {
        System.out.println(name+" has notified");
    }
}

使用示例：

public static void main(String[] args) {
    ConcreteSubject concreteSubject = new ConcreteSubject();
    concreteSubject.attach(new ConcreteObserver("Observer1"));
    concreteSubject.attach(new ConcreteObserver("Observer2"));
    concreteSubject.attach(new ConcreteObserver("Observer3"));
    concreteSubject.setState(1);
}

以上是本文對Java中設計模式的介紹，涉及了單例模式、工廠模式和觀察者模式。這些設計模式都是非常實用的，可以大大提高代碼的可維護性和重用性。讀者可以根據自己的需求選擇合適的設計模式來使用。