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:
Class Pessoa{
public $nome;
public $altura;
public $nascimento;
public $salario;
}
Agora vamos criar uma instância de pessoa:
$p1 = new Pessoa();
Agora vamos preencher seus atributos:
$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:
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:
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():
$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.
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:
//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:
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 "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(){
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:
$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.
Nenhum comentário:
Postar um comentário