Curso de PHP Orientado a Objetos – Parte 2
Segundo artigo do curso de PHP Orientado a Objetos. Dessa vez aprenderemos sobre os métodos. Veremos também na prática os métodos de inicialização (construtor) e finalização (destrutor).
Dando continuidade a nosso curso.
Esta é a segunda parte do curso de PHP Orientado a Objetos.
Clique aqui para conhecer a primeira parte.
Ao final deste artigo, você será capaz de:
- Criar métodos para suas classes
- Entender melhor a criação dos objetos
- Entender o método construtor e destrutor
Vamos agora criar uma classe chamada Pessoa:
|
1 2 3 4 5 6 7 8 |
Class Pessoa{ public $nome; public $altura; public $nascimento; public $salario; } |
Agora vamos criar uma instância de pessoa:
|
1 |
$p1 = new Pessoa(); |
Agora vamos preencher seus atributos:
|
1 2 3 4 |
$p1->nome = "José da Silva"; $p1->altura = 1.82; $p1->nascimento = "1989-01-22" $p1->salario = 3600; |
Podemos verificar os valores inseridos da seguinte forma:
|
1 2 |
echo " Meu nome é: ".$p1->nome.", minha altura é ".$p1->altura.", nasci no dia ".$p1->nascimento." e hoje meu salário é de ".$p1->salario."."; |
Agora vamos criar um método para a classe Pessoa, que trabalhará com as propriedades do objeto. O método terá o nome MostrarPessoa() e basicamente servirá para mostrar os dados do objeto.
Lembre-se que método age dentro do escopo da classe.
Classe alterada:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
Class Pessoa{ public $nome; public $altura; public $nascimento; public $salario; public function MostrarPessoa(){ echo "Nome: ".$this->nome; echo "Altura: ".$this->altura; echo "Nascimento: ".$this->nascimento; echo "Salario: ".$this->salario; } } |
Temos um novo conceito apresentado aqui. Trata-se da pseudo-variável $this, que serve basicamente para diferenciar as propriedades do objeto de variáveis locais. Lembre-se, $this referencia o objeto ATUAL e acessa suas propriedades.
Agora vamos novamente reescrever o objeto Pessoa executando o método MostrarPessoa():
|
1 2 3 4 5 6 7 |
$p1 = new Pessoa(); $p1->nome = "José da Silva"; $p1->altura = 1.82; $p1->nascimento = "1989-01-22"; $p1->salario = 3600; //executando o método $p1->MostrarPessoa(); |
Quando o método for executado, todos os dados do objeto P1 serão mostrados na tela.
Perceba que para criar um método, iniciamos com a palavra reservada public (isso em PHP 5, falaremos a respeito dessa funcionalidade no decorrer do curso, por enquanto, entenda como o parâmetro que define a visibilidade do método), seguido da palavra reservada function e o nome do método.
A grosso modo, podemos dizer que métodos são funções que agem dentro de uma classe.
É importante salientar que da mesma forma que criamos $p1, poderíamos criar $p2, $p3 e etc, todos com características (atributos) diferentes, mas executando o mesmo método MostrarPessoa().
Vamos utilizar de um exemplo clássico para diferenciarmos classe de objetos:
Uma classe é como uma receita de bolo. Não comemos a receita de bolo, não é verdade? A utilizamos como referência para prepará-lo. A função da classe é semelhante a receita do bolo: Criamos um objeto bolo a partir das especificações da receita.
Voltando aos métodos, vamos agora modelar uma classe um pouco mais completa, ela se chamará conta, e terá os métodos Sacar, Depositar e ObterSaldo.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 |
class Conta{ public $Cliente; public $Agencia; public $Conta; public $Saldo; public $Status; /* Método Sacar() * Diminui o saldo em quantia */ function Sacar($quantia){ if( $quantia > 0 ){ $this->Saldo -= $quantia; } } /* Método Depositar() * Deposita uma quantia, acrescendo o saldo */ function Depositar($quantia){ if ( $quantia > 0 ){ $this->Saldo += $quantia; } } /* Método ObterSaldo() * Retorna o saldo da conta */ function ObterSaldo(){ return $this->Saldo; } } |
É importante notar que o método Depositar e o método Sacar recebem valores e esses são atribuidos as variáveis do objeto.
O método ObterSaldo não recebe nenhum valor, ele apensa retorna (return) o valor atual da variável $saldo.
Executando o código:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
//criando o objeto conta $conta1 = new Conta(); //setando seus atributos $conta1->Cliente = "Jose da Silva"; $conta1->Agencia = 0196; $conta1->Conta = "07126934-24"; $conta1->Saldo = 5000; //executando os métodos $conta1->Depositar(500); $conta1->sacar(100); echo $conta1->ObterSaldo(); |
É mostrado o valor 5400, retornado pelo método ObterSaldo.
Método Construtor
O Construtor é um método (assim como o método Depositar, Sacar e ObterSaldo) executado toda vez que um objeto é instanciado a partir de uma classe. Geralmente é utilizado para executar procedimentos de inicialização de atributos do objeto. Quando é executado o comando $x = New… é automaticamente chamado o método construtor daquela classe.
Perceba que na classe Conta que criamos anteriormente, não criamos o tal método construtor, neste caso, as propriedades do objeto são inicializadas com o valor NULL, daí a necessidade de atribuir valores a todas as propriedades (Cliente, Agencia, Conta e Saldo).
Método Destrutor
Também é um método especial e é executado sempre que atribuímos o valor NULL a um objeto ou quando utilizamos a função unset() e em última instância, quando o programa é finalizado. Este método é comumente usado para apagar arquivos temporários, finalizar conexões e etc.
A seguir vamos criar o método construtor e destrutor para a classe Conta que criamos anteriormente:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 |
class Conta{ public $Cliente; public $Agencia; public $Conta; public $Saldo; public $Status; /* Método Construtor * Inicializa as propriedades */ function __construct($Titular,$Agencia,$Conta,$Saldo,$Status){ $this->Cliente = $Titular; $this->Agencia = $Agencia; $this->Conta = $Conta; $this->Saldo = $Saldo; $this->Cancelada = $Status; } /* Método Destrutor * Finaliza os objetos */ function __destruct(){ echo "<small>O Objeto foi destruído.</small> "; } /* Método Sacar() * Diminui o saldo em quantia */ function Sacar($quantia){ if( $quantia > 0 ){ $this->Saldo -= $quantia; } } /* Método Despositar() * Deposita uma quantia, acrescendo o saldo */ function Depositar($quantia){ if( $quantia > 0 ){ $this->Saldo += $quantia; } } /* Método ObterSaldo() * Retorna o saldo da conta */ function ObterSaldo(){ return $this->Saldo; } } |
Perceba que um construtor é definido pelo método: __construct() (usa-se dois underscores __) e no caso da classe conta, ele foi responsável por definir todos os atributos do objeto.
Vamos agora criar o objeto:
|
1 2 |
$conta1 = new conta("Jose da silva", "0144", "07126934-24", 5000, "ativa"); echo $conta1->ObterSaldo(); |
Criamos o objeto conta em $conta1, e no momento de sua criação enviamos os parâmetros que o construtor precisa para preencher os respectivos atributos.
Na imagem abaixo é possível identificar a relação do construtor com o memento de criação do objeto:
 |
| Construtor recebendo os parâmetros |
Na próxima aula apresentaremos a herança e o conceito de polimorfismo.
Utilize o espaço de comentários para tirar suas dúvidas.
Até a próxima.
Excelente, quando tiver aula de Jquery favor entrem em contato pelo email
http://www.youtube.com/watch?v=fq5SRwGAd8I
Muito boa a iniciativa e a materia ta me salvando…
Obrigado pessoal continuem com este espirito.
Cara, parabéns pelos tutoriais!
Eu fico só com uma dúvida, não necessariamente ligada a essa parte do curso…
Quando eu vou criar um projeto usando OO, por questão de organização ou de convesão, eu crio um arquivo pra cada classe?
Grato!
Amigo, na minha modesta opinião, seria interessante é bem mais fácil depois vc manutenir ou corrigir erros quando vc cria arquivos específicos para cada ocasião, um exemplo bem simples é um sistema de login, tem pessoas que fazem do jeito que lhes acham melhor….cria-se um arquivo apenas para conexao com DB, outro para fazer o CRUD, outro para validar o e-mail, outro para validar a senha, bem isso depende muito de cada um, eu prefiro fazer assim…..
parabens pelo site e pelas aula de PHP OO to gostando, to anotando os exemplos no caderno e depois eu faço na pratica, faço isso como forma de entender e memorizar alguns comandos
Olá
fiz o exemplo aqui e quando fui executar no navegador chrome da um erro no servidor dizendo q não foi carregado, mas o servidor local ta funcionando normal e no firefox aparece a pagina em branco, poderiam me ajudar com isso
Muito Bom Trabalho! Nota 10.
Olá amigos.
Primeiramente parabéns pela iniciativa, é bem louvável.
Só tenho uma observação a fazer. Na linha 20 do último exemplo (onde consta a classe Conta), no método construtor da classe você referencia um atributo inexistente: “$this->Cancelada = $status”, o certo, de acordo com o exemplo seria: “$this->Status = $Status”. Da maneira que está hoje não dá erro, porém, se você quiser imprimir o que tem no atributo “Status” você não conseguirá.
Abraços e muito obrigado pelo material disponibilizado.
Ola meus caros,
Quero parabenizar pelo material mas olha o meu __destruct dispara automáticamente
Muito bom esse curso, excelente mesmo..
Só notei um pequeno erro, no método construtor, você está setando o objeto $this->Cancelada. Não deveria ser $this->Status?
Caso eu esteja enganado, peço desculpas…
Vlw, sucesso….
Porque não foi colocado a visibilidade dos métodos(public, private ou protect): Sacar, Depositar, Obtersaldo ??
Sendo que no metodo MostrarPessoa tivemos…. pq uns tem e outros não?
Essa foi a minha dúvida.
Em php, a opção default atribuído a uma função é public.
Amigo, tbm estou acompanhando aqui o curso, e, eu acredito que por questão de o autor não abordar ou atentar tanto para o assunto de encapsulamento e visibilidade, acho que o foco disso será mais para frente, tendo em vista que tem pessoas que ainda estão aprendendo
Muito bom…
Estou pesquisando algum livro sobre o assunto, aconselha especifico?
Sugestão: PHP Programando com Orientação a Objetos – 2ª edição (ed. Novatec)
http://novatec.com.br/livros/phpobjetos2/
Cara posts muito bacanas, trabalho com PHP mas estudo muito Java e está me salvando abraço.
Olá,
Estou começando em php e estou gostando dos seus artigo.
Quando abro o arquivo php com a classe Pessoa ele dá esse “Warning: Creating default object from empty value in” mas logo em seguida imprime o echo normalmente, dei uma pesquisada mas não entendi muito bem, teria como explicar como tiro tal warning?
Ótimo tutorial,
Eu tenho um dúvida é boa prática se todo método construtor eu colocar um destrutor ? Ou somente faço isso quando for abandonar o sistema ?
Excelente Iniciativa.
Obrigado por está compartilhando esse rico material.
Deus o abençoe.
Leandro de Castro, sensacional este material que você disponibilizou. Estou absorvendo tudo de forma bem tranquila e agradável. Parabéns pelo ótimo trabalho!
Segui os passos dados resultou nesse código, obrigado.
Cliente = $Titular;
$this->Agencia = $Agencia;
$this->Conta = $Conta;
$this->Saldo = $Saldo;
//$this->Cancelada = $Status;
$this->Status = $Status;
}
/* Método Destrutor
* Finaliza os objetos
*/
function __destruct(){
echo “”;
echo ” O Objeto foi destruído. “;
}
/* Método Sacar()
* Diminui o saldo em quantia
*/
function Sacar($quantia){
if( $quantia > 0 ){
$this->Saldo -= $quantia;
}
}
/* Método Despositar()
* Deposita uma quantia, acrescendo o saldo
*/
function Depositar($quantia){
if( $quantia > 0 ){
$this->Saldo += $quantia;
}
}
/* Método ObterSaldo()
* Retorna o saldo da conta
*/
function ObterSaldo(){
echo “Saldo atual: “;
return $this->Saldo;
}
}
$conta1 = new conta(“Jose da silva”, “0144″, “07126934-24″, 5000, “ativa”);
echo $conta1->ObterSaldo();
//$this->Status = $Status
?>
Estava quase desistindo de aprender PHP OO, até agora estou conseguindo compreender. Parabéns pelo excelente trabalho
Muito obrigado pelo curso!!
Esta me ajudando muito no itendimento de OO!!
Valeu!!!