0

Tutorial - Memento com Java e o Ctrl+z

Mateus Silva
Mateus Silva

Memento é um Padrão de Projeto para o armazenamento do estado interno de um objeto que possa precisar ser restaurado, um exemplo clássico é a operação de desfazer em textos utilizando o Ctrl+z.


A grande questão é onde armazenar e quanto armazenar. O armazenamento pode ser feito de diversas formas (dentro da aplicação, arquivo de texto, banco de dados), o fator que vai determinar isso é o quanto aceitamos armazenar e o desempenho. Quanto mais armazenamos, mais caro é o processamento.


Classificação do padrão Memento:


Abaixo temos o tutorial de uma situação simples de escrita de texto em que os estados são salvos somente dentro do programa durante a execução.


Classe Memento que define o que é salvo

public class Memento {
    private String estadoTexto;

    public Memento(String texto){
        this.estadoTexto = texto;
    }

    public String recuperaTexto(){
        return estadoTexto;
    }
}


Classe ArmazenadorMemento é responsável por guardar todos os estados já criados.

import java.util.Stack;

public class ArmazenadorMemento {
    /*uso da pilha para garantir que o ultimo estado inserido
     seja recuperado primeiro*/
    private Stack<Memento> estados;

    public ArmazenadorMemento(){
       estados = new Stack<Memento>();
    }

    public void adicionaEstado(String conteudo){
        var novoEstado = new Memento(conteudo);
        estados.push(novoEstado);
    }

    public String recuperaEstado(){
        if(!estados.empty()){
            return estados.pop().recuperaTexto();
        }else{
            return "";
        }
    }
}


Classe Texto para gerenciar o texto escrito

public class Texto {
    private String texto;
    private ArmazenadorMemento armazenador;

    public Texto(){
        armazenador = new ArmazenadorMemento();
        texto = "";
    }

    public void concatenarTexto(String texto){
        this.texto += texto;
        armazenador.adicionaEstado(texto);
    }

    //funcao que remove o fim da string atual recuperando a ultima alteracao feita
    public void desfazer(){
        String ultimaAlteracao = armazenador.recuperaEstado();
        if(!ultimaAlteracao.isBlank()){
            texto = texto.substring(0, texto.length() - ultimaAlteracao.length());
        }
    }

    public void exibirTexto(){
        System.out.println(texto);
    }
}


Classe principal

public class Main {
    public static void main(String[] args){
        Texto texto = new Texto();
        texto.concatenarTexto("Teste acrescentando ");
        texto.concatenarTexto("palavras");
        texto.exibirTexto();
        texto.desfazer();
        texto.desfazer();
        texto.exibirTexto();
    }
}

Esse código pode ser melhorado ainda, por exemplo, na classe ArmazenadorMemento poderia ter um limite para o máximo de elementos na pilha.


Esse padrão é muito útil e que permite desenvolver funções muito comuns em aplicações como o desfazer em editores de texto.


Link para o tutorial do padrão Singleton:

  • https://web.digitalinnovation.one/articles/tutorial-implementando-o-padrao-de-projeto-singleton-em-java?back=%2Farticles&page=1&order=oldest


Fonte:

  • http://www.facom.ufu.br/~bacala/ESOF/05b-Padr%C3%B5es%20Gof.pdf
  • https://brizeno.wordpress.com/category/padroes-de-projeto/memento
0
0

Comentários (3)

0
Leandro Carvalho

Leandro Carvalho

15/07/2021 13:15

Parabéns pelo Artigo, ficou muito bom.

1
Rafael Santos

Rafael Santos

14/07/2021 20:56

Hmm, não conhecia essa pattern, mas é bem útil. Ficou muito bom o artigo, parabéns! Inclusive, valeu por ter compartilhado o pdf linkado também, ele oferece uma visão geral de várias patterns.

1
Mateus Silva

Mateus Silva

14/07/2021 22:34

Oi, Rafael. Muito obrigado. Sim, gosto muito daquele pdf, mas o livro Padrões de Projeto: Soluções reutilizáveis de software orientado a objetos do GoF é muito bom também.

None

Brasil