Fundamentos de Padrões de Projeto de Software

PADRÕES DE PROJETO

https://www.facebook.com/alvarofpinheiroaulas/br.linkedin.com/in/alvarofpinheiro/

http://www.alvarofpinheiro.eti.br

Padrões General ResponsabilityAssignment Software Pattern (GRASP)


1.Creator Designer

2.Low Coupling

3.Hight Cohesion

4.Information Expert

5.Controller

6.Polymorphism

7.Indirection

8.Protected Variations

9. Pure Fabrication

GRASPTrata-se de uma solução geral e reutilizável para algum determinado problema que ocorre com frequência no desenvolvimento de um projeto, isto é, são as melhores práticas formalizadas para resolver problemas comuns no desenvolvimento.

É designado para o paradigma orientado a objeto e mostram relacionamentos e interações entre classes e/ou objetos.

Resumindo, consiste de um conjunto de práticas para atribuição de responsabilidades a classes e objetos em projetos orientados a objeto.


GRASP Creator DesignerProblema & Solução

Problema: Quem deve ser o responsável por criar uma nova instância de uma determinada classe?

Solução: Atribui-se a classe B a responsabilidade para criar uma instância da classe A se alguma das situações acontecer:B contém ou agrega objetos do tipo A;B armazena instâncias do tipo A;B, de forma privada, usa objetos do tipo A;B tem os dados de inicialização que irão ser passados para A quando ele é criado; eDessa forma, B é um Expert em relação a criação de A.Se mais de uma opção se aplica, dê preferência a classe que agrega ou contém instâncias de A


GRASP Creator DesignerResponsabilidade de criar uma nova instância em

uma determinada classe.


public class Cliente {

public static String solicitarConta() {

return (Gerente.abrirConta());

}

}

public class Gerente {

public static String abrirConta() {

return (Conta.criarConta());

}

} public class Conta {

public static String criarConta() {

return ("Conta Criada");

}

}

GRASP Low Coupling

Problema & Solução

Problema: Como dar suporte a baixa dependência,

redução de impacto de mudanças e aumento do

reuso?

Solução: Atribuir a responsabilidade de forma que o

acoplamento desnecessário permaneça baixo.


GRASP Low CouplingAtribuir a responsabilidade de forma que o

acoplamento permaneça baixo.



public static String consultarConta() {

return (Conta.consultarSaldo());

}

}

public class Conta {

public static String consultarSaldo() {

return ("Saldo da Conta");

}

}

Evitar acoplamentos desnecessários.

GRASP High CohesinProblema & Solução

Problema: Como manter os objetos focados, fácies de entender, gerenciáveis e ainda pouco acoplados?

Solução: Atribuir responsabilidade de forma que a coesão, ou, mais especificamente, coesão funcional, permaneça alta.

O que é coesão ? É a medida de quão forte estão relacionadas e focadas as responsabilidades de um elemento. Um elemento com alta coesão, indica que suas responsabilidades são realizadas com pouco esforço. Por outro lado, um elemento com baixa coesão está ‘muito distante’, desassociado, dos outros elementos, gerando maior esforço para que ele cumpra suas responsabilidades.


GRASP High CohesionAtribuir responsabilidade de forma que a coesão

permaneça alta.



public static String consultarConta() {

return (Conta.consultarSaldo());

}

}




}

}

Deixar na classe o que pertence a ela.

GRASP Information Expert


Problema: Qual é o princípio básico para se atribuir

responsabilidades a objetos?

Solução: Atribuir responsabilidades para classes que

possuem a informação necessária.


GRASP Information ExpertAtribuir responsabilidades para classes que

possuem a informação necessária.



public static String solicitarSaldo() {

String corrente = (ContaCorrente.consultarSaldo());

String poupanca = (ContaPoupanca.consultarSaldo());

return ("Corrente:"+corrente+"/nPoupança:"+poupanca);

}

}

public class ContaCorrente {



}

}

public class ContaPoupanca {


return ("Saldo da Poupança");

}

}

GRASP ControllerProblema & Solução

Problema : Qual o primeiro objeto após a Interface de Usuário que receberá e coordenará a operação do sistema?

Solução : Atribuir essa responsabilidade a uma classe representando uma das opções:Classe que representa todo o sistema (aconselhável somente em situações em que existem poucos operações de sistema), serviços de um módulo ou subsistema ou qualquer outra variação de facade controller; eClasse que representa um cenário de caso de uso no qual o evento do sistema acontece. Normalmente o objeto definido pelo GRASP controller delega o seu trabalho a outros objetos, executando pouca ou nenhuma lógica em si. Adicionalmente este objeto não deve ser uma classe persistente do sistema.


GRASP ControllerDelegar trabalho a outros objetos, executando pouca

lógica em si.


public class ContaRegras {

public static String validarCliente() {

return ("Cliente Validado");

}

public static String validarConta() {

return ("Conta Validado");

}

}

public class ContaCorrente {


ContaRegras.validarCliente();

ContaRegras.validarConta();


}

}

public class ContaPoupanca {


ContaRegras.validarCliente();

ContaRegras.validarConta();


}

}

GRASP PolymorphismProblema & Solução

Problema: Como tratar alternativas baseadas em tipo? Como criar componentes de software plugáveis?

Solução: Quando alternativas ou comportamentos relacionados variam por tipo (classe), atribuir a responsabilidade ao comportamento – usando operações polimórficas – para os tipos nos quais o comportamento varia.

Nunca execute teste pelo tipo de um objeto e utilize lógica condicional para variar o comportamento baseado neste tipo.


GRASP PolymorphismTrata de comportamentos relacionados que variam

entre classes.



public static void solicitarSaldo() {

new ContaCorrente().consultarSaldo();

new ContaPoupanca().consultarSaldo();

}

}

public abstract class Conta {

public abstract String consultarSaldo();

}

public class ContaCorrente extends Conta {

public String consultarSaldo() {


}

}

public class ContaPoupanca extends Conta {

public String consultarSaldo() {


}

}Subclasses

GRASP Indirection


Problema: Onde atribuir uma responsabilidade para

evitar acoplamento direto entre duas ou mais

entidades? Como “desacoplar” objetos de forma que

baixo acoplamento seja suportado e que o potencial

de reuso permaneça alto?

Solução: Atribuir a responsabilidade a um objeto

intermediário que irá mediar entre os demais

componentes ou serviços de forma que eles não

sejam diretamente acoplados.


GRASP IndirectionAtribuir a responsabilidade a um intermediário que

irá mediar entre os demais componentes de forma

que eles não sejam diretamente acoplados.



public static void verificaAplicacao(double valor) {

Aplicacao.melhorAplicacao(valor);

}

}

public class Aplicacao {

public static String melhorAplicacao(double valor) {

if (valor > 1000) {

return (RendaFixa.aplicarMontante(valor));

} else {

return (Poupanca.aplicarMontante(valor));

}

}

}Classe que intermédia

GRASP Protected Variation


Problema: Como projetar objetos, sub-sistemas e

sistemas de forma que as variações ou

instabilidades nestes elementos não impliquem em

impacto indesejado sobre outros elementos?

Solução: Identificar pontos de variações ou

instabilidade previsíveis. Atribuir responsabilidades

para criação de uma interface estável em torno

desses pontos.


GRASP Protected VariationIdentificar pontos de variações ou instabilidade previsíveis e atribuir

responsabilidades para criação de uma interface estável em torno desses

pontos.



public static void aplicarDolar(String moedaReal) {

Real.aplicarMontante(moedaReal);

}

}

public class Real {

public static String aplicarMontante(String moedaReal) {

return (Cambio.converterMoeda(moedaReal));

}

}

public class Cambio {

public static String converterMoeda(String moedaReal) {

String moedaDolar = realizarConversao(moedaReal);

return (Dolar.aplicarMontante(moedaDolar));

}

}

public class Dolar {

public static String aplicarMontante(String moedaDolar) {

return ("Valor Convertido para Dolar");

}

}

Classe que resolve a incompatibilidade

GRASP Pure Fabrication


Problema: Que objetos devem possuir

responsabilidades quando não se quer violar os padrões

High Coesion e Low Coupling, uma vez que a solução

oferecida pelo Information Expert não é adequada?

Solução: Atribuir um conjunto de responsabilidades

altamente coesas a uma classe artificial ou conveniente

que não representa um conceito no domínio do

problema. Tal classe é uma criação da imaginação para

suportar alta coesão, baixo acoplamento e reuso.


GRASP Pure FabricationAtribuir responsabilidades altamente coesas a uma classe que não representa

um conceito no domínio do problema.


Classes do Padrão Arquitetural Model-View-

Control (MVC)

Classe adicionada ao Padrão MVC que não

representa o problema, mas melhor organiza a

aplicação

GRASP Pure Fabricationpublic class ModelarCliente {

//Clase de Domínio da Aplicação

private int codigo;

private String nome;

//gets...

//sets...

}

public class VisualizarCliente {

public static void cadastrarCliente() {

//Classe Visual de Entrada/Saída

ModelarCliente c = new ModelarCliente();

new ControlarCliente().validar(c);

}

}

public class ControlarCliente {

//Classe de Regras de Negócio

public static String validar(ModelarCliente c) {

new PersistirCliente().incluir(c);

return ("Realizar Regras de Negócio");

}

}


public class PersistirCliente {

//Classe Comandos SQL

public static String incluir(ModelarCliente c) {

return ("Realizar gravação no Banco de Dados");

}

}

Padrão de Arquitetura Model-View-Control (MVC)Visa separar a lógica do negócio da lógica da apresentação, permitindo o desenvolvimento, teste e manutenção isolado.

O model (domínio) é usado para definir e gerenciar o domínio da informação e notificar observadores sobre mudanças nos dados;

O view (apresentação) apresenta o modelo num formato adequado ao utilizador; e

O controller (regras) recebe a entrada de dados e inicia a resposta ao utilizador ao invocar objetos do modelo.

Exemplo: aluno, professor e turma fazem parte do domínio de um sistema acadêmico. Operações como calcular a média final do aluno ou o índice de faltas da turma fazem parte da lógica de domínio. A forma como o dado é armazenado é de responsabilidade do modelo.

Prática: uma aplicação web em que a visão é um documento HTML. O controlador recebe uma entrada GET ou POST após um estímulo do utilizador e decide como processá-la, invocando objetos do domínio para tratar a lógica de negócio, e por fim invocando uma visão para apresentar a saída.


Padrões Gang Of Four (GoF)


Criacional Estrutural Comportamental

1.Factory Method (Classe) 1.Adapter (Classe/Objeto) 1.Interpreter (Classe)

2.Abstract Factory (Objeto) 2.Bridge (Objeto) 2.Template Method (Classe)

3.Builder (Objeto) 3.Composite (Objeto) 3.Chain Responsability (Objeto)

4.Prototype (Objeto) 4.Decorator (Objeto) 4.Command (Objeto)

5.Singleton (Objeto) 5.Flyweight (Objeto) 5.Iterator (Objeto)

6.Facade (Objeto) 6.Mediator (Objeto)

7.Proxy (Objeto) 7.Memento (Objeto)

8.Observer (Objeto)

9.State (Objeto)

10.Strategy (Objeto)

11.Visitor (Objeto)

GoF CriacionalO objetivo é abstrair o processo de instanciar objetos, assim não é necessário a preocupação de como o objeto é criado, como é composto e como representá-lo.

A vantagem da adoção desse padrão é que quando o projeto sofre mudanças na criação de objetos o projeto de forma geral será pouco ou nada afetado.

Padrões de criação no escopo de classe vão utilizar herança para oferecer essa flexibilidade, exemplo Factory Method, já os de escopo objeto, exemplo Prototype delegam para um objeto a responsabilidade de instanciar novos objetos.


GoF EstruturalO objetivo é estruturar a relação entre as classes e

objetos, assim facilitando a modelagem do projeto,

identificando a forma mais adequada de relacionar

as entidades.

Os com escopo de classe utilizam a herança para

compor as implementações ou interfaces, exemplo

Adapter que pode definir uma nova interface para

adaptar duas outras já existentes. Os de escopo

objeto utilizam a composição de objetos para definir

a estrutura, exemplo Composite que define uma

estrutura de hierárquica parte-todo.


GoF ComportamentalO objetivo é atribuir responsabilidade das entidades,

assim facilitam a comunicação entre os objetos.

Os com escopo de classe utilizam herança para

realizar a distribuição do comportamento, exemplo

Template Method, que fornece um algoritmo padrão

e deixa as subclasses definirem os pontos da

execução desse algoritmo. Os de objetos serviram

para definir a comunicação, exemplo Mediator que

define um objeto que realiza a comunicação muitos-

para-muitos.


GoF Resumo


Abstract Factoty-Permitir que um cliente crie famílias de objetos sem especificar suas classes concretas

Adapter-Classe adaptadora entre a classe interna e um componente

Bridge-Desassociar a evolução de duas classes

Builder-Encapsular a construção de um comportamento e permitir que ele seja construído em etapas

Chain Responsibility-Define uma forma de passar uma solicitação entre objetos

Command-Encapsular um pedido de comando em um objeto

Composite-Criar uma hierarquia parte todo

Decorator-Estender a funcionalidade dinamicamente

Facade-Definir uma interface de alto nível

Factory Method-Subclasses decidem quais classes concretas serão criadas

Flyweight-Definir ajustes finos em subclasses

Interator-Fornecer uma maneira de acessar seqüencialmente uma coleção de objetos sem expor a sua implementação

Interpreter-Permitir a inclusão de elementos de linguagem em um aplicativo

Mediator-Definir comunicação simplificada entre classes

Mementor-Salvar e restaurar o estado interno de um objeto

Observer-Definir um regime de notificação de objetos de mudanças para um outro objeto

Prototype-Permitir criar novas instancias simplesmente copiando instancias existentes

Proxy-Um classe que controla o acesso para outra classe

Singleton-Assegurar que somente um objeto de uma determinada classe seja criado em todo o projeto

State-Alterar o comportamento de um objeto quando seu estado muda

Strategy-Encapsular um algoritmo dentro de uma classe

Template Method-Permitir que subclasses redefinem os passos de um algoritmo

Visitor-Define uma nova operação em uma classe sem trocá-la

GoF Criacional Factory MethodPermitir subclasses decidirem que classe instanciar.


public class Armas {

public Armas() {

}

}

public class Exercito extends Armas {

public static void usarInfantaria() {

}

}

public class Marinha extends Armas {

public static void usarNavios() {

}

}

public class Aeronautica extends Armas {

public static void usarAvioes() {

}

}

GoF Criacional Factory Method


public class Batalha {

public static void main(String[] args) {

if (args[0].equals("terra")) {

Armas arma = new Exercito();

}

else if (args[0].equals("mar")) {

Armas arma = new Marinha();

}

else if (args[0].equals("ar")) {

Armas arma = new Aeronautica();

}

}

}

GoF Criacional Abstract FactoryEncapsular um conjunto de fábricas que produzem

famílias análogas de objetos. O objetivo é criar uma

interface que poderá ser implementada por várias

classes que têm comportamentos diferentes com

métodos de mesma assinatura.


Classes com comportamentos diferentes mas mesma assinatura.

Exemplo método comer();

public abstract class Fruta {public abstract String comer();

}public class Pera extends Fruta {

public String comer() {return ("pegar;mastigar;");

}}public class Abacaxi extends Fruta {

public String comer() {return ("pegar;descascar;mastigar;");

}}public class Coco extends Fruta {

public String comer() {return ("pegar;descascar;abrir;mastigar;");

}}

GoF Criacional Abstract Factory


GoF Criacional SingletonCertifica que apenas uma única instância de uma classe possa existir, fornecendo um método único de acesso a ela.

public class Singleton {private static Singleton instancia;private Singleton() {}public static Singleton getInstancia() {

if (instancia == null)instancia = new Singleton();

return instancia;}

}http://www.alvarofpinheiro.eti.br

GoF Criacional PrototypeCriar uma instância inicializada para clonar ou

copiar.


Criada para gerar cópias. Exemplo método clonar();

GoF Criacional Prototypepublic abstract class CarroHonda {

protected double valor;

public abstract CarroHonda clonar();

}

public class HondaCivic extends CarroHonda {

protected HondaCivic(HondaCivic civic) {

}

public HondaCivic() {

this.valor = 70000;

}

public CarroHonda clonar() {

return new HondaCivic(this);

}

}

public class HondaCity extends CarroHonda {

protected HondaCity(HondaCity city) {

}

public HondaCity() {

this.valor = 60000;

}


return new HondaCity(this);

}

}http://www.alvarofpinheiro.eti.br

public class HondaFit extends CarroHonda {

protected HondaFit(HondaFit fit) {

}

public HondaFit() {

this.valor = 50000;

}


return new HondaFit(this);

}

}

public class Carro {


HondaCivic civic = new HondaCivic();

CarroHonda civicNovo = civic.clonar();

HondaCity city = new HondaCity();

CarroHonda cityNovo = city.clonar();

HondaFit fit = new HondaFit();

CarroHonda fitNovo = fit.clonar();

}

}

GoF Criacional BuilderEncapsular a construção de objetos complexos a

partir de sua representação, criando várias

representações e especificando apenas o conteúdo

especializado.


Ficando apenas o que é necessário especializar. Exemplo método

converterCaracter();

GoF Criacional Builderpublic abstract class Conversor {

public abstract String converterCaracter();

public abstract String converterParagrafo();

public abstract String converterTexto();

}

public class ConversorRTF extends Conversor {

public String converterCaracter() {

return ("Converte um caracter em PDF");

}

public String converterParagrafo() {

return ("Converte um parágrafo em PDF");

}

public String converterTexto() {

return ("Converte um texto em PDF");

}

}

public class CoversorPDF extends Conversor {

public String converterCaracter() {

return ("Converte um caracter em PDF");

}

public String converterParagrafo() {

return ("Converte um parágrafo em PDF");

}

public String converterTexto() {

return ("Converte um texto em PDF");

}

}


public class Leitor {


lerRTF("texto");

}

protected static void lerRTF(String txt) {

Conversor c = new ConversorRTF();

c.converterCaracter();

}

protected static void lerPDF(String txt) {

Conversor c = new CoversorPDF();

c.converterCaracter();

}

}

GoF Estrutural AdapterAdaptar uma interface para uma interface esperada.

O adaptador é um intermediador que recebe

solicitações do cliente e converte essas solicitações

num formato que o fornecedor entenda.


Classe intermediária que converte métodos incompatíveis porém

sendo necessária sua integração

public class Computador {public static String enviaSinalDigital() {

return ("Sinal Digital");}

}public class Telefone {

public static String enviaSinalAnalogico() {return ("Sinal Analogico");

}}public class Modem {

public static String modulaSinal(Computador c) {return ("Sinal modulado");

}public static String demodulaSinal(Telefone t) {

return ("Sinal demodulado");}

}

GoF Estrutural Adapter


GoF Estrutural BridgeDissociar uma interface de sua implementação.

Server como uma ponte que liga duas

implementações, permitindo que ambas possam

evoluir sem perder a comunicação.


Classe de ligação que permite que classes necessárias para integrar a solução continuem independentes

uma da outra

public class ProdutoPerecivel {

public void prazoValidade() {

}

public void definirRotulo() {

}

}

public class ProdutoNaoPerecivel {

public void realizarDepreciacao() {

}

public void definirUtilidade() {

}

}

GoF Estrutural Bridge


public class Vendas {

private ProdutoPerecivel pp;

private ProdutoNaoPerecivel pnp;

private String nf;

//gets...

//sets...

public void realizarVenda(ProdutoPerecivel pp,ProdutoNaoPerecivel pnp) {

}

}

GoF Estrutural CompositeCriar uma estrutura de árvore de hierarquias parte-

todo. A ideia do Composite é criar uma classe base

que contém toda a interface necessária para todos

os métodos e criar um método especial que agrega

os outros métodos.


Essas Classes são partes que compõem o todo que é a

Classe Empregado

public class Depto {

private int codigo;

private String descricao;

//gets...

//sets...

}

public class Cargo {

private int codigo;

private String descricao;

//gets...

//sets...

}

GoF Estrutural Composite


public class Empregado {

private int matricula;


private Depto departamento;

private Cargo cargo;

//gets...

//sets...

}

GoF Estrutural DecoratorEstender a funcionalidade dinamicamente. Tem

como principal objetivo adicionar novos métodos à

objetos dinamicamente sem alterar os métodos

existentes nas classes.


A Classe Atividade permite estender as

Classes Jovem, Adulto e Velho

dinamicamente sem alterá-las

public class Homem {

private int idade;

//gets...

//sets...

}

public class Jovem extends Homem {

public String Atividade() {

return("pouca");

}

}

public class Adulto extends Homem {


return("plena");

}

}

public class Velho extends Homem {


return("restrita");

}

}

GoF Estrutural Decorator


public class Atividade {

public String definicaoEtaria(int idade) {

if ((idade >= 0) && (idade < 4)) {

Jovem h = new Jovem();

return (h.Atividade());

//novo_método()

}

else if ((idade >= 4) && (idade < 60)) {

Adulto h = new Adulto();


//novo_método()

}

else {

Velho h = new Velho();


//novo_método()

}

}

}

GoF Estrutural FacadeDefine uma interface de alto nível.


Classe de alto nível de abstração

public class SistemaDigestivo {

public static void realizarDigestao() {

}

}

public class SistemaCirculatorio {

public static void realizarCirculacao() {

}

}

public class SistemaRespiratorio {

public static void realizarRespiracao() {

}

}

public class SistemaHumano {

public void inicializacao() {

SistemaRespiratorio nariz = new SistemaRespiratorio();

nariz.realizarRespiracao();

SistemaDigestivo intestino = new SistemaDigestivo();

intestino.realizarDigestao();

SistemaCirculatorio arteria = new SistemaCirculatorio();

arteria.realizarCirculacao();

}

}

GoF Estrutural Facade


public class Homem {


humano = new SistemaHumano();

humano.inicializacao();

}

}

GoF Estrutural FlyweightRealiza ajustes finos nos objetos através de

compartilhamento.


Classes que realizam pequenos ajustes na Classe Cliente


private int codigo;


private String email;

private String fone;

//gets...

//sets...

//métodos...

}

GoF Estrutural Flyweight


public class ClienteVIP extends Cliente {

private boolean especial;

//gets...

//sets...

//métodos...

}

public class ClienteNegativado extends Cliente {

private boolean bloqueio;

//gets...

//sets...

//métodos...

}

GoF Estrutural ProxyDefinir um objeto com controle de acesso para outro

objeto. Seu principal objetivo é encapsular um objeto

através de outro objeto de forma que o segundo

objeto possa controlar o acesso ao primeiro que é o

principal.


Classe que controla o acesso e encapsula a Classe Conta


private double saldo;

private String tipo;

//gets…

//sets…

public void movimentaSaldo(String tipo, double valor) {

double aux = 0;

if (tipo.equals("C")) {

aux = getSaldo();

aux = aux + valor;

setSaldo(aux);

} else {

aux = getSaldo();

aux = aux - valor;

setSaldo(aux);

}

}

}

GoF Estrutural Proxy


public class Correntista {

private String usuario;

private String senha;

private String conta;

private String tipo;

private float valor;

//gets...

//sets...

public void acesarConta(String usuario, String senha) throws Exception {

try

{

//entrada de dados do usuário

if ((usuario.equals(getUsuario())) && (senha.equals(getSenha()))) {

//entrada de dados da conta

Conta conta = new Conta();

conta.movimentaSaldo(valor)

} else {

throw new Exception(“Acesso negado");

}

}

catch (Exception ex) {

throw (ex);

}

}

}

GoF Comportamental Chain Responsability

Define uma forma de passar uma solicitação entre

objetos. Esse padrão trata da limitação de um

objeto em lidar com um determinado pedido.


Classe que passa a solicitação para a Classe que saiba resolvê-la

public class Piloto {

public static void informacaoVoo() {

}

}

public class Comissario {

public void atendimentoBordo() {

}

}

public class Passageiro {

public void solicitacao(String tipo) {

if (tipo.equals("voo")) {

new Piloto().informacaoVoo();

} else if (tipo.equals("bordo")) {

new Comissario().atendimentoBordo();

}

}

}

GoF Comportamental Chain Responsability


GoF Comportamental Template MethodPermite que subclasses redefinam um algoritmo.


Classes que redefinem a lógica da aplicação. Exemplo método navegar();

public abstract class Embarcacao {

public abstract void fazerNavegacao();

public void fazerAtracacao() {

//amarrar

}

}

public class Canoa extends Embarcacao

{

public void fazerNavegacao(){

//remar

}

}

public class Veleiro extends Embarcacao

{


//velejar

}

}

public class Lancha extends Embarcacao

{


//pilotar

}

}

GoF Comportamental Template Method


GoF Comportamental InterpreterPermitir a inclusão de elementos de linguagem.


Classe que adiciona novos métodos a partir de outros já existentes.

public interface TipoSinal {

String tratarSinal();

}

public class Voz implements TipoSinal {

public String tratarSinal() {

return ("Analógico");

}

}

public class Dados implements TipoSinal {

public String tratarSinal() {

return ("Digital");

}

}

public class VOIP {

public void usarSinal() {

Voz v = new Voz();

Dados d = new Dados();

v.tratarSinal();

d.tratarSinal();

}

}

GoF Comportamental Interpreter


GoF Comportamental ObserverDefine um regime de notificação de objetos de

mudanças para um outro objeto.


Classe observadora que redefine o comportamento

decorrente a uma mudança de estado (valor de um atributo)

public class Pessoa {

private int peso;

public void setPeso(int peso) {

this.peso = peso;

}

public int getPeso() {

return (this.peso);

}

}

public class Saude {

public static void saudavel() {

}

public static void obeso() {

}

}

public class Balanca {

public static void medir(Pessoa p) {

if (p.getPeso() < 80) {

Saude.saudavel();

}

else {

Saude.obeso();

}

}

}

GoF Comportamental Observer


public class Principal {


Pessoa p = new Pessoa();

p.setPeso(60);

Balanca.medir(p);

}

}

GoF Comportamental StateAlterar o

comportamento de um

objeto quando seu

estado muda.


public class Oficial {

private String patente;

public Oficial(String patente)

{

this.patente = patente;

verificaAtribuicoes(patente);

}

public void verificaAtribuicoes(String patente)

{

if (patente.equals("General")) {

//executa atribuições

}

else if (patente.equals("Coronel")) {


}

else if (patente.equals("Major")) {


}

else if (patente.equals("Capitão")) {


}

else if (patente.equals("Tenete")) {


}

}

}

GoF Comportamental CommandEncapsular um pedido de comando em um objeto.


Classe que encapsula um comando em um método. Exemplo método

fazerPagamento();

public class Compra {

public static void fazerPagamento(double valor, String tipo) {

}

}

public class Pagamento {

public static String especie() {

return (“dinheiro“);

}

public static String credito() {

return (“cartão de crédito“);

}

public static String debito() {

return (“cartão de débito“);

}

}

public class Loja {


Compra.fazerPagamento(100, new Pagamento().especie());

Compra.fazerPagamento(100, new Pagamento().debito());

}

}

GoF Comportamental Command


GoF Comportamental MementoSalvar e restaurar o

estado interno de um

objeto.


import java.util.Arrays;

import java.util.ArrayList;

public class Contatos

{

private int codigo;


private ArrayList<String> email;

private ArrayList<String> fones;

//gets...

//sets...

}

GoF Comportamental StrategyEncapsular um algoritmo dentro de uma classe.


Classe que encapsula o algoritmo para definir qual comportamento usar. Exemplo método viagem();

public class Carro {

public void viajar() {

//custo médio & tempo médio

}

}

public class Onibus {


//custo baixo & tempo alto

}

}

public class Aviao {


//custo alto & tempo baixo

}

}

GoF Comportamental Strategy


public class Estrategia {

private static void viagem(float custo, int tempo) {

if ((custo < 100) && (tempo > 10))

{

Onibus a = new Onibus();

}

else if ((custo > 1000) && (tempo < 10))

{

Aviao a = new Aviao();

}

else

{

Carro a = new Carro();

}

}

}

public class Passageiro {


Estrategia.viagem(80,8);

}

}

GoF Comportamental MediatorDefine comunicação simplificada entre classes.


Classe que intermédia a comunicação entre outras classes

public class Regras {

public void defineRegraUm() {

}

public void defineRegraDois() {

}

public void defineRegraTres() {

}

}

public class Candidato {

public void explicaPropostaUm() {

}

public void explicaPropostaDois() {

}

public void explicaPropostaTres() {

}

}

public class Mediador {

public void mediarCandidado(Candidato candidato) {

}

public void aplicarRegras(Regras regra) {

}

}

GoF Comportamental Mediator


public class Debate {


Candidato x = new Candidato();

Candidato y = new Candidato();

Regras r = new Regras();

Mediador m = new Mediador();

m.mediarCandidado(x);

m.aplicarRegras(r);

m.mediarCandidado(y);

m.aplicarRegras(r);

}

}

GoF Comportamental VisitorDefine uma nova operação em uma classe sem

trocá-la.


public class Paciente {

public void solicitaTratamento() {

}

}

public class Medico {

public void realizaTratamento(Paciente p) {

}

}

public class Visitante {

public void visitaPaciente(Paciente p) {

}

}

public class Hospital {


Paciente p = new Paciente();

Medico m = new Medico();

Visitante v = new Visitante();

p.solicitaTratamento();

m.realizaTratamento(p);

v.visitaPaciente(p);

}

}

GoF Comportamental Visitor


GoF Comportamental IteratorDefine uma nova operação em uma classe sem trocá-la.import java.util.*;

public class Iteracao {public static void main(String args[]) {

ArrayList lista = new ArrayList();lista.add("elemento1");lista.add("elemento2");lista.add("elemento3");lista.add("elemento4");lista.add("elemento5");Iterator iterar = lista.iterator();while(iterar.hasNext()) {

Object element = iterar.next();}ListIterator iterarLista = lista.ListIterator();while(iterarLista.hasNext()) {

Object element = iterarLista.next();iterarLista.set(element + "modificarLista");

}}

}


Fundamentos de Padrões de Projeto de Software

Technology

Transcript of Fundamentos de Padrões de Projeto de Software