Skip to content
TheChatArchiveThe Chat Archive
gpt-3.5-turbo-0301· openaiHugging Face Suzhen/CodeChat

使用观察者模式又未使用的JAVA代码区别,请举例

  1. User

    使用观察者模式又未使用的JAVA代码区别,请举例

  2. Assistant

    使用观察者模式的JAVA代码:

    
    //定义被观察者类
    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(String message){
            for(Observer observer:observers){
                observer.update(message);
            }
        }
    }
    
    //定义观察者接口
    public interface Observer {
        void update(String message);
    }
    
    //定义具体的观察者类
    public class ConcreteObserver implements Observer{
        @Override
        public void update(String message) {
            System.out.println(message);
        }
    }
    
    //测试代码
    public static void main(String[] args) {
        Subject subject = new Subject();
        ConcreteObserver observer1 = new ConcreteObserver();
        ConcreteObserver observer2 = new ConcreteObserver();
        subject.addObserver(observer1);
        subject.addObserver(observer2);
        subject.notifyObservers("Hello World");
    }
    
    

    未使用观察者模式的JAVA代码:

    
    //定义一个类
    public class MyClass {
        public void doSomething(){
            System.out.println("doSomething");
        }
    }
    
    //测试代码
    public static void main(String[] args) {
        MyClass myClass = new MyClass();
        myClass.doSomething();
    }
    
    

    两段代码的区别在于,第一段代码中定义了被观察者类、观察者接口和具体的观察者类,实现了观察者模式。当一个对象发生变化时,它会通知它的所有观察者,观察者可根据通知内容来做出相应的处理。

    而第二段代码没有定义观察者模式,只是定义了一个简单的类,在主函数中直接调用这个类的方法执行操作。它没有与其他对象进行交互,也没有通知其他对象发生了什么事情,所以无法实现观察者模式的效果。

  3. User

    可以具体点吗

  4. Assistant

    好的,我来更具体地举例:

    使用观察者模式的JAVA代码:

    考虑一个简单的需求:当某人发表了新的微博,他的所有粉丝都要收到一条通知。这里需要用到观察者模式。

    import java.util.ArrayList;
    import java.util.List;
    
    // 定义被观察者类:微博用户。
    public class WeiboUser {
        private String name;
        private List<Fan> fans;
    
        public WeiboUser(String name) {
            this.name = name;
            this.fans = new ArrayList<>();
        }
    
        // 添加新的粉丝。
        public void addFan(Fan fan) {
            fans.add(fan);
        }
    
        // 删除粉丝。
        public void removeFan(Fan fan) {
            fans.remove(fan);
        }
    
        // 发布新微博。
        public void publishWeibo(String content) {
            System.out.println(name + " 发表了新微博:\"" + content + "\"");
            notifyFans(content);
        }
    
        // 通知所有粉丝新微博的发布。
        private void notifyFans(String content) {
            for (Fan fan : fans) {
                fan.receiveNotification(name, content);
            }
        }
    }
    
    // 定义观察者接口:粉丝。
    public interface Fan {
        void receiveNotification(String name, String content);
    }
    
    // 定义具体的观察者类:普通粉丝。
    public class OrdinaryFan implements Fan {
        private String name;
    
        public OrdinaryFan(String name) {
            this.name = name;
        }
    
        @Override
        public void receiveNotification(String name, String content) {
            System.out.println(this.name + " 收到了 @" + name + " 发表的新微博:\"" + content + "\"");
        }
    }
    
    // 测试代码。
    public static void main(String[] args) {
        WeiboUser user = new WeiboUser("Mary");
        Fan fan1 = new OrdinaryFan("Alice");
        Fan fan2 = new OrdinaryFan("Bob");
    
        // 关注 Mary。
        user.addFan(fan1);
        user.addFan(fan2);
    
        // Mary 发布新微博。
        user.publishWeibo("今天天气真好!");
    }
    

    这段代码中,WeiboUser 类是被观察者类,Fan 接口是观察者接口,OrdinaryFan 类是具体的观察者类。当 Mary 发布新微博时,它会通知它的所有粉丝收到新微博的通知。

    未使用观察者模式的JAVA代码:

    我们仍然考虑前面的需求:当某人发表了新的微博,他的所有粉丝都要收到一条通知。

    // 定义微博用户类。
    public class WeiboUser {
        private String name;
        private List<String> fanNames;
    
        public WeiboUser(String name) {
            this.name = name;
            this.fanNames = new ArrayList<>();
        }
    
        public String getName() {
            return name;
        }
    
        public void addFan(String fanName) {
            fanNames.add(fanName);
        }
    
        public void removeFan(String fanName) {
            fanNames.remove(fanName);
        }
    
        public void publishWeibo(String content) {
            System.out.println(name + " 发表了新微博:\"" + content + "\"");
            notifyFans(content);
        }
    
        private void notifyFans(String content) {
            for (String fanName : fanNames) {
                System.out.println(fanName + " 收到了 @" + name + " 发表的新微博:\"" + content + "\"");
            }
        }
    }
    
    // 测试代码。
    public static void main(String[] args) {
        WeiboUser user = new WeiboUser("Mary");
        user.addFan("Alice");
        user.addFan("Bob");
    
        user.publishWeibo("今天天气真好!");
    }
    

    这段代码中,WeiboUser 类代表微博用户,它有一个 fanNames 列表来保存它的所有粉丝名字。当 Mary 发布新微博时,它会遍历 fanNames 列表,给每个粉丝发送新微博的通知。但这种做法不够灵活,还需要不断地维护 fanNames 列表,繁琐且易出错。这种做法不能很好地应对变化和扩展,因此不适合大规模的系统。

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.