如何在Kotlin中实现Memento模式

Question

我目前正在尝试在Kotlin中实现一些设计模式作为练习，并且我有点卡住了'Memento'模式。我的参考资源是SourceMaking: Memento。

我想要实现这样的结构：

虽然跟随他们的 “清单”

1. 确定“看守”和“鼻祖”的角色。
2. 创建纪念品课程并将创建者声明为朋友。
3. 看守人知道什么时候“检查点”发端人。
4. 发起人创建一个纪念品并将其状态复制到该纪念品。
5. 看守持有（但不能偷看）纪念品。
6. 看守人知道何时“回滚”发起人。
7. 发起人使用Memento中保存的状态恢复自己。

我无法获得第5步的工作。如何制作一个Memento对象，其字段可以从Originator实例中读取，但对Caretaker完全不透明？

我已经成功地在Java中实现这个如下：

public class Originator { 

    private final int id; 
    private String title; 
    private String description; 

    public Originator(int id) { 
     this.id = id; 
    } 

    /* skipping title and description getter & setter */ 

    public Memento saveState() { 
     return new Memento(new State(id, title, description)); 
    } 

    public void restore(Memento memento) { 
     id = memento.state.id; 
     title = memento.state.title; 
     description = memento.state.description; 
    } 

    private class State { 

     private final int id; 
     private final String title; 
     private final String description; 

     public State(int id, String title, String description) { 
      this.id = id; 
      this.title = title; 
      this.description = description; 
     } 
    } 

    public class Memento { 

     private final State state; 

     public Memento(State state) { 
      this.state = state; 
     } 
    } 
} 

而且看守

public class Caretaker { 

    public Originator originator; 

    public Caretaker(@NotNull Originator originator) { 
     this.originator = originator; 
    } 

    public Originator.Memento save() { 
     return originator.saveState(); 
    } 

    public void restore(@NotNull Originator.Memento memento) { 
     originator.restoreFromState(memento); 
    } 
} 

因为他们是内部类，我可以从我的Originator例如读取Memento和State私人领域，但是对于Caretaker我的Memento实例是完全不透明的（仅显示Object的成员函数）。

现在我该如何在Kotlin中实现这种确切的行为？基本上我缺少阅读内部类的私人领域的功能。

我能想到的最接近的事是这样的：

class Originator(id: Long) { 

    private var id: Long = id 
    var description: String = "" 
    var title: String = "" 

    fun saveState() = Memento(State(id, title, description)) 

    fun restoreState(memento: Memento) { 
     id = memento.state.id // <-- cannot access 'state': it is private in 'Memento' 
     title = memento.state.title // <-- cannot access 'state': it is private in 'Memento' 
     description = memento.state.description // <-- cannot access 'state': it is private in 'Memento' 
    } 

    inner class State(private val id: Long, 
        private val title: String, 
        private val description: String) 

    inner class Memento(private val state: State) 
} 

这有Memento是完全不透明的，以我的Caretaker实例的预期效果，但我不能读Originator中的字段无论是。
这段代码顺便说一下，与我的Java代码中使用IntelliJ的'Convert Java to Kotlin'特性生成的生成代码几乎完全一样（它显然不能编译）。

那么有什么明显的（或神奇的）我在这里失踪？也许是类图中显示的结构以外的东西？或者，这些确切的规格是不是可以在Kotlin中实现？

另一个说明：Memento对象的不透明度要求实际上是Memento Pattern的通俗接受属性还是SourceMaking提出了这个要求？

Answer 1

您可以定义Memento公共父类和私有继承类吧：

class Originator { 
    /* irrelevant declarations skipped */ 

    abstract inner class Memento 

    private inner class MementoImpl(val state: State) : Memento() 

    fun saveState(): Memento { 
     return MementoImpl(State(id, title, description)) 
    } 

    fun restore(memento: Memento) { 
     memento as MementoImpl 
     id = memento.state.id 
     title = memento.state.title 
     description = memento.state.description 
    } 
} 

实现类是private，并且，外Originator的情况下，才会被视为Memento（见功能签名），以便该状态不可访问。

Answer 2

您应该使用包级访问来定义您的Memento类属性。