State Design Pattern: 在使用entry()和exit()时如何避免代码重复？

huangapple
go评论112阅读模式
英文:

State Design Pattern: How to avoid code duplication when using entry() and exit()?

问题

Situation: 我的状态类(State)具有需要在状态转换时调用的entry()和exit()方法。为确保这一点，我在State类中使用了一个changeState()方法，其中包含必要的过程。它由上下文(Context)在涉及状态机的操作时每次调用。然而，问题在于，每次添加新方法时，我都需要调用state.changeState()，我确信有一种方法可以避免这种代码重复。以下是进一步说明的代码：

  1. class Context {
  2.     State state;
  4.     void method1() {
  5.         state.method1();
  6.         state.changeState();
  7.     }
  9.     void method2() {
  10.         state.method2();
  11.         state.changeState(); // 代码重复！
  12.     }
  14.     // 其他方法
  15. }
  17. abstract class State {
  18.     Context context;
  19.     State next;
  21.     void changeState() {
  22.         this.exit();
  23.         next.entry();
  24.         context.setState(next);
  25.     }
  27.     // 其他必要的方法
  28. }
  30. class ConcreteState extends State {
  31.     void method1() {
  32.         // 做一些事情
  33.         next = AnotherConcreteState;
  34.     }
  36.     void entry() {/* 做一些事情 */}
  37.     void exit() {/* 做一些事情 */}
  38. }
  40. 如果我想在Context中添加额外的方法，有什么方法可以避免在新方法中每次调用state.changeState()时出现代码重复？
英文:

Situation: My States have an entry() and exit() method that needs to be called every time when a State transitions. To ensure that, I used a changeState() method in State that contains the necessary procedure. It is called by the Context every time it uses an operation involving the state machine. The problem however, is that I need to call state.changeState() every time when I add a new method and I'm sure there's a way to avoid that code duplication. Below is code for further clarification

  1. class Context {
  2.     State state;
  4.     void method1() {
  5.         state.method1();
  6.         state.changeState();
  7.     }
  9.     void method2() {
  10.         state.method2();
  11.         state.changeState(); // Code duplication!!
  12. }
  14. abstract class State {
  15.     Context context;
  16.     State next;
  18.     void changeState() {
  19.         this.exit();
  20.         next.entry();
  21.         context.setState(next);
  22.     }
  23.     // other necessary methods
  24. }
  26. class ConcreteState extends State {
  27.     void method1() {
  28.         // do something
  29.         next = AnotherConcreteState;
  30.     }
  31.     void entry() {/*do something */};
  32.     void exit() {/*do something */};
  33. }

If I want to add additional methods in Context, what can I do to avoid code duplication of calling state.changeState() every time inside the new methods?

答案1

得分: 2

你已经非常接近了。changeState 方法应该属于 Context 类，而不是 State 类。这里有一篇关于这个主题的好文章。请注意，类图中显示 changeState 在 Document（上下文）类中。

为了使代码更清晰，changeState 可以接受 next 状态作为参数，像这样：

  1. class Context {
  2.   State state;
  4.   void method1() {
  5.     state.method1();
  6.   }
  8.   void changeState(next) {
  9.     state.exit();
  10.     this.state = next;
  11.     state.enter();
  12.   }
  13. }
  15. abstract class State {
  16.   Context context;
  18.   // 其他方法
  19. }
  21. class ConcreteState extends State {
  22.   void method1() {
  23.     // 做一些事情
  24.     context.changeState(AnotherConcreteState);
  25.   }
  27.   void enter() { /* 做一些事情 */ }
  28.   void exit() { /* 做一些事情 */ }
  29. }

现在，当你向 Context 添加更多方法时，不会在 Context 中出现重复。它将如下所示：

  1. class Context {
  2.   State state;
  4.   void method1() {
  5.     state.method1();
  6.   }
  8.   void method2() {
  9.     state.method2();
  10.   }
  12.   void changeState(next) {
  13.     state.exit();
  14.     this.state = next;
  15.     state.enter();
  16.   }
  17. }
  19. abstract class State {
  20.   Context context;
  22.   // 其他方法
  23. }
  25. class ConcreteState extends State {
  26.   void method1() {
  27.     // 做一些事情
  28.     context.changeState(AnotherConcreteState);
  29.   }
  31.   void method2() {
  32.     // 做一些其他事情
  33.     context.changeState(YetAnotherConcreteState);
  34.   }
  36.   void enter() { /* 做一些事情 */ }
  37.   void exit() { /* 做一些事情 */ }
  38. }
英文:

You are very close. The changeState method belongs in the Context class, not the State class. Here's a good article on the topic. Note that the class diagram shows changeState in the Document (context) class.

To make it even cleaner, changeState could take the next state as a parameter. Like this:

  1. class Context {
  2.   State state;
  4.   void method1() {
  5.     state.method1();
  6.   }
  8.   void changeState(next) {
  9.     state.exit();
  10.     this.state = next;
  11.     state.enter();
  12.   }
  13. }
  15. abstract class State {
  16.   Context context;
  18.   // other methods
  19. }
  21. class ConcreteState extends State {
  22.   void method1() {
  23.     // do something
  24.     context.changeState(AnotherConcreteState);
  25.   }
  27.   void enter() { /* do something */ }
  28.   void exit() { /* do something */ }
  29. }

Now, as you add more methods to Context, there is no duplication in Context. It'd look like this:

  1. class Context {
  2.   State state;
  4.   void method1() {
  5.     state.method1();
  6.   }
  8.   void method2() {
  9.     state.method2();
  10.   }
  12.   void changeState(next) {
  13.     state.exit();
  14.     this.state = next;
  15.     state.enter();
  16.   }
  17. }
  19. abstract class State {
  20.   Context context;
  22.   // other methods
  23. }
  25. class ConcreteState extends State {
  26.   void method1() {
  27.     // do something
  28.     context.changeState(AnotherConcreteState);
  29.   }
  31.   void method2() {
  32.     // do something else
  33.     context.changeState(YetAnotherConcreteState);
  34.   }
  36.   void enter() { /* do something */ }
  37.   void exit() { /* do something */ }
  38. }

huangapple
  • 本文由 发表于 2020年8月4日 19:03:46
  • 转载请务必保留本文链接：https://go.coder-hub.com/63245531.html
  • code-duplication
  • design-patterns
  • java
  • state-pattern
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定