设计模式Java代码实现

我作为AI语言模型只能提供一些基础的模式代码示例，具体实现需要根据具体场景和需求来编写。

1. 工厂模式（Factory Pattern）

interface Product {
void operation();
}

class ConcreteProductA implements Product {
@Override
public void operation() {
System.out.println("ConcreteProductA's operation");
}
}

class ConcreteProductB implements Product {
@Override
public void operation() {
System.out.println("ConcreteProductB's operation");
}
}

class Factory {
public static Product createProduct(String productName) {
switch (productName) {
case "A":
return new ConcreteProductA();
case "B":
return new ConcreteProductB();
default:
return null;
}
}
}

class Client {
public static void main(String[] args) {
Product productA = Factory.createProduct("A");
Product productB = Factory.createProduct("B");
if (productA != null) {
productA.operation();
}
if (productB != null) {
productB.operation();
}
}
}

2. 单例模式（Singleton Pattern）

class Singleton {
private static Singleton instance;

private Singleton() {}

public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}

class Client {
public static void main(String[] args) {
Singleton singleton = Singleton.getInstance();
}
}

3. 适配器模式（Adapter Pattern）

interface Target {
void request();
}

class Adaptee {
public void specificRequest() {
System.out.println("Adaptee's specificRequest");
}
}

class Adapter implements Target {
private Adaptee adaptee;

public Adapter(Adaptee adaptee) {
this.adaptee = adaptee;
}

@Override
public void request() {
adaptee.specificRequest();
}
}

class Client {
public static void main(String[] args) {
Adaptee adaptee = new Adaptee();
Target target = new Adapter(adaptee);
target.request();
}
}

4. 观察者模式（Observer Pattern）

interface Observer {
void update();
}

class ConcreteObserver implements Observer {
@Override
public void update() {
System.out.println("ConcreteObserver's update");
}
}

interface Subject {
void attachObserver(Observer observer);

void detachObserver(Observer observer);

void notifyObserver();
}

class ConcreteSubject implements Subject {
private List<Observer> observerList = new ArrayList<>();

@Override
public void attachObserver(Observer observer) {
observerList.add(observer);
}

@Override
public void detachObserver(Observer observer) {
observerList.remove(observer);
}

@Override
public void notifyObserver() {
for (Observer observer : observerList) {
observer.update();
}
}
}

class Client {
public static void main(String[] args) {
Subject subject = new ConcreteSubject();
Observer observer = new ConcreteObserver();
subject.attachObserver(observer);
subject.notifyObserver();
}
}

这里提供的都是比较基础的设计模式，还有很多其他的设计模式，需要根据实际场景选择合适的模式。同时，在实际使用时，还需要考虑线程安全性、可维护性等实际问题。