Objota O mundo orientado a objetos

Animação com JavaScript e imagens Sprite

Posted on junho 14, 2011

Posted by Rodrigo Ireno

Olá a todos caros leitores do objota, antes de mais nada gostaria de dizer que tem sido difícil arrumar tempo para postar, devido a alguns projetos. Mas finalmente consegui arrumar um tempo para me dedicar a mais um artigo no objota.

Neste artigo vamos falar sobre animação utilizando imagens sprite e javascript. Recentemente o site de buscas google.com.br utilizou no lugar de seu logo uma animação muito legal para homenagear uma artista - que não me lembro qual. Mas enfim, fiquei realmente intrigado com aquela bela animação e fui atrás de saber como funcionava aquilo. A base da animação utiliza um conceito bem conhecido: imagens sprite, muito utilizadas em layouts de site para maximizar o carregamento das páginas web. Seguindo esta mesma linha de raciocínio criei o tutorial abaixo.

Primeiramente vamos definir o que é uma animação. Uma animação é uma sequencia de imagens mostradas a uma velocidade que dá a ilusão de existir algo animado, mesmo com desenhos e imagens estáticas.

Sabendo disso, para dar continuidade ao artigo precisamos de uma seqüência de imagens, e para que nós possamos utilizá-la ela precisa ser transformada em um sprite, ou seja, unir todas em uma única imagem. Abaixo segue a imagem que utilizei:

Como pode ver a imagem acima é um sprite de uma seqüência de imagens para animação. Sabendo disso fica claro que para animar esta imagem precisamos movimentar o seu background-position. E o javascript será a ferramenta que iremos utilizar para fazer esta animação.

Eu mesmo implementei um objeto que chamei de MovieClip, não querendo irritar os "flasheiros", hehe.

Dica: Caso ainda não saiba como implementar objetos em javascript veja este artigo.

movie-clip.js

window.MovieClip = function(posx){
 var that = this;
 this.count = 0;
 this.posx = posx || [];
 this.interval = 0;

 this.play = function(){
 that.interval = window.setInterval(function(){
 var s = document.getElementById('sprite');
 s.setAttribute('style','background-position: -'+that.posx[that.count]+'px 0px;');
 that.count++;
 if(that.count >= that.posx.length)that.count = 0;
 }, 300);
 };

 this.stop = function(){
 window.clearInterval(that.interval);
 that.count = 0;
 that.interval = 0;
 };

 this.isRun=function(){
 if(that.interval > 0)return true;
 return false;
 };
};

exemplo.html

<html>
<head>
<title>Sprite</title>
<script type="text/javascript" src="movie-clip.js"></script>
<style type="text/css">
#sprite{
 width: 59px;
 height: 37px;
 background-image: url(RushRun.gif);
 background-repeat: no-repeat;
 background-color: #fff;
}
</style>
</head>
<body>

<div id="sprite"></div>
<input type="button" value="play" id="control"/>

<script>
/*
Inicio o objeto passando um array de valores do eixo X da imagem
iniciando de zero
*/
var filme = new MovieClip([0,59, 117, 177, 235, 294]);
var bt = document.getElementById('control');

bt.onclick=function(){
 if(!filme.isRun()){
 filme.play();
 bt.setAttribute('value', 'stop');
 }
 else{
 filme.stop();
 bt.setAttribute('value', 'play');
 }
};
</script>
</body>
</html>

Veja que neste exemplo de implementação você deve fornecer um array contendo as coordenadas para a animação do sprite. Também deve configurar o número de frames por segundo.

Isso também nos leva a um outro assunto, a qualidade da animação, assim como dos vídeos, depende muito do número de frames por segundo que ele exibe. Quanto maior a quantidade de frames por segundo melhor será a qualidade do vídeo ou animação. Claro, sem apelar para qualidade da imagem e etc.

Bom, este foi meu artigo sobre animação com javascript utilizando sprite. Porém com CSS 3 e HTML 5 a capacidade de criação e os feitos com javascript serão ainda mais incríveis, realmente não vejo a hora destes novos formatos serem adotados e consolidados.

Comente! Qualquer dúvida ou sugestão a respeito deste artigo! Bons estudos.

arquivos para download: js-sprite

Simulando herança em JavaScript

Posted on fevereiro 14, 2011

Posted by Rodrigo Ireno

Já faz algum tempo que escrevi um artigo de como fazer classes em javascript, porém foi somente uma introdução. Na verdade javascript não é uma linguagem orientada a objetos, ela somente possui alguns recursos que possibilitam simular este conceito de programação.

Se fossemos comparar com todos os recursos que Java (por exemplo) disponibiliza, seria uma completa injustiça, pois atende em peso este conceito. Enquanto javascript sustenta-se apenas com functions, prototipagem e alguns métodos especiais.

Mesmo assim consegue simular uma série de conceitos da orientação a objetos, como:

  • Estruturas de objeto
  • Herança de atributos e métodos – (entre functions)

E pode acreditar, com isso já dá pra fazer muita coisa. Então mão na massa.

Existem várias formas de se fazer esta simulação, mas vou mostrar os métodos que prefiro usar, pois demonstra ter mais organização.

Herança via métodos call e apply

Call:

call( objeto, argumento1, argumento2, argumento3)

Apply:

apply( objeto, ArrayDeArgumentos )

Ambos os métodos trabalham de forma igual, o que eles fazem é trazer o contexto do objeto chamado para dentro do seu objeto atual, não entendeu?.  Vendo é mais fácil!

function Pai( nome, sobreNome){
 this.nome = nome;
 this.sobreNome = sobreNome;
}

function Filho(nome, sobrenome, idade){

 //call chama construtor do objeto Pai
 Pai.call(this, nome, sobrenome);

 this.idade = idade;

 this.mostra = function(){
 alert("Nome completo: "+this.nome+" "+this.sobreNome+"\nIdade: "+this.idade);
 };
}

var objota = new Filho("Maria", "Bonita", 35);

objota.mostra();

Veja que neste exemplo o que fiz foi chamar o construtor do objeto Pai, utilizando a função call. E veja que passei os parâmetros nome e sobrenome.

Agora vejamos este outro exemplo utilizando o método apply. Prefiro esse pois você escreve menos! Hehehe.


function Pai( nome, sobrenome){
 this.nome = nome;
 this.sobreNome = sobrenome;
}

function Filho(nome, sobrenome, idade){

 //apply chama construtor do objeto Pai
 Pai.apply(this, arguments);

 //também pode ser:
 //Pai.apply(this, new Array(nome, sobrenome));

 this.idade = idade;

 this.mostra = function(){
 alert("Nome completo: "+this.nome+" "+this.sobreNome+"\nIdade: "+this.idade);
 };
}

var objota = new Filho("Maria", "Bonita", 35);

objota.mostra();

Como vimos anteriormente o método apply recebe um array com os argumentos, certo. Então. A grande vantagem dele é que podemos utilizar a propriedade arguments herdada do objeto global (que todo objeto em javascript possui). Ele é um array justamente com todos os argumentos necessários para a construção do objeto pai. A única vantagem é a facilidade de implementação caso o objeto em questão tenha muitos argumentos. Você escreve bem menos.

Estes métodos pra mim já dão conta do recado, se você quiser se aprofundar um pouco mais aqui vai pelo menos os nomes dos outros métodos utilizados.

Herança via Object masquerading

Herança via Prototype

Multipla herança

É isso galera, até a próxima. E qualquer coisa comente aí.

Classes e Objetos em JavaScript

Posted on outubro 31, 2010

Posted by Rodrigo Ireno

O objetivo deste artigo é apenas mostrar a curiosa forma que toma uma classe feita em javascript puro.

Muitos usuários da biblioteca prototype não fazem questão de fazer desta forma afinal, nem sempre é viável. Para quem não sabe prototype é uma biblioteca que maximiza o poder de orientação a objetos do javascript. Porém no nosso caso presente, não a utilizaremos.

Veremos algumas coisas básicas comparando uma classe em php, por exemplo, e a classe em javascript.

A primeira coisa que podemos ver é que o JS não possui um envoltório chamado class para isso ele usa function.

Php:

class MinhaClasse{
 	//Aqui o conteúdo
}

JavaScript:

function MinhaClasse(){
 	//Aqui o conteúdo
}

Ótimo, e o construtor da classe. Em php se utiliza um método com o mesmo nome da classe ou __constructe. E em JS..  não tem!! Isso mesmo. O conteúdo do construtor fica mergulhado juntamente com os atributos.

Php:

class MinhaClasse{
        private $nome;
 	public function MinhaClasse($novoNome){
 		$this->nome = $novoNome;
 	}
}

JavaScript:

function MinhaClasse(novoNome){
  	var nome;
        this.nome = novoNome;
}

Vejamos agora uma declaração  dos famosos métodos get e set:

Php:

class MinhaClasse{
        private $nome;
 	public function MinhaClasse($novoNome){
 		$this->nome = $novoNome;
 	}
        public function getNome(){
 		return  $this->nome ;
 	}
        public function setNome($novoNome){
 		$this->nome = $novoNome;
 	}
}

JavaScript:

function MinhaClasse(novoNome){
  	var nome;
        this.nome = novoNome;
        this.getNome=function(){
 		return this.nome;
 	};
        this.setNome=function(otroNome){
 		this.nome = otroNome;
 	};
}

Agora vamos ver uma peculiaridade do javascript de passar uma função via parâmetro, ou dados no formato JSON. Veja como é simples:

Função via parâmetro:

function hello(){
 	document.write("Oi objota!");
}
function executaPraMim(funcaoQualquer){
 	funcaoQualquer(); //pronto! Ele chama a função
}

//passo uma função já implementada ou..
executaPraMim(hello());

//implementa-se no ato da parametrização
executaPraMIm(function(){
 	document.write("Essa eu implementei agora!");
});

Muito bacana não é!

Agora vejamos um exemplo bem simples de uma função que recebe dados no formato JSON.


function mostra(dados){
	Alert("O nome é: "+dados.nome+"\nemail: "+dados.email);
}
//vejamos a chamada
Mostra({nome: "Objota", email: "objota@teste.com.br"});

Neste artigo vimos como implementar classes, receber funções via parâmetro e dados no formato JSON. Neste artigo quis mostrar algumas peculiaridades do JS, nada em especial. Somente algumas dicas aos curiosos. Abaixo temos os exemplos completos coloque os dois arquivos no mesmo diretório e inicie a índex.html.

É isso! Até a próxima. Dúvidas, postem aí! 😉

Classes.js


//Classe Carro
function Carro(){
    var placa;
    var cor;

    this.getPlaca=function(){
        return this.placa;
    };

    this.setPlaca=function(novaPlaca){
        this.placa = novaPlaca;
    };
    this.getCor=function(){
        return this.cor;
    };

    this.setCor=function(novaCor){
        this.cor = novaCor;
    };
}

//Classe Pessoa
function Pessoa() {

    //@interface
    var nome;
    var idade;
    var email;
    var carro;
    //@end

    //@constructe
    this.carro = new Carro();
    this.carro.setPlaca(7520);
    this.carro.setCor("Amarelo");
    //@end

    //@implementation
    this.getCarro=function(){
        return this.carro;
    };

    this.getNome=function(){
      return this.nome;
    };

    this.getIdade=function() {
      return this.idade;
    };

    this.getEmail=function() {
      return this.email;
    };

    this.setNome=function(_nome) {
      this.nome = _nome;
    };

    this.setIdade=function(_idade) {
      this.idade = _idade;
    };

    this.setEmail=function(_email) {
      this.email = _email;
    };

    this.mostraValores=function() {
      return 'Nome: '+this.nome+
             '<br/>Idade: '+this.idade+
             ' anos<br/>Email: '+this.email+
             '<br/>Carro:<br/>* Placa:'+this.carro.getPlaca()+
             '<br/>**Cor: '+this.carro.getCor();
    };

    //Recebe uma função por parâmetro e executa
    this.executa=function(i,funcao){
          if(i > 0)
          funcao();
    };

    //Recebe dados no formato JSON via parâmetro
    this.mostraJson=function(dados){
          return 'Id:'+dados.id_conteudo+'<br/>Nome: '+dados.nome;
    };
    //@end
}

index.html


<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Classes em javascript</title>
<script type="text/javascript" src="Classes.js"></script>
</head>

<body>
<script type="text/javascript">
  var Objota = new Pessoa();

  Objota.setNome('Objota - POO');
  Objota.setIdade(21);
  Objota.setEmail('email@objota.com.br');

  document.write(
    Objota.mostraValores()
  );
  document.write(
    Objota.getCarro().getPlaca()
  );

  //Altera placa do meu atributo carro, que é um objeto!
  Objota.getCarro().setPlaca(5051);

  //Passando função por parâmetro
  Objota.executa(1,function(){
      Objota.setNome('Rodrigo I.O.');
      Objota.setIdade(22);
      Objota.setEmail('bass_oliveira@hotmail.com');

      document.write(Objota.mostraValores());
  });

  //Passo dados no formato JSON via parâmetro {label: valor}
  document.write(Objota.mostraJson({id_conteudo: 50, nome: 'Manezinho'}));
</script>
</body>
</html>

Carrinho de compras orientado a objetos

Posted on setembro 1, 2010

Posted by Rodrigo Ireno

Carrinho de compras, por vezes temos curiosidade de saber qual é a melhor forma de implementar um. De fato não existe "melhor forma" existe a forma que funciona para a sua necessidade. Então vamos lá.

O objetivo deste artigo é mostrar como implementar um carrinho de compras utilizando sessão.

Para iniciar uma sessão e registrar variáveis nela é preciso iniciá-la com session_start(). Você pode ver nos seus cookies que vai aparecer um PHPSESSID que só permanecerá em seu computador durante a sua navegação no site. E bom, de fato isso é só pra te identificar.

Coloque esse session_start() no seu config.php

Quando jogamos variáveis ou objetos dentro de uma variavel de sessão o php gera um cookie no servidor, um arquivo de texto. Por isso não precisamos ficar com tanto medo de "sobrecarregar" a memória, pois isso fica no disco rígido e não na memória do servidor.

E qual é a grande vantagem de utilizar sessão, é que ela pode ser recuperada enquanto o usuário estiver navegando em seu site. Em qualquer lugar do seu site é possível criar uma veriavel na sessão e recuperá-la quando necessário.

Como seria isso?? Simples, você tem três paginas:

>index.php
>catalogo.php
>formulario.php

Vamos supor que o usuário navega pela index.php (session_start() já foi acionado lá no config), ele já tem uma PHPSESSID. Agora ele vai para o "catalogo.php" e escolhe alguns produtos. Ou seja, ele joga no carrinho (na sessão). A partir de agora é possível recuperar esse conteúdo em qualquer página fazendo a seguinte verificação:

	if(isset($_SESSION["nomeDaMinhaVariavel"])){
	//Entrou aqui, quer dizer que o valor existe.
	// e que você pode recuperá-la
	}

Bom, vamos então a nossa implementação, vamos criar um objeto Carrinho. E o objetivo deste carrinho é armazenar produtos. Vamos considerar os seguintes atributos para produto: id , nome, descricao.

id para podermos referenciar o produto escolhido, o nome do produto e uma breve descrição. Pois quando o usuário clicar em visualizar carrinho ele terá estas informações mais básicas para ver.

Vejamos a classe Carrinho, coloque ela no arquivo Carrinho.class.php para usar __autoload(), do último artigo!

Produto.class.php

<?php
class Produto{
	private $id;
	private $nome;
	private $descricao;
	private $quantidade;
	public function Produto($id, $nome, $descricao, $quantidade=1){
		$this->id = $id;
		$this->nome = $nome;
		$this->descricao = $descricao;
		$this->quantidade = $quantidade;
	}
	public function getQuantidade() {
		return $this->quantidade;
	}
	public function setQuantidade($quantidade) {
		$this->quantidade = $quantidade;
	}
	public function getId() {
		return $this->id;
	}
	public function getNome() {
		return $this->nome;
	}
	public function getDescricao() {
		return $this->descricao;
	}
	public function setId($id) {
		$this->id = $id;
	}
	public function setNome($nome) {
		$this->nome = $nome;
	}
	public function setDescricao($descricao) {
		$this->descricao = $descricao;
	}
}
?>

Carrinho.class.php

<?php
class Carrinho{
	private $produto;
	public function Carrinho(){}
        //Adiciona um produto
	public function addProduto(Produto $m){
		$this->produto[] = $m;
	}
        // Recupera um produto pelo id
	public function getProduto(int $idProduto){
		foreach($this->produto as $pro){
			if($pro->getId() == $idProduto){
				return $pro;
			}
		}
	}
        // Remove um produto pelo id
	public function removeProduto(int $idProduto){
		for($i=0;$i < count($this->produto);$i++){
			if($this->produto[$i]->getId() == $idProduto){
				unset($this->produto[$i]);
			}
		}
	}
        // lista todos os produtos
	public function listar(){
		foreach($this->produto as $pro){
			echo "<b>Código:</b> {$pro->getId()}<br/>
				  <b>Nome:</b> {$pro->getNome()}<br/>
				  <b>Descrição:</b> {$pro->getDescricao()}<br/>
				  --------------------<br/>";
		}
	}
}
?>

Depois de já criadas as entidades, vamos ao config, e depois as paginas que irão criar e recuperar o carrinho da sessão.

Config.php

Onde vamos configurar o __autoload()

<php
function __autoload($nomeClasse){
	//Verifica se existe a classe no diretório classes
	if(file_exists("classes/".$nomeClasse.".class.php")){
		//Se existe carrega
		include_once("classes/".$nomeClasse.".class.php");
	}
}
session_start();
?>

index.php

Onde vamos carregar o nosso produto

<php
include_once("config.php");

//Inicio o carrinho
$Carrinho = new Carrinho();

//Joga na sessão
$_SESSION["carrinho"] = $Carrinho;

//inicio dois produtos
$produto1 = new Produto(23,"Chave de Fenda","Chave de fenda blindada, com ponta em diamante");
$produto2 = new Produto(354,"Batedeira","Batedeira Braslenp, com três velocidades");

//Adiciona produto 1
$_SESSION["carrinho"]->addProduto($produto1);

//Adiciona produto 2
$_SESSION["carrinho"]->addProduto($produto2);

//Link para a página carrinho.php
echo "<a href=\"carrinho.php\">Meu carrinho</a>";
?>

Carrinho.php

Onde iremos recuperar o nosso produto da sessão

<?php
include_once("config.php");
//Recupera objetos da sessão
?>

<h2>Produtos no meu carrinho:</h2><br/>
<?php
if(isset($_SESSION["carrinho"])){
	$_SESSION["carrinho"]->listar();
}
else{
	echo "Não existem produtos no seu carrinho";
}
?>

Agora é só testar. utilize a estrutura de diretórios sugerida, ou uma de sua preferência.

Estrutura:
>index.php
>config.php
>carrinho.php
>classes>Carrinho.class.php
>classes>Produto.class.php

É isso meus caros, dúvidas e sugestões! postem aí. E até a próxima!

Utilizando arrays em classes

Posted on julho 21, 2010

Posted by Rodrigo Ireno

Olá, para quem já tem acompanhado meus artigos sobre php deve ter visto o último arrays e matrizes em php que mostrava como utilizar arrays em php. Neste artigo quero mostrar um exemplo prático com arrays em php em uma classe. Vendo todos os métodos de iteração.

Iteração

Este termo é usado para designar uma busca em um array. Quando digo que se deve iterar por um array, quer dizer que devo percorrer este array até encontrar algum valor ou algo assim. Para iterar por um array é preciso fazer uso de algum tipo de loop. Para não ficar nenhuma dúvida vou demonstrar como iterar por um array com diversos tipos de loop. Tudo isso dentro do paradigma de orientação a objetos.

Teremos neste artigo dois objetos. O objeto contato e o objeto agenda, que não passa de uma lista de contatos. Eis a primeira classe:

Contato


class Contato{
	private $nome;
	private $telefone;
	private $email;

	public function Contato($nome, $telefone, $email){
		$this->nome = $nome;
		$this->telefone = $telefone;
		$this->email = $email;
	}

	public function setNome($novoNome){
		$this->nome = $novoNome;
	}
	public function setTelefone($novoTelefone){
		$this->telefone = $novoTelefone;
	}
	public function setEmail($novoEmail){
		$this->email = $novoEmail;
	}

	public function getNome(){
		return $this->nome;
	}
	public function getTelefone(){
		return $this->telefone;
	}
	public function getEmail(){
		return	$this->email;
	}
}

A classe acima tem por objetivo representar a entidade lógica contato com todos os atributos relevantes ao nosso escopo. Vejamos adiante a classe Agenda:

Agenda


class Agenda{

	// Um array com objetos do tipo Contato
	private $contatos;

	public function Agenda(){
		$contatos = array();
	}

	//Adiciona contatos a lista
	public function addContato($novoObjetoContato){
		$this->contatos[] = $novoObjetoContato;
	}

	//Mostra todos os contatos com foreach
	public function mostraContatos1(){
	 	foreach($this->contatos as $obj){
	 		echo "Nome: {$obj->getNome()}<br/>
	 			  Telefone: {$obj->getTelefone()}<br/>
	 			  Email: {$obj->getEmail()}<br/>
	 			  -----------------<br/>";
	 	}
	}

	//Mostra todos os contatos com for
	public function mostraContatos2(){
	 	for($i=0;$i < count($this->contatos);$i++){
	 		$obj = $this->contatos[$i];

	 		echo "Nome: {$obj->getNome()}<br/>
	 			  Telefone: {$obj->getTelefone()}<br/>
	 			  Email: {$obj->getEmail()}<br/>
	 			  -----------------<br/>";
	 	}
	}

	//Mostra todos os contatos com while
	public function mostraContatos3(){
		$i = 0;
	 	while($i < count($this->contatos)){
	 		$obj = $this->contatos[$i];

	 		echo "Nome: {$obj->getNome()}<br/>
	 			  Telefone: {$obj->getTelefone()}<br/>
	 			  Email: {$obj->getEmail()}<br/>
	 			  -----------------<br/>";
	 		$i++;
	 	}
	}

	//Mostra todos os contatos com 'do while'
	public function mostraContatos4(){
		$i = 0;
	 	do{
	 		$obj = $this->contatos[$i];

	 		echo "Nome: {$obj->getNome()}<br/>
	 			  Telefone: {$obj->getTelefone()}<br/>
	 			  Email: {$obj->getEmail()}<br/>
	 			  -----------------<br/>";
	 		$i++;
	 	}while($i < count($this->contatos));
	}
}


Veja como iteramos pelo array. O foreach sempre itera por todo o array. Já com os outros tipos de loop posso ter mais controle sobre a iteração. Outra observação a fazer é o método nativo do php count() que retorna um número inteiro, referente ao número de elementos dentro do array.

Depois de feitas estas duas classes, vamos juntar tudo isso em um único arquivo php e executar para ver o que acontece. Copie as duas classes e cole uma e depois a outra. Depois das duas classes. Adicione este código, abaixo, (tudo entre tags php, lógico):


$obj = new Agenda();

// Instancio dois contatos
$contato1 = new Contato("Rodrigo","11-2222-5555","rodrigo@objota.com.br");
$contato2 = new Contato("objota","22-5555-1111","objota@objota.com.br");

// adiciono estes a minha lista
$obj->addContato($contato1);
$obj->addContato($contato2);

$obj->mostraContatos4();


Neste código é feita a inicialização do objeto Agenda e adicionados dois contatos. Após isso utilizamos o método mostraContatos() para mostrar todos os contatos já adicionados.

Repare que tão importante quanto utilizar métodos de iteração por arrays, vimos também um bom exemplo de orientação a objetos. Construímos duas classes, sendo que um objeto utiliza o outro. Todos em conjunto formam uma agenda.

obs: O loop mais rápido é o for, só uma dica! 🙂

Teste o arquivo e veja o resultado. Este artigo fica por aqui, até a próxima e bom aprendizado!

No próximo post vamos falar de conexão com o banco de dados! até!

Classes em php

Posted on julho 12, 2010

Posted by Rodrigo Ireno

Antes de ler este artigo.

Se você não conhece nada de php veja: Primeiros passos com php

E se não conhece nada sobre programação orientada a objetos veja: Conceitos básicos de POO – Abstração e Modularização

Se já leu estes artigos ou já conhece o assunto, vamos proseguir.

Neste artigo vou mostrar como fazer classes em php, porém antes de falar de classes é preciso antes falar de orientação a objetos. Caso você não tenha nenhum conhecimento de orientação a objetos, leia este artigo que escrevi sobre:

Abstração e modularização.

Se já sanou suas dúvidas sobre POO (programação orientada a objetos) vamos prosseguir, visto que já leu ou procurou sobre tal assunto vou utilizar termos referentes a tal assunto.

Regras básicas para se construir uma classe em php:

  • O arquivo deve ter o mesmo nome da classe
  • O nome da classe deve sempre iniciar com letra maiúscula
  • Toda classe deve sempre iniciar com a palavra chave class

Seguindo estas regras podemos então, ter a classe da seguinte forma:

<?php

class Pessoa{
	private $nome;
	private $cpf;

	//Método construtor
	public function Pessoa($nome, $cpf){
		$this->nome = $nome;
		$this->cpf = $cpf;
	}

	//Métodos de acesso
	public function getNome(){
		return $this->nome;
	}

	public function getCpf(){
		return $this->cpf;
	}

	//Métodos modificadores
	public function setNome($novoNome){
		$this->nome = $novoNome;
	}

	public function setCpf($novoCpf){
		$this->cpf = $novoCpf;
	}

	//Outros métodos

	public function mostraDados(){
		echo "O nome é: ".$this->nome."<br />
		     "e o cpf é: ".$this->cpf;
	}
}

?>

Como visto no exemplo acima o nome do método construtor deve ser o mesmo nome da classe. Sempre, caso contrário não será considerado um método construtor. Fica inicialmente  a dúvida de porque fazer “métodos de acesso” e “métodos modificadores”, pois bem. Tudo isso é feito para manter o encapsulamento do objeto pessoa.
Por hora basta saber que uma classe que é construída de forma a tornar o objeto bem encapsulado é uma boa prática de programação.

Como isso acontece?

Através das palavras chave public, private.

Essas palavras especificam a visibilidade de elementos da classe. Por exemplo, veja no exemplo anterior que declarei que os atributos da classe (cpf e nome) são private, ou seja, eles só podem ser referenciados diretamente de dentro da classe. Visto que ações externas não podem alterá-las ou acessá-las, foi preciso então utilizar-se de métodos que auxiliassem esta relação. São os chamados métodos de acesso e modificadores.

Em outras linguagens como Java é possível declarar public ou private para a própria classe.

Vejamos agora um exemplo funcionando do nosso objeto Pessoa.

Crie um arquivo com o nome de Pessoa.class.php. Por favor, por questão de organização tenha o costume de dar a seguinte extensão para arquivos que contém classes “.class.php”. Veja que o “ponto class” (.class) na verdade ainda é parte do nome, e que a verdadeira extensão ainda é (.php).

Crie e copie o exemplo 1 para dentro deste arquivo e salve. Agora veremos o exemplo 2.

<?php
//incluo minha classe neste arquivo
include_once("Pessoa.class.php");

//Instanciando ou Inicializando um objeto

// A variavel abaixo poderia se chamar joaozinho, caso vocÊ queira
	$obj = new Pessoa("Objota",333);

// Acesso o método modificador com (->), e altero cpf para '222'
	$obj->setCpf(222);

// Por fim chamo o método que mostra na tela
	$obj->mostraDados();

?>

Salve este arquivo com o nome de executar.php. jogue os dois arquivos dentro da pasta htdocs do seu servidor apache. E veja o que acontece. Se tudo der certo você verá a seguinte mensagem na tela:

O nome é: Objota
e o cpf é: 333

Obs: Lembrando que o método echo, nativo do php, imprime na tela toda string a sua frente até encontra um “;” (ponto-e-vírgula) que indica o final de uma linha de comando.

Veja também, um exemplo classe em java: Construindo uma classe
e note como é muito parecido com php.

Este artigo finaliza aqui. Dúvidas por favor deixe nos comentários. Até a próxima.

O objeto ArrayList

Posted on junho 29, 2010

Posted by Rodrigo Ireno

Neste artigo vou abordar brevemente o objeto ArrayList. Ele permite fazer uma coleção de valores e/ou objetos, ou seja, ele aceita valores primitivos e objetos. E é estremamente fácil de utilizar, pois não é necessário inicializar ele com um tamanho fixo, ele trabalha com um tamanho variável. Sendo que em qualquer momento você pode adicionar elementos e remover elementos.

Ele porém não faz parte do pacote padrão do java: java.lang...

Sendo assim é necessário fazer a importação de seu pacote, desta forma:

import java.util.ArrayList;

Este comando importa a classe ArrayList que se encontra no pacote java.util. Neste pacote existem outras classes, Como Iterator que pretendo demonstrar seu uso em futuros artigos.

Existe também a possibilidade de importar todo o conteúdo do pacote, porém isso deixa sua aplicação mais pesada:

import java.util.*;

esse comando importa todo o conteúdo do pacote.

Vejamos abaixo uma classe e um trecho de código, para executar:

//Aqui importo o pacote para dentro de minha classe
import java.util.ArrayList;

public class MinhaLista {
    private ArrayList lista;

    public MinhaLista(){
        //Instancio o objeto ArrayList
        lista = new ArrayList();
    }

    public void addItem(String valor){
        //O método add() adiciona um valor ao array, detalhe:
        //isso aumenta o seu tamanho dinamicamente
        lista.add(valor);
    }

    public void removerItem(int indice){
        //Este método remove o objeto que ocupa
        //o indice indicado por parâmetro
        lista.remove(indice);
    }

    public void setItem(int indice, String valor){
        //Este método altera o objeto que o ocupa o índice indicado
        lista.set(indice, valor);
    }

    public String getItem(int indice){
        // O método get() retorna o endereço de memória do objeto
        //que se encontra no índice fornecido por parâmetro
        //Por este motivo é preciso fazer uso de um casting (conversão de tipo)
        //Isso diz ao ArrayList que você quer o objeto e não seu endereço de memória

        return (String) lista.get(indice);
    }

    public void mostrar(){

        //Este é o loop for. Uma estrutura de controle que repete um comando
        //por um numero determinado de vezes

        for(int i=0; i < lista.size();i++){
            String n = (String) lista.get(i);

            //Este método println() recebe uma String como parâmetro
            //e imprime na tela.
            System.out.println(n);
        }
    }
}

Agora fiz uma outra classe para executar a classe MinhaLista. Abaixo temos o uso do método main() que  executa uma aplicação java.

public class TestaMinhaLista {
    public static void main(String[] args){
        MinhaLista obj = new MinhaLista();

        //Adicionando um item ao índice 0
        obj.addItem("Java");

        //Adicionando um item ao índice 1
        obj.addItem("Brasil");

        //Adicionando um item ao índice 3
        obj.addItem("Texto a ser removido");

        //Adicionando um item ao índice 4
        obj.addItem("Programação");

        obj.removerItem(2);

        //Mostro o conteúdo de minha lista
        obj.mostrar();

        System.exit(0); //Este comando encerra a aplicação
    }
}

Para ver este exemplo em funcionamento. Crie dois arquivos, sendo que o nome do arquivo que você criar deve ter exatamente o mesmo nome da classe, ex:

criei um arquivo no JGrasp com o nome de MinhaLista.java e dentro deste arquivo eu coloco a classe MinhaLista, aproveite pois é só copiar e colar. Em seguida clique no botão com símbolo "+" (na cor verde) e isso compila a sua classe .java e será visível a você que surge um arquivo com o mesmo nome do original, porém com uma estenção .class. Faça o mesmo com o arquivo TestaMinhaLista, compile-o e este em especial, por possuir o método main(), irá executar o programa. No JGrasp, visualizando a classe TestaMinhaLista execute o programa com o botão RUN. Veja o que acontece.

Dúvidas, por favor comente.

Instanciando objetos

Posted on junho 29, 2010

Posted by Rodrigo Ireno

Como visto no artigo anterior, construímos uma classe para representar um objeto do mundo real. Nós pegamos o objeto em questão e utilizamos como atributo somente o que nos for relevante, digo, o que for relevante para nosso módulo ou sistema.

No artigo passado, representei um objeto caneta. Porém para exemplificar vou utilizar um objeto um pouco mais simples. É o clássico é muito usado durante o aprendizado de iniciantes "objeto pessoa", não é nada de especial, porém muitos autores utilizam, pois é de fácil entendimento. Vamos a definição:

O que é preciso para diferenciar uma pessoa de outra no mundo... ..tá.. vamos pensar um pouco mais pequeno. Como representar uma pessoa como única em uma aplicação, pensando apenas no seu pais. É fácil! é só utilizar um atributo CPF. Agora,  seria bom colocar nome também, ora sejamos mais humanos! um atributo NOME já está de bom tamanho.

Já que definimos os atributos de nosso objeto, vamos montar sua estrutura em uma classe bem simples. Somente os atributos métodos de acesso e construtor. Vamos lá !

Classe pessoa:

public class Pessoa {

	private String cpf;

	private String nome;

	public Pessoa(String cpf,String nome ){
                //this.nome é o atributo da classe
                //e "nome" é o valor que vem por parâmetro
		this.nome = nome;

		this.cpf = cpf;

	}

	public String getNome(){
		return this.nome;
	}

	public String getCpf(){
		return this.cpf;
	}

}

Objeto construido, vamos a instanciação. Mas afinal de ocntas o que é instanciar..

Instanciar ou inicializar um objeto é o ato de trazer ele de uma lógica escrita para um objeto armazenado na memória em tempo de execução. Ou seja seu objeto vai para a memória do computador enquanto o aplicativo estiver rodando.

A palavra chave do java, usada para instanciar objetos,  e de muitas outras linguagens é new. Vejamos um exemplo:


//Declaro um objeto do tipo Pessoa

Pessoa obj = new Pessoa("333.666.777-22","Rodrigo");

//Pronto o objeto já está na memória e disponível para manipulação

Bom agora,  se eu utilizar o método getNome() terei acesso ao  dado armazenado no atributo nome, em tempo de execução. Agora para fixar melhor a idéia não tem jeito, tem que praticar. Para isso no próximo artigo pretendo falar de arrays, uma variável capaz de armazenar várias dentro dela.
Pretendo utilizar a nossa classe Pessoa, então até a próxima.

Conceitos básicos de POO – Abstração e Modularização

Posted on junho 29, 2010

Posted by Rodrigo Ireno

Olá, vamos abordar alguns assuntos importantes antes de iniciar na prática POO.
Antes de adentrar mais aos conceitos de POO, vamos fazer um breve comparativo entre o modo estruturado de programar e o Orientado a Objetos.  A programação estruturada é seqüencial, tudo é executado de uma vez em milhares de linhas com loops gigantescos e condicionais para controlar o fluxo da aplicação. Isso tornava o trabalho muito confuso depois de certo tempo desenvolvendo o projeto e a manutenibilidade mais complicada ainda.
A programação Orientada a Objetos é organizada em classes, entidades lógicas que representam objetos com suas características.
Sendo assim vamos a algumas das vantagens de se programar OO. A primeira melhoria que se vê neste jeito de se programar é a organização da aplicação, que é distribuída em diferentes classes. Cada uma fazendo uma tarefa específica. Juntas formam a aplicação.
Vamos então, abordar alguns conceitos básicos:

Abstração:
Faz-se uso deste conceito ao abstrair as coisas do mundo real e pegar somente o que for relevante para sua classe. Por exemplo, se eu quisesse fazer uma aplicação para manipular e armazenar dados de um carro para um estacionamento, eu deveria pegar os dados relevantes dos carros-clientes, como: Número da placa, cor, modelo, ano. Estes são chamados atributos. Muito falaremos de “atributos”, como sendo partes de classes. Um veículo tem muitas características, porém só nos interessa pegar o que nos for relevante para a aplicação.

Modularização:
Este é um conceito aplicado quando se trabalha em equipe. Uma vez que o engenheiro de software e analista validaram toda a lógica do projeto e já se tem em mãos a documentação das classes, o programador pode trabalhar em uma classe enquanto outros programadores fazem outras partes da aplicação. Um exemplo simples para entender como isso acontece:
Imagine um técnico em elétrica responsável pelas instalações de uma empresa em fase de construção. Ele não precisa saber como as paredes foram feitas ou de que material foram feitas para iniciar as instalações, só precisa de uma documentação, no caso uma planta do projeto que indique como serão feitas as instalações e quais os parâmetros que ele deverá seguir. Isso define bem a idéia, pois no caso de um programador, ele não precisa conhecer todas as implementações do projeto (o que chega a ser impossível), desde que ele tenha uma documentação adequada para fazer a sua parte.

Bom, é isso. Espero ter esclarecido um pouco mais alguns conceitos de POO.
Obrigado leitor, e até o próximo artigo.