这是一个实现的草图。
1.您可以将每个状态建模为单独的类：
第一个
1.然后，在Actor中，您可以为A和B定义接收函数，并将其初始化为A或B，具体取决于哪一个是初始值

private static class MyActor extends AbstractActor
  {
    private AbstractActor.Receive receive4StateA(StateA stateA)
    {
      return new ReceiveBuilder()
        .matchEquals("a", msg -> stateA.setSomeProperty(msg))
        .matchEquals("changeToB", msg -> getContext().become(
          receive4StateB(StateB.fromStateA(stateA))))
        .build();
    }

    private AbstractActor.Receive receive4StateB(StateB stateB)
    {
      return new ReceiveBuilder()
        .matchEquals("b", msg -> stateB.setSomeProperty(msg))
        .matchEquals("changeToA", msg -> getContext().become(
          receive4StateA(StateA.fromStateB(stateB))))
        .build();
    }

    //assuming stateA is the initial state
    @Override
    public AbstractActor.Receive createReceive()
    {
      return receive4StateA(StateA.fromBase(new BaseState()));
    }
  }

诚然，我的Java是生疏的，但举个例子，这个演员（或者非常类似的东西......）将接收字符串，直到它接收到一个Lock消息，之后可以查询它在被锁定之前接收到了多少个不同的字符串。它跟踪接收到的字符串的Set以执行重复数据删除。在Lock上，它转换到不包含Set的第二个Receive（仅Integer字段），并忽略String和Lock消息。

import akka.japi.JavaPartialFunction;
import java.util.HashSet;
import scala.runtime.BoxedUnit;

public class StringCounter extends AbstractActor {
  public StringCounter() {}

  public static class Lock {
    private Lock() {}
    public static final Lock INSTANCE = new Lock();
  }

  public static class Query {
    private Query() {}
    public static final Query INSTANCE = new Query();
  }

  /**The taking in Strings state */
  public class AcceptingStrings extends JavaPartialFunction<Object, BoxedUnit> {
    private HashSet<String> strings;

    public AcceptingStrings() {
      strings = new HashSet<String>();
    }

    public BoxedUnit apply(Object msg, boolean isCheck) {
      if (msg instanceof String) {
        if (!isCheck) {
          strings.add(msg);
        }
      } else if (msg instanceof Lock) {
        if (!isCheck) {
          context().become(new Queryable(strings.size()), true);
        }
      } else {
        // not handling any other message
        throw noMatch();
      }

      return BoxedUnit.UNIT;
    }
  }

  /**The responding to queries state */
  public class Queryable extends JavaPartialFunction<Object, BoxedUnit> {
    private Integer ans;

    public Queryable(int answer) {
      ans = Integer.valueOf(answer);
    }

    public BoxedUnit apply(Object msg, boolean isCheck) {
      if (msg instanceof Query) {
        if (!isCheck) {
          getSender().tell(ans, getSelf());
        }
      } else {
        // not handling any other message
        throw noMatch();
      }

      return BoxedUnit.UNIT;
    }
  }

  @Override
  public Receive createReceive() {
    return new Receive(new AcceptingStrings());
  }
}

注意，在Queryable中，set已经消失了。需要注意的一点是，JavaPartialFunction通常会在isCheck设置为true时调用apply一次，如果该调用没有抛出noMatch()返回的异常，它将被再次“for真实的”调用，并且isCheck被设置为false。因此，您需要注意，在isCheck为true的情况下，除了throw noMatch()或返回之外，不要执行任何操作。
这种模式与Akka Typed（尤其是函数API）中的情况非常相似。
希望这能阐明这种方法，当然，你的老师也有可能不接受这一点，尽管在这种情况下，可能值得用下面的论点来反驳：

• 在参与者模型中，状态和行为实际上是同一件事
• 所有功能 * 都 * 包含在AbstractActor中

我也不一定推荐在JavaAkka代码中使用这种方法（字段中带有state的AbstractActor更像是Java-y）。