希望在java中使用回调将项插入arraylist时发出通知吗

我对java中的回调方法实现非常感兴趣。我通过了 网上有一些例子，但我仍然没有太多的信心来解决这个问题。 我的问题是我的程序必须在项目插入时发出消息通知 带有回调方法实现的列表。我怎样才能解决这个问题请帮忙

---

谢谢

扩展您使用的list类（或自己实现list接口）。定义回调接口，例如仅使用一种方法的AddListCallback

void itemAdded(Object item)

在列表的构造函数中，传递回调接口实现并将其存储在字段中。覆盖

void add(int index, E element);

列表接口的方法（如有必要，可以使用更多的方法）。调用

super.add（index，element）

，然后调用

storedCallback.itemsadded（element）

，以调用回调的方法

---

更新：您可以使用基于AOP的方法，例如查看并侦听add（）方法调用，但这似乎是更困难的方法。

扩展您使用的列表类（或自己实现列表接口）。定义回调接口，例如仅使用一种方法的AddListCallback

void itemAdded(Object item)

在列表的构造函数中，传递回调接口实现并将其存储在字段中。覆盖

void add(int index, E element);

列表接口的方法（如有必要，可以使用更多的方法）。调用

super.add（index，element）

，然后调用

storedCallback.itemsadded（element）

，以调用回调的方法

更新：您可以使用基于AOP的方法，例如查看并侦听add（）方法调用，但这似乎是一种更困难的方法。

执行类似的操作

public class MyList extends ArrayList{
public boolean add(Object o){
    boolean b = super.add(o);
    callBack();
    return b;
}

public static void main(String[] args){
    List myList = new MyList();
    myList.add("abc");
    System.out.println(myList);
}

public void callBack(){
    //Operation to do in callback
    System.out.println("in callback");
}

}

您需要扩展要使用的列表实现器类，然后覆盖add方法

public class MyList extends ArrayList{
public boolean add(Object o){
    boolean b = super.add(o);
    callBack();
    return b;
}

public static void main(String[] args){
    List myList = new MyList();
    myList.add("abc");
    System.out.println(myList);
}

public void callBack(){
    //Operation to do in callback
    System.out.println("in callback");
}

}

---

您需要扩展要使用的列表实现器类，然后重写Add方法。

< P>您应该考虑创建一个列表装饰器（设计模式），它只允许在现有代码中更改一行就可以通知每个<代码>列表<代码>实现。

这是总体思路：

public interface ListListener<E> {
    void onAdd(List list, E element);
    void onDelete(List list, E element);
    ...
}

public class EventfulList<E> implements List {
    private List<E> decoratedList;
    private ListListener<E> listener;

    public EventfulList(final List targetList) {
        decoratedList = targetList;
    }

    public void setListener(final ListListener<E> listener) {
        this.listener = listener;
    }

    public boolean add(E element) {
        final boolean result = decoratedList.add(element);
        doOnAdd(element);
        return result;
    }

    public void doOnAdd(final E element) {
        if (listener != null) {
            listener.onAdd(this, element);
        }
    }
}

公共接口ListListener{
无效onAdd（列表，E元素）；
void onDelete（列表，E元素）；
...
}
公共类EventfulList实现列表{
私有列表修饰列表；
私有列表侦听器；
公共事件列表（最终列表目标列表）{
装饰列表=目标列表；
}
public void setListener（最终ListListener侦听器）{
this.listener=listener；
}
公共布尔加法（E元素）{
最终布尔结果=decoratedList.add（元素）；
杜纳德（元素）；
返回结果；
}
公共无效数据（最终E元素）{
if（侦听器！=null）{
onAdd（this，元素）；
}
}
}

您可以这样使用它：

public class ListEventsDemo {
    public static void main(String[] args) {
        // Assume this is existing code.
        List<String> list1 = new ArrayList<String>();
        List<String> list2 = new LinkedList<String>();

        // This is new code.
        ListListener<String> listener = new ListListener<String>() {
            public void onAdd(List list, E element) {
                System.out.println(String.format("'%s' added to %s.",
                    element.toString(), list.getClass().getName()));
            }

            public void onDelete(List list, E element) {
                System.out.println(String.format("'%s' removed from %s.",
                    element.toString(), list.getClass().getName()));
            }
        }

        list1 = new EventfulList<String>(list1);
        list2 = new EventfulList<String>(list2);
        ((EventfulList) list1).setListener(listener);
        ((EventfulList) list2).setListener(listener);

        // Existing code again.
        list1.add("123");
        list2.add("abc");
    }
}

public类listentsdemo{
公共静态void main（字符串[]args）{
//假设这是现有代码。
List list1=新的ArrayList（）；
List list2=新链接列表（）；
//这是新代码。
ListListener=新建ListListener（）{
公共无效onAdd（列表，E元素）{
System.out.println（String.format（“%s”添加到%s.”，
元素.toString（），list.getClass（）.getName（））；
}
公共void onDelete（列表，E元素）{
System.out.println（String.format（“%s”从%s中删除），
元素.toString（），list.getClass（）.getName（））；
}
}
list1=新事件列表（list1）；
list2=新事件列表（list2）；
（（eventfulllist）list1.setListener（listener）；
（（eventfulllist）list2.setListener（listener）；
//再次修改现有代码。
清单1.添加（“123”）；
清单2.添加（“abc”）；
}
}

---

它可能看起来像是一个过多的杀戮，但它需要对现有代码进行更少的更改，并且不需要对每个<代码>列表实现进行子类监视。

< P>您应该考虑创建列表装饰器（设计模式）。这将允许您只更改现有代码中的一行，就可以收到每个

列表
实现的通知

这是总体思路：

public interface ListListener<E> {
    void onAdd(List list, E element);
    void onDelete(List list, E element);
    ...
}

public class EventfulList<E> implements List {
    private List<E> decoratedList;
    private ListListener<E> listener;

    public EventfulList(final List targetList) {
        decoratedList = targetList;
    }

    public void setListener(final ListListener<E> listener) {
        this.listener = listener;
    }

    public boolean add(E element) {
        final boolean result = decoratedList.add(element);
        doOnAdd(element);
        return result;
    }

    public void doOnAdd(final E element) {
        if (listener != null) {
            listener.onAdd(this, element);
        }
    }
}

公共接口ListListener{
无效onAdd（列表，E元素）；
void onDelete（列表，E元素）；
...
}
公共类EventfulList实现列表{
私有列表修饰列表；
私有列表侦听器；
公共事件列表（最终列表目标列表）{
装饰列表=目标列表；
}
public void setListener（最终ListListener侦听器）{
this.listener=listener；
}
公共布尔加法（E元素）{
最终布尔结果=decoratedList.add（元素）；
杜纳德（元素）；
返回结果；
}
公共无效数据（最终E元素）{
if（侦听器！=null）{
onAdd（this，元素）；
}
}
}

您可以这样使用它：

public class ListEventsDemo {
    public static void main(String[] args) {
        // Assume this is existing code.
        List<String> list1 = new ArrayList<String>();
        List<String> list2 = new LinkedList<String>();

        // This is new code.
        ListListener<String> listener = new ListListener<String>() {
            public void onAdd(List list, E element) {
                System.out.println(String.format("'%s' added to %s.",
                    element.toString(), list.getClass().getName()));
            }

            public void onDelete(List list, E element) {
                System.out.println(String.format("'%s' removed from %s.",
                    element.toString(), list.getClass().getName()));
            }
        }

        list1 = new EventfulList<String>(list1);
        list2 = new EventfulList<String>(list2);
        ((EventfulList) list1).setListener(listener);
        ((EventfulList) list2).setListener(listener);

        // Existing code again.
        list1.add("123");
        list2.add("abc");
    }
}

public类listentsdemo{
公共静态void main（字符串[]args）{
//假设这是现有代码。
List list1=新的ArrayList（）；
List list2=新链接列表（）；
//这是新代码。
ListListener=新建ListListener（）{
公共无效onAdd（列表，E元素）{
System.out.println（String.format（“%s”添加到%s.”，
元素.toString（），list.getClass（）.getName（））；
}
公共void onDelete（列表，E元素）{
System.out.println（String.format（“%s”从%s中删除），
元素.toString（），list.getClass（）.getName（））；
}
}
list1=新事件列表（list1）；
list2=新事件列表（list2）；
（（eventfulllist）list1.setListener（listener）；
（（eventfulllist）list2）.setL