Objota O mundo orientado a objetos

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!

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)

Herança e Polimorfismo

Posted on julho 30, 2010

Posted by Rodrigo Ireno

Herança

Herança em orientação a objetos é algo simples de se entender, pois assim como um filho herda características do pai uma classe também herda características de uma superclasse. A superclasse pode ser uma classe pai, avô ou bisavô.

Enfim a superclasse vem antes da classe atual. E assim como em uma arvore genealógica uma superclasse pode ser uma subclasse de alguém, e assim sucessivamente.

Então, assim como um filho que herda os olhos do pai, uma classe herda atributos de sua super classe. E assim como (desconsidero as especulações científicas) um filho herda o temperamento e algumas atitudes do pai, uma classe herda métodos de sua super classe.

Mais que herdar atributos e métodos de uma classe para outra, existe uma real vantagem nisso tudo. Reaproveitamento de código! Afinal se já programei um método que faz exatamente isso na superclasse, pra que fazer isso outra vez? Minha classe irá herdar estes métodos e atributos! Entenderam? É simples o entendimento deste conceito, porém muito mais difícil é aplicá-lo. Mas isso fica por conta das camadas mais altas. Analistas, Engenheiros e Arquitetos de software.

Para programar em php uma classe que herda atributos e métodos de uma superclasse é muito simples. Basta usar a palavra chave "extends"

Ex: classeFilho extends classePai. Isso fica lá em cima na assinatura da classe. Veja um exemplo abaixo:


<?php
class Automovel{
	private $numeroPlaca;
	private $numeroDeRodas;

	public function Automovel($Placa, $nRodas){
		$this->setNumeroPlaca($Placa);
		$this->setNumeroDeRodas($nRodas);
	}

	public function setNumeroPlaca($novaPlaca){
		if($novaPlaca > 999 && $novaPlaca <= 9999)
		$this->numeroPlaca = $novaPlaca;
	}
	public function setNumeroDeRodas($novoNumeroRodas){
		if($novoNumeroRodas > 0)
		$this->numeroDeRodas = $novoNumeroRodas;
	}

	public function getNumeroPlaca(){
		return $this->numeroPlaca;
	}
	public function getNumeroDeRodas(){
		return $this->numeroDeRodas;
	}

}

class Carro extends Automovel{

	private $modelo;

	public function Carro($Placa, $nRodas, $modelo){
		parent::Automovel($Placa, $nRodas);
		$this->setModelo($modelo);
	}

	public function setModelo($nomeModelo){
		$this->modelo = $nomeModelo;
	}
	public function getModelo(){
		return $this->modelo;
	}

}

$obj = new Carro(8945,4,"Phusca");

echo "Modelo : {$obj->getModelo()}<br/>
	  Placa : {$obj->getNumeroPlaca()}<br/>
	  Rodas : {$obj->getNumeroDeRodas()}<br/>";

?>

Como visto no exemplo acima, a classe Carro "extend", ou seja, ela se estende a classe Automovel. Herdando atributos comuns a qualquer automóvel, veja que para elaborar uma estrutura de classes desta forma é preciso analisar bem o problema.

Repare que instanciei no final um objeto do tipo Carro e ele chama pelo método getNumeroPlaca() e getNumeroDeRodas(), sendo que ambos foram implementados na superclasse Automovel.

Nas duas classes ao declarar os atributos, utilizei private, pois isso deixa com um baixo grau de acoplamento. Porém em algumas circunstancias é necessário que uma subclasse “veja” atributos da superclasse, como se fosse public. Para isso declare como protected então esses atributos serão visíveis somente para a classe herdeira. Vide exemplo, com as mesmas classes:


<?php
class Automovel{
	protected $numeroPlaca;
	protected $numeroDeRodas;

	public function Automovel($Placa, $nRodas){
		$this->setNumeroPlaca($Placa);
		$this->setNumeroDeRodas($nRodas);
	}

	public function setNumeroPlaca($novaPlaca){
		if($novaPlaca > 999 && $novaPlaca <= 9999)
		$this->numeroPlaca = $novaPlaca;
	}
	public function setNumeroDeRodas($novoNumeroRodas){
		if($novoNumeroRodas > 0)
		$this->numeroDeRodas = $novoNumeroRodas;
	}

	public function getNumeroPlaca(){
		return $this->numeroPlaca;
	}
	public function getNumeroDeRodas(){
		return $this->numeroDeRodas;
	}

}

class Carro extends Automovel{

	private $modelo;

	public function Carro($Placa, $nRodas, $modelo){
		//parent::Automovel($Placa, $nRodas);

		//Atributos da superclasse visíveis somente dentro da classe Carro
		$this->numeroPlaca = $Placa;
		$this->numeroDeRodas = $nRodas;

		//Isto é da clase Carro
		$this->setModelo($modelo);
	}

	public function setModelo($nomeModelo){
		$this->modelo = $nomeModelo;
	}
	public function getModelo(){
		return $this->modelo;
	}

}

$obj = new Carro(8945,4,"Phusca");

echo "Modelo : {$obj->getModelo()}<br/>
	  Placa : {$obj->getNumeroPlaca()}<br/>
	  Rodas : {$obj->getNumeroDeRodas()}<br/>";

?>

Polimorfismo

Junto com esse conceito de herança está vinculado algo muito útil. O polimorfismo. A própria palavra já explica um pouco: polimorfismo (muitas formas) aqui está uma idéia bacana, um objeto genérico que pode em qualquer momento assumir uma forma específica. Muito útil quando você não sabe que objeto vem por aí.

Por exemplo, um método que recebe um objeto por parâmetro que pode variar entre alguns tipos. Se você não tem certeza do que vem aí, por que colocar algo específico. Coloque algo genérico!

Como? Veja, agora teremos um terceiro objeto Moto e um objeto de exemplo por nome de Exemplo, que irá executar toda a história:


<?php
class Automovel{
	private $numeroPlaca;
	private $numeroDeRodas;

	public function Automovel($Placa, $nRodas){
		$this->setNumeroPlaca($Placa);
		$this->setNumeroDeRodas($nRodas);
	}

	public function setNumeroPlaca($novaPlaca){
		if($novaPlaca > 999 && $novaPlaca <= 9999)
		$this->numeroPlaca = $novaPlaca;
	}
	public function setNumeroDeRodas($novoNumeroRodas){
		if($novoNumeroRodas > 0)
		$this->numeroDeRodas = $novoNumeroRodas;
	}

	public function getNumeroPlaca(){
		return $this->numeroPlaca;
	}
	public function getNumeroDeRodas(){
		return $this->numeroDeRodas;
	}

}

class Carro extends Automovel{

	private $modelo;

	public function Carro($Placa, $nRodas, $modelo){
		parent::Automovel($Placa, $nRodas);
		$this->setModelo($modelo);
	}

	public function setModelo($nomeModelo){
		$this->modelo = $nomeModelo;
	}
	public function getModelo(){
		return $this->modelo;
	}

}

class Moto extends Automovel{

	private $modelo;

	public function Moto($Placa, $nRodas, $modelo){
		parent::Automovel($Placa, $nRodas);
		$this->setModelo($modelo);
	}

	public function setModelo($nomeModelo){
		$this->modelo = $nomeModelo;
	}
	public function getModelo(){
		return $this->modelo;
	}

}

class Exemplo{
	private $objetoGenerico;

	/*
		Veja! Declaro no parâmentro que aceito
		um objeto do tipo Automovel, assim posso
		receber tanto um objeto Carro como um Moto
	 */
	public function Exemplo( Automovel $obj){
		$this->setObjetoGenerico($obj);
	}

	public function setObjetoGenerico(Automovel $novoObj){
		$this->objetoGenerico = $novoObj;
	}

	public function Mostra(){
		if($this->objetoGenerico !== NULL){
			echo "Modelo : {$this->objetoGenerico->getModelo()}<br/>
				  Placa : {$this->objetoGenerico->getNumeroPlaca()}<br/>
			  	  Rodas : {$this->objetoGenerico->getNumeroDeRodas()}<br/><br/>";
		}
	}
}

//objeto do tipo carro
$carro = new Carro(9999,4,"Phusca");

//objeto do tipo moto
$moto = new Moto(4444,2,"Ronda");

$exemplo = new Exemplo($carro);

//mostra dados do carro
$exemplo->Mostra();

//muda de objeto
$exemplo->setObjetoGenerico($moto);

//mostra dados da Moto
$exemplo->Mostra();

?>

Veja que fantástica é essa organização! Como eu disse mais difícil do que compreender herança e polimorfismo é aplicá-lo. Mas isso já é outra história, este artigo fica por aqui e até a próxima meus caros. Dúvidas? Postem a vontade.

próximo artigo: Vamos voltar a falar de conexão com banco de dados, desta vez usando um objeto. 🙂

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 – Glossário

Posted on julho 15, 2010

Posted by Rodrigo Ireno

Olá caros leitores, este artigo é uma definição sumária de cada elemento de uma classe. Utilize este artigo para consulta, sempre que necessário. Sendo um glossário será atualizado toda vez que surgir conteúdo novo.

Classe:

Uma classe em php assim como em outras linguagens tem um conjunto de métodos e atributos que tem por objetivo implementar uma entidade lógica, que pode ser baseada no mundo real ou não.

Atributos:

Um atributo representa, para classes e orientação a objetos, um dado específico, uma característica de uma entidade lógica. Em geral se deve considerar atributo um dado (característica) muito relevante de tal objeto, que é indispensável para cumprir com sua finalidade na aplicação. Por exemplo, uma classe Pessoa deve com certeza conter um atributo nome, cpf... e outros registros que tornem este indivíduo único. Um classe Automovel deve conter um atributo muito relevante, o número da placa, por exemplo.

Atributos e a visibilidade:

Em orientação a objetos se ouve muito de herança, encapsulamento. Em geral construir uma classe com um bom encapsulamento é uma boa prática de programação. Para tanto, é preciso sempre declarar seus atributos como private e fazer uso de métodos modificadores e de acesso

Método:

Um método consiste em um trecho de código que é escrito ( implementado) uma vez. Sendo possível executá-lo quantas vezes for necessário simplesmente chamando-0 pela sua assinatura.

Método construtor:

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.

Em php pode-se declarar um método construtor de duas formas. Pode-se dar o nome do construtor igual ao nome da classe, isso é padrão para muitas linguagens. Ou é possível também declarar com o método nativo do php "__construct()".

Método de acesso:

Métodos de acesso são necessários quando um atributo é declarado como private. Tem a ver com a visibilidade do atributo em questão. Quando o atributo é público não é necessário um método de acesso, porém o objeto fica com um nível alto de acoplamento, e isso é ruim na orientação a objetos. Quando se utiliza private o atributo é inacessível fora da classe exceto atravez deste método, que tem por objetivo retornar o valor contido neste atributo.

Método modificador:

Tem por finalidade modificar o valor de um atributo da classe. Geralmente ele recebe o novo valor por parâmetro. Quando necessário é aconselhável fazer uma lógica de validação deste dado de entrada, para somente então atribuir este novo valor ao atributo da classe.


static:

Em php,  atributos ou métodos declarados como estáticos faz deles acessíveis sem precisar instanciar a classe. Um membro declarado como estático não pode ser acessado com um objeto instanciado da classe (embora métodos estáticos possam).

protected:

Esta palavra chave  limita o acesso a classes herdadas (e para a classe que define o item). Este conceito já é fio para entrar em herança e polimorfismo. Em termos mais simples, protected é o mesmo que public, somente para quem herda o método ou atributo. E para quem não herda nada protected tem o mesmo efeito de um private.

const

Utiliza-se esta palavra chave para transformar o atributo de uma classe um valor constante e inalterável. Para acessar uma constante de uma classe usa-se está sintaxe: NomeDaClasse::NomeDaConstante. Isso irá retornar o valor da constante existente na classe. É muito usual para números fixos usados durante o desenvolvimento, por exemplo o status de um usuário no seu site: 0 = desabilitado; 1 = habilitado; 2 = pendente; e etc. sendo mais fácil a associação de palavras.. do que de números fica mais fácil usar constantes como Status::DESABILITADO; Status::ABILITADO; Status::PENDENTE.

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.

Arrays em java

Posted on junho 29, 2010

Posted by Rodrigo Ireno

Deixando de lado ( só um pouco) as classes, vamos agora tratar de um elemento muito útil em qualquer linguagem de programação. O array.

Um array e um elemento que existe em praticamente todas as linguegens de programação, que é capaz de armazenar vários valores dentro dele. Sendo possível armazenar diversos valores dentro dele, tembém é preciso um modo de recuperar este falor, que é atravez de um índice.

Algumas linguagens possuem arrays de tamanho fixo e variável, que é o caso do java. Em outras como php o array tem tamanho sempre variável. Bom sendo assim vamos exemplificar como seria o armazenamento de valores dentro de um array, em java.
No java,  elementos não primitivos são objetos e todos os objetos devem ser inicializados com a palavra chave new. Para utilizar um array de tamanho fixo em java é preciso especificar seu tamanho durante a inicialização, veja:


int[] meuArray = new int[16];

 meuArray[0] = 23;
 meuArray[15] = 40;

Tomando nota do código acima, já é possível ter uma idéia de como funciona. Tenho um array de números inteiros, vamos aos detalhes.

Ao instanciar um array de tamanho fixo, é preciso determinar o número exato de elementos que ele poderá suportar. Neste caso o array suporta 16 números inteiros. Para poder referenciar um valor dentro deste array, eu utilizo a chave ou índice do array. É aquele [indice] abre-colchete :  índice  : fecha colchete. Sendo que a contagem dos índices começa a partir do zero, então o primeiro elemento está no índice 0, e o último elemento está no índice 15.

Veja que eu atribui um valor 40 ao índice 15, portanto meuArray[15] retornará a partir de então o valor 40.

Arrays são muito utilizados em conjunto com loops, estruturas de controle que repetem determinado comando. veja um exemplo:


//    Veja um exemplo com o loop for

int[] meuArray = new int[3];

meuArray[0] = 50;
meuArray[1] = 25;
meuArray[2] = 48;

// ou esqueça o feito anterior e faça assim..

int[] meuArray = {50, 25, 48};

// O resultado é o mesmo

for(int i=0; i < meuArray.length;i++){

 System.out.println(meuArray[i]);

}

//    O loop acima itera por todo o array e imprime na tela todo o seu conteudo.

Bom este é o exemplo de array de tamanho fixo, porém o java possui um array de tamanho variável, ou seja, você não precisa determinar um tamanho específico para ele. E é usado justamente quando não se tem certeza do que vem por aí para preencher o array.

Apresento, o ArrayList do  pacote java.util.ArrayList. Como ele faz parte de um pacote não incluso por padrão, ele deve ser importado com o comando import.

Mostrarei um exemplo completo no próximo artigo. desta vez com classes inteiras.

até.

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.

Iniciando em programação – Tipos de linguagem

Posted on junho 29, 2010

Posted by Rodrigo Ireno

Olá, neste artigo quero fazer uma breve abordagem sobre linguagens de programação, e citar algumas de suas propriedades.

As linguagens são divididas de acordo com suas características, tipo de aplicação ou estrutura:

Baixo nível: Assembly

Estruturadas: Cobol, Basic

Procedurais: C, Pascal, FORTRAN, ADA

Funcionais: PROLOG e LISP

Orientadas a Objeto: Smaltalk, C++ e Java

Específicas: Clipper e SQL

4ª Geração ou visuais: Visual Basic e Delphi

Linguagem de Baixo Nível:

Estão mais próximas ao código de máquina (mais próximas ao hardware). Por tanto estão vinculadas ao processador da máquina. Um exemplo para isso seria o fato de que existe um conjunto de instruções diferentes para processadores Intel 486, Pentium etc;

Exemplo ASSEMBLY:

As máquinas processam as informações baseadas em uma lógica boleana. É o conceito do ‘0’ e ‘1’, ou seja, circuito ligado ou desligado. Essa, porém é a linguagem binária, utilizada para comandos do hardware. Sendo ela muito confusa e difícil de programar, optou-se por resumir cadeias inteiras de ‘0’ e ‘1’ que representavam um comando específico e transformá-lo numa palavra que tivesse relação com o comando.

Exemplo:

Imagine o seguinte comando: “pular para determinado endereço”

(É somente um exemplo e não um comando!)

Em linguagem binária:

01100110011000110011100110011000011001

Em Assembly:

JMP

É com certeza bem mais fácil escrever JMP – que vem do inglês ‘jump’ e tem certa relação com o termo citado acima.

Linguagens Estruturadas:

São linguagens que não possuem vínculo ao processador utilizado e a semântica de termos é mais genérica podendo ser utilizada em outras plataformas;

Seu ciclo iniciou-se em 1960 com o COBOL e 1963 com a linguagem BASIC.

COBOL:

COmmon Business Oriented Language –

Linguagem comum orientada a negócio;

Criada para o desenvolvimento de aplicações comerciais: estoque, contabilidade, folha pagamento. Disponível em todas as plataformas existentes.  Atualmente possui versões orientadas a objeto e visuais.

Linguagens Procedurais:

São consideradas subtipos das linguagens estruturadas;

Permitem maior clareza de sintaxe e organização;

Estruturas:

If..then..else

case/switch

for..

while

do until.

Veremos estas estruturas nos próximos artigos

Linguagem C:

Surgiu da necessidade de uma linguagem de alto nível para o desenvolvimento do sistema operacional UNIX na década de 70. É uma linguagem genérica utilizada para criação de processadores de texto, planilhas, sistemas operacionais, comunicação, automação, banco de dados etc.

Outras Representantes:

PASCAL: utilização científica e educacional (1968)

FORTRAN: Formula Translation – científica (1966)

ADA: Baseada no Fortran e Pascal (1978)

Possui conceitos modernos:

  • Reuso
  • Portável
  • tempo real.

Linguagens Funcionais:

Baseado na avaliação de expressões e fundamentos matemáticos.

Estilo diferente de programar;

Requer conhecimento específico.

Exemplos:

PROLOG: (França, 1973) – Uso simples – base matemática

LISP: Baseia-se estudos de Inteligência artificial - 1980

Linguagens Específicas:

SQL (Structured Query Language);

Linguagem de acesso a banco de dados;

São executadas pelos SGBDs;

Clipper (1980-1990)

Base em C e Smaltalk;

Usada para acessar base de dados Dbase;

Dominou o mercado comercial entre 1988-1995 devido as restrições de memória e espaço em disco dos computadores da época (XT, 286, 386)

Linguagens Específicas:

HTML (Hyper Text Markup Language);

Permite a formatação de textos e imagens em páginas WEB;

JAVASCRIPT

Proporciona maior flexibilidade às aplicações WEB;

Sintaxe semelhante ao Java;

Permite operações no browser sem requisições ao servidor;

Uso ampliado em função do AJAX.

Linguagens 4ª Geração ou Visuais:

O surgimento do sistema operacional Windows mudou a forma de interação do usuário com o computador. Essas mudanças afetaram a forma de desenvolver as aplicações e a estrutura das linguagens de programação.

Houve um grande salto de qualidade no desenvolvimento de novas aplicações.

Visual Basic

Criada pela Microsoft em 1994;

Explora os princípios básicos do Windows gerando aplicações com alta interatividade com o usuário e desenvolvedor. Atualmente é orientada a objetos e faz parte do framework  .NET.

DELPHI

Criada pela Borland e baseada na linguagem Pascal, possui as mesmas características do Visual Basic

E finalmente!

Linguagens Orientada a Objetos:

Surgiram em razão das novas técnicas de análise orientada a objetos. Fazendo

paradigmas sofrerem radical transformação.

Exemplos:

SMALTALK: Xerox – década de 70 – 100% OO;

C++: Extensão da linguagem C – 1986;

JAVA: Sun – 1990

Possui portabilidade, pois é compilada e interpretada – bytecode

Falaremos disso mais adiante.

Bom. Por enquanto é isso. Espero que tenha sido esclarecedor a todos.