MUDAMOS DE ENDEREÇO

MUDAMOS DE ENDEREÇO.

ACESSE: 

WWW.CAFEESOFTWARE.COM

Novidades - Parte II

Não está nada fácil a migração do site. Mas, na próxima semana estará no ar nosso novo layout.
Estou preparando também uma seqüência de aulas sobre JSP.
Aguardem!

Curso de PHP Orientado a Objetos - Parte 9

Imagem meramente ilustrativa

Vamos dar início ao nono artigo do curso de PHP Orientado a Objetos. Hoje falando sobre os métodos interceptores.

Para conhecer as demais partes, clique aqui.

Ao final deste artigo, você será capaz de:

• Entender o que são os métodos interceptores;
• Fazer uso dos métodos __set(), __get() e __call().

Intercepções

Métodos de intercepção são métodos especiais predefinidos no PHP. Seus nomes são reservados, todos prefixados com dois caracteres "_" (underscore) no início.

Os métodos __set(), __get() e __call são alguns desses métodos. Trata-se de métodos opcionais e geralmente utilizados para executarem ações consideradas "especiais" e específicas.

__set()

O método __set() é invocado toda vez que um atributo não declarado da classe recebe a atribuição de um valor. Este método espera dois parâmetros, o primeiro contendo o nome do atributo e o segundo seu valor. 

Em resumo, toda vez que for atribuído um valor a uma propriedade do objeto, automaticamente esta atribuição passa pelo método __set().

Para facilitar o entendimento, vamos ao exemplo:

/* Vamos crair a classe Pessoa
*  com somente uma propriedade
*  chamada Idade.
*/
class Pessoa{

  private $Idade;

  /* Quando tentarmos
   * atribuir um valor
   * para a propriedade idade
   * o método __set() entre em ação
  */

  public function __set( $propriedade, $valor ){

    if( $propriedade == "Idade" ){

      if( is_integer($valor) && strlen($valor) > 1 ){

        $this->Idade = $valor;
        echo "Valor: " . $valor . " Atribuído à propriedade: " . $propriedade;

      }else{

        echo "Valor: " . $valor . "NÃO atribuído à propriedade: " . $propriedade;

      }

    }

  }

}

$leandro = new Pessoa();
$leandro->Idade = 27;

Observe que criamos o objeto normalmente (linha 36) e quando fomos atribuir 27 a propriedade idade do objeto, nosso amigo __set() interceptou, validou e só assim, permitiu ou não que o valor chegasse de fato ao atributo $idade.
Lembre-se, o __set() sempre espera dois parâmetros: $propriedade e $valor. Esses sempre devem ser verificados.
Imagine que em sua aplicação você possui a propriedade senha. Você pode utilizar o __set() para validar se a senha informada pelo usuário atende todos os requisitos necessário e só depois, a propriedade recebe o conteúdo (caso hipotético).

__get()

Análogo ao método __set(), o __get() é chamado quando um atributo da classe precisa ser retornado para o objeto. Ele espera um parâmetro, que será preenchido com o nome do atributo chamado.
Para exemplificar melhor o uso do __get(), vamos ao exemplo:

class Carro{

  public $Nome;
  private $Valor;

  const MargemLucro = 8;

  public function __construct($Nome, $Valor){
    $this->Nome = $Nome;
    $this->Valor = $Valor;
  }

  /* Quando o usuario requisitar
  *  uma propriedade, o __get()
  *  irá interceptar, verificar se a
  *  propriedade é a "Valor" e realizar
  *  o ajuste da margem de lucro
  */
  function __get($Propriedade){

    if( $Propriedade == "Valor" ){

      $valor_reajustado = $this->Valor * ( 1 + self::MargemLucro / 100 );

      return "R$ " . number_format($valor_reajustado, 3, ',', '.');

    }

  }

}

$vectra = new Carro("Vectra 2.0", 40.000);
echo $vectra->Valor;

Perceba que ao executar, quando realizamos a requisição a propriedade Valor, o método __get() faz a intercepção, ajusta o valor para a margem de lucro pré-definida além de formatar e só assim o valor e entregue.
Esta é um uso clássico do método __get().

__call()

Diferente dos métodos __set() e __get, o método __call() entra em ação quando é feita uma chamada a um método (não mais uma propriedade) que não existe. Sempre que um método não existir no objeto, automaticamente a execução será direcionada para ele que também recebe dois parâmetros, o nome e o parâmetro informados, assim ele pode decidir o que fazer nesta situação. 
Vamos ao exemplo para entender melhor:

class Carro{

  public $Nome;
  private $Valor;

  const MargemLucro = 8;

  public function __construct($Nome, $Valor){
    $this->Nome = $Nome;
    $this->Valor = $Valor;
  }

  //Este é o método que fará a intercepção

  function __call($Metodo, $Parametros){

    echo "Método executado: " . $Metodo;
    echo "Parâmetros do método:< br />";
     
    // Um array para mostrar os parametros passados

    foreach ( $Parametros as $Chave => $Parametro ){

      echo "Parâmetro {$Chave} = " . $Parametro;

    }

  }

}

$vectra = new Carro("Vectra s.0", 40.000);
// Opa!! Que método é esse?? Ah, deixa que o __call cuida
echo $vectra->DefineCaracteristicas("Preto",2.0,"4 portas");

Ao executar, será mostrado todas as características passadas pelo método DefineCaracteristicas, justamente pela intercepção realizada pelo método __call(). Mesmo não tendo este método na classe.

Existem diversos outros métodos considerados especiais, clique aqui para consultar a lista completa.

Lembre-se que estes métodos foram projetados para facilitar a vida do programador, grandes frameworks como Zend fazem uso dessa funcionalidade para atribuir de forma dinâmica nas camadas do modelo de visão. Falaremos sobre frameworks em breve.

Terminamos assim mais uma aula. 
Utilize o espaço de comentários para dúvidas, críticas, elogios ou sugestões. É sempre um prazer ler sua opinião sobre meu conteúdo.
Gostaria de agradecer novamente pelos comentários que venho recebendo.

Na próxima aula estudaremos um pouco mais sobre métodos, desta vez o __autoload(), além de conhecermos algumas funções para manipulação de objetos.

Curso de PHP Orientado a Objetos - Parte 8

Vamos iniciar o oitavo artigo do curso de PHP Orientado a Objetos do site www.cafeesoftware.com.

Para conhecer as demais partes, clique aqui.

Ao final deste artigo, você será capaz de:

• Entender como se da a relação entre objetos
• Entender quando se dá um relacionamento de associação, agregação e composição 

Imagem meramente ilustrativa

Em OO é comum que objetos se relacionem um com os outros para desempenhar suas tarefas. Neste tutorial veremos os tipos de relacionamentos existentes.

Associação: É a relação mais comum entre dois objetos. Quando acontece? Quando uma classe "usa" outra classe.

Exemplo: Um motorista utiliza (depende do carro, mas este não faz parte do motorista) o carro para trabalhar. 

Agregação: É o tipo de relação conhecida como todo/parte. Na agregação o objeto agrega outro objeto, ou seja, torna um objeto externo parte de si.. Assim o objeto pai poderá utilizar funcionalidades do objeto agregado, mas ele não depende dele (agregado) para existir.

Exemplo: A tampa de uma caneta é parte da caneta, se a caneta não tiver a tampa, ela não deixará de ser uma caneta.

Composição: Neste caso, o objeto-pai é responsável pela criação e destruição de suas partes. O objeto-pai realmente "possui" as instâncias de suas partes. Resumidamente, um só existe caso o outro também exista.

Exemplo: O motor de um carro é parte fundamental do carro.

Agora que você já conhece na teoria os tipos de relacionamento, que tal vermos na prática?

Associação

A forma mais comum de associação é quando temos um objeto como atributo de outro. Criaremos um objeto Produto e outro Fornecedor. Onde Fornecedor é um dos atributos de Produto.

Vamos analisar o diagrama UML:

Associação entre Produto e Fornecedor

Observe que uma das propriedades (Fornecedor), espera receber um objeto do tipo Fornecedor.

Vamos agora criar as duas classes e em seguida os objetos.

class Produto{

  public $Id;
  public $Nome;
  public $Valor;
  public $Fornecedor;

  public function __construct($Id, $Nome, $Valor, $Fornecedor){
    $this->Id = $Id;
    $this->Nome = $Nome;
    $this->Valor = $Valor;
    $this->Fornecedor = $Fornecedor;
  }

}

class Fornecedor{

  public $Id;
  public $RazaoSocial;
  public $Endereco;
  public $Telefone;

  public function __construct($Id, $RazaoSocial, $Endereco, $Telefone){
    $this->Id = $Id;
    $this->RazaoSocial = $RazaoSocial;
    $this->Endereco = $Endereco;
    $this->Telefone = $Telefone;
  }

}

$fornecedor = new Fornecedor(359, "Mercado da Casa", "Rua B", "3232-2222" );

$produto = new Produto(122, "Café 250g", 2.85, $fornecedor );

echo "Código: " . $produto->Codigo . "< br />";
echo "Produto: " . $produto->Nome . "< br />";
echo "Fornecedor: " . $produto->Fornecedor->RazaoSocial . "< br />";

Perceba que, ao criar o objeto Produto, passamos o objeto Fornecedor, em seguida, para imprimir fizemos uma referenciação de Produto e Fornecedor.

Agregação

Conforme visto anteriormente, esta relação se dá quando temos o "TODO/PARTE". 
Uma forma de exemplificar sua implementação e com o clássico exemplo de um carrinho de compras. 
Teremos duas classes, produto (bem parecido com a que vimos anteriormente) e a classe Carrinho.
Observe o diagrama:

Relação de Agregação

Importante destacar que a propriedade Itens é um array, poderia ser representando como: Itens[] : Produto.
Observer que a classe Carrinho possui dois métodos, ExibeLista() e o CalculaTotal().
Vamos criar codificar as duas classes e em seguida criar os objetos:

class Produto{

  public $Id;
  public $Nome;
  public $Valor;

  public function __construct($Id, $Nome, $Valor){
    $this->Id = $Id;
    $this->Nome = $Nome;
    $this->Valor = $Valor;
  }

}

Agora vamos criar a classe Carrinho:

class Carrinho{

  private $itens;

  public function InsereProduto(Produto $item){

    $this->itens[] = $item;

  }

  public function ExibeLista(){

    foreach( $this->itens as $item ){
      return $item->nome."< br />;
    }

  }

  public function CalculaTotal(){

    $valor_total = 0;

    foreach( $this->itens as $item ){
      $valor_total += $item->Valor;
    }

    echo " R$ " . number_format($valor_total, 2, ',', '.');

  }

}

Vamos as explicações: Repare que na linha 5 da classe Carrinho estamos obrigando o $item a ser do tipo Produto. Este é um conceito conhecido como TypeHinting ou "Sugestão de tipo", caso este método receba algo que não seja um Produto, ocasionará um erro.
Na linha 7 estamos inserindo cada produto no array $itens.
O método ExibeLista apenas percorre o array de itens exibindo o nome de cada produto.
O método CalculaTotal percorre o array de itens somando o valor de cada um e em seguida mostrando (formatado) o valor final.

Vamos testar?

$produto1 = new Produto(1, "Milho verde", 1.75);
$produto2 = new Produto(2, "Ervilha", 1.65);
$produto3 = new Produto(3, "Café 250Gr", 3.45);
$produto4 = new Produto(4, "Refrigerante 2L", 3.69);

$CarrinhoCompra = new Carrinho();
$CarrinhoCompra->InsereProduto($produto1);
$CarrinhoCompra->InsereProduto($produto2);
$CarrinhoCompra->InsereProduto($produto3);
$CarrinhoCompra->InsereProduto($produto4);

$CarrinhoCompra->ExibeLista();
$CarrinhoCompra->CalculaTotal();

Ao executar, você perceberá que a lista de itens (nome) será exibida, seguido do valor total.

Composição

A diferença da composição para a agregação é que quando o objeto "todo" é destruído, suas partes também são, exatamente por terem sido criadas pelo objeto "todo". Podemos dizer que na composição o objeto-pai "possui" as instâncias de suas partes.
Observe a notação para a composição:

Relação de Composição

Neste exemplo, a classe cliente será responsável por instanciar contato. Vamos agora codificar para entender melhor:

class Contato{

  public $Nome;
  public $Email;
  public $Telefone;

  /* Método setContato()
  *  Grava informações de contato
  */

  public function setContato($Nome, $Email, $Telefone){

    $this->Nome = $Nome;
    $this->Email = $Email;
    $this->Telefone = $Telefone;

  }

  /* Método EscreveContato()
  *  Escreve as informações de contato
  */

  public function EscreveContato(){

    echo "Nome: " . $this->Nome . "< br />";
    echo "Email: " . $this->Email . "< br />";
    echo "Telefone: " . $this->Telefone . "< br />";

  }

}

Agora vamos criar a classe Cliente:

class Cliente{

  public $Codigo;
  public $Endereco;
  public $Contato;

  /* Método construtor()
  *  Construtor da classe
  */

  public function __construct(){

    /* Instancia um novo Contato
    * Perceba que isso só é feito 
    * aqui. Não é feito fora dessa
    * classe
    */
 
    $this->Contato = new Contato();

  }

  /* Método setContato()
  *  Grava informações de contato
  */

  public function setContato($Nome, $Email, $Telefone){

    // Chama e envia informações para o objeto Contato
    $this->Contato->setContato($Nome, $Email, $Telefone);

  }

  /* Método EscreveContato()
  *  Escreve as informações de contato
  */

  public function EscreveContato(){

    // Chama um método do objeto Contato
    $this->Contato->EscreveContato();

  }

}

Perceba que a classe Cliente só existe se também existir a classe Contato. Uma aplicação clara da relação de composição. Vamos agora testar o exemplo:

$leandro = new Cliente();
$leandro->Codigo = 7;
$leandro->setContato("Leandro","leandrocastro@gmail.com","(33) 3333-3333");
$leandro->Endereco = "Rua 13 de maio";

$leandro->EscreveContato();
echo "Endereço: " . $leandro->Endereco;

Note que em nenhum momento instanciamos Contato, pois quem faz isso é a classe Cliente, daí a relação de composição.


Finalizamos assim mais um artigo do curso. 
Na próxima aula veremos os métodos __set(), __get() e __call() conhecidos como métodos interceptores. 
Utilize o espaço de comentários para críticas, sugestões ou elogios.

Curso de PHP Orientado a Objetos - Parte 7

imagem meramente ilustrativa

Este é o sétimo artigo do curso de PHP Orientado a Objetos.

Para conhecer as demais partes, clique aqui.

Ao final deste artigo, você será capaz de:

• Entender o conceito de constantes na POO;
• Entender o conceito de propriedades estáticas;
• Entender o conceito de métodos estáticos.

As classes permitem armazenar valores de duas formas: constantes de classe e propriedades estáticas. Estes atributos são comuns em todos os objetos da mesma classe.

Constantes

Primeiro vamos definir o que é constante.

Uma constante é exatamente o oposto de uma variável, ou seja, algo que mantém seu valor até o final do script (salvo alguma exceções). Geralmente definimos uma constante perto do início do código ou em uma função.

A declaração de constantes é feita através da palavra-chave const. Para acessar constantes de classe fora do escopo dela, a seguinte notação é utilizada NomeClasse::Constante; e já dentro da classe, utilizamos a notação self::Constante. A palavra-chave self também pode ser utilizada para referenciar a própria classe.

Vamos analisar:

/* Vamos declarar uma  
* constante chamada pi
*/
class Funcoes{

  const Pi = 3.14;
}

/* Vamos herdar Funcoes 
* e criar outra constante
*/

class Aplicacao extends Funcoes{

  const Versao = 3.8;  

  function __construct($Nome){
    echo $Nome. "< br/>";
    echo self::Versao . "< br />";
    echo parent::Pi . "< br />";
    echo Funcoes::Pi . "< br />";  
  }
}


$sistema1 = new Aplicacao("CafeeSoftware");

Perceba que acessamos a constante Pi tanto pela sintaxe: Funcoes::Pi, quanto pela sintaxe: parent::Pi.
Lembre-se que parent se refere a classe-pai. E Pi é da classe-pai de Aplicação. Self refere-se a classe em questão.

Propriedades e métodos estáticos

Podemos considerar que propriedades e métodos estáticos podem ser acessados sem a necessidade de instanciar um objeto. Utilizamos este recurso quando, por exemplo, temos um método que é acessado diversas vezes na mesma aplicação, e queremos economizar algumas linhas de código a fim de não ter que criar um objeto a todo momento. É importante destacar que um método estático não pode fazer referencia a propriedades internas pelo operador $this, pois este operador é usado para referenciar instâncias da classe ou seja, objetos.

Utilizamos a palavra chave static para definir a declaração de membros estáticos.

Vamos ao exemplo:

class Teste{

     public static $propriedade = "Esta é uma propriedade estática";


     public static function MetodoEstatico(){
        echo "Este é um método estático";
     }
}

/* Para acessar é simples, 
* perceba que não é necessário 
* criar o objeto.
*/

echo Teste::$propriedade;
//Agora o método
Teste::MetodoEstatico();

Membros estáticos também podem ser acessados internamente utilizando o operador self (o mesmo que vimos anteriormente), veja:

class Teste{
     public static $propriedade = "www.cafeesoftware.com - Transformando Café em Software";
     public static function RetornaPropriedade(){

       return self::propriedade;   

     }

     public static function UsarMetodoRetorna(){
        return self::RetornaPropriedade();   
     }
}
// Para acessar:
echo Teste::RetornaPropriedade();
Teste::UsarMetodoRetorna();

Quando se tratar de uma subclasse herdando propriedades ou mesmo métodos estáticos, a referência é feita normalmente através da palavra reservada parent, como já vimos anteriormente.
No próximo artigo estudaremos os relacionamentos: Composição, agregação e associação. Veremos na prática quando ocorre cada um deles e sua utilização no PHP.
Utilize o espaço de comentários para dúvidas, sugestões e elogios.

Até a próxima.

Novidades!

Ainda está semana o Café e Software irá mudar seu layout e mais, teremos um servidor próprio. Cortesia de um ilustre visitante do blog.

Não deixe de acompanhar!

Curso de PHP Orientado a Objetos - Parte 6

Vamos começar a semana com o sexto artigo do Curso de PHP Orientado a Objetos.

Para conhecer as demais partes, clique aqui.

Ao final deste artigo, você será capaz de:

• Entender o significado do encapsulamento para a POO;
• Entender e aplicar a visibilidade dos métodos e propriedades.

Encapsulamento

É um dos recursos mais interessantes que a programação orientada a objetos nos fornece. Trata-se de um mecanismo que provê proteção de acesso aos membros internos de um objeto.

Alguns métodos e propriedades devem ser só de responsabilidade da classe-pai. Sem os modificadores de acesso, ela perde esta responsabilidade, fazendo com que outras classes tenham acesso a estes métodos e propriedades.

Para atingir o encapsulamento, uma das formas é definindo a visibilidade das propriedades e dos métodos de um objeto. A visibilidade define a forma como essas propriedades devem ser acessadas. Existem três formas de acesso:

1. private: Este modificador não permite ser acessado por classes descendentes (classes-filhas), só pode ser acessado dentro da própria classe.
2. public: Este modificador é o default (padrão), ou seja, quando um método não tiver um modificador de visibilidade definido, ele sempre será public. Public significa que o método ou propriedade em questão pode ser acessado por todas as outras classes e métodos sem quaisquer restrições.
3. protected: Pode ser acessado apenas por métodos da própria classe e classes filhas.

Podemos dizer que o encapsulamento nos permite "ocultar" tudo aquilo que não é "importante", ou seja, detalhes internos do funcionamento da classe são ocultos para os objetos. O objeto só conhece o que é necessário, o que ele não precisa saber/conhecer, fica oculto (a nível de objeto).

Private

Até agora, nos artigos anteriores, declaramos classes como public e não definimos visibilidades dos métodos. Vamos iniciar com um exemplo prático, para facilitar a compreensão.

A proposta é criar uma classe chamada Fornecedor e marcaremos algumas das propriedades como private. Dessa forma, os elementos private só poderão ser alterados por métodos da mesma classe. Deixaremos para livre acesso, o nome e o valor, marcado como public.

class Fornecedor{
   private $Id;      //identificação
   public  $Nome;    //nome do produto
   private $Compra;  //valor de compra
   public  $Valor;   //valor de venda

}

Observe a imagem abaixo:

Eclipse exibindo apenas as propriedades públicas da classe Fornecedor

Criamos o objeto Fornecedor e ao definir as propriedades, o próprio Eclipse, através de sua função autocomplete, carregará somente as funções públicas (public). Perceba que ele não exibe na lista as funções privadas (private).


Se mesmo assim você tentar algo como:

$empresa1 = new Fornecedor();
$empresa1->Compra = 400;

Será retornado uma mensagem de erro, pois a propriedade Compra é privada (private).


Ok, mas como faço para atribuir algo a essa propriedade caso necessário?
Se você fez essa pergunta, parabéns!
Para atribuir algo, basta criar um método pertencente a classe Fornecedor que manipule estas propriedades. Que tal chamarmos de "Set" para definir e "Get" para obter o conteúdo dos atributos?
Veja o exemplo:

class Fornecedor{
   private $Id;      //identificação
   public  $Nome;    //nome do produto
   private $Compra;  //valor de compra
   public  $Valor;   //valor de venda

/* Olha o método setCompra()
 * que vai definir um valor para
 * a propriedade $Compra
*/
 public function setCompra($Compra){

 if (is_numeric($Compra) && $compra > 0)
 {
    $this->Compra = $Compra;
 }

 }
/* Vamos agora criar o método
 * getCompra que vai retornar
 * o conteúdo da propriedade $compra
*/
 public function getCompra(){

  return $this->Compra;

 }
}

Agora que criamos o método get e set para a propriedade $Compra, é possível realizar a chamada normalmente:

$empresa1 = new Fornecedor();
$empresa1->Nome = "Vale";
$empresa1->setCompra(400);
echo "O valor do produto ".$empresa1->Nome." é de ".$empresa1->getCompra();

O interessante neste caso, é perceber que para um determinado valor chegar a propriedade $Compra, ele deve passar pelo método setCompra. Isso nos traz um controle maior sobre a aplicação visto que, você pode realizar várias operações antes da chagada do valor, neste caso perceba que no método setCompra, checamos se o valor é um número (is_numeric) e se é maior que zero.
Poderíamos criar um set e um get para mais elementos definidos como private mas cuidado, utilize os Getters e Setters somente quando existe a real necessidade, variáveis internas ou que não precisam de nenhum tipo de verificação ou tratamento, não utilize.
Prefira sempre utilizar métodos Getter e Setters ao invés de um campo público (public) mas lembre-se, simplificar é a alma da POO, criar dezenas de métodos não simplifica.


Protected


Vimos no exemplo anterior, o uso do parâmetro de visibilidade private. Vale ressaltar que quando uma propriedade é definida como private, ela não pode ser sobrescrita por classes filhas, ou seja, uma classe filha não consegue chamar os métodos setters e getters da classe pai (no caso do atributo estar como private).
Caso você tenha uma classe Funcionário com o método setSalario e o atributo Salário do tipo private, e crie a subclasse Estagiário, você não consegue chamar o método mesmo fazendo uso da herança, está é uma característica do private.
Em outras palavras, se um atributo é do tipo private, ele só funciona na classe que foi declarado, caso você queira fazer uso do mesmo em outras classes (filhas) é necessário modificar o tipo para Protected.


Veja:

class Funcionario{
  private $Id;
  private $Nome;
  private $Nascimento;
  private $Salario;

 function setSalario($Salario){

   if (is_numeric($Salario) && $Salario > 0)
   {
      $this->Salario = $Salario;
   }

 }

 function getSalario(){

   return $this->Salario;

 }

}

Agora, vamos criar a classe Estagiário, que será uma subclasse de Funcionário.

class Estagiario extends Funcionario {
  /* Método getSalario será
   * sobrescrito pois o estagiário
   * neste modelo possui um bônus
   * de 10%
   */ 

  function getSalario(){
   return $this->Salario * 1.10;
  }

}

Depois das duas classes criadas, vamos criar o objeto estagiário:

$junior = new Estagiario;
$junior->setSalario(300);
echo "O salario é: ".$junior->getSalario;

Essa ação resultaria em um erro. Isso ocorre porque a propriedade $Salario é uma propriedade private, o que significa que ela somente pode ser acessada de dentro da classe em que ela foi declarada, neste caso, a classe Funcionário.
Para que as subclasses consigam acessar uma propriedade da classe pai, definimos como protected.


Exemplo:

class Funcionario{
  private   $Id;
  private   $Nome;
  private   $Nascimento;
  protected $Salario;

 function setSalario($Salario){

   if (is_numeric($Salario) && $Salario > 0)
   {
      $this->Salario = $Salario;
   }

 }

 function getSalario(){

   return $this->Salario;

 }

}

Agora podemos criar a classe Estagiário da mesma forma que fizemos no exemplo anterior e em seguida criar o objeto:

$junior = new Estagiario;
$junior->setSalario(300);
echo "O salario é: ".$junior->getSalario;

Com essa pequena modificação, tornamos o atributo $Salario "extensível" a todas as classes que forem criadas a partir da classe Funcionário. Este exemplo não retornaria erro.

Public


Explicar o comportamento do modificador de acesso public é simples, pois é a propriedade padrão do PHP. Basicamente, quando não é definido a visibilidade, ela será pública ou seja, você pode modificar, herdar ou atribuir sem nenhum impedimento, não é necessário os métodos Getters e Setters para propriedades públicas.


Terminamos aqui mais um artigo.
No próximo veremos constantes e propriedades estáticas.


Utilize o espaço de comentários para dúvidas, sugestões e elogios.
Ps.: Venho recebendo alguns comentários que tem servido de estímulo para a continuação desta série. Muito obrigado!