学习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中设计模式的介绍，涉及了单例模式、工厂模式和观察者模式。这些设计模式都是非常实用的，可以大大提高代码的可维护性和重用性。读者可以根据自己的需求选择合适的设计模式来使用。