Leitores como você ajudam a apoiar o MUO. Quando você faz uma compra usando links em nosso site, podemos ganhar uma comissão de afiliado.
O padrão de design de método de modelo permite definir as etapas de um algoritmo em um único método de uma classe. Isso permite restringir operações específicas de um aplicativo a um único método.
Cada etapa do algoritmo que o método de modelo define é um método interno. No entanto, o método de modelo lida apenas com a implementação de alguns de seus métodos internos. As subclasses geralmente implementam um ou mais métodos internos do método de modelo.
Uma subclasse pode implementar um método abstrato, mas não pode redefinir o algoritmo implementado por um método final.
Como funciona o método de modelo
Um padrão de método de modelo típico terá a seguinte estrutura:
finalvaziotemplateMethod(){
abstractOperation1();
abstractOperation2();operaçãoconcreta1();
operaçãoconcreta2();
gancho();
}
A primeira coisa importante a observar é que templateMethod() é final, então nenhuma subclasse pode sobrescrever este método. A outra coisa importante a observar são os três tipos de métodos que o padrão de método de modelo usa: concreto, abstrato e gancho.
A classe abstrata que abriga o método modelo implementa todos os seus métodos concretos, enquanto as subclasses concretas implementam seus métodos abstratos. O método hook geralmente não faz nada por padrão, mas uma subclasse tem a capacidade de sobrescrever esses métodos quando necessário.
Implementando o padrão de método de modelo em Java
O padrão de método de modelo atua como uma estrutura para um aplicativo. Portanto, você verá esse padrão com frequência em estruturas de software que fornecem o modelo para o desenvolvimento de aplicativos.
Por exemplo, você pode conectar seu aplicativo a um dos muitos sistemas de banco de dados. As etapas para se conectar e usar um banco de dados seguem um modelo semelhante:
públicoabstratoaulaBase de dados{
// método de modelo
finalvaziobanco de dadosTemplate(){
// métodos abstratos
setDBDriver();
setCredentials();// método concreto
conectar();// métodos abstratos
criaDB();
setData();
lerDados();// métodos de gancho
if (userWantsToUpdate()) {
atualizarDados();
}if (userWantsToDelete()) {
deletarDados();
}// método concreto
fecharConexão();
}abstratovaziosetDBDriver();
abstratovaziodefinirCredenciais();
abstratovaziocriarDB();
abstratovaziosetData();
abstratovazioreadData();
abstratovazioatualizarDados();
abstratovazioexcluir dados();vazioconectar(){
System.out.println("Conectando ao banco de dados...");
}vaziocloseConnection(){
System.out.println("Destruindo conexão com o banco de dados...");
}boleanouserWantsToUpdate(){
retornarfalso;
}
boleanouserWantsToDelete(){
retornarfalso;
}
}
Esta classe de banco de dados de exemplo usa o padrão de método de modelo para criar um modelo que pode ser usado com qualquer banco de dados. Para usar um banco de dados, seu aplicativo precisará se conectar a ele e destruir a conexão após o uso. Essas atividades são geralmente as mesmas para todos os bancos de dados. Portanto, a classe abstrata Database pode implementar o conectar() e closeConnection() métodos.
Os outros métodos no método de modelo serão diferentes com base no tipo de banco de dados. Por exemplo, um banco de dados MySQL armazena dados em tabelas, enquanto um O banco de dados MongoDB armazena dados em coleções. Se você quiser usar um Banco de dados MySQL em Java, simplesmente crie uma nova classe MySQL que estenda a classe Database:
públicoaulaMySQLestendeBase de dados{
@Sobrepor
vaziosetDBDriver(){
System.out.println("Selecionando driver MySQL...");
}@Sobrepor
vaziodefinirCredenciais(){
System.out.println("Configurando a credencial do banco de dados MySQL...");
}@Sobrepor
vaziocriarDB(){
System.out.println("Criando uma nova tabela...");
}@Sobrepor
vaziosetData(){
System.out.println("Inserindo dados no banco de dados...");
}@Sobrepor
vazioreadData(){
System.out.println("Recuperando dados do banco de dados...");
}@Sobrepor
vazioatualizarDados(){
System.out.println("Atualizando dados no banco de dados...");
}
@Sobrepor
vazioexcluir dados(){
System.out.println("Excluindo dados do banco de dados...");
}
}
A classe MySQL implementa todos os métodos abstratos da classe Database. Ele também pode substituir alguns métodos concretos. No entanto, ele não pode tocar o banco de dadosTemplate() método, que usa a palavra-chave final.
públicoaulaPrincipal{
públicoestáticovazioprincipal(String[] argumentos){
Banco de Dados mySQLDB = novo MySQL();
mySQLDB.databaseTemplate();
}
}
Essa classe Main cria um novo objeto de banco de dados MySQL e usa o método de modelo para simular como um aplicativo se conectaria ao banco de dados. A execução do método main imprime a seguinte saída no console:
Na saída, você notará que o aplicativo nunca chama o atualizarData() e deleteData() métodos. É por isso que os métodos de gancho são importantes. Em um banco de dados SQL, você desejará criar novas tabelas, inserir dados e visualizar seus dados. No entanto, talvez você não queira atualizar ou excluir dados. Portanto, os métodos hook dão às subclasses a opção de controlar esses aspectos críticos do algoritmo.
@Sobrepor
boleanouserWantsToUpdate(){
retornarverdadeiro;
}Simplesmente adicionando o código acima à classe MySQL, o aplicativo agora atualiza os dados no banco de dados. Se você executar a classe Main novamente, ela exibirá a seguinte saída atualizada:
Como você pode ver, o aplicativo agora está atualizando os dados no banco de dados.
Os benefícios de usar o padrão de design do método de modelo
Um grande benefício do padrão de método de modelo é que ele promove a reutilização de software. Esse padrão de design também suporta programação eficiente. Uma subclasse só precisa implementar métodos que são exclusivos para sua operação.
Além disso, uma aplicação que utiliza o padrão de método template é mais segura, pois classes externas não podem alterar sua estrutura de operação.
