Conceito. Desenvolvimento com ZF

Fala pessoal tudo bom? Hoje não vou fazer um post mas sim deixar aqui um SLIDE que estou mostrando de forma conceitual e rápida como funciona o desenvolvimento ágil e prático com o Zend Framework ligado a outras tecnologias...

Desenvolvimento ágil com ZF

Valeu.

Entenda Singleton

Olá tudo bem? Hoje vou falar sobre um assunto muito interessante para o desenvolvimento atual, vou falar sobre Singleton!

Mas espera ai... o que é singleton? Pesquisei no google e vi que Singleto é um whisky.....
Sério um WHISKY! Eita, em um blog assim eu vou ficar falando sobre bebidas? 
Não! Na verdade SINGLETON é uma palavra muito falada atualmente no desenvolvimento mas muitas pessoas não sabem nem a que se refere e as vezes até falam por ai Oo'...

Singleton é um padrão de desenvolvimento(os famosos Design Patterns) . Sabe? assim como o MVC, DAO... Lógico que não é igual ao MVC,DAO pois não é possível que alguém tenha criado o mesmo padrão duas vezes não acham? O Singleton é na verdade bem específico pois sua proposta é para garantir a existência de uma única instância de uma classe, permitindo um acesso global a esta instância.

Quando é necessário utilizar?
Muitos projetos necessitam de classes que sejam instanciadas apenas uma vez, por exemplo:
Classes de conexão com banco de dados, entre outras. veja um exemplo prático do php.net (fique ligado[a] nos comentários do código)

1. 
   <?php
2. class Exemplo{
3.     // Guarda uma instância da classe
4.     private static $instance;
5.    
6.     // Um construtor privado; previne a criação direta do objeto
7.     private function __construct()
8.     {
9.         echo 'Sou um construtor';
10.     }
12.     // O método singleton
13.     public static function singleton()
14.     {
15.         if (!isset(self::$instance)) {
16.             $c = __CLASS__;
17.             self::$instance = new $c;
18.         }
20.         return self::$instance;
21.     }
22.    
23.     // Método exemplo
24.     public function latir()
25.     {
26.         echo 'Au!';
27.     }
29.     // Previne que o usuário clone a instância
30.     public function __clone()
31.     {
32.         trigger_error('Clone is not allowed.', E_USER_ERROR);
33.     }
35. }
36. ?>

Isso permite que uma instância única de Exemplo seja recuperada.

1. 
   <?php
2. // Isso falharia porque o construtor é privado
3. $test = new Exemplo;
5. // Isso sempre vai recuperar uma instância da classe
7. $test = Exemplo::singleton();
8. $test->latir();
10. // Isso irá emitir um E_USER_ERROR.
11. $test_clone = clone $test;
12. ?>

Conclusão

A utilização do pattern singleton permite uma facilidade maior no controle das classes que não devem ser instanciadas mais do que uma vez.
Normalmente uma classe singleton é utilizada em conjunto com uma classe factory que em breve eu irei explicar.

s-i-g-a-m-e @pv_fusion

Polimorfismo e Herança no PHP

Olá meus amigos e amigas tudo bem? Hoje vou falar de um assunto atípico dos meus posts... hoje vou falar sobre Polimorfismo e Herança no PHP. E se você acha que não existe isso no php tome cuidado com o que fala, o php vem evoluindo muito!

Uma classe é uma estrutura básica para a criação de objetos ou seja, vários objetos podem ser criados seguindo a mesma estrutura, porém com dados diferentes. 
Em algumas casos é necessários ter objetos idênticos com algumas funcionalidades a mais ou então com as mesmas funcionalidades, mas com comportamentos diferentes...

Herança

O que será esse carinha? Herança faz parte de um dos 3 pilares da POO uma herança é a
forma de um filho obter características do pai na vida real concorda? Na POO também é assim...

Por exemplo um carro e uma moto possuem características bem parecidas. Ambos possuem rodas e marchas que são semelhantes em qualquer veículo.
Pensando assim podemos dizer que carro é um veículo, assim como uma moto também é um veículo concordam? Logo carro e moto herdam características de veículo.

Esse exemplo é muito simples no php, e para herdar de uma classe utilizamos o 'extends' veja:

1. <?php
2. class Veiculo
3. {
4.         private $marcha;
6.         private $quantidadeRodas;
8.         public function passarMarcha()
9.         {
10.                 // código
11.         }
13.         public function andar()
14.         {
15.                 // código
16.         }
17. }
19. class Carro extends Veiculo
20. {
21.         public function __construct()
22.         {
23.                 $this->quantidadeRodas = 4;
24.         }
25. }
27. $carro = new Carro();
28. $carro->andar();
29. 
    

Veja só, criamos a classe veículo com atributos marcha e quantidadedeRodas e criamos uma classe carro que extende da veículo já com o construtor montando a quantidade de rodas. simples não? Herança SUALINDA :D


Polimorfismo

Poli o que? Oo'
POLIMORFISMO! Mas o que é isso? Vamos primeiro entender a palavra, polimorfismo significa muitas formas (poli: muitas, morphos: formas). Esse conceito é perfeito pois na POO significa que várias classes podem possuir a mesma estrutura e comportamentos diferentes. Quando utilizamos herança não apenas podemos reutilizar métodos da classe pai, como também podemos sobreescrever os métodos da classe pai, fazendo assim com que certas características sejam modificadas para a determinada classe.

Vamos imaginar que um banco possui dois tipos de cheques; o chque comum e o especial. Os dois possuem a mesma estrutura o que diferencia um do outro é a forma de cobrança de juros. O comum cobra 25% em cima do valor e o cheque especial o valor dos juros de 10% como podemos fazer sem escrever a mesma coisa? Assim:

1. 
   <?php
2. class ChequeComum
3. {
4.     protected $valor;
6.         // ... outros métodos da classe
8.         public function setValor( $valor )
9.         {
10.                 $this->valor = $valor;
11.         }
13.         public function getValor()
14.         {
15.                 return $this->valor;
16.         }
18.         public function calculaJuros()
19.         {
20.                 return $this->valor * 1.25; // soma 25% em cima do valor
21.         }
22. }
24. class ChequeEspecial extends ChequeComum
25. {
26.         public function calculaJuros()
27.         {
28.                 return $this->valor * 1.10; // soma 10% em cima do valor
29.         }
30.        
31.         public function calculaJurosPai(){
32.                 return $this->valor = parent::calculaJuros();
33.         }
34. }
36. $cheque = new ChequeEspecial();
37. $cheque->setValor(1000);
39. //CHAMANDO DA PRÓPRIA CLASSE
40. echo $cheque->calculaJuros();
42. echo "<hr>";
44. //CHAMANDO DA CLASSE PAI
45. echo $cheque->calculaJurosPai();

Antes de mais nada veja que na classe ChequeComum criei o atributo $valor com o acesso 'protect' ou seja, disse que ele é protegido assim pode ser acessado pela própria classe e classes que 'ligam' ela.

Perceba que na classe ChequeEspecial eu criei um método chamado calculaJurosPai ele foi apena para mostrar que se existir a necessidade do uso de um método sobrescrito devemos acessar ele paralelamente dessa forma (parent::).
Como exemplo eu criei o objeto e exibi os dois calcula juros...

Legal não é? Agora utilize =]

Obrigado e até a próxima