Implemention Patterns

http://www.ﬂickr.com/photos/tambako/4112834255/sizes/l/in/set-72157600220682086/

Padrões de
Implementação
com Java
de Kent Beck
André Faria Gomes
quarta-feira, 6 de janeiro de 2010

Valores e Princípios

http://www.ﬂickr.com/photos/tambako/3103490954/sizes/l/

Valores são conceitos
que guiam nossas escolhas.

http://www.ﬂickr.com/photos/rxmﬂickr/


http://www.ﬂickr.com/photos/sgw/2857641872/sizes/l/

Simplicidade

http://www.ﬂickr.com/photos/khalid-almasoud/474399662/sizes/o/

Flexibilidade

http://www.ﬂickr.com/photos/rxmﬂickr/2687319911/sizes/l/

Comunicação

Os princípios explicam
a motivação
por trás dos padrões



Princípios
Os princípios são baseados nos valores e
são mais concretos
Ajudam a agir conforme os valores e são
mais fácil de serem traduzidos à
práticas
São como guias
http://www.ﬂickr.com/photos/werkunz/3680331543


Agile Manifesto - Values and Principles
Individuals and Our highest priority is to satisfy the a development team is face-to-face
customer through early and continuous conversation.
interactions
delivery of valuable software.
over processes Working software is the primary
and tools Welcome changing requirements, even measure of progress.
late in development. Agile processes
Agile processes promote sustainable
harness change for the customer's
Working development. The sponsors, developers,
competitive advantage.
software over and users should be able to maintain a
Deliver working software frequently, constant pace indeﬁnitely.
comprehensive
from a couple of weeks to a couple of
documentation Continuous attention to technical
months, with a preference to the
excellence and good design enhances
shorter timescale.
agility.
Customer
Business people and developers must
collaboration Simplicity--the art of maximizing the
work together daily throughout the
over contract amount of work not done--is essential.
project.
negotiation The best architectures, requirements,
Build projects around motivated
and designs emerge from self-
individuals. Give them the environment
Responding to organizing teams.
and support they need, and trust them
change over to get the job done. At regular intervals, the team reﬂects
following a on how to become more effective, then
The most efficient and effective method
plan tunes and adjusts its behavior
of conveying information to and within
accordingly.


Vamos aos
Princípios...

Consequências Locais
Estruture o código de forma que as
consequências sejam locais. Reduza os
efeitos colaterais. Diminua o custo de
fazer alterações.


Reduza a Repetição
Esse principio contribui para manter as
consequências locais. Quando mais cópias do
mesmo código, mais cara se torna a
mudança.

Quebre o sistema em pequenas partes, pequenos
pacotes, pequenos métodos, pequenos objetos.


Lógica e Dados
devem andar Juntos
Na maioria da vezes quando se altera a estrutura
dos dados, também se altera a lógica. Se eles
estivem juntos a consequência de alterar será local.


Simetria
Um método add pede um remove, input, output
Um grupo de métodos recebem os mesmos
parâmetros

Atributos com o mesmo ciclo de vida
Faz o código torna-se mais fácil de se ler
Se você entender uma parte, entende o todo
“A mesma idéia deve ser expressada da
mesma forma em todos os lugares”


Expressões Declarativas
Expressar-se o máximo que puder


Taxa de Alterações
(Rate of Change)
setAmont(int value, String currency) {
this.value = value;
this.currency = currency;
}

setAmont(int value, String currency) {
this.money = new Money(value, currency);
}

setAmont(Money money) {
this.money = money;
}

Evita Duplicidade e Criar Consequências Locais


Os padrões expressão um ou mais
valores de comunicação,
simplicidade ou flexibilidade



Motivação


O Custo do Software
Custo Total

=
Custo de Desenvolver

+
Custo de Manter


Custo de
Manter
é maior!

Consome mais tempo
É mais propenso a erros
Tem que aprender o que o código faz


Os Padrões tem o objetivo
de gerar Código Claro para
o desenvolvimento futuro,
reduzindo o custo de
manutenção e melhorando
a comunicação de
programador com
programador

Você passa mais

tempo lendo
do que escrevendo
código

Classes http://www.ﬂickr.com/photos/tambako/4112153517/sizes/l/


Classes e
Arquétipos
de Platão


Classe
“Estes dados vão juntos e essa lógica também”

Dados são alterados mais frequentemente do que
lógica.

Aprender como empacotar lógica em classes e como
expressar suas variações é essencial para se programar
de forma eﬁcaz com orientação à objetos.


Super-Classe

Use herança cautelosamente
“Sou parecida com a minha superclasse, apenas um
pouco diferente”

Reduzir a quantidade de classes em um sistema é
uma melhora, na condição de as outras classes não
ﬁquem inchadas


Simple Superclass Name
Encontrar o nome perfeito é dos momentos
mais satisfatórios da vida de um programador

O nome certo implica em simplicidade e
expressividade

Encontrar o nome certo pode levar horas, dias,
meses ou até mesmo anos


Qualified Subclass Name
O Nome de uma sub-classe deve comunicar duas coisas

1. Com que classe ela se parece
2. No que ela é diferente
Boleto
BoletoSimples
BoletoRegistrado


Abstract Interface
“Aumentar o número de interfaces não diminuem o
custo do software.”

Uma nova interface é algo a mais para
compreender, documentar, debugar, organizar,
navegar e nomear.

Pague esse preço quando realmente precisar da
ﬂexibilidade de uma interface.


Mudança é Ruim?
“Esses dias li uma lista com todas as razões pelas
quais mudanças ocorrem em software, negligência
do levantamento de requistos, bla, bla.... A lista
assumia que todas as mudanças eram ruins.”


Mudança é Ruim?
Porque a previsão do tempo é realizada para um
ano inteiro de uma só vez? Porque o tempo muda
de maneiras imprevisíveis!

Em Java, Interfaces e Classes abstratas podem te
ajudar a conseguir ﬂexibilidade quando for preciso.


Interfaces

File < FileImpl

IFile < File

Interfaces Versionadas

O que você faz quado precisa alterar uma interface
mas não pode?

Crie uma nova interface que extende a anterior e
utilize instanceof para veriﬁcar se pode utilizar a
nova operação!


Interfaces Versionadas
interface Command { void run(); }

interface ResersibleCommand extends Command {
void undo();
}

...
if (recent instanceof ReversibleCommand)
((ReversibleCommand) recent).undo()
...


Value Object


Value Object
São objetos que depois de
criados nunca mais tem seus
valores alterados.

Exemplos desse padrão na linguagem Java:
Integer, Float, String, BigDecimal, Double


Value Object
Transação {
int valor;

(int valor, Conta credito, Conta debito) {
this.valor = valor;
credit.addCredito(this);
debit.addDebit(this);
}

int getValor() { return this.valor; }
}


Class Specialization

SubClass

Subclass

É um forma de dizer “Esse
objeto é semelhante a aquele
exceto...”


Cuidado com o Anti-Pattern
de Hierarquias Paralelas
Duplicidade, Complexidade e Acoplamento

Contrato Produto

ContratoDeSeguro ContratoDeSeguro

ContratoDePensão ContratoDePensão


Inner Class
Static and Non-Static


Instance
Specific
Behavior

Condicionais
Cuidado com a Duplicidade
public void display() { public void contains() {
switch(getType()) { switch(getType()) {
case MOUSE_DOWN: case MOUSE_DOWN:
//.. //..
break; break;
case SELECT: case SELECT:
//.. //..
break; break;
case MOUSE_OVER: case MOUSE_OVER:
//.. //..
break; break;
} }
} }


Imagine que você agora,
precisa adicionar um novo
tipo...

Será preciso alterar todos os
métodos incluindo um nova
entrada no swtich case
statement.

Delegation

A lógica comum deve ﬁca na
referring class e a especiﬁca
nos delegates.


Delegation
É comum passar a referência do delegador

// Graphic Editor
public void mouseDown() {
tool.mouseDown(this);
}

// Retangle Tool
public void mouseDown(Editor editor) {
editor.add(new RetangleFigure());
}

Ou Passe o Delegator no Construtor do Delegating Object


Pluggable Selector
Quando existem poucas implementações

Crie todos os métodos em uma única classe e armazene os
nomes dos métodos em Strings e chame-os através de
reﬂection. Como é feito no JUnit:

String name;
public void runTest() {
Class[] noArguments = new Class[0];
Method method = getClass().getMethod(name, noArguments);
method.invoke(this, new Object[0]);
}


Anonymous
Inner Class
public class Pato {

Habilidade andar = new Habilidade() {
public void fazer() {
//...
}
};

}


Anonymous
Inner Class
Difícil de Testar

Como a classe não possui nome é você não
pode expressar sua intenção facilmente

Pode tornar o código mais difícil de ler


?
O que você pode
fazer quando
precisa de alguma
funcionalidade que
não encaixa em
nenhum objeto


?
Que tal criar uma
classe cheia de
métodos estáticos
com essas
funcionalidades


Library Class
public class Collections {
//..
public static <T extends Comparable<? super T>> void sort(List<T> list) {
Object[] a = list.toArray();
Arrays.sort(a);
ListIterator<T> i = list.listIterator();
for (int j=0; j<a.length; j++) {
i.next();
i.set((T)a[j]);
}
}
//..
}


Library Class
Não têm Estado

Difícil de Testar

Procedural


Estado



State
Trabalha com valores que que variam ao
longo do tempo

“Olhe para o sol, espere uma hora e olhe
novo, ele já não estará mais no mesmo
lugar“


Cuidado!

Estado e concorrência
não se dão muito bem.


Separar Estados
Quando tiver dúvida,
pergunte-se se os atributos
devem nascem e morrem ao
mesmo tempo. Se a reposta
for sim, eles devem ﬁcar
juntos.

Access

Mantém a Flexibilidade limitando o
acesso ao estado


Access

A distinção entre acessar dados
armazenados e invocar computações é
uma dicotomia das linguagens de
programação.


Direct Access

Acessa o estado de um objeto
diretamente.

Geralmente utilizados em métodos
acessores e construtores.


Legibilidade

numeroDeFilhos = 10;

porta = 1;

abrirPorta();

porta.abrir();


Indirect Access

Acessa o estado de um objeto através de
métodos para aumentar a ﬂexibilidade


Indirect Access

“Minha estratégia padrão é permitir
acesso direto à própria classe, incluindo
inner classes, e acesso indireto à classes
clientes”
Kent Beck


Common State

Armazena o estado comum a todos os
objetos de uma classe.


Exemplo do Cartesiano
class Point {
int x;
int y;
}

Todos os atributos compartilham o
mesmo ciclo de vida.


Variable State
Armazena o estado que variam de
instancia para instancia em um mapa

Alta Flexibidade
Comunicação Pobre


Variable State
public class ObjetoFlexivel {

Map<String, Object> properties = new HashMap<String, Object>();

public Object getProperty(final String key) {
return properties.get(key);
}

public void setProperty(final String key, final Object value) {
properties.put(key, value);
}

}

Use preﬁxos para representar propriedades
relacionadas: border, borderColor, borderWidth...


Variable
Variáveis provêem um namespace para
acessar o estado.

Leitores devem entender facilmente o
escopo, o ciclo de vida e o papel de uma
variável.


Escopo
Local

Atributo
(Field)

Estático

+ Modiﬁcadores
(private, default, protected, public)

Local Variable
Variáveis Locais detém o estado de um
escopo único


Variável Local Coletora

Coleta Informações para uso posterior.

Geralmente são usadas no retorno de
métodos, neste caso chame de result ou
results.


Variável Local
Contadora
Um Tipo de Especial de Variável Coletora
que armazena a contagem de objetos.


Variável Local Explicatória
Quando há um cálculo complexa
armazene suas partes variáveis para
facilitar a leitura.

int top = 10;
int left = 10;
int heigth = 10;
int width = 10;

new Retangle(top, left, height, width);


Variável Local de Reuso
Quando você precisa utilizar o mesmo
valor mais de uma vez.

long now = System.currentTimeMills();
for (Clock each: getClocks())
each.setTime(now);


Field
Fields armazenam o estado de vida de
um objeto. Elas nascem e morrem junto
com o objeto.


Helper Field
Helper Fields guardam referências de
objetos que são usados por vários
métodos.

Se um objeto é passado por parâmetro
para muitos métodos, considere torná-lo
um ﬁeld


Flag Field
Flag Fields indicam que o objeto pode ter
dois tipos de comportamentos diferentes.
Se houver um setter para esse ﬁeld o
comportamento pode ser mudado ao
longo da vida do objeto.

Atenção: Se houver muitas consultas repetitivas a
ﬂag para determinar o comportamento do objeto,
analise a possibilidade de usar o padrão Strategy


Strategy
Quando você quiser expressar que
existem formas diferentes de realizar
parte do comportamento do objeto crie
um strategy ﬁeld.

Se ele puder mudar ao longo da vida do
objeto, crie um setter, caso contrário
deﬁna no construtor.


Components
Atributos componentes contém objetos
ou dados que pertencem ao objeto em
questão.

Carro Motor


Parameter
Parâmetros comunicam o estado durante
a execução de um único método


Parameter
Além de variáveis não privadas, a única
forma de comunicar o estado de um
objeto para outro é através de
parâmetros.


Parameter
O acoplamento introduzido por um
parâmetro é bem menor do que uma
referência de permanente (atributo) de
um objeto para outro.


Parameter
Quando um parâmetro se repete em
muitos métodos de um objeto, é muito
provável que ele deva ser uma atributo.


Collection Parametor


Passa um parâmetro para coletar
resultados complicados de múltiplos
métodos


void listar() {
List results = new ArrayList();
addTo(results);
return results;
}

private void adicionar(List elements) {
...
}


Optinal Parameter
Utilizado em métodos e construtores,
também conhecido como Telescoping
Pattern

public void mascarar() {mascarar(2,2);}

public void mascarar(int decimals) {
mascarar(decimals, decimals);
}

public void mascarar(int min, int max) { ... }


Parameter Object
Consolida longas listas de parâmetros
usados frequentemente em um objeto

setBordaExterna ( x,y,w,h );
setBordaInterna ( x+2,y+2,w-4,h-4 );

setBordaExterna ( borda );
setBordaInterna ( borda.expandir(-2) );


Constant
Armazena o estado que não se altera

Utilize variáveis static ﬁnal com nomes
em uppercase.

Cuidado setAlignment(CENTERED) não
comunica também como center()


• count: armazena contagens
• each: armazena elemento durante iterações
• result: armazena o valor que a função retornará


Nomeie variáveis de acordo com seus papéis



Role-Suggesting Name
Nomeie variáveis de acordo com seus papéis



Declared Type
Declara um tipo genérico para variáveis

List<Pessoa> candidatos =
new ArrayList<Pessoas>();


Inicialization

Eager Inicialization
Inicializa campos de um instancia em
tempo de criação

class Clube {
List<Pessoa> membros = Lists.newArrayList();
}

class Clube { ... Clube() { /* inicialização */ } }


Lazy Inicialization
Inicializa campos cujo valores são caros
de se calcular apenas antes de serem
usados pela primeira vez

public List<Pessoa> getMembros() {
if (membros == null) {
membros = Lists.newArrayList();
}
return membros;
}


Métodos

Intetion-Revealing
Method
Métodos devem ter nomes que revelem
seu objetivo e sejam intuitivos para que
um potencial invocador o descubra

Customer.findById(id);

iterator.hasNext();


Method Visibility
public, package, protected ou private?

“Revelar o mínimo possível
garante maior ﬂexibilidade”


Method Object
Esse padrão pode te ajudar a transformar
um código massivo aglomerado em um
método impossível em um código legível,
limpo e claro, que revela gradualmente
suas intenções ao leitor.


Method Object
Aqueles métodos, cheios de variáveis
temporárias e um montão de parâmetros
são ótimos candidatos se transformarem
em um objeto, tentar apenas fazer um
Extract Method, resultaria em sub-
métodos difíceis de nomear com dezenas
de variáveis.


Method Object
1. Crie uma classe com o nome do método

2. Crie um atributo para cada parâmetro, variável local e atributos do objeto
original usados no método.

3. Crie um construtor que recebe os parâmetros e atributos.

4. Copie o método original para a nova classe substituindo seus parametrôs
pelas referencias dos atributos da nova classe.

5. Altere a chamada do método na classe original

6. Se atributos eram deﬁnidos na classe original, obtenha-os por getters e
deﬁna-os.

7. Agora faça os extract methods necessários para tornar o código mais
legível.

Overidden Method
Métodos sobre-escritos são
uma forma clara de se expressar
variações.


Overloaded Method
Métodos sobrecarregados representam
formas alternativas de se invocar o
mesmo método.

Todos as versão sobrecarregadas devem
servir para o mesmo propósito, caso
contrário é melhor procurar um novo
nome.


Method Return Type
Identiﬁcam se o método é uma
Procedure (void) ou uma Function
(Object).

Generalize o tipo de retorno para
esconder detalhes de implementação.


Comentários
Expresse o máximo de informação
possível através de nomes e da
escreva
estrutura do seu código,
comentários somente para o
que não estiver óbvio.

Evite comentários redundantes.

Helper Method

São métodos private que compõe um
método público e tornam seu o código
mais legível e coeso.


Debug Print Method
Implemente o método toString() dos
objetos de forma a identiﬁcar seu
valor facilmente, essa prática pode
reduzir signiﬁcativamente o tempo de
debugging .


Conversion
Quando você precisa converter
um objeto de um tipo em outro de
um tipo diferente.


Conversion Method
class Farenheight {

public Celsius convertToCelsius(Farenheight f) {
...
}

}


Conversion Contructor
class Farenheight {

public Farenheight (Celsius c) {
...
}

}


Construtor
Deve representar a criação de um
objeto


Factory Method
Forma alternativa ao Construtor para
representar a criação de um objeto em um
método estático.

Calculadora c = Calculadora.criar();

Muito útil quando se precisa de caching ou
retornar diferentes subclasses dependendo
dos parâmetros.


Internal Factory
Quando criar ou calcular um objeto for
complexo, crie um método que cria e
retorna o novo objeto.

getX(){
if (x == null)
x = computeX();
return x;
}


Collection
Accessor Method
Como prover acesso a uma Collection?

public List<Livro> getLivros() {
return livros;
}

Qual o problema dessa
implementação?

Collection
Accessor Method
return livros;
}

Apesar de dar máxima ﬂexibilidade,
você perde o controle sobre um
atributo de seu objeto que pode ser
invalidado sem que você saiba.


Unmodifiable Wrapper
return Collections.unmodifiableList(livros);
}


Collection Accessor Method
public void addLivro(Livro livro) {}

public int getQuantidadeDeLivros() {}

public Iterator getLivros() {}

Uma boa prática é fornecer métodos que
para operações limitadas e signiﬁcativas.
Isso melhora a coesão, torna o código mais
legível e testável. E você ﬁca no controle.


Boolean Setting Method
procure usar

cache.ativar();
cache.inativar();

ao invés de
cache.setStatus(true);
cache.setStatus(false);


Boolean Setting Method
a menos que

if (booleanVar)
cache.ativar();
else
cache.inativar();

nesse caso

cache.setStatus(booleanVar);


Getting
Method


Setting Method
void setX(int x){ ... }

void centered(){ ... }


http://www.ﬂickr.com/photos/pong/288491653/sizes/o/

Safe Copy

public void getLivros() {
List<Livro> result = new ArrayList<Livros>();
result.addAll(this.livros);
return result;
}


Coleções

http://www.ﬂickr.com/photos/tambako

Array
Simples e Pouco Flexíveis

Tamanho Fixo
Sintaxe de Acesso Simples
Acesso Rápido


Iterable
Interface básica que permite apenas que
se realizem iterações e nada mais.


Collection
Oferece Adição, Remoção e Veriﬁcação de
Presença.


List
Elementos Ordenados que podem ser
acessados por sua localização.


Set
Um conjunto de elementos sem
duplicidade.


SortedSet
Um conjunto ordenado de elementos
sem duplicidade


Map
Um coleção de chaves ligadas a valores


Comunicação
As colections Java comunicam o que
são o que elas fazem. Esse é o grande

beneﬁcio de ter padrões.


Referência

Leia o Livro!

http://www.amazon.com/Implementation-Patterns-Kent-Beck/dp/0321413091


OBRIGADO!!!!

http://www.ﬂickr.com/photos/tambako

Implemention Patterns

Recommandé

Recommandé

Contenu connexe

Similaire à Implemention Patterns

Similaire à Implemention Patterns (20)

Plus de André Faria Gomes

Plus de André Faria Gomes (20)

Implemention Patterns