Faaaala povo! Alguém por acaso ainda lê isso aqui regularmente? Se lia com certeza já parou faz tempo. Não atualizo o blog faz meses. Como me desculpar não é algo digno de se fazer quando não posso prometer que irei mudar, vou me focar apenas em escrever algo interessante. Neste momento me apetece escrever sobre Software Design Patterns. Não que eu seja um grande programador, mas eu preciso treinar o conteúdo e acho que farei bem escrever enquanto estudo. Vou inaugurar então com este post a sessão Software Design Patterns no blog, onde irei em cada post falar sobre algum modelo para a padronização do código.

O primeiro Software Design Pattern, ou em bom português, Padrões de Projeto de Software, que irei falar é Abstract Factory.

Abstract Factory

Objetivo – definir uma interface para a criação de famílias de objetos relacionados ou dependentes, não fazendo uso do acesso direto as classes concretas. Através do uso de Abstract Factory é possível criar aplicações que diante variáveis do ambiente possam criar diferentes objetos através de métodos em comum.

Um exemplo comum é a criação de diferentes tipos de interfaces gráficas por uma aplicação através da detecção do tipo de ambiente a qual a aplicação está e execução. Outro exemplo, que será aqui demonstrado, é a criação de um objeto do tipo Customer ou Staff mediante a verificação da opção que o utilizador escolheu durante o cadastro. O modelo UML para o exemplo segue abaixo.

Segue o código em C++ que testa o Desing Pattern Abstract Factory.

abstract class PersonFactory {
public static PersonFactory getFactory(){

if( Form.isCustomerOrStaff() == “Customer” ){
return new CustomerFactory();
} else {
return new StaffFactory();
}
}

public abstract Person createPerson();
}

class CustomerFactory extends PersonFactory {
public Person createPerson() {
return new Customer();
}
}

class StaffFactory extends PersonFactory {
public Person createPerson() {
return new Staff();
}
}

abstract class Person {
public abstract void flush();
}

class Customer extends Person {
public void flush() {
System.out.println(“Storing customer data!“);
}
}

class Staff extends Person {
public void flush() {
System.out.println(”Storing staff data!“);
}
}

public class Form {
public static void main(String[] args) {
PersonFactory factory = PersonFactory.getFactory();

Person person = factory.createPerson();
person.flush();
}
}

O exemplo acima se inicia na classe Form. Após verificada qual a opção que foi escolhida durante o cadastro, a classe PersonFactory retorna um objeto estático capaz de criar objetos do tipo a qual foi pedido no formulário. Por fim, as classes concretas possuem sobreposição do método abstrato flush para a gravação dos dados (o que no código do exemplo não ocorre, se resumindo a mostrar uma mensagem).

Caso o exemplo acima seja demasiado simples, aqui e aqui você poderá obter outros cenários de uso do padrão de projeto Abstract Factory.

Até o próximo Desing Pattern! 🙂