迭代方法

Question

我在使用for循环时遇到了一些麻烦。我不确定我是否正确设置了这种方法。

以下是它要求我做的事情

迭代subscriber数组中的所有元素。你应该使用更简单的版本 执行此操作的for循环。循环内部：如果元素不等于null，则调用 该订户的notify方法。当你调用那个方法时，你需要给它一个 Message参数：使用与此方法相同的Message。 请注意，您在notify方法中，并且您正在调用notify方法 再次。但是，这不是递归，因为您正在调用的通知方法是在 完全不同的ISubscriber实例。

package message;

public class Broadcaster implements IPublisher, ISubscriber {
    private Object [] members;
    private int i = 0;

    Broadcaster(int a) {
        a = 4;
        Object[] array = new Object[a];  
        members = array;    
    }

    @Override
    public void subscribe(ISubscriber subscriber) {
        members[i] = subscriber;       
        i++;   
    }

    @Override
    public void unsubscribe(ISubscriber subscriber) {
    }

    @Override
    public void notify(Message msg) {
    }
}

Answer 1

通常你不会为此使用数组，而是动态的。例如一个LinkedList

import java.util.LinkedList;
public class Broadcaster
{
    LinkedList<ISubscriber> subscribers = new LinkedList<ISubscriber>();

    public void subscribe(ISubscriber addMe)
    {
        if(addMe!= null)
        {
            if(! subscribers.contains(addMe))
            {
                this.subscribers.add(addMe);
            }
        }
    }

    public void unsubscribe(ISubscriber removeMe)
    {
        if(removeMe!= null)
        {
            this.subscribers.remove(removeMe);
        }
    }

    public void notifySubscribers() //this is called notify in your code
    {
        for(ISubscriber current : subscribers)
        {
            if(current != null)
            {
                current.beNotified(new Message());
            }
        }
    }
}

interface ISubscriber
{

    void beNotified(Message msg);    //also called notify for you; if possible avoid
}

如果你被迫使用数组，你可以得到这样的结果：

public class Broadcaster
{
    int maxsubscribers = 4;
    ISubscriber[] subscribers = new ISubscriber[maxsubscribers];

    public void subscribe(ISubscriber addMe)
    {
        if(addMe != null)
        {
            for(int i = 0; i <maxsubscribers;i++)
            {
                if(subscribers[i] != null)
                {
                    if(subscribers[i].equals(addMe))
                    {
                        return; //already in array; not adding 
                    }
                }
            }

            for(int i = 0; i <maxsubscribers;i++)
            {
                if(subscribers[i] == null)
                {
                    subscribers[i] = addMe;
                }
            }
        }
    }

    public void unsubscribe(ISubscriber removeMe)
    {
        if(removeMe != null)
        {
            for(int i = 0; i <maxsubscribers;i++)
            {
                if(subscribers[i].equals(removeMe))
                {
                    subscribers[i] = null;
                }
            }
        }
    }

    public void notifySubscribers() //this is called notify in your code
    {
        for(ISubscriber current : subscribers)
        {
            if(current != null)
            {
                current.beNotified(new Message());
            }
        }
    }
}

使用数组的缺点是，您只能存储一定数量的元素，或者只要用完空闲插槽就必须更改数组的大小。

正如您所看到的那样，避免将订阅者添加两次到阵列也有点困难。它需要一个加法循环来检查这个，而LinkedList为这个检查提供了一个方便的方法。

最后但并非最不重要：尽管可能有一个notify()和notify(Message msg)方法完全不同，但这不是一个好习惯，因为它很容易导致功能混淆。