JAVA写一个程序包含三种设计模式并使用MVC体系结构

好的，我可以给您提供一个简单的示例。

在这个示例中，我们将使用三种设计模式：工厂模式、观察者模式和代理模式。我们将使用MVC（Model-View-Controller）体系结构来组织我们的代码。

首先，我们定义一个接口，表示我们的模型：

public interface Model {
    void doSomething();
}

然后，我们实现这个接口的两个类：

public class ModelImplA implements Model {
    @Override
    public void doSomething() {
        System.out.println("Model A is doing something.");
    }
}

public class ModelImplB implements Model {
    @Override
    public void doSomething() {
        System.out.println("Model B is doing something.");
    }
}

接下来，我们定义一个工厂类，用于创建模型实例：

public class ModelFactory {
    public static Model createModel(String type) {
        switch (type) {
            case "A":
                return new ModelImplA();
            case "B":
                return new ModelImplB();
            default:
                throw new IllegalArgumentException("Unknown model type: " + type);
        }
    }
}

现在，我们可以在控制器中使用工厂类来创建模型实例：

public class Controller {
    private Model model;

    public Controller(String modelType) {
        this.model = ModelFactory.createModel(modelType);
    }

    public void doSomething() {
        model.doSomething();
    }
}

接下来，我们定义一个观察者接口：

public interface Observer {
    void update();
}

然后，我们定义一个主题类，用于管理观察者：

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

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

    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

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

现在，我们可以在模型中使用主题类来通知观察者：

public class ModelImplA implements Model {
    private Subject subject = new Subject();

    @Override
    public void doSomething() {
        System.out.println("Model A is doing something.");
        subject.notifyObservers();
    }

    public void addObserver(Observer observer) {
        subject.addObserver(observer);
    }

    public void removeObserver(Observer observer) {
        subject.removeObserver(observer);
    }
}

最后，我们定义一个代理类，用于控制对模型的访问：

public class ModelProxy implements Model {
    private Model model;
    private List<Observer> observers = new ArrayList<>();

    public ModelProxy(String modelType) {
        this.model = ModelFactory.createModel(modelType);
        if (model instanceof ModelImplA) {
            ((ModelImplA) model).addObserver(() -> notifyObservers());
        }
    }

    @Override
    public void doSomething() {
        model.doSomething();
    }

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

    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

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

现在，我们可以在视图中使用代理类来访问模型：

public class View {
    private Controller controller;

    public View(String modelType) {
        this.controller = new Controller(modelType);
    }

    public void doSomething() {
        controller.doSomething();
    }
}

这样，我们就使用了工厂模式、观察者模式和代理模式，并使用MVC体系结构组织了我们的代码。