Explication détaillée du modèle de mémo et de son implémentation dans la programmation de modèles de conception Java

1. La définition
capture l'état interne d'un objet et enregistre cet état à l'extérieur de l'objet sans détruire l'encapsulation. Cela vous permet de restaurer ultérieurement l'objet à son état d'origine enregistré.

2. Raison d'utilisation
Vous souhaitez restaurer l'état d'origine de l'objet à un certain moment.

3. Exemples de situations applicables
Il existe de nombreuses applications du mode mémo, mais nous les avons déjà vues, mais nous n'avons pas soigneusement réfléchi à l'utilisation du mode mémo : eg1. L'utilisation du mémo dans jsp javabean :
Lors de l'ajout d'un compte dans un système, vous devez remplir le nom d'utilisateur, le mot de passe, le numéro de contact, l'adresse et d'autres informations dans le formulaire. ou sont mal renseignés, lorsque l'utilisateur clique sur le bouton « Envoyer », les options saisies par l'utilisateur doivent être enregistrées sur la nouvelle page et les mauvaises options seront proposées. Ceci est réalisé en utilisant les caractéristiques scope="request" ou scope="session" de JavaBean, c'est-à-dire en utilisant le mode mémo.
par exemple2. Lors de la réparation des freins de la voiture. Retirez d'abord les déflecteurs des deux côtés pour exposer les plaquettes de frein gauche et droite. Une seule pièce peut être retirée, puis l'autre pièce sert de rappel de la façon dont les freins sont installés. Une fois la réparation de cette pièce terminée, l’autre pièce peut être retirée. Lorsque le deuxième morceau se détache, le premier devient un mémo.
par exemple3. On dit qu'il n'y a pas de médicament contre le regret à acheter dans la vie. Nous payons tous le prix de ce que nous avons fait, mais dans le monde doux, il existe un « médicament contre le regret » après avoir changé l'état de quelque chose. , tant que nous l'avons fait auparavant. Après avoir enregistré un certain état de la chose, nous pouvons restaurer l'état de la chose via le mode mémo. En fait, ce n'est pas un « coffre au trésor au clair de lune » qui peut remonter le temps. est toujours "magique".

4. Structure et description du diagramme de classes

(1) Le diagramme de classes est le suivant :

(2) Description de la classe   

( i ) Memento : rôle de mémo, principalement responsable des tâches suivantes :
stocke l'état interne de l'objet initiateur
peut protéger son contenu contre la lecture par tout objet autre que l'objet initiateur (Originator).
(ii) Auteur : le rôle d'initiateur effectue principalement les tâches suivantes :
Créer un objet mémo contenant l'état interne actuel
Utiliser l'objet mémo pour stocker son état interne ;
(iii) Gardien : rôle de personne responsable, termine le travail comme suit :
est responsable de la sauvegarde de l'objet mémo
n'enregistre pas le contenu de l'objet mémo ;

5. Exemple

/**
 * 数据对象
 */
public class DataState {
  private String action;
  
  public void setAction(String action) {
    this.action = action;
  }
    
  public String getAction() {
    return action;
  }

/**
 * 一个保存另外一个对象内部状态拷贝 的对象.这样以后就可以将该对象恢复到原先保存的状态.
 */
import java.io.File;
import java.io.Serializable;
  
public class Memento implements Serializable {
  
  /*private int number;
  private File file = null;
  
  public Memento(Originator o) {
    this.number = o.getNumber();
    this.file = o.getFile();
  }
  
  public int getNumber() {
    return this.number;
  }
  
  public void setNumber(int number) {
    this.number = number;
  }
  
  public File getFile() {
    return this.file;
  }
  
  public void setFile(File file) {
    this.file = file;
  }
*/
  private DataState state;
  public Memento(Originator o) {
    this.state = o.getState();
  }
    
  public DataState getState() {
    return state;
  }
    
  public void setState(DataState state) {
    this.state = state;
  }
}

public class Originator {
  
/* private int number;
  private File file = null;
  
  public Originator() {
  
  }
  
  // 创建一个Memento，将自身作为参数传入
  public Memento getMemento() {
    return new Memento(this);
  }
  
  // 从Memento中取出保存的数据，恢复为原始状态
  public void setMemento(Memento m) {
    number = m.getNumber();
    file = m.getFile();
  }
  
  public int getNumber() {
    return number;
  }
  
  public void setNumber(int number) {
    this.number = number;
  }
  
  public File getFile() {
    return file;
  }
  
  public void setFile(File file) {
    this.file = file;
  }*/
    
  private DataState state;
  public Originator() {
      
  }
    
  public Originator(DataState state) {
    this.state = state;
  }
    
  // 创建一个Memento，将自身作为参数传入
  public Memento getMemento() {
    return new Memento(this);
  }
    
  // 从Memento中取出保存的数据，恢复为原始状态
  public void setMemento(Memento m) {
    /*
     * getMemento() 创建的对象，保存在某个容器里，
     * 当需要恢复时，将其传入当前方法, 再使用getState(),得出
     */
    this.state = m.getState();
  }
    
  public DataState getState() {
    return state;
  }
    
  public void setState(DataState state) {
    this.state = state;
  }
}

/*
 * Originator用于 加载数据， 建立Memento对象，及通过Memento恢复原始数据
 */
public class Test {
  public static void main(String[] args) {
      
//   Originator originator = new Originator();
//   originator.setNumber(8);
//   
//   Memento memento = originator.getMemento();
//   System.out.println(memento.getNumber());
      
    DataState state = new DataState();
    state.setAction("copy a character");
    Originator originator = new Originator();
    System.out.println("创建原始数据");
    originator.setState(state);
      
    System.out.println("创建备忘录对象, 保存原始数据状态");
    Memento memento = originator.getMemento();
      
    System.out.println("创建了一个新数据");
    originator.setState(new DataState());
  
    System.out.println("创建新数据后：" + originator.getState().getAction());
      
    /*
     * memento 需要保存在某地，需要时取出，以恢复它内部所保存的数据
     */
    System.out.println("创建新数据后，恢复原数据");
    originator.setMemento(memento);
    System.out.println(originator.getState().getAction());
  }
}

Imprimer :

创建原始数据
创建备忘录对象, 保存原始数据状态
创建了一个新数据
创建新数据后：null
创建新数据后，恢复原数据
copy a character

Pour des explications plus détaillées sur le modèle de mémo et son implémentation dans la programmation de modèles de conception Java, veuillez faire attention au site Web PHP chinois !