Design patterns – Factory (Fábrica)

Antes de começarmos, segue algumas pergunta/respostas:

  1. O que é padrão de projeto?
    R: http://pt.wikipedia.org/wiki/Padr%C3%A3o_de_projeto_de_software
  2. O que é Factory pattern (fábrica)?
    1. Explicação sobre o padrão Factory:R: http://en.wikipedia.org/wiki/Factory_method_pattern
      R: http://en.wikipedia.org/wiki/State_pattern
    2. Qual sua categoria?R: Criacional
    3. Sua estrutura padrão:Estrutura Básica

Bom, explicações dadas, agora vamos começar a brincar com nossopadrão. O exemplo usado foi de uma fábrica celular.

Com base na estrutura básica do padrão fábrica, criei as seguintes classes:

//Produto
    abstract class Celular
    {
protected string numero;
public Celular(string numero) { this.numero = numero; }
public abstract void Ligar(string numero);
   }

//Produto concreto.

class IPhone : Celular
{
public Hashtable Agenda = new Hashtable();
public IPhone(string numero) : base(numero) { }
public override void Ligar(string numero)
{
Console.WriteLine(“({0} ligando para {1}.”,this.numero,numero);
Agenda[numero] = ( Agenda[numero] == null)? 0 : Convert.ToInt32( Agenda[numero])+1;
}
}
class Nokia : Celular
{
public Nokia(string numero) : base(numero) { }
   public override void Ligar(string numero)
{
Console.WriteLine(“({0} ligando >>> {1}…”, this.numero, numero);
}
}

//Criador

abstract class Factory
{
private Celular celular;
public abstract void Criar( string numero);
public Celular Celular
{
get {   return celular;  }
set  { celular = value;  }
}
}

//Fábrica

class IPhoneFactory : Factory
{
public override void Criar(string numero)
{
this.Celular = new IPhone(numero);
}
}
class NokiaFactory : Factory
{
public override void Criar( string numero)
{
this.Celular = new Nokia(numero);
}
}

O Diagrama dessa implementação ficará assim:


Sua chamada ficará assim:

Anúncios

Criando um jogo da forca em 80 linhas com javascript puro [ nada de framework! ;-) ]

Esse artigo é básicamente para mostrar como é fácil desenvolver coisas legais em javascript, em apenas algumas linhas de código, sem depender de frameworks, basta colocar a caixóla para funcionar.

Então vamos ao código, simples e fácil! 😉

Diagrama de nossa ‘classe’:

function Forca(params){

var root = this,elemento = params.Elemento || document.body;
this.Palavras = params.Palavras || []; // vetor de palavras
this.Palavra = “”;  // palavra corrente
this.Erros = 0; // número de errros
this.Boneco = “”; // desenho do boneco

this.Teclado = function(){ // metodo responsável por montar o teclado.
var teclado = document.getElementById(“forca_teclado”);
if(!teclado){
teclado = document.createElement(“div”);
teclado.setAttribute(“id”,”forca_teclado”);
teclado.setAttribute(“class”,”teclado”);
for(var i = 65; i < 91; i++){
var tecla = document.createElement(“div”);
tecla.setAttribute(“class”,”tecla”);
tecla.innerHTML = String.fromCharCode(i);
tecla.setAttribute(“title”,String.fromCharCode(i));
if(tecla.addEventListener )
tecla.addEventListener(‘click’,function(){ root.Validar(this); },false);
else
tecla.attachEvent(‘onclick’,function(e){ root.Validar(event.srcElement);  });
teclado.appendChild(tecla);
}
elemento.appendChild(teclado);
}
}
this.Sorteio = function(){ //Método responsável pelo sorteio de uma nova palavra.
var novoIndice = Math.ceil(Math.random()*params.Palavras.length-1)
root.Palavra = params.Palavras[novoIndice];
var painel = document.getElementById(“forca_painel”);
if(!painel){
painel = document.createElement(“div”);
painel.setAttribute(“id”,”forca_painel”);
painel.setAttribute(“class”,”painel”);
elemento.appendChild(painel)
}
painel.innerHTML = “”;
for(var i = 0; i < root.Palavra.length;i++){
var letra = document.createElement(“div”);
letra.setAttribute(“id”,root.Palavra.substr(i,1));
letra.setAttribute(“class”,”letra”);
letra.innerHTML = “”;//root.Palavra.substr(i,1);
painel.appendChild(letra);
}
}
this.Validar = function(letra){   // Método responsável por validar e desenhar o boneco.
var desenho = document.getElementById(“forca_desenho”);
if(!desenho){
desenho = document.createElement(“div”);
desenho.setAttribute(“id”,”forca_desenho”);
elemento.appendChild(desenho);
}
var boneco;
if(root.Palavra.indexOf(letra.title) == -1){
this.Erros++;
switch(this.Erros){
case 1: root.Boneco += “\n   o”; break;
case 2: root.Boneco += “\n  \/”; break;
case 3: root.Boneco += “|”; break;
case 4: root.Boneco += “\\”; break;
case 5: root.Boneco += “\n  /”; break;
case 6: root.Boneco += ” \\\n <button onclick=’window.location.reload(true);’ style=’padding:0px;width:85px;border:1px solid black;’>GAME OVER</button>”; break;
}
desenho.innerHTML = ” <pre> “+root.Boneco+” </pre> “;
}
else
{
var indices = [];
for(var i = 0; i < root.Palavra.length;i++)
if(root.Palavra.substr(i,1) == letra.title) indices.push(i);
painel = document.getElementById(“forca_painel”).getElementsByTagName(“div”);
for(var i = 0; i < indices.length; i++)
painel[indices[i]].innerHTML =  letra.title;
}
}
this.Comecar = function(){ // Método responsável por iniciar tudo, criado só para deixar a chamada mais organizada!  😉
root.Teclado();
root.Sorteio();
}
}

A chamada do jogo ficará assim:

var parametros = { Elemento:/*algum elemento (div,e etc…)*/, Palavras:[/* um vetor de palavras, exemplo: “BRASIL”,”PADRE” */] }

var forca = new Forca(parametros);
forca.Comecar();

literalmente simples assim…

Para ver o jogo funcionando, acesse : http://migre.me/5ld1V

Uma simplória analogia entre caverna do dragão e uma empresa de desenvolvimento de sistemas.

( Empresa de desenvolvimento de sistemas = Caverna do Dragão )

O escritório geralmente fica num lugar longe pra caramba, cheio de perigos para chegar (Marginal Tietê, enchente, trânsito), onde você nunca sabe como chegou e tem que penar para sair. Na verdade quando você entrou nele parecia um parque de diversão, mas na verdade é o lugar onde você vai passar por todo tipo de perrengue antes de voltar pra casa!

Gerente de TI = Mestre dos Magos: Responsável por te colocar nas maiores enrascadas, sempre aparece do nada, pergunta umas paradas nada a ver, não tem reposta para nenhuma de suas perguntas, nunca ajuda e por ele você não sai nunca da Caverna do Dragão. Dizem que ele tem um poder e conhecimento ilimitado, mas você nunca vai ver em utilização. Se é que é verdade mesmo.

Suporte Técnico = Uni: Só faz volume no grupo, não tem nenhuma habilidade especial, não sabe falar (nem escrever), precisa ser salva a toda hora colocando a equipe toda em perigo. Na verdade ninguém sabe porque ela está na party, e sempre tem um que quer se sacrificar para ajudá-la. E no final, a party nunca vai embora sem a Uni!


Gerência de Projeto (PMO) = Vingador:
Como se não bastasse o Mestre dos Magos para encher o saco, o Vingador (que não tem nada a ver com você ou com seus problemas) vem toda hora te torrar a paciência, aumentando suas tarefas (ou enrascadas) e tentando te aterrorizar com prazos e atividades que você não pode cumprir. Na verdade a função principal dele ninguém sabe direito, mas é um dos seres mais temidos da Caverna do Dragão, que sempre aparece na hora errada e quando aparece você sabe que vem encrenca.


Equipe de Manutenção = Eric, Diana e Presto:
Tem um que sempre quer se defender de tudo quanto é bucha (com o escudo) e está sempre reclamando por isso, outro que é obrigado a fazer mágica para cumprir a demanda (com o chapéu), e no final todo mundo acaba tendo que pular todos os processos (com o bastão) para o sistema voltar a funcionar..


Equipe Desenvolvimento = Hank, Sheila e Bobby:
Sempre precisa conseguir fazer qualquer coisa (arma, defesa, corda, rede, programa em três camadas) com apenas um arco e flecha e tem sempre um novato que vem e acaba quebrando tudo o que funcionava perfeitamente (com o tacape). E a Sheila? Digamos que sempre tem um que desaparece quando mais se precisa.

Cliente = Tiamat: No fundo, só quer ter um pouco de sossego. É gigante e poderoso. A Uni (suporte) acha que ele vai  comê-la, por isso se caga de medo e perde a voz perto dele, o Vingador (PMO) que se acha o maioral, também treme na base e acaba cedendo a tudo o que ele pede, o Mestre dos Magos (Gerente) não ajuda em nada mesmo, só fica perguntando coisas sem sentido e some quando se precisa dele, e sempre sobra para a party (Manutenção e Desenvolvimento) se f*#% para vencê-lo a qualquer custo. E depois, com todo mundo cansado e sem paciência, o Mestre dos Magos e o Vingador voltam para trazer mais um desafio antes de te deixar voltar para casa.

enviado por Domingos de paola

Design patterns – State (Estado)

Antes de começarmos, segue algumas pergunta/respostas:

  1. O que é padrão de projeto? 
    R: http://pt.wikipedia.org/wiki/Padr%C3%A3o_de_projeto_de_software
  2. O que é   State pattern (estado)?

    1. Explicação sobre o padrão State:

      R: http://pt.wikipedia.org/wiki/State
      R: http://en.wikipedia.org/wiki/State_pattern

    2. Qual sua categoria?

      R: Comportamental

    3. Sua estrutura padrão:

      Estrutura Básica

  3. O que é um semáforo?

    R: http://bit.ly/mVxUVT

Bom, explicações dadas, agora vamos começar a brincar com nossopadrão. O exemplo usado foi de um semafóro de trânsito.

Com base na estrutura básica do padrão de estado, criei as seguintes classes:

public enum Sinal { VERMELHO, AMARELO, VERDE };

//Estado
public abstract class Status
{
public abstract Sinal Sinal { get; }
  public abstract ConsoleColor Cor { get; }
public abstract void ProximoStatus(Semaforo semaforo);
}

//Estados concretos.

public class Verde : Status
{
     public override ConsoleColor Cor { get { return ConsoleColor.Green; } }
public override Sinal Sinal { get { return Sinal.VERDE; } }
public override void ProximoStatus(Semaforo semaforo)
{
semaforo.Status = new Amarelo();
}
}

public class Verde : Status
{
public override ConsoleColor Cor { get { return ConsoleColor.Green; } }
       public override Sinal Sinal { get { return Sinal.VERDE; } }
public override void ProximoStatus(Semaforo semaforo)
{
semaforo.Status = new Amarelo();
}
}

public class Vermelho : Status
{
public override ConsoleColor Cor { get { return ConsoleColor.Red; } }
public override Sinal Sinal { get { return Sinal.VERMELHO; } }
public override void ProximoStatus(Semaforo semaforo)
{
semaforo.Status = new Verde();
}
}

//Contexto

 public class Semaforo
{
private Status status;
private ConsoleColor Vermelho = ConsoleColor.DarkRed;
private ConsoleColor Amarelo = ConsoleColor.DarkYellow;
private ConsoleColor Verde = ConsoleColor.DarkGreen;
public Semaforo(Status status)
{
this.status = status;
this.Desenhar();
}
public Status Status
{
get { return status; }
set
{
status = value;
Vermelho = ConsoleColor.DarkRed;
Amarelo = ConsoleColor.DarkYellow;
Verde = ConsoleColor.DarkGreen;
switch (status.Sinal)
{
case Sinal.VERDE:
Verde = ConsoleColor.Green;
break;
case Sinal.AMARELO:
Amarelo = ConsoleColor.Yellow;
break;

case Sinal.VERMELHO:
Vermelho = ConsoleColor.Red;
break;
}
this.AlterarSemaforo();
}
}
public void AlterarSinal()
{
status.ProximoStatus(this);
}
   private void AlterarSemaforo()
{
//código que aleterá as cores do semáforo.

}
private void Desenhar()
{
//código que desenhará o semáforo no console.
}

}

O Diagrama dessa implementação ficará assim:

Sua chamada ficará assim:

E o resultado final no console será :

Fonte : http://www.xmasters.com.br/francke/StatePattern.zip

public enum Sinal { VERMELHO, AMARELO, VERDE };