Question

美好的一天，

我正在用Java编写自定义事件处理程序。我有一个名为BoogieCarMain.java的类，它实例化一个名为BoogieCar的类型的三个实例。只要三个实例中的任何一个超过某个速度限制，就应该触发一个事件。我目前拥有的代码正在运行，所以这就是我所拥有的：

// BoogieCar.java
import java.util.ArrayList;

public class BoogieCar {

    private boolean isSpeeding = false;

    private int maxSpeed;
    private int currentSpeed;
    private String color;
    BoogieSpeedListener defaultListener;

    public BoogieCar(int max, int cur, String color) {
        this.maxSpeed = max;
        this.currentSpeed = cur;
        this.color = color;
    }

    public synchronized void addSpeedListener(BoogieSpeedListener listener) {
        defaultListener = listener;
    }

    public void speedUp(int increment) {
        currentSpeed += increment;
        if (currentSpeed > maxSpeed) {
            processSpeedEvent(new BoogieSpeedEvent(maxSpeed, currentSpeed, color));
            isSpeeding = true;
        } else {
            isSpeeding = false;
        }
    }

    public boolean getSpeedingStatus() {
        return isSpeeding;
    }

    private void processSpeedEvent(BoogieSpeedEvent speedEvent) {
        defaultListener.speedExceeded(speedEvent);
    }
}

// BoogieCarMain.java
import java.util.ArrayList;

public class BoogieCarMain {

    public static void main(String[] args) {
        BoogieCar myCar = new BoogieCar(60, 50, "green");
        BoogieCar myCar2 = new BoogieCar(75, 60, "blue");
        BoogieCar myCar3 = new BoogieCar(65, 25, "pink");

        BoogieSpeedListener listener = new MySpeedListener();

        myCar.addSpeedListener(listener);
        myCar2.addSpeedListener(listener);
        myCar3.addSpeedListener(listener);

        myCar.speedUp(50); // fires SpeedEvent
        System.out.println(myCar.getSpeedingStatus());

        myCar2.speedUp(20);
        System.out.println(myCar2.getSpeedingStatus());

        myCar3.speedUp(39);
        System.out.println(myCar3.getSpeedingStatus());
    }
}

// BoogieSpeedListener.java
public interface BoogieSpeedListener { // extends java.util.EventListener 
    public void speedExceeded(BoogieSpeedEvent e);
}

// MySpeedListener.java
public class MySpeedListener implements BoogieSpeedListener {
    @Override
    public void speedExceeded(BoogieSpeedEvent e) {
        if (e.getCurrentSpeed() > e.getMaxSpeed()) {
        System.out.println("Alert!  The " + e.getColor() + " car exceeded the max speed: " + e.getMaxSpeed() + " MPH.");
        }
    }
}

// BoogieSpeedEvent.java
public class BoogieSpeedEvent { // extends java.util.EventObject

    private int maxSpeed;
    private int currentSpeed;
    private String color;

    public BoogieSpeedEvent(int maxSpeed, int currentSpeed, String color) {
        // public SpeedEvent(Object source, int maxSpeed, int minSpeed, int currentSpeed) {
        // super(source);
        this.maxSpeed = maxSpeed;
        this.currentSpeed = currentSpeed;
        this.color = color;
    }

    public int getMaxSpeed() {
        return maxSpeed;
    }

    public int getCurrentSpeed() {
        return currentSpeed;
    }

    public String getColor() {
        return color;
    }
}

我的问题是：虽然这段代码有效，但我希望BoogieCar类型能够直接通知BoogieCarMain，而不必使用＆＃34; poll＆＃34;必须调用getSpeedingStatus（）方法的BoogieCar类型。

换句话说，也许在BoogieCarMain.java中定义一个变量，当三辆汽车中的一辆超过其预定的速度限制时，该变量会发生变化。是否可以让BoogieCar类型设置变量？

有更简洁的方法吗？

TIA，

coson

Answer 1

回调是这种情况的理想选择。

// BoogieCarMain provides a sink for event-related information
public void handleSpeeding(BoogieCar car) {
  System.out.println(car.getSpeedingStatus());
}

// MySpeedListener knows about an object that wants event-related information.
// I've used the constructor but an addEventSink method or similar is probably better.
public MySpeedListener(BoogieCarMain eventSink) {
  this.eventSink = eventSink;
}

// MySpeedListener handles events, including informing objects that want related information.
// You decide if the event is an appropriate type for the sink to know about.
// Often it isn't, and instead your listener should pull the relevant info out of the event and pass it to the sink.
public void speedExceeded(BoogieSpeedEvent e) {
  if (e.getCurrentSpeed() > e.getMaxSpeed()) {
    // I've taken the liberty of adding the event source as a member of the event.
    eventSink.handleSpeeding(e.getCar());
  }
}

Java自定义事件处理

1 个答案: