这算是实现了观察者模式吗？

public interface Observer {
    // 监听
    public void update(String msg);
}
public class ObserverImpl implements Observer {


    @Override
    public void update(String msg) {
        System.out.println("观察者发现消息："+msg);
    }
}
public interface Subject {
    /**
     *增加观察者
     */
    public void add(Observer observerVo);
    /**
     *删除观察者
     */
    public void delete(Observer observerVo);
    /**
     *发送观察者消息
     */
    public void notifyObservers(String msg);
}
public class SubjectImpl implements Subject {

    private List<Observer> observerVoList = new ArrayList<>();

    /**
     * 增加观察者
     *
     * @param observerVo
     */
    @Override
    public void add(Observer observerVo) {
        observerVoList.add(observerVo);
    }

    /**
     * 删除观察者
     *
     * @param observerVo
     */
    @Override
    public void delete(Observer observerVo) {
        observerVoList.remove(observerVo);
    }

    /**
     * 发送观察者消息
     *
     * @param msg
     */
    @Override
    public void notifyObservers(String msg) {
        if (observerVoList != null && observerVoList.size()>0){
            for (Observer observerVo: observerVoList){
                observerVo.update(msg);
            }
        }
    }
}
public class ObserverTest {
    @Test
    public void test(){
        Subject subject = new SubjectImpl();
        subject.add(new ObserverImpl());
        subject.add(new ObserverImpl());
        subject.add(new ObserverImpl());
        subject.notifyObservers("更新");
    }
}

大概算是

从类的关系上，勉强算是。
但实际中程序设计中，存在很多问题，或者说有更好的设计方式。
重点，抓住观察者模式的逻辑解决的问题。

观察者作为一个第三人，观察其他人的动作行为，当其中一个人发生某个动作后，观察者负责将这个动作告诉其他人，其他人选择性跟着做对应的动作。

1、从上面的场景来看。第一想到的“其他人”的动作行为可能是一致性，也可能是不一致的，但是抽象来说他们都是“人”。
所以，人抽象类决定人的基本属性和行为，人的动作接口约束其他人都做哪些特定动作。
2、从上面的场景来看，“观察者”做了一件事，检查人的行为动作发生，然后通知其他人，所以这个“观察者”可以说不存于具体的业务行为，仅仅是“观察、通知”两件事。
所以，“观察者”应该是面向“其他人的动作行为”是一种“面向切面的设计模式”，这就需要用到“动态代理”设计模式。

尝试着重新程序设计一次。