No último post, comentei sobre classes internas comum e de métodos. Finalizarei sobre o assunto com este post. Onde estarei falando sobre: classes anônimas simples (em suas duas maneiras), classes anônimas definida no argumento e classes internas estáticas. Vamos lá!

Classes Anônimas Simples

Bom, de cara vamos achar estranho a sintáxe das classes anônimas, pelo fato de ser uma sintáxe não muito comum de se ver, exceto em: Swing, e alguns frameworks como o GWT da google. Segue abaixo um exemplo de como declarar uma classe anônima simples.

Olha ae! Definimos uma classe anônima. Mas, porque Anônima? Bom, como o próprio nome diz, e pelo o que vemos acima, é uma classe que não tem nome e sim uma referência a Car e onde teriamos a criação de um objeto, estamos na verdade definindo uma subclasse de Car, isso mesmo, quando declaramos classes anônimas estamos na verdade criando uma subclasse do tipo do objeto, não da referência. Dentro da classe anônima, pode ser feito qualquer coisa, que for feito em outra classe interna , até mesmo acesso aos seus membros.

Outro local, onde podesse ser empregado esta prática é na criação de implementadores. Exemplo, onde Car poderia ser uma interface, é o único local na linguagem Java, onde daremos um new em um interface. Com relação aos modificadores, segue a regra de qualquer variável local, se declarada em um método. Outra, não esqueção de adicionar o ponto-e-virgula depois da chave de fechamento (causará erro de compilação) e não podem conter membros static.

Classes Anônimas Definidas no Argumento

Das classes definidas no argumento, não tem muito o que se falar, devido a única diferença é a forma de declaração eo local obviamente. Veja.

Percebi, quase igual. Podendo também ser usada com interfaces, não pode ter membros static. Sobre classes anônimas acaba por aqui. Vamos entrar agora nas classes internas estáticas.

Classes Estáticas

As classes estáticas são declaradas fora de qualquer método, já vimos que as classes internas de método só podem ter com modificador (não relacionado a acesso) o final. As classes estáticas diferem das comuns, por não poderem acessar membros de instâncias e a forma de instância-las. Os modificadores são os mesmos da classes interna comum. Abaixo um exemplo da declaração.

Facil! – A maneira de instânciar uma classe estática é um pouco diferente, já que ela não precisa de uma instância de sua classe externa, para ser instanciada. Vejamos:

Para fixar, vou repetir mais uma vez, classes estáticas não tem acesso aos membros de instância da classe externa. E é isso ai, nossos posts sobre classes internas acabam por aqui!

Obrigado, até o próximo pessoal!

Ontem a noite estava voltando para casa eu e minha dignissíma ilustríssima exuberante linda devotada e maravilhosa esposa de carona com um casal de amigos e a irmã da nossa amiga (que é nossa amiga também) e iamos conversando sobre vários assuntos. De repente comentei que antes de vir para Curitiba (sim, eu moro aqui onde faz muito frio e até a gente mofa, sério!) eu estava cursando uma pós-graduação. A nossa amiga perguntou toda interessada:
- Sério? Fazia pós de que?
Eu todo solicito respondi:
- Programação Orientada a Objetos.
Nessa hora eu me senti o nerd dos nerds. Poxa vida, como eu fui idiota. Para mim programação orientada a objetos [momento advogado ON] daqui por diante referida como POO [momento advogado OFF] é comum como faca para açogueiro.
No meu contexto isso tão natural, mas tão natural que até minha mulher já está acostumada com alguns termos, técnicas e até piadas. Sério, sabe aquelas piadas de profissão, tipo “Existem 10 tipos de pessoas aquelas que sabem binário e as que não sabem”. Se você não entendeu essa piada tudo bem, você é normal e ainda goza de perfeita saúde, ok? Não precisa se preocupar, aqui tem uma explicação que você não precisa entender (para continuar a ler o post, pelo menos).
Então, como ia dizendo, isso para mim é tão natural que nem me toquei que ninguém mais no veículo, exceto minha esposa, fazia a menor idéia do que isso seria. Mas, como Deus é bom, a minha amiga perguntou:
- Mas o que é “Programação Orientada a Objetos”.
Neste momento foi que a situação ficou mais complicada. Veja bem caro amigo internauta, para fazer alguns universitários entenderem o que é POO ao longo de 2 ou 3 anos já é díficil. Agora imagina eu tendo que explicar da maneira mais simples possível para um público totalmente leigo no assunto o que é POO. É uma missão digna de Jack Bauer, Macgyver ou Chuck Norris.
Não sei se foi totalmente eficiente a explicação, sabe? O fato é que ou a explicação ficou realmente boa ou eles são camaradaços meus e ótimos atores porque o ar de “Nossa! Que Legal” e “Entendi! Isso é bom pra caramba” que eles fizeram dava para pintar um quadro, de tão nítido que foi.

A idéia deste post é justamente apresentar uma explicação nem um pouco técnica, mas sim didática e simples sobre o que é POO.

Vamos lá, apesar do nome ser bastante intuitivo ele não é muito claro, afinal alguém que ler isso pode pensar “Hummm, programação orientada a objetos deve ser para fazer programas para celular, TV, DVD player, afinal eles são objetos.”. Se você pensa não existem pessoas capaz disso então leia o post Estórias da Vida (1).

Vejamos como é simples. Exemplo: Neste presente momento você deve estar de frente com um monitor que está sobre uma mesa e você está sentado em uma cadeira. Monitor, mesa e cadeira são objetos. Mesa e cadeira são móveis certo? Então se fossemos fazer um sistema de loja de móveis  teriamos que dizer ao computador que ele está trabalhando com móveis.

Bom neste ponto já temos o objeto de negócio e o contexto que é loja de móveis.

O que é interessante para uma loja de móveis saber sobre todo e qualquer móvel que ela tenha?
Respondo, são altura, largura, comprimento, peso, cor e marca.
Isso são atributos dos objetos, no caso os móveis, independente de quais sejam os móveis tem esses atributos. Podem ter outros, mas consideremos apenas esses que são relevantes ao nosso contexto.
Em uma pseudo linguagem de programação seria isso:

Movel
atributos: altura, largura, comprimento, peso, cor marca.

No caso da cadeira ela terá tudo o que um móvel tem e uma caracteristica a mais: rodinhas. Uma cadeira pode ou não ter rodinhas. Isso seria um atributo exclusivo da cadeira além de ter todos os outros de móveis.

Cadeira é Movel
atributos: temRodinhas.

Nota: O computador já saberia que sendo móvel Cadeira tem os atributos dele e mais o que foram específicados aqui.

Além de atributos um objeto pode ter comportamentos. Vamos usar um monte de imaginação agora. Muita imaginação mesmo.
Digamos que o nosso sistema de móveis faz testes em cadeiras de rodas motorizadas (Eu disse que era para usar a imaginação, não disse?).
A cadeira de rodas motorizada (neste contexto que é bem absurdo, mas já que estamos usando a imaginação vamos desligar um pouco o realismo) seria um tipo de cadeira que tem rodas (atributo da cadeira) e um motor (atributo exclusivo da cadeira de rodas motorizada).

No caso teriamos uma cadeira capaz de ir em várias direções, mas como ela faria isso?
Digamos que para ir para frente o motor faria força nas rodas, para trás ele mudaria o sentido de rotação das rodas e faria força nelas, para virar para direita ele faria mais força na roda esquerda que na direita e para esquerda o contrário (Meio confuso né?).
Então em pseudo linguagem ficaria:

CadeiraDeRodasMotorizada é Cadeira
atributos: motor.

comportamento fazerForcaNasRodas com: intensidadeParaRodaEsquerda, intensidadeParaRodaDireita é:
rodarRodaComIntensidade usando: ESQUERDA, intensidadeParaRodaEsquerda.
rodarRodaComIntensidade usando: DIREITA, intensidadeParaRodaDireita.
fimDoComportamento.

comportamento irRetoParaFrente é:
fazerForcaNasRodas usando: 10, 10.
fimDoComportamento.

comportamento irRetoParaTras é:
inverterSentidoDeRotacaoDasRodas.
fazerForcaNasRodas usando: 10, 10.
fimDoComportamento.

comportamento virarParaDireita é:
fazerForcaNasRodas usando: 10, 5.
fimDoComportamento.

comportamento virarParaEsquerda é:
fazerForcaNasRodas usando: 5, 10.
fimDoComportamento.

Neste caso temos as seções de comportamento que diz quais comportamentos a cadeira de rodas motorizada tem e o que eles fazem. Não listei aqui como que acontece o inverterSentidoDeRotacaoDasRodas e rodarRodaComIntensidade e nem da onde veio o ESQUERDA e DIREIRA porque é para ser simples não considero relevante, até porque isso é só um exemplo e tinha falado sobre usar a imaginação, lembra?
Se quiser saber pode me contactar ou procure o curso de tecnologia mais próximo.

Se por acaso tivessemos uma cadeira de rodas motorizada que tivesse acento ejetável (imaginação meu caro, use a imaginação não o realismo) ela seria:

CadeiraDeRodasMotorizadaComAssentoEjetavel é CadeiraDeRodasMotorizada
atributos: assentoEjetavel.

comportamento ejetar é:
ativarAssentoEjetavel.
fimDoComportamento.

Neste caso a cadeira de roadas motorizada com assento ejetável teria os atributos de cadeira, de cadeira de rodas motorizada e mais um atributo que seria o assento ejetável. Além disso ela faria tudo que uma cadeira de rodas motorizada faz (irRetoParaFrente, irRetoParaTras, etc.) e além disso ela seria capaz de ejetar o assento.

Não quer usar a imaginação? Acha que uma cadeira de rodas  com assento ejetável é absurdo?
Então pense na seguinte situação: uma pessoa cadeirante usando a sua cadeira de rodas resolve descer uma ladeira, de repente quebram os controles de movimento, as engrenagem e freios de forma que a cadeira começa a acelerar rapidamente. No fim da ladeira está vindo um ônibus biarticulado (coisa comum em Curitiba, então a situação seria aqui, tá?). O motorista do ônibus está todo feliz e contente dirigindo o veículo e começa a andar porque o sinal abriu. Daí o cadeirante que está na cadeira desembestada ladeira abaixo vê que inevitávelmente irá colidir com o grande veículo de transporte coletivo. Antes da colisão garanto que ele pensaria: “Poxa, se minha cadeira fosse aquela com assento ejetável eu teria usado logo que ela começou acelerar”.
Pronto. Se tivesse sido uma cadeira motorizada com assento ejetável ele poderia ter se salvado.

Bem, justificativas a parte, depois dos comportamentos definidos basta usarmos eles atraves de uma tela, controle remoto ou seja lá como você imaginou que isto será feito.

É claro que na prática existe muito mais coisa do que isso, mas espero que com essa explicação e exemplo já dá para ter uma boa idéia do que é POO.

Ah, e principalmente, acho que já dá para explicar para quem não sabe nada de programação o que é POO ou passar esse post.

Visual Basic (VB) é uma linguagem de programação baseada na linguagem original de DOS chamado BASIC (Beginners ‘All-purpose Symbolic Instruction Code). VB.NET 2005, é um desdobramento do Visual Basic, é uma linguagem de programação orientada e baseada em VB que é implementado usando o Microsoft.NET Framework. É uma linguagem totalmente orientada a objetos.

Programação Orientada a Objetos

“Abstrair é tirar tudo que é essencial e nada mais.”
Aaron Walsh

Os 3 pilares da Programação Orientada a Objetos são:

• Encapsulamento: É um mecanismo interno do objeto, “escondido” do usuário, uma caixa preta, onde se mostra a saida mais não se mostra o processamento.
• Herança: É um mecanismo que nos permite basear uma nova classe a partir de uma existente.
• Polimorfismo: Polimorfismo é uma facilidade que permite que dois ou mais objetos diferentes respondam a mesma mensagem.

As camadas de um software são projetadas durante o projeto de arquitetura do software. Uma camada bastante relevante é a camada de persistência, embora nem todo software a implemente deixando para a camada de negócio controlar o armazenamento de dados.

O objetivo da camada de persistência é exatamente isolar das camadas de fronteira, negócio e controle o mecanismo de armazenamento de dados.

Em um projeto de software, especificamente utilizando o método de orientação a objetos, classificamos os objetos como transientes e persistentes. Um objeto transiente existe somente na memória principal durante a execução do programa, já o objeto persistente deve ter sua existência garantida ao término da execução do programa.

Um objeto deve ser persistido (armazenado) em meios de armazenamento permanentes – banco de dados ou arquivos tradicionais.

Geralmente é feito o mapeamento de cada classe para uma tabela de um banco de dados relacional. Cada atributo é mapeado para um campo da tabela.

As associações entre classes são implementadas no banco de dados por meio de chaves estrangeiras.

Quando a associação é de muitos para muitos, cria-se uma nova tabela que absorva as chavez primárias das tabela relacionadas (ou classes relacionadas).

A herança/generalização pode ser implementada:

- Criando-se uma tabela para a classe genérica e uma para cada classe específica;
- Utilizando-se uma tabela única que absorva todos os atributos da classe genérica e de todas as classes específicas;
- Ou criando uma tabela para cada classe específica.

Outra possibilidade é utilizar um banco de dados orientado a objetos, dessa forma não é necessário preocupar-se com o mapeamento de classes para tabelas.

Atualmente, a clássica modelagem de dados entidade-relacionamento mostra-se ineficiente e custosa de ser implementada juntamente com tecnologias recentes, como por exemplo, a programação orientada a objetos. Quando a modelagem entidade-relacionamento foi desenvolvida, não existiam perspectivas para aplicações mais complexas, juntamente com os tipos de dados complexos providos pelas mesmas.

A partir da década de 90, com o avanço do hardware e das interfaces gráficas, novas aplicações complexas (do ponto de vista de dados) começaram a surgir, proporcionadas pela orientação a objetos. A príncipio, bancos de dados relacionais eram utilizados nessas aplicações, entretanto era muito custoso mapear os tipos de dados necessários as aplicações para o modelo entidade-relacionamento. Surgiu então a necessidade por bancos de dados capazes de armazenar esses dados de forma simples e integrada com a aplicação, pois em orientação a objetos, tratam-se objetos e não registros e entidades, como propõem o modelo entidade-relacionamento.

Essa necessidade foi sanada com o surgimento dos bancos de dados orientados a objetos, que armazenam de forma nativa os objetos gerados pela programação orientada a objetos sem a necessidade de conversão ou mapeamento de um tipo complexo de dados criado em uma aplicação orientada a objetos para um modelo relacional.

Banco de Dados orientado a objetos: os objetos são armazenado naturalmente no banco de dados, sem a necessidade de mapeamento para tabelas em um banco de dados relacional.

Essa abordagem torna muito mais simples e conveniente a programação orientada a objetos e a manipulação dos determinados tipos de dados gerados por este tipo de programação.  Com o uso de um banco de dados orientado a objetos, a manipulação dos dados junto ao banco de dados torna-se algo natural, incorporado a linguagem em que a aplicação foi desenvolvida.

Retirado de AMORIM, Gabriel e BRAGA, Daniel. Bancos de dados orientados a objetos – uma abordagem prática utilizando o db4objects. UNIFIEO. Osasco – 2009.

Classe: Uma Estrutura de um determinado objeto, possui atributos e métodos para definir este objeto. Toda classe vai servi de base para criação de objetos.

Digamos uma Classe:

public class Carro{

private String color;

private Integer velocidadeMaxima;

public void setColor(String color) { this.color = color; }

public String getColor() { return this.color; }

public void setVelocidadeMaxima(Integer velocidadeMaxima) { this.velocidadeMaxima = velocidadeMaxima; }

public Integer getVelocidadeMaxima() { return this.velocidadeMaxima; }

}

Atributos e métodos:

Atributos: São opções que definem tua classe, forma correta é coloca-los private! Porque? Porque ninguém altera o valor deles direto, é um intermédio através dos métodos gets e sets.

Métodos: São funções que definem as opções da tua classe.

Método get: Utilizado para buscar o valor de um atributo da tua classe.

Método set: Utilizado para informar o valor de um atributo da tua classe.

Objeto: É a instanciação da Classe. É a definição do que vai ser tua classe. Como segue o exemplo abaixo:

public class AppMain{

public static void main (String[] Args){

Carro car = new Carro(); // Apartir do momento que tu utiliza o comando new: é instanciado um objeto.

car.setVelocidadeMaxima(160); //Setando a velocidade máxima para 160.

car.setCor(“Azul“); //Setando a cor do carro para Azul;

}

}

Desta maneira, você instanciou um objeto da tua Classe Carro e definiu qual seria o carro com que gostaria de trabalhar.

Esta é uma maneira prática de Definição de classe e objeto.

Classe é a receita do teu bolo, quando tu vai fazer um bolo, tu precisaria de uma receita. A classe é esta receita.

E o objeto é o bolo após você seguir as instruções da receita e saber o que deve ser posto ou o que deve fazer!

Primeira da Série sobre orientação a objetos.

Na próxima vez teremos assunto de interfaces e definições de classe.

Obrigado, qualquer coisa pode me contatar pelo meu e-mail.

Atenciosamente,

Jonathan Souza Santos

Programador Java (Web / Desktop / Mobile)

Twitter ~> http://twitter.com/JhonyProgrammer

Criar 2 construtores diferentes em PHP

Encontrei esse tópico aqui na minha análise de buscas dentro deste blog como um dos mais procurados, então resolvi que deveria comentar um pouco sobre esse caso.

Como o pessoal que acompanha esse weblog deve lembrar, concluí há pouco tempo atrás o curso da Academia do Java, na Globalcode, em São Paulo. Esse curso me ensinou muito (graças ao mestre Jedi, sr. Giulian Dalton Luz) sobre orientação a objetos.

Um dos tópicos abordados foi “overload“, que significa “sobrecarregar” um certo método (veja também, polimorfismo), fazendo com que ele possa ser chamado de maneiras diferentes, passando parâmetros diferentes ou nenhum parâmetro na sua composição.

Como funciona essa parte de OO no PHP? Do mesmo jeito que no Java, oras! Ou pelo menos, deveria ser, pois orientação a objetos é um conceito e não uma linguagem. Ela não pode ser diferente ou variável de acordo com o projeto.

Acontece que, pela gênese do PHP, a orientação a objetos foi adaptada, enquanto que no Java, ela é nativa. Isso dá margem a uma série de diferenciações.

Minha fonte foi o fórum da bytes.com:
http://bytes.com/topic/php/answers/497948-constructor-overloading-php

Se você tentar programar as seguintes linhas:

class Teste{
function __construct($usuario){
}
function __construct($usuario, $senha){
}
function __construct($usuario, $senha, $nome){
}
}

Receberá o seguinte erro:
Fatal error: Cannot redeclare Teste::__construct()

Em linhas brasileiras, isso é um erro fatal de redeclaração de método dentro de uma classe.

E agora? Se o overload dá esse erro, como eu faço? Redeclaração não é quase sinônimo de overload? Como pode existir overload se redeclarações não são permitidas?

Calma……………..

Atenção, pessoal!
Segundo o conceito do PHP, isso não é considerado gambi:

class Teste{
function __construct($usuario, $senha=”", $nome=”"){
}
}

Dessa maneira você pode codificar:

$x = new Teste(“usuario”);
ou
$x = new Teste(“usuario”, “senha”);
ou
$x = new Teste(“usuario”, “senha”, “nome”);

Os argumentos que não forem passados serão iguais a “”, que no caso é o valor default para $senha e $nome.

Isso acontece porque, segundo Janwillem Borleffs, overload é suportado no PHP, porém não da mesma forma como ele é suportado no Java.

Justo!

um abraço.

Vamos falar sobre a orientação a objeto. No começo pode parecer um bicho de sete cabeças, mas depois de entender a essência, tudo vai fluir de forma natural.  Vou dividir esse assunto em várias partes para que não fique um post imenso. E vamos começar falando das Classes (uhul… não podia ser diferente).

1 – Classes

Pense numa classe como um container de métodos e atributos. Vamos ao Exemplo:

Criamos a nossa primeira classe. Vou explicar algumas coisas sobre a nossa classe:
1 – Temos uma variável da classe com o nome “$nome” e ela tem o valor “oi” por padrão.
2 – Temos um método com o nome “mostra” que também é público.

Ok, algumas observações:
Como eu programo em Java, coloquei o nome da minha classe em maiúsculo. É um padrão que se segue, até pq no java, uma classe com nome em minúsculo o programa nem vai rodar, pq o compilador não irá deixar. Mas estamos falando de PHP.
No PHP não existe essa obrigatoriedade, eu coloquei apenas pq já é um costume meu. Mas poderia ser com o nome “foo” sem problemas.
Crie uma pasta classes e salve seu arquivo com o nome: class.foo.php. O nome pode ser qualquer um. Coloquei dessa forma por uma questão de padrões que é muito usado no php, salvar da seguinte forma: class.nome_da_classe.php.

Note que dentro do método mostrar() usamos o $this. o $this no PHP é usado pra dizer que eu to usando um método ou um atributo da classe em questão. No próximo post isso vai ficar mais claro. Ok, temos a nossa classe, então vamos a prática de usar a nossa classe. Vamos criar uma página chamada teste.php e vamos incluir nossa classe nessa página.

teremos a seguinte saída no navegador:
oi

Vamos a explicação:
Demos o include da nossa classe na nossa página teste.php. Criamos a variável foo e instânciamos a classe Foo pelo comando “new”. Toda vez que quisermos instânciar uma classe, devemos usar o comando new. Agora nossa variável $foo contém um objeto, que no nosso caso é a classe Foo.
chamamos o método mostrar() da classe Foo, com o seguinte comando:
$foo->mostrar();
Como isso foi possível?
Na variável foo, como já disse, temos nossa classe. Então na variável foo, temos uma referência a nossa classe Foo, que contém o método mostrar. Quando quisermos acessar um método ou um atributo da classe, usamos o “->” para acessar o que desejamos.
Se você quiser testar isso o que acabei de falar, execute o seguinte código:

Rode isso e você vai ver que será printado tudo o que existe na classe Foo, e que poderemos acessar pela variável foo, que é uma referência a nossa classe.

Pode parecer complicado, mas aos poucos iremos clareando tudo. No próximo post vou falar sobre tipos de visibilidade (o tal do public e os outros que iremos ver), vamos falar também de construtores e como modificar valores de atributos…. enfim, vai ser bem abrangente. E falarei mais sobre o $this. Isso as vezes causa uma certa confusão em quem está iniciando.

Um abraço e até a próxima!!!

Se você está iniciando no mundo de orientação a objetos ou apenas quer relembrar os pricipais conceitos, vai encontrar aqui uma vídeo aula bem descontraída. O vídeo vai te ajudar a entender com diversos exemplos do mundo real. Bom aprendizado!

Boa semana!

Poderíamos dizer muito a respeito da programação, baseada em objetos (OOP – Object-Oriented Programming). Para simplificar, as linguagens baseadas em objetos consistem em três maneiras principais para realizar a atividade de programação.

Toda função e grupo de funções inter-relacionadas (chamadas classes) não devem afetar os valores de dados em outras funções; a isso se chama encapsulamento.

A linguagem deve permitir que você reutilize grande parte do seu código em funções semelhantes, em lugar da velha maneira de copiar seu código antigo e efetuar alterações.

As funções que herdam características de cada uma das outras devem ter a possibilidade de se personalizarem, caso seja necessário; a isso chamamos de polimofirmos.

Para algumas pessoas é difícil a adaptação ao paradigma (ou modo de fazer as coisas) baseadas em objetos. Uma vez implementada, a OO facilita bastante o projeto que pode ser ampliado posteriormente com pouco trabalho.

Iniciando. . .

O uso de interface nos fornece alguns benefícios, os quais não são possíveis quando fazemos o uso de classes abstractas. Você pode se perguntar por que vou usar interface, se ela vai apenas especificar métodos e constantes, os quais poderia definir na própria classe. Que benefícios a interface trará que compensará, a criação de outro arquivo? Para responder estas perguntas vamos saber primeiro o que é essa tal de Interface.

O que é interface?

A interface pode ser vista como um contrato no qual uma ou mais classes irá seguir, ou seja, ao implementar uma determinada interface você estará assumindo a responsabilidade de fornecer uma implementação válida, dos métodos(abstractos) que nela foram definidos, a não ser que a classe de implementação seja abstract, sendo assim, a primeira classe concreta terá de fornecer implementação dos métodos declarados na interface. Puxando a sardinha pro meu lado, a Sun também implementou interface no Java, um dos motivos é pelo o fato de Java não ter herança múltipla, ou seja, uma classe só pode ter um “pai”, outro motivo, é que a interface nos dar maior flexibilidade de desenvolvimento, sem falar na possibilidade de trabalharmos polimorficamente nossas referências.

Exemplo da necessidade de interfaces

Temos duas classes abstracta: Eletronico e Computador; tenho também classe Notebook;
Como faria para criar a classe Notebook já que, ele é Eletronico e ao mesmo tempo é Computador, não teríamos como, pois como já falei só podemos herdar uma classe.

Implementando interfaces…

Aqui vamos ao mesmo tempo solucionar o problema acima, e aprender como implementar interfaces em Java. Primeiro criaremos as duas interfaces:

public interface Eletronico{
void ligar();
}

public interface Computador{
int calcular();
}

Antes de criarmos nossa classe implementadora, vamos conhecer todas as regras de implementação das classes abstractas. As regras são as seguintes:

• Fornecer a implementação dos métodos(caso não seja abstract);
• Seguir as mesmas regras de sobrecarga;
• Não alterar a assinatura, assim como o retorno;
• Não declarar novas exceções (com exceção de todas que sejam RuntimeException);
• Não é preciso declarar as exceções existentes no método da interface;

agora vamos criar nossa classe de implementação…

public class Notebook implements Computador, Eletronico{

//Instanciando um objeto Notebook, em uma referência a Computador (polimorficamente), benefício de se usar interfaces…
Computador nb = new Notebook();

//Defino a implementação do método, declarando uma RuntimeException, compila por ser uma exceção de Tempo de execução
public int calcular() throws RuntimeException{
return 1;
}

//Defino um corpo para o método de Eletronico
public void ligar() {

}

}

Vale lembrar que uma interface pode herdar(extends) mais de uma interface, mas nunca implentar(implements) uma interface. Bom galera este artigo termina por aqui, qualquer dúvida é só postar ai, que se estiver ao meu alcance, garanto que ajudo.

Confesso: O PHP é minha linguagem preferida.

Fico aborrecido quando eu tento comparar certas facilidades que algumas linguagens apresentam e comprovo que elas deixam a desejar no PHP.

O conceito de application é uma delas. No ASP é perfeito, no Java é perfeito e no PHP nem existe previsão de quando será implementado. #triste

Outra coisa é o polimorfismo. No PHP, eu acho polimorfético.

Segundo cita SOARES*, na página 291:

“Polimorfismo(…) É a capacidade de dois ou mais objetos responderem à mesma mensagem de diferentes maneiras. Em termos de classes podemos pensar em superclasses e subclasses, em que o mesmo método possui comportamentos e resultados diferentes na superclasse e nas subclasses, desta forma quem chama o método não precisa distinguir qual deve chamar.”

Uma boa definição, mas eu iria ainda mais longe ao opinar que o polimorfismo é uma propriedade das classes onde seus objetos instanciados podem ser vistos de maneira distinta pelo servidor ou pelo interpretador de acordo com o contexto onde eles são declarados.

Ficou confuso? Sim… Você tem um “ser humano”. Também possui dois tipos distintos de “ser humano”, onde um deles é “homem” e outro é “mulher”. “Homem” é um “ser humano” e “mulher” também é. Todo “homem” pode ser instanciado… referenciado… como “homem” ou “ser humano” e toda “mulher” pode ser instanciada… referenciada… como “mulher” ou “ser humano”. A diferença está em ver características a mais, a menos, ou comportamentos distintos de acordo com esse contexto onde você está referenciando o terráqueo em questão. Opa! “terráqueo” pode ser uma interface implementada por “ser humano”, logo, qualquer ser humano também pode ser considerado um “terráqueo”, a menos que descubram seres humanos em outros planetas… Isso é o Polimorfismo.

Mas e o PHP?

Os tipos em PHP são emulados, mas não precisam ser declarados, pois o PHP tem o conceito de “mixed” e “resource” que atrapalham um pouco ou polimorfismo, ou facilitam de acordo com aquilo que você precisa fazer. Às vezes é um saco, mas às vezes é uma mão na roda.

No mais, o máximo que eu vi de polimorfismo em PHP foi casting de ArrayObject pra Array, mas eu não posso dizer se isso está correto, a menos que você já opte por definir um array como uma coleção. O que no PHP não deixa de ser uma verdade.

Que seria mais ou menos isso:

$array = (array) new ArrayObject();

No Java você precisa de um List ou um Set pra fazer uma coleção usando array, porém no PHP você já trata o array como algo sem tamanho definitivo, ou seja, pode crescer, diminuir, classificar, etc, usando a API padrão, que já é o próprio PHP. A própria matriz de valores cresce, diminui e se comporta como uma coleção.

O exemplo acima é totalmente inútil no PHP porque você vai esperar que o interpretador do Apache veja a sua nova instância de ArrayObject como um array simples. Bicho… declara logo um array[] e pára de complicar o código!!!

Falando de ArrayObject, vou mostrar aqui algumas coisas mais interessantes a fazer com essa classe do que apenas casting inúteis.

O construtor do ArrayObject pode receber um array ou um outro ArrayObject. Quando o construtor não recebe parâmetros, ele é apenas uma instância vazia de um ArrayObject, sem implementação, porém, pronta para receber um elemento.

Pegando os exemplos da documentação do PHP:

Construtor

$array = array('1' => 'um',
'2' => 'dois',
'3' => 'três');

$arrayobject = new ArrayObject($array);

var_dump($arrayobject);

Append

Adiciona um elemento no ArrayObject

$arrayobject->append("O mundo do PHP"); // adiciona um elemento ao final

offsetUnset

Remove o elemento indicado

$arrayobject->offsetUnset(4); // retira o elemento do indice definido

getIterator

Pega um ponteiro navegável

$ponteiro = $arrayobject->getIterator(); // cria um ponteiro navegavel

getIterator()->current()/next()/key()/rewind()/seek(int $chave)/valid()

Funções navegadoras do Iterator. O valid verifica se o elemento da posição atual do ponteiro é ou não é nulo.

$ponteiro = $arrayobject->getIterator(); // cria um ponteiro navegavel

echo $ponteiro->current(); // pega a posição atual do ponteiro

echo "<hr>";

$ponteiro->next(); // manda o ponteiro para a proxima posição

echo $ponteiro->current(); //

Funções de ordenação/classificação

$arrayobject->asort(); // organiza por ordem dos valores

$arrayobject->ksort(); // organiza por ordem dos índices

uasort() e uksort()

Organizam por funções personalizadas de comparação, sendo “a” referente aos valores e “k” referente aos índices

// Função de Comparação

function cmp($a, $b) {

if ($a == $b) {

return 0;

}

return ($a < $b) ? -1 : 1;

}

// Array para classificar

$array_2 = array('a' => 4, 'b' => 8, 'c' => -1, 'd' => -9, 'e' => 2, 'f' => 5, 'g' => 3, 'h' => -4);

$arrayObject_2 = new ArrayObject($array_2);

print_r($arrayObject_2);

echo "<hr color=blue>";

// organiza e imprime

$arrayObject_2->uasort('cmp');

print_r($arrayObject_2);

echo "<hr color=blue>";

// Função de Comparação

function cmp2($a, $b) {

$a = preg_replace('@^(a|an|the) @', '', $a);

$b = preg_replace('@^(a|an|the) @', '', $b);

return strcasecmp($a, $b);

}

// Array para classificar

$array_3 = array("João" => 1, "A Terra" => 2, "Uma maçã" => 3, "Uma banana" => 4);

$arrayObject_3 = new ArrayObject($array_3);

// organiza e imprime

$arrayObject_3->uksort('cmp2');

foreach ($arrayObject_3 as $key => $value) {

echo "$key: $value\n";

}

echo "<hr color=blue>";

FLAGS

São diferentes modos de tratar o índice dentro de um ArrayObject

Por padrão as flags estão setadas para STD_PROP_LIST e ignoram as chaves como propriedades do objeto.

Para isso funcionar de uma maneira mais bacana, usamos ARRAY_AS_PROPS.

Veja o exemplo:

// FLAGS: Array e objectArray de frutas

$fruits = array("lemons" => "verde", "oranges" => "laranja", "bananas" => "amarela", "apples" => "vermelha");

$fruitsArrayObject = new ArrayObject($fruits);

// Tentando usar o indice como propriedade

print_r($fruitsArrayObject->lemons);    // por padrao as flags estao setadas para

// STD_PROP_LIST e ignora as chaves como propriedades

// Mudando a flag padrão

// ARRAY_AS_PROPS transforma chaves como propriedades

$fruitsArrayObject->setFlags(ArrayObject::ARRAY_AS_PROPS);

// Agora sim ele imprime o valor

print_r($fruitsArrayObject->lemons);

echo "<hr color=blue>";

Para trocar ou inserir um array do ArrayObject

exchangeArray($outroarray);

Para fazer a exportação de um ArrayObject para array sem usar o cast direto

$array = getArrayCopy($arrayObject);

Sempre que quiser testar, use esse script abaixo:

echo "<pre>";

echo htmlspecialchars( var_dump($arrayobject) );

echo "</pre>";

Existem outros métodos, como os “métodos Nat” que organizam um array pelo algoritmo de ordem natural.

Há também outros “métodos Offset”, como o offsetExists, offsetSet, offsetGet, que servem para manipular e verificar a existência de índices.

Todos eles bem bacanas.

Boa diversão!

Um abraço,

Diogo Besson

* SOARES, Walace. PHP 5 Conceitos, Programação e Integração com Banco de Dados. Segunda Edição. ISBN 85-365-0031-X. Editora Érica. São Paulo – SP. 2006

Estou disponibilizando aqui um material sobre alguns conceitos de orientação a objetos e alguns diagramas de UML que representam esses conceitos.

O arquivo pode ser baixado aqui.

Treinamento de OO ministrado hoje, 14/07/2009.

Atte,

Bem,

Muitos desenvolvedores iniciantes tem dificuldades em entender Orientação a Objetos.

Tentarei abordar alguns dos conceitos básicos nesse e nos proxímos capítulos. =)

A Orientação a Objetos surgiu com o intuito de “não reinventar a roda”. Com a intenção de não criar o que ja existe e sim, reutilizar e se preciso customizar para sua solução atual. Ganhando tempo e produtividade.

Primeiramente quero comentar que a Orientação a Objetos possui os seguintes principios: Encapsulamento, Herança e Polimorfismo. (comentarei sobre mais a frente…)

Vamos ao que nos interessa…

Um dos elementos de maior importancia na Orientação a Objetos são as Classes e por ela que vamos começar nossa explicação.

Clasess

Inicialmente, entenderemos Classes como tipos de dados compostos e os Objetos como as variaveis que utilizarão esse tipo de dado.

As Classes são modelos, ou representação de  algo real que queremos manipular em nosso desenvolvimento. Uma Classe determinará  todas as caracteristicas e ações que nosso objeto possuirá. Essas caracteristicas e ações sãos chamados de Atributos e Métodos.

Atributos são as caracteristicas do “algo real” que nossa classe está representando.

Ex.: Vamos imaginar uma Classe Pessoa. Os Atributos são as caracteristicas que uma pessoa possui.

Uma Pessoa possui como caracteristicas nome, idade, altura, sexo, etc…

Os Métodos são as ações que a Classe permitirá o Objeto executar (Método é apenas um nome bonito das funções [com ou sem retorno] em Orientação a Objetos).

Novamente utilizaremos a nossa Classe Pessoa, uma ação, ou função que pessoa pode fazer é: falar, andar, comer, etc…

Tudo que pertence a Classe é denominado Membros da Classe.

Por que falar de Classes se é Orientação a Obejtos???

Bem, como disse as Classes apenas descreverá tudo que o objeto vai possuir. São os objetos “o elemento” que eu irei manipular!!!

Objetos

Como disse anteriormente, Objetos são as variaveis que utilizarão as Classes como tipo de dados. Tudo que uma Classe representa um Objeto possui!!! As Classes servirão apenas como modelos,  o que irei manipular são Objetos!!!

Tudo que pertence a um Objeto é denominado Membros do Objeto.

Exemplos

(Para esse exemplo utilizarei como linguagem o Portugol.)

Vamos exemplificar uma Classe Pessoa.

classe Pessoa {

string nome;

int idade;

double altura;

string sexo;

atribuirNome (string nome) {

este.nome = nome;

}

falarNome () {

escreva nome;

}

}

Minha Classe Pessoa possui como atributos: nome, idade, sexo e altura. Como métodos possui: receberNome e falarNome. Que são as ações, funções uma Pessoa executará.

Uma Observação Importante…

Um Objeto será unico!!! Por mais que exista mais de um Objeto com carcteristicas semelhantes!!!

Objetos – Metodos e Atributos

Bem vindos.

Este é o primeiro post de uma série de posts sobre Padrões de Projeto (Design Patterns). Pretendo, nesta série, abordar alguns dos padrões mais utilizados. Pretendo usar Java nos exemplos de código, porém, em certas circunstâncias, disponibilizarei também os códigos em PHP.

Neste primeiro post dou uma idéia geral da história e do que são Padrões de Projeto.

A idéia original de Padrões de Projeto surgiu com Christopher Alexander, um engenheiro civil que propôs a criação de catálogos de padrões para arquitetura na década de 70. Segundo Alexander, “Um padrão descreve um problema que ocorre inúmeras\par vezes em determinado contexto, e descreve ainda a solução para esse problema, de modo que essa solução possa ser utilizada sistematicamente em distintas situações.“

Em 1987, a partir dos conceitos criados por Alexander, os programadores Kent Beck e Ward Cunningham propuseram os primeiros padrões de projeto para a área da ciência da computação.

Padrões para arquitetura de software são soluções de eficiência já comprovadas e amplamente utilizadas para a resolução de problemas comuns em projeto de software. Estas soluções são desenvolvidas e conhecidas por especialistas e tornam-se padrões por serem reutilizadas várias vezes em vários projetos e por terem eficácia comprovada.

A idéia de aplicar padrões de projeto no desenvolvimento de softwares ganhou popularidade com o livro Design Patterns: Elements of Reusable Object-Oriented Software , de 1995. Os autores, Eric Gamma, Richard Helm , Ralph Johnson e John Vlissides, conhecidos como Gang of Four(Gangue dos Quatro) descrevem no livro 23 padrões, hoje conhecidos como padrões GoF.

Os padrões GoF são divididos em 3 famílias: de criação, estruturais e comportamentais. Os padrões de criação são relacionados à criação de objetos, os estruturais tratam das associações entre classes e objetos e os comportamentais das interações e divisões de responsabilidades entre as classes ou objetos.

Posteriormente outros livros descreveram outros padrões de projeto, como o conjunto de padrões GRASP.

Dentre as principais propriedades dos padrões de projetos estão:

• Capturam o conhecimento e a experiência de especialistas em projeto de software;
• Especificam abstrações que estão acima do nível de classes ou objetos isolados ou de componentes;
• Definem um vocabulário comum para a discussão de problemas e soluções de projeto;
  Facilitam a documentação e manutenção da arquitetura do software;
• Auxiliam o projeto de uma arquitetura com determinadas propriedades;
• Auxiliam o projeto de arquiteturas mais complexas.

Dentre os principais benefícios para que a utilização dos padrões de projeto seja justificada estão:

• Fornecem soluções que já foram testadas e aprovadas;
• Tornam o sistema mais fácil de entender e manter;
• Facilitam o desenvolvimento de módulos coesos;
• A comunicação entre os participantes do projeto fica mais eficiente.

“Uma classe é o estêncil a partir do qual são criados (gerados) objetos. Cada objeto tem a mesma estrutura e comportamento da classe na qual ele teve origem. Se o objeto obj pertence à classe C, dizemos que obj é uma instância de C” (PAGES – JONES).

Poesia!