Objota O mundo orientado a objetos

Utilizando spl_autoload_register

Posted on fevereiro 25, 2011

Posted by Rodrigo Ireno

Neste breve artigo quero mostrar como funciona a função spl_autoload_register que atua igualmente a  função __autoload. Neste caso o próprio nome já descreve em parte o que ela faz, pois esta função registra (ou empilha) mais conteúdo dentro de um escopo de autoload. Disse “escopo” e não função pois ela não pode ser utilizada junto com a função __autoload.

A grande vantagem de utilizar esta função é que você pode incluir módulos em seu sistema web sem se preocupar em incluir as classes deste módulo em seu class path. E utilizá-la é tão fácil quanto o autoload convencional.

Utilizando __autoload:

supondo que os arquivos Objota.class.php e Joao.class.php estão no mesmo diretório do arquivo index.php

Objota.class.php


<?php

class Objota{

 public function __construct(){
 echo "Incluiu Objota<br/>";
 }

}

?>

Joao.class.php


<?php

class Joao{

 public function __construct(){
 echo "Incluiu Joao<br/>";
 }

}

?>

index.php


<?php

function __autoload( $nomeDaClasse ){

 if(file_exists( $nomeDaClasse.".class.php"  )){
 include($nomeDaClasse.".class.php");
 }
 else{
 echo "Não foi possível carregar a classe";
 }

}

$obj = new Objota();

$o = new Joao();

?>

Utilizando a função spl_autoload_register:

Desta vez vamos supor que as classes Objota e Joao são de módulos completamente diferentes, por isso representei com nomes diferenciados., vejamos abaixo:

Objota.objota.class.php


<?php

class Objota{

 public function __construct(){
 echo "Incluiu Objota<br/>";
 }

}

?>

Joao.joao.class.php


<?php

class Joao{

 public function __construct(){
 echo "Incluiu Joao<br/>";
 }

}

?>

index.php


<?php

//funcao que carrega classes do modulo OBJOTA
function objota_carregar_classes( $nomeDaClasse ){

 if(file_exists( $nomeDaClasse.".objota.class.php"  )){
 include($nomeDaClasse.".objota.class.php");
 }

}
spl_autoload_register("objota_carregar_classes");

$obj = new Objota();

//funcao que carrega classes do modulo JOAO
function joao_carregar_classes( $nomeDaClasse ){

 if(file_exists( $nomeDaClasse.".joao.class.php"  )){
 include($nomeDaClasse.".joao.class.php");
 }

}

spl_autoload_register("joao_carregar_classes");

$jo = new Joao();

?>

Observação: A função spl_autoload_register sobrescreve a função autoload então se for adotar o uso desta, certifique-se de que nenhuma parte de seu sistema esteja usando o autoload convencional mas sim a spl_autoload_register.

Esta é uma solução, por exemplo, para a implantação do framework Smarty 3.0 ao seu sistema web. Pois ele utiliza esta função, e caso você não faça uso dela também, terá problemas.

Bom caros leitores este artigo (dica), fica por aqui. Caso haja dúvidas poste 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 Config para carregar suas classes

Posted on agosto 28, 2010

Posted by Rodrigo Ireno

Muito foi visto e comentado até agora a respeito de php e orientação a objetos, suas classes e recursos. Vamos então agora falar de um recurso muito importante do php na hora de utilizar suas classes.

Junto com este conceito, se você ainda não conhece, iremos falar de um arquivo chamado config. Que nada mais é do que um arquivo de configuração, onde se declara constantes do sistema (site), e onde geralmente se declara a função __autoload() do php.

Para este artigo vamos criar quatro arquivos:

index.php
config.php
Automovel.class.php
Carro.class.php

Config será nosso arquivo de configuração, index.php será o arquivo que será requisitado, e nossas classes serão carregadas pela função __autoload().

Como funciona o autoload?

Toda vez que você instancia um objeto esta função recebe por parâmetro o nome do objeto que você está instanciando. Sendo assim com o nome do objeto e uma pequena concatenação de string é possível incluir o arquivo da classe quando necessário.

Porém só é possível implementar isso uma vez, geralmente no config. Então fica bem mais fácil, pois você só precisa saber que pra carregar as classes é só dar um include no config.

Tendo isso em mente só é preciso estar atento a uma coisa. Mantenha um padrão de nomenclatura para suas classes, geralmente se faz assim:

NomeDaClasse.class.php -

O "NomeDaClass", em verde, é o mesmo nome declarado para a classe dentro do arquivo php. O final em vermelhor "class.php" é o sufixo adotado para a nomenclatura.

Vejamos abaixo um exemplo prático. Coloque as classes em um diretorio chamado classes e o restante dos arquivos no diretório raiz:

>classes>Automovel.class.php
>classes>Carro.class.php
>config.php
>index.php

Automovel.class.php


<?php
class Automovel{
	public function Automovel(){
		echo "Placa = BAE-5533<br/>";
	}
}
?>

Carro.class.php


<?php
class Carro extends Automovel{

	public function Carro(){
		parent::Automovel();
		echo "Numero de Rodas = 4";
	}
}
?>

config.php


<?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");
	}
}
?>

index.php


<?php
include_once("config.php");

//Instancio o objeto Automóvel
echo "<b>Instancio o objeto Automóvel</b><br/>";
$Automovel = new Automovel();

echo "<br/>";

//Instancio o objeto Carro
echo "<b>Instancio o objeto Carro</b><br/>";
$Carro = new Carro();
?>

Neste exemplo utilizamos um conceito já conhecido de um outro artigo, a herança de classes. Como deve ter visto na implementação, basta indicar o diretório das classes e a função autoload irá se encarregar de carregar as classes quando necessário. Veja que é você que tem que implementar esta função, por isso é muito importante verificar a existência do arquivo para depois incluí-lo, e use include_once ou include, pois caso ocorra algum erro no carregamento ele irá apresentar o erro, porém a aplicação seguirá em frente executando o resto do script.

Tudo certinho, agora acesse a página index.php e veja o resultado!

Bem mais fácil lembrar somente do endereço do config,  não !?

Esperimente criar mais classes no diretório classes. Até a próxima! 🙂

Classe de conexão com php utilizando PDO

Posted on agosto 22, 2010

Posted by Rodrigo Ireno

Olá neste artigo vamos aprender a fazer conexão com um banco de dados utilizando um recurso muito bacana que o php nos oferece, o PDO (PHP Data Object). Ele é um objeto que possibilita tornar sua "fábrica de conexões" - já vou exeplicar também - portável.

Imagine que você está usando o banco de dados MySql e que a vida é bela e seu sistema sempre usará este banco! lindo esse sonho não? 🙂

Tá! agora acorda! e veja como o mundo é cruel e as coisas não tão simples assim. Pois se você se baseia totalmente em usar funções como mysqli_connect() , mysqli_.. qualquer coisa., trate de terminar de ler este artigo!

E se esta galera! Estes métodos estão misturados em diversas partes do seu código! Vai te dar uma dor de cabeça sem tamanho, só de pensar em mudar de banco de dados. Pensando nessa, foi que desenvolveram um recurso no php, o PDO. Uma classe que se encarrega de fazer o gerenciamento dos drivers pra você. Isso mesmo! parece que existe uma luz no fim do túnel!

E lembra do que falei? - "fábrica de conexões"

Este é outro conceito muito usado, para garantir tanto uma certa organização quanto a integridade do banco de dados. É o pattern conhecido como Singleton.

Qual é a idéia? Manter uma instância única para que toda a aplicação possa utilizá-la. Veja como isso faz sentido ser utilizado principalmente para conectar-se com um banco. Toda vez que se conecta o banco abre uma porta, e se você criar conexões sem nenhum controle, dependendo do número de acessos que o seu site tiver ele vai derrubar o banco.

O conceito deste pattern está bem explícito na própria wikipedia, mas vamos fazer um código aqui também. Então vamos ao que intereça:

O PDO


/*
 Chega de funções, e funções. Tudo no método construtor do PDO
*/
$pdo = new PDO("tipoDeBanco:host=EnderecoDoHost;dbname=nomeDoBanco", "usuário", "senha" );

Veja só, o objeto já faz tudo numa tacada só. Depois disso é só ir trabalhando com ele e seus métodos de interface.

Executando uma query

Se estiver executando local, o host é localhost, senha não tem e usuário é root. Há e o tipo de banco de dados também!

<?php
try {
	// PDO em ação!
	$pdo = new PDO ( "mysql:host=localhost;dbname=tutorial", "root", "" );

	// Com o objeto PDO instanciado
	// preparo uma query a ser executada
	$stmt = $pdo->prepare("SELECT * FROM cliente");

	// Executa query
	$stmt->execute();

	// lembra do mysql_fetch_array?
	//PDO:: FETCH_OBJ: retorna um objeto anônimo com nomes de propriedades que
	//correspondem aos nomes das colunas retornadas no seu conjunto de resultados
	//Ou seja o objeto "anônimo" possui os atributos resultantes de sua query
	while ( $obj = $stmt->fetch ( PDO::FETCH_OBJ ) ) {

		// Resultados podem ser recuperados atraves de seus atributos
		echo "<b>Nome:</b> " . $obj->nome . " - <b>Telefone:</b> " . $obj->fone."</br>";
	}
	// fecho o banco
	$pdo = null;
	// tratamento da exeção
} catch ( PDOException $e ) {
	echo $e->getMessage ();
}
?>

obs: com a função fetch() é possível trazer os resultados de várias maneiras, este foi só um exemplo. O que determina o tipo de retorno é a constante "PDO::FETCH_OBJ", para mais informações vide manual. Sobre a função fetch().

Compare! um exemplo com o modo tradicional de conexão com MySql

Veja que está tudo dentro de um bloco try, catch. Para quem não sabe, o programa quando encontra um erro dentro de um bloco try, salta para o catch e consegue recuperar a exceção ou erro, por um objeto de exceção que vem por parâmetro. Para mais informações sobre o uso de pdo visite seu manual no site oficial do php.

A fabrica de conexões

Se você seguiu o link que existe ali em cima, já deve ter visto a página da wikipedia com exemplos em diversas linguagens do pattern Singleton, mas vamos terminar a coisa aqui pra não ficar dúvida! 🙂


<?php
class Conexao extends PDO {

	private static $instancia;

	public function Conexao($dsn, $username = "", $password = "") {
		// O construtro abaixo é o do PDO
		parent::__construct($dsn, $username, $password);
	}

	public static function getInstance() {
		// Se o a instancia não existe eu faço uma
		if(!isset( self::$instancia )){
			try {
				self::$instancia = new Conexao("mysql:host=localhost;dbname=conteudo", "root", "");
			} catch ( Exception $e ) {
				echo 'Erro ao conectar';
				exit ();
			}
		}
		// Se já existe instancia na memória eu retorno ela
		return self::$instancia;
	}
}
?>

Então fazendo uso desta classe toda vez que eu quiser fazer conexão com o banco eu uso o método implementado getInstance(), pois ele é quem vai me retornar uma conexão existente ou criá-la para mim.

Veja que eu coloquei direto alí os valores, senhas e talls.. pra conectar certo. Então, porém tanto pra php quanto pra java - falando de web - o ideal é centralizar todas as configurações em um único arquivo, para o site. Em java se faz uso do arquivo de configuração web.xml, já no php este arquivo de configuração geral é mais conhecido como config.

É nada mais nada menos que um arquivo com extensão .php que contem todas as configurações necessárias para o site. Acho que esse assunto ainda rende um post, vou colocar algo a respeito futuramente!
é isso obrigado por ler este post, e até a próxima! vlew 🙂

:: Este post possui uma complementação neste outro artigo! Usando Classe de Conexão com PDO (exemplos práticos)

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.

Construindo uma classe

Posted on junho 29, 2010

Posted by Rodrigo Ireno

Vamos iniciar este artigo fazendo um link com o anterior que falava sobre abstração e modularização.  Pois bem, quanto à modularização podemos dizer que a idéia é transformar um problema “grande” em vários pequenos. Assim fica mais fácil você se concentrar em um problema de cada vez...  E uma vez resolvidos passo a passo, os pequenos, você irá sanar o problema maior. Já quando se fala de abstração, estamos falando do “ato” que se realiza para construir uma classe. Vamos construir uma classe simples neste artigo, pode até ser com o bloco de notas. Porém, se quiserem já começar a utilizar uma IDE, dou todo o apoio. Aconselho a começar pela IDE JGrasp. Para os interessados segue:

(A ordem de instalação é importante, primeiro o JDK e depois a IDE)

1° - baixem o JDK – instalem. Não tem segredo o assistente de instalação fará tudo por vocês.

2º - baixem a IDE JGrasp – tem um link para download na barra lateral deste blog em “links úteis”. Esse também não tem segredo algum.

Bom para quem já tem tudo certinho funcionando, vamos começar a construção da classe. Primeiramente vamos lembrar o que é uma classe. Uma classe é uma entidade lógica que representa um objeto com suas ações e características, nem sempre um objeto é visível como em outras formas de desenvolvimento, como por exemplo ActionScript ou JavaScript.

Vamos então ao nosso objeto. É uma caneta. Quando se fala de caneta sei que existem vários tipos, porém me refiro a uma simples caneta esferográfica. Pois bem, vamos pensar que atributos uma caneta teria. Inicialmente eu diria de cara o atributo COR depois vem mais algum como tamanho: COMPRIMENTO e talvez um teste boleano (verdadeiro ou falso, no caso do Java usa-se as palavras chave true e false) para saber se existe tinta. Bem vamos então escrever a classe com estes atributos:

cor – da caneta
comprimento – em milímetros
temTinta  - verdadeiro ou falso, indica se há tinta na caneta.

Abaixo explicarei mais sobre esta estrutura.


public class Caneta{
private String cor;
private double comprimento;
private boolean temTinta;

// Construtor
public  Caneta(String novaCor, double novoComprimento, boolean novoValorTemTinta ){
cor = novaCor;
comprimento = novoComprimento;
temTinta = novoValorTemTinta;
}

// Métodos de acesso
public String getCor(){
return cor;
}
// (…)

// Métodos modificadores
public void setCor(String novaCor){
cor = novaCor;
}
//(...)
}

A estrutura: public class Caneta{  aqui vem o conteúdo da classe }

Indica que a classe é pública (outras classe podem usá-la) e que seu nome é “Caneta”, detalhe toda classe deve ser nomeada começando com uma letra maiúscula. Dentro das chaves, vai o conteúdo da classe.

Dentro dela são apresentados os seus atributos:


private String cor;
private double comprimento;
private boolean temTinta;

A palavra chave private indica que estes atributos só são visíveis dentro desta classe, e para que outra classe possa utilizar destes atributos é necessário implementar métodos específicos para isso. Veremos adiante. Em seguida vem o tipo do atributo, String indica que o atributo pode armazenar somente caracteres, ex: “ABCDabcd1234” – sempre dentro de aspas duplas. E por último vem o nome do atributo, que deve ser nomeado com letras minúsculas. Isso é considerado uma boa prática de programação.

Exemplo de boa prática de programação está na nomenclatura de seus atributos e variáveis

private String cor;    -    bom
private String Cor;    -   Não aconselhável
private String  nome;  -    bom
private String sobreNome;   -    bom, pois fica visualmente menos agrecivo.
private String SobreNome; - Não aconselhável

O método construtor


// Construtor

public  Caneta(String novaCor, double novoComprimento, boolean novoValorTemTinta ){
cor = novaCor;
comprimento = novoComprimento;
temTinta = novoValorTemTinta;
}

O método construtor é o responsável por inicializar um objeto com seu valor default. Um método construtor pode ter um conteúdo em seu bloco ou não. O bloco abriga as ações a serem executadas pelo método. O bloco é indicado abaixo:


public Caneta(){
//Aqui, entre as chaves,  vem o conteúdo do bloco.
}

O que vem entre seus parênteses, são os chamados parâmetros.
Parâmetros são valores que vem de fora do método para serem usados dentro do método. Neste caso eu estou atribuindo os valores dos parâmetros (valores que vem de fora) aos atributos: cor, comprimento,  temTinta.
veja:

cor = novaCor;

Se  a variável novaCor, que vem como parâmetro, armazena dentro dela o valor “amarelo” seria o mesmo que dizer:

cor  = “amarelo”;

Será mais fácil compreender estes conceitos quando instanciarmos objetos desta classe, porém vamos só tratar de entende-la, mesmo que superficialmente.

Métodos de acesso

// Métodos de acesso
public String getCor(){
return cor;
}

Métodos de acesso servem para acessar o valor de um atributo, por tanto cada atributo tem que ter um método de acesso. Vamos analisar a assinatura deste método. Ele inicia pela palavra chave public, que indica que ele é um método público, ou seja, visível tanto dentro da classe como foram dela. Em seguida vem a palavra String que indica o tipo de valor retornado pelo método. Por último vem o nome do método seguido de parênteses. O bloco é naturalmente indicado por um par de chaves {}. E dentro do bloco é utilizada a palavra chave return que no caso retorna o valor do atributo cor.

obs: Assinatura de um método indica entre outras coisas seu nome e parâmetros que recebe.
public void setCor()   // assinatura
{
//Aqui vem o bloco ou corpo do método
}
Métodos modificadores

// Métodos modificadores
public void setCor(String novaCor){
cor = novaCor;
}

O método modificador basicamente tem a função de modificar o valor de um atributo. Ele recebe um valor como parâmetro e atribui esse novo valor ao atributo. Note que na assinatura do método não é indicado um tipo de retorno, pois quando se usa a palavra chave void indica-se que não existe um valor a ser retornado. Visto que sua função é modificar e não retornar.

Bem caros leitores, por hora é somente isso. Nos próximos artigos veremos como instanciar objetos.

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.