Ir para conteúdo

POWERED BY:

Arquivado

Este tópico foi arquivado e está fechado para novas respostas.

WGuedes

Armazenar valores de uma classe no vetor

Recommended Posts

Olá pessoal,

 

 

Tenho uma classe Cliente, a mesma possui alguns valores. Minha dúvida é:

 

Como armazenar esses valores em um vetor? para ser acessado depois e que possa ser lido essas informações:

 

Cliente.php

 

<?php 

class Cliente{ 

    private $nome;
    private $data_nasc;
    private $cpf;
    private $rg;
    private $endereco;    

    public function setNome($nome)
    { 
       $this -> nome = $nome;
    }

    public function setData_nasc($data_nasc)
    { 
       $this -> data_nasc = $data_nasc;
    }

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

    public function setRg($rg)
    { 
       $this -> rg = $rg;
    }

    public function setEndereco($endereco)
    { 
       $this -> endereco = $endereco;
    }
     
    public function getNome()
   
     { 
     	return $this -> nome;
    }

    public function getData_nasc()
    { 
     	return $this -> data_nasc;
    }

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

    public function getRg()
    { 
     	return $this -> rg;
    }

    public function getEndereco()
    { 
     	return $this -> endereco;
    }

	}

?>

Compartilhar este post


Link para o post
Compartilhar em outros sites

Amigo que tipo de armazenamento que você quer fazer? Depois quando você quer recuperar esse valor?

Existe várias maneiras...

 

<?php
       
       $cli = new Cliente();

       $cliente["nome"] = $cli->getNome();
       $cliente["data_nasc"] = $cli->getData_nasc();
       $cliente["cpf"] = $cli->getCpf();
       $cliente["rg"] = $cli->getRg();
       $cliente["endereco"] = $cli->getEndereco();

       // OU

       $cliente[0] = $cli->getNome();
       $cliente[1] = $cli->getData_nasc();
       $cliente[2] = $cli->getCpf();
       $cliente[3] = $cli->getRg();
       $cliente[4] = $cli->getEndereco();

       // e para recuperar esses dados.

       for ($i = 0; $i < count($cliente); $i++)
       {
            echo $cliente[$i];
       }
?>

Se for isso tá aí.

 

Abraços!

Compartilhar este post


Link para o post
Compartilhar em outros sites

Olá Vinicius,

 

Obrigado pela ajuda, só uma última dúvida

 

Como fazer essa classe armazenar n elementos da classe cliente? E também inserir elementos em qualquer posição vetor.

 

 

Um abraço!

Compartilhar este post


Link para o post
Compartilhar em outros sites

Olá Vinicius,

 

Obrigado pela ajuda, só uma última dúvida

 

Como fazer essa classe armazenar n elementos da classe cliente? E também inserir elementos em qualquer posição vetor.

 

 

Um abraço!

 

 

 

Desculpa mais não entendi muito a sua dúvida na questão de armazenar N elementos.

Explique um pouco melhor porque realemnte não entendi, desculpe.

 

Para armazenar use:

 

$seu_vetor[posicao] = $cli->getNome();

 

Se for isso tá aí, mais explica melhor sua dúvida pra saber se posso lhe ajudar.

 

Abraços

Compartilhar este post


Link para o post
Compartilhar em outros sites

Vinicius,

 

vou tentar lhe explicar melhor:

 

Estou construindo de uma classe que implemente um vetor. O vetor irá armazenar infinitos elementos de uma classe qualquer (cliente). Vai ser possivel inserir elementos em qualquer posição do(vetor).

 

Obrigado e agradeço sua atenção!

 

Um abraço

Compartilhar este post


Link para o post
Compartilhar em outros sites

Existe a possibilidades sim do jeito que te falei, vou dar um exemplo fácil não usando sua classe.

 

$vetor[2] = "Vinicius";

$vetor[10] = "WGuedes";

$vetor[500] = "teste";

 

E aí vai embora, desculpe novamente se não for essa sua dúvida.

 

se não for pode falar denovo hehe

 

abraços

Compartilhar este post


Link para o post
Compartilhar em outros sites

É quase isso, mas no caso cada cliente teria um dado.

 

 

Cliente 1 - Nome - endereco...

 

Cliente 2 - Nome - endereco...

 

<?php
       
include "Cliente.php";	   
	   
       $cli = new Cliente();

             $cliente["nome"] = $cli->getNome(); 
			 $cliente["data_nasc"] = $cli->getData_nasc();
			 $cliente["cpf"] = $cli->getCpf();
			 $cliente["rg"] = $cli->getRg();
			 $cliente["endereco"] = $cli->getEndereco();

       // e para recuperar esses dados.

       for ($i = 0; $i < count($cliente); $i++)
       {
            echo $cliente[$i];
       }
	    
	 
	//  var_dump($cliente);

?>

Compartilhar este post


Link para o post
Compartilhar em outros sites


include "Cliente.php";

$cli = new Cliente();

 

//atribuindo valores

$cli->setNome("victor");

$cli->setData_nasc("20/08/1992");

$cli->setCpf("123.456.789-09");

$cli->setRg("2938742198");

$cli->setEndereco("hjdh");

 

//variável contadora

$cont=0;

 

//passando para array

$cliente[$cont]["nome"] = $cli->getNome();

$cliente[$cont]["data_nasc"] = $cli->getData_nasc();

$cliente[$cont]["cpf"] = $cli->getCpf();

$cliente[$cont]["rg"] = $cli->getRg();

$cliente[$cont]["endereco"] = $cli->getEndereco();

 

//atribuindo valores

$cli->setNome("marcos");

$cli->setData_nasc("20/08/1992");

$cli->setCpf("098.765.432-10");

$cli->setRg("88975482");

$cli->setEndereco("jghjkghg");

 

//incrementando a variável

$cont++;

 

//passando para array

$cliente[$cont]["nome"] = $cli->getNome();

$cliente[$cont]["data_nasc"] = $cli->getData_nasc();

$cliente[$cont]["cpf"] = $cli->getCpf();

$cliente[$cont]["rg"] = $cli->getRg();

$cliente[$cont]["endereco"] = $cli->getEndereco();

 

//imprimindo

for($i=0;$i<=$cont;$i++){

echo "Cliente ".($i+1).":<br>";

echo $cliente[$i]["nome"]."<br>";

echo $cliente[$i]["data_nasc"]."<br>";

echo $cliente[$i]["cpf"]."<br>";

echo $cliente[$i]["rg"]."<br>";

echo $cliente[$i]["endereco"]."<br>";

echo "----------------------<br>";

}

 

Compartilhar este post


Link para o post
Compartilhar em outros sites

Senhores,

 

Numa boa, por favor não me levem a mal, mas qual o sentido de se ter um objeto, armazenar dados em suas propriedades para depois pegar esses dados e colocá-los em uma matriz ???

 

Se estão trabalhando com objetos, trabalhem com objetos até o fim.

 

$clientes = new ArrayObject();
$clientes[] = new Cliente();
$clientes[] = new Cliente();
$clientes[] = new Cliente();
$clientes[] = new Cliente();
$clientes[] = new Cliente();
$clientes[] = new Cliente();
$clientes[] = new Cliente();
$clientes[] = new Cliente();
//Você pode ter N clientes armazenados aqui

//...


//Lá na frente, em qualquer ponto do seu código, quando você precisar usar esses dados:

echo '<h1>Lista de clientes</h1>';

foreach( $clientes->getIterator() as $offset => $cliente ){
echo '<h2>Cliente[ ' , $offset , ' ]' , $cliente->getNome() , '</h2>';
echo '<span class="address">' , $cliente->getEndereco() , '</span><br />';
//...
}

Compartilhar este post


Link para o post
Compartilhar em outros sites

Senhores,

 

Numa boa, por favor não me levem a mal, mas qual o sentido de se ter um objeto, armazenar dados em suas propriedades para depois pegar esses dados e colocá-los em uma matriz ???

 

Se estão trabalhando com objetos, trabalhem com objetos até o fim.

 

$clientes = new ArrayObject();
$clientes[] = new Cliente();
$clientes[] = new Cliente();
$clientes[] = new Cliente();
$clientes[] = new Cliente();
$clientes[] = new Cliente();
$clientes[] = new Cliente();
$clientes[] = new Cliente();
$clientes[] = new Cliente();
//Você pode ter N clientes armazenados aqui

//...


//Lá na frente, em qualquer ponto do seu código, quando você precisar usar esses dados:

echo '<h1>Lista de clientes</h1>';

foreach( $clientes->getIterator() as $offset => $cliente ){
echo '<h2>Cliente[ ' , $offset , ' ]' , $cliente->getNome() , '</h2>';
echo '<span class="address">' , $cliente->getEndereco() , '</span><br />';
//...
}

 

 

Conforme fui lendo as sugestões, fui pensando na solução =)

 

Eu ia sugerir uma Composite implementando a interface IteratorAggregate, mas sua solução ficou beeeeeem mais simples.

Compartilhar este post


Link para o post
Compartilhar em outros sites

concordo plenamente João Batista Neto, eu ainda n intendi o motivo para querer armazenar variáveis dos objetos em array, inclusive eu fiz até uma pergunta no inicio

quando você fala acessa depois você ker dizer em outro arquivo diferente do que você estanciou?? ou no mesmo??

 

para dá uma melhor solução, mas não foi respondida.

Compartilhar este post


Link para o post
Compartilhar em outros sites

Na verdade estou tentando passar isso para uma Lista Linear.

 

A lista irá armazenar n elementos de uma classe qualquer (cliente, pessoas, etc.). É possível inserir elementos em qualquer local permitido na

lista. Outra opção é a remoção de elemento a partir de qualquer lugar da lista.

 

O meu problema é como implementar essa classe usando lista, então pensei em armazenar em um vetor.

 

Obrigado pessoal, agradeço a todos pela ajuda!

Compartilhar este post


Link para o post
Compartilhar em outros sites

@WGuedes,

 

Bom amigo, o que você entende como lista linear ?

 

Já olhou no manual para ver como a solução que lhe apresentei funciona http://forum.imasters.com.br/public/style_emoticons/default/seta.gif ArrayObject ?????

Compartilhar este post


Link para o post
Compartilhar em outros sites

Prezado João Batista Neto,

 

Estou olhando o manual e lendo mais sobre ArrayObject.

 

E sobre as listas lineares o que entendi

 

Uma lista linear é uma seqüência de n itens que vão de x0 a xn-1 em C (isso graças a características dos vetores em C iniciarem do índice 0).

Como um Tipo Abstrato de Dados, a Lista deve possuir além de atribuições de trabalho, operações sobre objetos do tipo Lista

 

 

Aqui tem um exemplo explicando melhor sobre o mesmo

 

http://tdsed.blogspot.com/2007/09/listas-lineares-parte-1.html

 

Só não sei como implementar em uma classe PHP.

 

Muito obrigado!

Compartilhar este post


Link para o post
Compartilhar em outros sites

Uma lista linear é uma seqüência de n itens que vão de x0 a xn-1 em C (isso graças a características dos vetores em C iniciarem do índice 0).

Como um Tipo Abstrato de Dados, a Lista deve possuir além de atribuições de trabalho, operações sobre objetos do tipo Lista

 

Ok amigão, agora estamos caminhando...

 

Uma lista linear é uma sequencia N elementos.

 

Tipos de lista linear:

 

Fila -> FIFO -> Igual a uma fila de banco, onde o primeiro a entrar na fila é o primeiro a ser atendido.

Pilha -> FILO -> Igual a uma pilha de pratos, onde o primeiro a entrar é o último a sair, você sempre pega o último prato da pilha.

 

Deque -> Um deque é como uma fila, mas os elementos podem entrar e sair de qualquer uma das extremidades da lista.

Lista Encadeada -> Em uma lista encadeada, existe uma referência a um outro elemento da lista, isso permite que um elemento seja incluído em qualquer lugar da lista.

Lista Duplamente Encadeada -> É como uma lista encadeada, a diferença é que ela possui duas referências, uma para o próximo elemento e outra para o elemento anterior.

 

Como já chegamos até aqui, vamos ver como fazer uma implementação orientada a objetos:

 

 

A partir desse ponto, é fundamental o mínimo de entendimento de todos os conceitos de orientação a objetos, não explicarei OOP aqui, então, caso surja alguma dúvida referente ao tema, abram um novo tópico para isso.

 

 

 

 

Bom, a primeira coisa que faremos será definir um objeto Object, será a menor partícula da nossa implementação, todos os outros objetos descenderão dessa partícula, consequentemente, será uma interface conhecida e utilizada por toda a implementação.

 

org/base/Object.php

<?php
/**
* Classes e objetos de base da aplicação
* @package 	base
* @category	oop
*/
namespace org\base;

use \stdClass;
use \ReflectionObject;

/**
* Objeto básico da aplicação
* @package 	base
* @category	oop
*/
class Object extends stdClass {
	/**
	* Constroi o novo objeto
	*/
	public function __construct(){
	 	gc_enable();
	}

	/**
	* Destroi o objeto
	*/
	public function __destruct(){
	 	gc_collect_cycles();
	}

	/**
	* Recupera uma String que representa o objeto
	* @return string
	*/
	public function __toString(){
	 	return sprintf( '%s@%s' , $this->getReflection()->getName() , $this->hashCode() );
	}

	/**
	* Compara a igualdade entre dois objetos
	* @param Object $object
	*/
	public function equals( Object $object ){
	 	return $this->hashCode() == $object->hashCode();
	}

	/**
	* Recupera uma instância de ReflectionObject para o objeto
	* @return ReflectionObject
	*/
	public function getReflection(){
	 	return new ReflectionObject( $this );
	}

	/**
	* Recupera o hash do objeto
	* @return string
	*/
	public function hashCode(){
	 	return base_convert( spl_object_hash( $this ) , 16 , 10 );
	}
}

 

O objetivo da definição dessa partícula é conseguir o nível de abstração necessária para programação para interfaces, todos os objetos dessa ilustração serão capazes de trabalhar com qualquer implementação justamente por não programarmos para uma implementação. Ao programar para uma interface, deixamos que cada objeto faça seu trabalho utilizando um dos princípios fundamentais da orientação a objetos que é o encapsulamento, não precisamos saber como uma coisa realmente é feita, apenas confiaremos nos contratos que os objetos assinam ao implementar uma interface específica.

 

Com a interface do Object definida, passamos a definir as interfaces que usaremos para a implementação de nossas listas:

 

org/util/Collection.php

<?php
/**
* Classes utilitárias para a aplicação
* @package 	util
* @category	oop
*/
namespace org\util;

use \IteratorAggregate;
use \Countable;
use org\base\Object;

/**
* Define a interface de uma coleção de objetos
* @package 	util
* @category	oop
*/
interface Collection extends IteratorAggregate, Countable {
	/**
	* Adiciona um novo objeto na coleção
	* @param Object $o
	* @return boolean
	*/
	public function add( Object $o );

	/**
	* Adiciona todos os objetos de uma coleção nessa coleção
	* @param Collection $c
	* @return boolean
	*/
	public function addAll( Collection $c );

	/**
	* Limpa a coleção atual deixando-a sem nenhum elemento
	* @return boolean
	* @see Collection::isEmpty()
	*/
	public function clear();

	/**
	* Verifica se a coleção atual pussui um determinado objeto
	* @param Object $o
	* @return boolean
	*/
	public function contains( Object $o );

	/**
	* Verifica se a coleção atual possui todos os objetos de outra coleção
	* @param Collection $c
	* @return boolean
	*/
	public function containsAll( Collection $c );

	/**
	* Verifica se a coleção atual é igual a outro objeto
	* @param Object $o
	* @return boolean
	*/
	public function equals( Object $o );

	/**
	* Recupera um hash para identificação da coleção
	* @return string
	* @see Object::hashCode()
	*/
	public function hashCode();

	/**
	* Verifica se a coleção está vazia
	* @return boolean
	* @see Collection::clear()
	*/
	public function isEmpty();

	/**
	* Remove um elemento da coleção
	* @param Object $o
	* @return boolean
	*/
	public function remove( Object $o = null );

	/**
	* Remove todos os objetos de uma outra coleção da coleção atual
	* @param Collection $c
	* @return boolean
	*/
	public function removeAll( Collection $c );

	/**
	* Mantém na coleção apenas os elementos existentes na coleção especificada
	* @param Collection $c
	* @return boolean
	*/
	public function retainAll( Collection $c );

	/**
	* Recupera uma matriz contendo os elementos da coleção
	* @return array
	*/
	public function toArray();
}

 

 

Uma Collection, como o próprio nome pode sugerir, é uma coleção de objetos, em uma coleção podem ou não haver elementos duplicados, podem ou não estar ordenados, enfim, uma implementação de uma coleção pode ser muito específica e comportamentalmente totalmente diferente de outra.

 

Para facilitar uma implementação de uma coleção, definiremos uma abstração de uma implementação base, para facilitar outras implementações:

 

org/util/AbstractCollection.php

<?php
/**
* Classes utilitárias para a aplicação
* @package 	util
* @category	oop
*/
namespace org\util;

use \ArrayObject;
use org\base\Object;
use org\base\exception\InvalidArgumentException;
use org\base\exception\CastException;
use org\util\Collection;

/**
* Essa classe é o esqueleto de uma implementação da interface Collection.
* @abstract
* @package 	util
* @category	oop
*/
abstract class AbstractCollection extends Object implements Collection {
	/**
	* Armazenamento dos dados
	* @access private
	* @var ArrayObject
	*/
	protected $storage;

	/**
	* Constroi uma nova coleção
	* @param mixed $elements Os elementos iniciais da coleção<p>
	* $elements pode ser uma matriz, Collection ou um Iterator</p>
	* @throws LogicException Se algum item da lista inicial de elementos não for um Object
	* @throws CastException Se $elements não for um tipo válido
	*/
	public function __construct( $elements = null ){
	 	parent::__construct();

	 	$this->clear();

	 	if ( !is_null( $elements ) ){
	 	 	if ( is_array( $elements ) || ( $elements instanceOf Collection ) || ( $elements instanceOf Iterator ) || ( $elements instanceOf IteratorAggregate ) ){
	 	 	 	foreach ( $elements as $e ){
	 	 	 	 	if ( $e instanceOf Object ){
	 	 	 	 	 	$this->add( $e );
	 	 	 	 	} else {
	 	 	 	 	 	throw new CastException( 'Apenas objetos podem ser armazenados' );
	 	 	 	 	}
	 	 	 	}
	 	 	} else {
	 	 	 	throw new CastException( sprintf( '$emements precisa ser uma matriz, Collection ou Iterator, %s foi dado.' , gettype( $elements ) ) );
	 	 	}
	 	}
	}

	/**
	* Recupera a representação da coleção como string
	* @return string
	*/
	public function __toString(){
	 	return sprintf( '%s[%s]' , parent::__toString() , implode( ',' , $this->toArray() ) );
	}

	/**
	* Adiciona um novo objeto à coleção
	* @param Object $o
	* @return boolean
	* @throws CastException Se o objeto for de um tipo diferente da lista
	*/
	public function add( Object $o ){
	 	if ( $this->isValid( $o ) ){
	 	 	$this->storage->append( $o );
	 	}

	 	return true;
	}

	/**
	* Adiciona todos os objetos de uma outra coleção a esta coleção
	* @param Collection $c
	* @return boolean
	*/
	public function addAll( Collection $c ){
	 	foreach ( $c->getIterator() as $o ){
	 	 	$this->add( $o );
	 	}

	 	return true;
	}

	/**
	* Limpa a coleção deixando-a sem nenhum elemento
	* @return boolean
	*/
	public function clear(){
	 	$this->storage = new ArrayObject();

	 	return true;
	}

	/**
	* Recupera o total de elementos da coleção
	* @return integer
	*/
	public function count(){
	 	return $this->storage->count();
	}

	/**
	* Verifica se a coleção contém um determinado elemento
	* @param Object $o O elemento que será verificado se está contido na coleção
	* @return boolean
	*/
	public function contains( Object $o ){
	 	foreach ( $this->getIterator() as $item ){
	 	 	if ( $item->equals( $o ) ){
	 	 	 	return true;
	 	 	}
	 	}

	 	return false;
	}

	/**
	* Verifica se a coleção possui todos os elementos de outra coleção
	* @param Collection $c A coleção que possui os elementos que será verificados
	* @return boolean
	*/
	public function containsAll( Collection $c ){
	 	foreach ( $c->getIterator() as $o ){
	 	 	if ( !$this->contains( $o ) ){
	 	 	 	return false;
	 	 	}
	 	}

	 	return true;
	}

	/**
	* Recupera um Iterator para a coleção
	* @return Iterator
	*/
	public function getIterator(){
	 	return $this->storage->getIterator();
	}

	/**
	* Verifica se a coleção está vazia
	* @return boolean
	* @see AbstractCollection::count(), AbstractCollection::clear()
	*/
	public function isEmpty(){
	 	return $this->count() == 0;
	}

	/**
	* Método que será utilizado para verificação de um objeto antes da inserção
	* @param Object $o
	* @return boolean
	*/
	abstract protected function isValid( Object $o );

	/**
	* Remove um elemento da coleção
	* @param Object $o O objeto que se deseja remover
	* @return boolean
	*/
	public function remove( Object $o = null ){
	 	$ret = false;

	 	if ( !is_null( $o ) ){
	 	 	foreach ( $this->getIterator() as $key => $e ){
	 	 	 	if ( $o->equals( $e ) ){
	 	 	 	 	$this->storage->offsetUnset( $key );
	 	 	 	 	$ret = true;
	 	 	 	}
	 	 	}
	 	}

	 	return $ret;
	}

	/**
	* Remove da coleção todos os elementos contidos em outra coleção
	* @param Collection $c A coleção que contém os elementos que se deseja remover
	* @return boolean TRUE Se todos os elementos contidos na coleção especificada tiverem sido removidos
	*/
	public function removeAll( Collection $c ){
	 	foreach ( $c->getIterator() as $e ){
	 	 	if ( !$this->remove( $e ) ){
	 	 	 	return false;
	 	 	}
	 	}

	 	return true;
	}

	/**
	* Mantém apenas os elementos contidos na outra coleção
	* @param Collection $c A coleção que contém os elementos que se deseja manter
	* @return boolean
	*/
	public function retainAll( Collection $c ){
	 	foreach ( $this->getIterator as $e ){
	 	 	if ( !$c->contains( $e ) ){
	 	 	 	if ( !$this->remove( $e ) ){
	 	 	 	 	return false;
	 	 	 	}
	 	 	}
	 	}

	 	return true;
	}

	/**
	* Recupera uma matriz com todos os elementos da coleção
	* @return array
	*/
	public function toArray(){
	 	return $this->getIterator()->getArrayCopy();
	}
}

 

Como podem ver, AbstractCollection é uma classe abstrata e, como tal, jamais poderá ser instanciada, somente implementações dessa classe poderão. Um outro aspecto da AbstractCollection é a falta de uma implementação base para o método isValid( Object $o ), esse método foi declarado como abstrato, o que significa que todas as implementações da AbstractCollection precisarão necessariamente definir esse método. Apesar de isValid() não ser um método público, ele é também conhecido como método de interface, porque, ao implementar AbstractCollection, os objetos derivados assinam um contrato com essa classe e, consequentemente, deverão implementar esse método, que será utilizado "nos bastidores" pela abstração.

Um outro detalhe sobre a implementação de AbstractCollection é que ela deriva Object, ou seja, AbstractCollection e todos seus herdeiros serão, por definição, Objects também.

 

Além da Collection, vamos definir uma outra interface um pouco parecida, mas conceitualmente totalmente diferente, a interface Set. Um Set, assim como uma Collection é uma coleção de objetos, a diferença principal é que, conceitualmente, um Set jamais permite elementos duplicados.

 

org/util/Set.php

<?php
/**
* Classes utilitárias para a aplicação
* @package 	util
* @category	oop
*/
namespace org\util;

use org\util\Collection;

/**
* Um Set é uma Collection, com a diferença que, por definição, um Set possui apenas elementos únicos
* @package 	util
* @category	oop
*/
interface Set extends Collection {}

 

Como disse, um Set difere de uma Collection apenas conceitualmente, as interfaces são idênticas, agora, uma abstração de uma implementação de um Set para facilitar outras implementações:

 

org/util/AbstractSet.php

<?php
/**
* Classes utilitárias para a aplicação
* @package 	util
* @category	oop
*/
namespace org\util;

use org\base\Object;
use org\base\exception\LogicException;
use org\util\AbstractCollection;
use org\util\Set;

/**
* Essa classe é o esqueleto de uma implementação da interface Set.<p>
* Um Set é uma Collection, com a diferença que, por definição, um Set possui apenas elementos únicos
* </p>
* @package 	util
* @category	oop
*/
abstract class AbstractSet extends AbstractCollection implements Set {
	/**
	* Verifica se o objeto é válido
	* @param Object $o
	* @return boolean
	*/
	protected function isValid( Object $o ){
	 	if ( $this->contains( $o ) ){
	 	 	throw new LogicException( sprintf( 'O elemento %s já existe na lista.' , $o ) );
	 	}

	 	return true;
	}
}

 

Agora a abstração começa a funcionar, não sabemos quem está implementando o Set, sabemos com certeza apenas que essa implementação terá necessariamente um método contains() que retornará um boolean dizendo se um objeto está contido no Set.

 

Bom, até esse momento, apenas definimos a forma de entrada e saída referentes à Collection, passaremos agora, a definir as formas de saída das Listas, vamos usar Collection para as definições, primeiro de uma fila:

 

org/util/Queue.php

<?php
/**
* Classes utilitárias para a aplicação
* @package 	util
* @category	oop
*/
namespace org\util;

use org\base\Object;

/**
* Interface para definição de uma fila FIFO
* @package 	util
* @category	oop
*/
interface Queue extends Collection {
	/**
	* Oferece um elemento para ser inserido na lista
	* @param Object $o
	* @return boolean
	* @see Collection::add()
	*/
	public function offer( Object $o );

	/**
	* Recupera de forma não destrutiva o primeiro elemento da fila
	* @return Object
	* @see Queue::peek()
	* @throws NoSuchElementException Se a fila estiver vazia
	*/
	public function element();

	/**
	* Recupera de forma não destrutiva o primeiro elemento da fila
	* @return Object ou NULL se a fila estiver vazia
	* @see Queue::element()
	*/
	public function peek();

	/**
	* Recupera de forma destrutiva o primeiro elemento da fila
	* @return Object ou NULL se a fila estiver vazia
	* @see Collection::remove()
	*/
	public function pool();
}

 

E agora uma abstração para uma fila:

 

org/util/AbstractQueue.php

<?php
/**
* Classes utilitárias para a aplicação
* @package 	util
* @category	oop
*/
namespace org\util;

use org\base\exception\NoSuchElementException;
use org\base\Object;

/**
* Essa classe é o esqueleto de uma implementação de uma fila FIFO
* @abstract
* @package 	util
* @category	oop
*/
abstract class AbstractQueue extends AbstractCollection implements Queue {
	/**
	* Cabeça da fila
	* @var integer
	*/
	private $head;

	/**
	* Constroi a fila
	*/
	public function __construct(){
	 	parent::__construct();

	 	$this->head = 0;
	}

	/**
	* Oferece um elemento para ser inserido na lista
	* @param Object $o
	* @return boolean
	* @see Collection::add()
	*/
	public function offer( Object $o ){
	 	return $this->add( $o );
	}

	/**
	* Recupera de forma não destrutiva o primeiro elemento da fila
	* @return Object
	* @see Queue::peek()
	* @throws NoSuchElementException Se a fila estiver vazia
	*/
	public function element(){
	 	if ( is_null( $ret = $this->peek() ) ){
	 	 	throw new NoSuchElementException( 'A fila está vazia' );
	 	}

	 	return $ret;
	}

	/**
	* Recupera de forma não destrutiva o primeiro elemento da fila
	* @return Object ou NULL se a fila estiver vazia
	* @see Queue::element()
	*/
	public function peek(){
	 	$ret = null;

	 	if ( $this->count() ){
	 	 	$ret = $this->storage->offsetGet( $this->head );
	 	}

	 	return $ret;
	}

	/**
	* Recupera de forma destrutiva o primeiro elemento da fila
	* @return Object ou NULL se a fila estiver vazia
	* @see Queue::remove()
	*/
	public function pool(){
	 	$ret = null;

	 	if ( $this->count() ){
	 	 	$ret = $this->storage->offsetGet( $this->head );
	 	 	$this->storage->offsetUnset( $this->head++ );
	 	}

	 	return $ret;
	}

	/**
	* Recupera de forma destrutiva o primeiro elemento da fila
	* @return Object
	* @see Queue::pool()
	* @throws NoSuchElementException Se a fila estiver vazia
	*/
	public function remove( Object $o = null ){
	 	if ( is_null( $ret = $this->pool() ) ){
	 	 	throw new NoSuchElementException( 'A fila está vazia' );
	 	}

	 	return $ret;
	}
}

 

Putz, esse já é provavelmete meu maior post, estou parando por aqui, hehehe, vou apenas colocar uma ilustação do uso disso tudo, as exceções utilizadas, caso alguém ache realmente interessante que eu continue com as implementações da pilha, deque e das listas encadeadas basta que se manifestem que eu postarei aqui, contudo, saibam desde já que essas implementações serão provavelmente maiores que as já postadas anteriormente.

 

Exceções

 

org/base/exception/RPOException.php

<?php
/**
* Exceções base da aplicação
* @package 	base
* @subpackage exception
* @category	oop
*/
namespace org\base\exception;

use \Exception;

/**
* Exceção base da aplicação
* @package 	base
* @subpackage exception
* @category	oop
*/
class RPOException extends Exception {
}

 

org/base/exception/RuntimeException.php

<?php
/**
* Exceções base da aplicação
* @package 	base
* @subpackage exception
* @category	oop
*/
namespace org\base\exception;

/**
* Exceção de tempo de execução
* @package 	base
* @subpackage exception
* @category	oop
*/
class RuntimeException extends RPOException {
}

 

org/base/exception/LogicException

<?php
/**
* Exceções base da aplicação
* @package 	base
* @subpackage exception
* @category	oop
*/
namespace org\base\exception;

/**
* Exceção de tempo de execução referêntes a lógica
* @package 	base
* @subpackage exception
* @category	oop
*/
class LogicException extends RuntimeException {
}

 

org/base/exception/UnexpectedValueException.php

<?php
/**
* Exceções base da aplicação
* @package 	base
* @subpackage exception
* @category	oop
*/
namespace org\base\exception;

/**
* Exceção para um valor inesperado
* @package 	base
* @subpackage exception
* @category	oop
*/
class UnexpectedValueException extends LogicException {
}

 

org/base/exception/InvalidArgumentException.php

<?php
/**
* Exceções base da aplicação
* @package 	base
* @subpackage exception
* @category	oop
*/
namespace org\base\exception;

/**
* Exceção para um argumento inesperado é passado
* @package 	base
* @subpackage exception
* @category	oop
*/
class InvalidArgumentException extends UnexpectedValueException {
}

 

org/base/exception/CastException.php

<?php
/**
* Exceções base da aplicação
* @package 	base
* @subpackage exception
* @category	oop
*/
namespace org\base\exception;

/**
* Exceção disparada quando um tipo inválido é utilizado em algum contexto
* @package 	base
* @subpackage exception
* @category	oop
*/
class CastException extends UnexpectedValueException {
}

 

org/base/exception/NoSuchElementException.php

<?php
/**
* Exceções base da aplicação
* @package 	base
* @subpackage exception
* @category	oop
*/
namespace org\base\exception;

/**
* Exceção de tempo de execução
* @package 	base
* @subpackage exception
* @category	oop
*/
class NoSuchElementException extends RuntimeException {
}

 

Agora a implementação de uma fila de clientes, primeiro a interface de um cliente:

 

com/model/Clients.php

<?php
namespace com\model;

/**
* Interface para definição de um cliente
*/
interface Clients {
	/**
	* Recupera o nome do cliente
	* @return string
	*/
	public function getName();
}

 

Agora uma implementação simples de um Clients:

 

com/model/SimpleClient.php

<?php
namespace com\model;

use org\base\Object;

/**
* Um cliente qualquer
*/
class SimpleClient extends Object implements Clients {
	/**
	* Nome do cliente
	* @var string
	*/
	private $name;

	/**
	* Constroi um novo cliente definindo seu nome
	* @param string $name O nome do cliente
	*/
	public function __construct( $name ){
	 	parent::__construct();
	 	$this->name = $name;
	}

	/**
	* Recupera o nome do cliente
	* @return string
	*/
	public function getName(){
	 	return $this->name;
	}
}

 

E finalmente nossa fila de Clients:

 

com/model/ClientsQueue.php

<?php
namespace com\model;

use org\base\Object;
use org\base\exception\CastException;
use org\util\AbstractQueue;

/**
* Implementação de uma fila de clientes
*/
class ClientsQueue extends AbstractQueue {
	/**
	* Verifica se o objeto é válido
	* @param Object $o
	* @return boolean
	* @throws CastException Se o objeto passado não for uma instância de Clients
	*/
	protected function isValid( Object $o ){
	 	$reflection = $o->getReflection();

	 	if ( !$reflection->implementsInterface( 'com\model\Clients' ) ){
	 	 	throw new CastException( sprintf( 'ClientsQueue aceita apenas Clients, %s foi dado.' , $reflection->getName() ) );
	 	}

	 	return true;
	}
}

 

Usando tudo isso:

 

<?php
use com\model\ClientsQueue;
use com\model\SimpleClient;

$fila = new ClientsQueue();
$fila->add( new SimpleClient( 'João' ) );
$fila->add( new SimpleClient( 'Batista' ) );
$fila->add( new SimpleClient( 'Neto' ) );

echo $fila->pool()->getName() , PHP_EOL;
echo $fila->pool()->getName() , PHP_EOL;
echo $fila->pool()->getName() , PHP_EOL;

 

A saída, como esperado, será:

 

João

Batista

Neto

 

Se tentar adicionar um outro tipo de objeto à fila, uma exceção será disparada:

 

use org\base\Object;

class Pet extends Object {
}

 

$fila = new ClientsQueue();
$fila->add( new SimpleClient( 'João' ) );
$fila->add( new SimpleClient( 'Batista' ) );
$fila->add( new SimpleClient( 'Neto' ) );
$fila->add( new Pet() );

echo $fila->pool()->getName() , PHP_EOL;
echo $fila->pool()->getName() , PHP_EOL;
echo $fila->pool()->getName() , PHP_EOL;

 

Saída:

Fatal error: Uncaught exception 'org\base\exception\CastException' with message 'ClientsQueue aceita apenas Clients, Pet foi dado.' in /var/www/html/lists/application/com/model/ClientsQueue.php:22

Stack trace:

#0 /var/www/html/lists/application/org/util/AbstractCollection.php(71): com\model\ClientsQueue->isValid(Object(Pet))

#1 /var/www/html/lists/index.php(16): org\util\AbstractCollection->add(Object(Pet))

#2 /tmp/dummy.php(1): include('/var/www/html/l...')

#3 {main}

thrown in /var/www/html/lists/application/com/model/ClientsQueue.php on line 22

 

;)

Compartilhar este post


Link para o post
Compartilhar em outros sites

Nossa, excelente João Batista Neto

 

Amigo muito obrigado mesmo, com certeza vai me ajudar muito.

 

Já estou lendo e vendo como fazer novas implmenentações.

 

Não imaginava que tivesse várias maneiras de fazer.

 

Espero que mais pessoas possam aproveitar, por que realmente está muito completo.

 

 

Um forte abraço!!

Compartilhar este post


Link para o post
Compartilhar em outros sites

Nossa, excelente João Batista Neto

 

Valeu amigão. :D

 

por que realmente está muito completo.

 

Na verdade, como disse nesse post gigaaante, eu deixei de implementar a Pilha, Deque e as listas encadeadas porque o post já tinha ficado imenso, contudo, se o pessoal quiser, posso postar as implementações restantes.

 

;)

Compartilhar este post


Link para o post
Compartilhar em outros sites

A parte mais f*da de OO é que tudo acontece por baixo dos panos

 

$fila = new ClientsQueue();
$fila->add( new SimpleClient( 'João' ) );
$fila->add( new SimpleClient( 'Batista' ) );
$fila->add( new SimpleClient( 'Neto' ) );
$fila->add( new Pet() );

echo $fila->pool()->getName() , PHP_EOL;
echo $fila->pool()->getName() , PHP_EOL;
echo $fila->pool()->getName() , PHP_EOL;

PS.: O João empolga MUUUUITO

Compartilhar este post


Link para o post
Compartilhar em outros sites

O João empolgou mesmo está ótimo, tirou todas minhas dúvidas.

 

Só uma erro que tive, crei uma classe para imprimir os dados.

 

ClientsPrincipal.php

 


<?php
use com\model\ClientsQueue;
use com\model\SimpleClient;

$fila = new ClientsQueue();
$fila->add( new SimpleClient( 'Wellington' ) );
$fila->add( new SimpleClient( 'Silva' ) );
$fila->add( new SimpleClient( 'Guedes' ) );

echo $fila->pool()->getName() , PHP_EOL;
echo $fila->pool()->getName() , PHP_EOL;
echo $fila->pool()->getName() , PHP_EOL;
?>

e deu o erro:

 

Fatal error: Class 'com\model\ClientsQueue' not found in C:\Users\Vista\Documents\wamp\www\lista\com\model\lista_principal.php on line 5

 

Estranho que diz not found nos arquivos, sendo que os coloquei na mesma pasta que você.

Compartilhar este post


Link para o post
Compartilhar em outros sites

×

Informação importante

Ao usar o fórum, você concorda com nossos Termos e condições.