Curso de PHP - Objetos

Curso de PHP – Objetos Fábio M. Pereira
UNIVERSIDADE ESTADUAL DO SUDOESTE DA BAHIA – UESB
UNIDADE ORGANIZACIONAL DE INFORMÁTICA - UINFOR

Roteiro
•Criando um Objeto
•Acessando Propriedades e Métodos
•Declarando Uma Classe
•Introspecção
•Serialização

Objetos
•A Programação Orientada a Objetos (POO) abriu a porta para o design limpo, manutenção mais fácil e maior reuso de código
•O valor já provado da POO é tanto que poucos hoje em dia iriam desafiar ao introduzir uma linguagem que não fosse orientada a objetos
•PHP dá suporte a muitas características úteis da POO
•POO reconhece a conexão fundamental entre os dados e o código que manipula os dados e permite o projeto e implementação de programas em torno desta conexão
•Projetar sistemas orientados a objetos é um tópico complexo, existindo muitos livros escritos sobre isto
•A boa notícia é que não importa como projete o seu sistema, poderá implementá-lo em PHP
•Este tópico mostra como definir, criar e usar objetos em PHP, cobrindo desde os conceitos básicos até tópicos avançados como introspecção e serialização

Criando Um Objeto
•É muito mais fácil criar um objeto e utilizá-lo do que definir classes de objetos, então, antes de discutir como definir classes, veremos como criar objetos
•Para criar um objeto de uma data classe, usamos a palavra chave new:
$objeto = new Classe;
•Assumindo que uma classe Pessoa tenha sido definida, criamos um objeto Pessoa:
$rasmus = new Person;
•Podemos passar argumentos em algumas classes na chamada new:
$object = new Person("Fred", 35);

Criando Um Objeto
•O nome da classe não precisa ser diretamente inserido no programa, podemos fornecê-lo através de uma variável:
$class = "Person";
$object = new $class;
// é equivalente a
$object = new Person;
•Variáveis contendo referências a objetos são apenas variáveis normais, podendo ser tratadas da mesma maneira:
$account = new Account;
$object = "account";
${$object}->init(50000, 1.10);
// o mesmo que $account->init

OBJETOS ACESSANDO PROPRIEDADE E MÉTODOS

Acessando Propriedades e Métodos
•Uma vez que tenhamos um objeto, podemos usar a notação -> para acessar métodos e propriedades do objeto:
$object->propertyname $object->methodname([arg, ... ])
•Por exemplo:
echo "Rasmus is {$rasmus->age} years old.n";
// acesso a propriedade
$rasmus->birthday(); // chamada do método
$rasmus->setAge(21); // chamada com argumento
•Métodos agem como funções, então eles podem receber argumentos e retornar um valor:
$clan = $rasmus->family("extended");

•Dentro da definição da classe, podemos especificar métodos e propriedades publicamente acessíveis e acessíveis apenas dentro da própria classe, usando os modificadores de acesso public e private, permitindo o encapsulamento
•Podemos usar variáveis de variáveis com nomes de propriedades:
$prop = 'age';
echo $rasmus->$prop;

•Um método estático é aquele que é chamado em uma classe, não em um objeto
–Estes métodos não podem acessar propriedades
•O nome de um método estático é o nome da classe seguido por dois pontos duas vezes e o nome da função
•Por exemplo, para chamar o método estático p() da classe HTML:
HTML::p("Hello, world");
•Quando declaramos uma classe, definimos quais propriedades e métodos são estáticos usando a propriedade static

•Uma vez criados, objetos são passados por referência, por exemplo:
$f = new Person("Fred", 35);
$b = $f; // $b and $f point at same object
$b->setName("Barney");
printf("%s and %s are best friends.n",
$b->getName(), $f->getName());
Barney and Barney are best friends.

•Se quisermos criar uma cópia real do objeto, devemos utilizar o operador clone:
$f = new Person("Fred", 35);
$b = clone $f; // make a copy
$b->setName("Barney");// change the copy
printf("%s and %s are best friends.n",
$b->getName(), $f->getName());
Fred and Barney are best friends.

•Quando usamos o operador clone para criar uma cópia de um objeto e a classe declara o método __clone(), este método é chamado no novo objeto imediatamente após a cópia
•Podemos usar isto em casos quando um objeto guarda recursos externos (como em manipuladores de arquivos) para criar novos recursos, em vez de copiar os existentes

Declarando Uma Classe
•Para projetar um programa ou uma biblioteca de código de maneira orientada a objetos, precisamos definir nossas próprias classes, usando a palavra chave class
•Uma definição de classe inclui o nome da classe, suas propriedades e métodos
–Nomes de classe não são sensíveis à caixa e devem seguir as mesmas regras de identificadores PHP
–O nome de classe stdClass é reservado

Declarando Uma Classe
•Sintaxe:
class classname [ extends baseclass ] [ implements interfacename , [interfacename, ... ] ]
{
[ use traitname, [ traitname, ... ]; ]
[ visibility $property [ = value ]; ... ]
[ function functionname (args) {
// code
}
...
]
}

Declarando Métodos
•Um método é uma função definida dentro de uma classe
•Nomes de métodos que iniciam com dois sublinhados (__) podem ser usados no futuro por PHP (são atualmente usados pelos métodos de serialização de objetos __sleep() e __wakeup(), dentre outros), portanto não é recomendado iniciar os nomes de métodos com essa sequência
•Dentro do método, a variável $this contém uma referência ao objeto no qual o método foi chamado
–Por exemplo, se chamarmos $rasmus->birthday(), dentro do método birthday(), $this armazena o mesmo valor de $rasmus

Declarando Métodos
•Exemplo:
class Person
{
public $name = '';
function getName()
{
return $this->name;
}
function setName($newName)
{
$this->name = $newName;
}
}

Declarando Métodos
•Para declarar um método estático, usamos a palavra chave static
•Dentro de métodos estáticos a variável $this não está definida
•Exemplo:
class HTMLStuff
{
static function startTable() {
echo "<table border="1">n";
}
static function endTable() {
echo "</table>n";
}
}
HTMLStuff::startTable();
// imprimir linhas e colunas de uma tabela HTML
HTMLStuff::endTable();

Declarando Métodos
•Se declararmos um método usando a palavra chave final, subclasses não podem sobrescrever o método
•Exemplo:
class Person {
public $name;
final function getName() {
return $this->name;
}
}
class Child extends Person {
// erro de syntaxe
function getName() {
// faça alguma coisa
}
}

Declarando Métodos
•Usando modificadores de acesso podemos mudar a visibilidade dos métodos
•public – métodos podem ser acessados fora do objeto
•private – métodos podem ser acessados apenas por métodos dentro da mesma classe
•protected – métodos podem ser acessados por métodos dentro da mesma classe e métodos de classes que herdam da mesma
•Se a visibilidade não for especificada, um método é considerado público

Exemplo
class Person {
public $age;
public function __construct() {
$this->age = 0;
}
public function incrementAge() {
$this->age += 1;
$this->ageChanged();
}
protected function decrementAge() {
$this->age −= 1;
$this->ageChanged();
}
private function ageChanged() {
echo "Age changed to {$this->age}";
}
}

Exemplo
class SupernaturalPerson extends Person{
public function incrementAge() {
// idades em reverso
$this->decrementAge();
}
}
$person = new Person;
$person->incrementAge();
$person->decrementAge(); // não permitido
$person->ageChanged(); // também não permitido
$person = new SupernaturalPerson;
$person->incrementAge(); // chama decrementAge

Declarando Métodos
•Podemos usar sugestão de tipo quando declararmos um método de um objeto:
class Person {
function takeJob(Job $job) {
echo "Now employed as a {$job->title}n";
}
}

Declarando Propriedades
•Na definição anterior da classe Person declaramos explicitamente a propriedade $name
•Declarações de propriedades são opcionais e são simplesmente uma cortesia para quem quer que faça a manutenção do programa
•Versão de Person sem declaração da propriedade $name:
class Person {
function getName() {
return $this->name;
}
function setName($newName) {
$this->name = $newName;
}
}

•Podemos atribuir valores padrões a propriedades, mas estes valores devem ser constantes simples:
public $name = "J Doe"; // funciona
public $age = 0; // funciona
public $day = 60 * 60 * 24; // não funciona
•Usando modificadores de acesso, podemos mudar a visibilidade de propriedades: public, private e protected
•Exemplo:
class Person {
protected $rowId = 0;
public $username = 'Anyone can see me';
private $hidden = true;
}

•Adicionalmente a propriedades de instâncias de objetos, PHP permite a definição de propriedades estáticas, que são variáveis de uma classe e podem ser acessadas referenciando a propriedade com o nome da classe
•Exemplo:
class Person {
static $global = 23;
}
$localCopy = Person::$global;
•Podemos também referenciar propriedades estáticas de dentro da instância da classe através da palavra chave self, como em echo self::$global;

Declarando Constantes
•Da mesma forma que constantes globais, atribuídas através da função define(), PHP fornece uma maneira de atribuir constantes dentro de uma classe
•Assim como propriedades estáticas, constantes podem ser acessadas diretamente através da classe ou de métodos dentro do objeto usando a notação self
•Uma vez que o valor de uma constante é definido, não poderá mais ser mudado:
class PaymentMethod {
const TYPE_CREDITCARD = 0;
const TYPE_CASH = 1;
}
echo PaymentMethod::TYPE_CREDITCARD;
0

Herança
•Para herdar as propriedades e métodos de outra classe, use a palavra chave extends na definição da classe, seguida pelo nome da classe base:
class Person {
public $name, $address, $age;
}
class Employee extends Person {
public $position, $salary;
}
•Para acessar um método sobreposto em um objeto da classe pai, use a notação parent::method():
parent::birthday();
// chama o método birthday() da classe pai

Herança
•Para verificar se um objeto é uma instância de uma classe em particular ou se ele implementa uma determinada interface, podemos usar o operador instanceof:
if ($object instanceof Animal) {
// faça alguma coisa
}

Interfaces
•Interfaces fornecem uma maneira para definirmos contratos que uma classe adere
–A interface fornece protótipos de métodos e constantes
–Qualquer classe que implementa a interface deve fornecer implementação para todos os métodos da interface
•Sintaxe:
interface interfacename
{
[ function functionname();
...
]
}

Interfaces
•Para declarar que uma classe implementa uma interface, devemos incluir a palavra chave implements seguida de qualquer número de interfaces, separadas por vírgulas:
interface Printable {
function printOutput();
}
class ImageComponent implements Printable {
function printOutput() {
echo "Printing an image...";
}
}

Interfaces
•Uma interface pode herdar de outras interfaces (incluindo múltiplas interfaces) desde que nenhuma das interfaces que ela herda declare métodos com o mesmo nome daqueles declarados na interface filha

Características
•Características fornecem um mecanismo para reuso de código fora de uma hierarquia de classes
•Características permitem que compartilhemos funcionalidade através de diferentes classes que não compartilham um ancestral em comum em uma hierarquia de classes
•Sintaxe:
trait traitname [ extends baseclass ] {
[ use traitname, [ traitname, ... ]; ]
[ visibility $property [ = value ]; ... ]
[ function functionname (args) {
// code
}
...
]
}

Características
•Para declarar que uma classe deve incluir métodos trait, devemos incluir a palavra chave use e qualquer número de características, separados por vírgula:

Características
trait Logger {
public log($logString) {
$className = __CLASS__;
echo date("Y-m-d h:i:s", time()) .
": [{$className}] {$logString}";
}
}
class User {
use Logger;
public $name;
function __construct($name = '') {
$this->name = $name;
$this->log("Created user '{$this->name}'");
}
function __toString() {
return $this->name;
}
}

Características
class UserGroup { use Logger; public $users = array(); public addUser(User $user) { if (!$this->includesUser($user)) { $this->users[] = $user; $this->log("Added user '{$user}' to group"); } } } $group = new UserGroup; $group->addUser(new User("Franklin")); 2012-03-09 07:12:58: [User] Created user 'Franklin' 2012-03-09 07:12:58: [UserGroup] Added user 'Franklin' to group

Características
•Características podem ser compostas por outras características pela inclusão da instrução use na declaração da característica, seguida por uma ou mais características separadas por vírgulas:
trait First {
public doFirst() {
echo "firstn";
}
}
trait Second { public doSecond() { echo "secondn"; } }
trait Third {
use First, Second;
public doAll() {
$this->doFirst();
$this->doSecond();
}
}
class Combined {
use Third;
}
$object = new Combined;
$object->doAll();
first
second

Resolvendo Conflitos
trait Command {
function run() {
echo "Executing a command";
}
}
trait Marathon {
function run() {
echo "Running a marathon";
}
}

Resolvendo Conflitos
trait Command {
function run() {
echo "Executing a command";
}
}
trait Marathon {
function run() {
echo "Running a marathon";
}
}
class Person { use Command, Marathon { Command::run as runCommand; Marathon::run insteadof Command; } } $person = new Person; $person->run(); $person->runCommand(); Running a marathon Executing a command

Métodos Abstratos
•PHP também fornece um mecanismo para declaração de que certos métodos na classe devem ser implementados por subclasses
–A implementação desses métodos não está definida na classe pai
–Nesses casos, fornecemos um método abstrato
•Em adição, se uma classe possui qualquer método definido como abstrato, podemos também declarar a classe como abstrata

Métodos Abstratos
abstract class Component {
abstract function printOutput();
}
class ImageComponent extends Component {
function printOutput() {
echo "Pretty picture";
}
}

Métodos Abstratos
•Classes abstratas não podem ser instanciadas
•Diferentemente de algumas linguagens, também não podemos fornecer uma implementação padrão para métodos abstratos
•Características também podem declarar métodos abstratos
•Classes que incluem uma característica que define um método abstrato deverá implementá-lo

Métodos Abstratos
trait Sortable { abstract function uniqueId(); function compareById($object) { return ($object->uniqueId() < $this->uniqueId()) ? −1 : 1; } } class Bird { use Sortable; function uniqueId() { return __CLASS__ . ":{$this->id}"; } }

Métodos Abstratos
trait Sortable { abstract function uniqueId(); function compareById($object) { return ($object->uniqueId() < $this->uniqueId()) ? −1 : 1; } } class Bird { use Sortable; function uniqueId() { return __CLASS__ . ":{$this->id}"; } }
class Car {
use Sortable;
}
// fatal
$bird = new Bird;
$car = new Car;
$comparison = $bird->compareById($card);

Construtores
•Podemos fornecer uma lista de argumentos após o nome da classe quando instanciamos um objeto:
$person = new Person("Fred", 35);
•Estes argumentos são passados ao construtor da classe, uma função especial que inicializa as propriedades da classe
•Uma construtor é uma função da classe chamada __construct()
•Construtor da classe Person:
class Person {
function __construct($name, $age) {
$this->age = $age;
}
}

Construtores
•PHP não fornece encadeamento automático de construtores:
–Se iniciarmos um objeto de uma classe derivada, somente o construtor da classe derivada é automaticamente chamado
•Para que o construtor da classe pai seja chamado, o construtor da classe derivada deve explicitamente chamá-lo

Construtores
class Person {
public $name, $address, $age;
function __construct($name, $address, $age) {
$this->address = $address;
$this->age = $age;
}
}
class Employee extends Person {
public $position, $salary;
function __construct($name, $address, $age,
$position, $salary) {
parent::__construct($name, $address, $age);
$this->position = $position;
$this->salary = $salary;
}
}

Destrutores
•Quando um objeto é destruído, como quando a última referência a um objeto é removida ou o fim do script é alcançado, o seu destrutor é chamado
•Uma vez que PHP automaticamente limpa todos os recursos quando eles saem do escopo e no fim da execução de um script, a sua aplicação é limitada
•O destrutor é um método chamado __destruct():
class Building {
function __destruct() {
echo "A Building is being destroyed!";
}
}

Introspecção
•Introspecção é a habilidade de um programa examinar as características de um objeto, como o seu nome, classe pai (se existir), propriedades e métodos
•Com introspecção, podemos escrever código que opere em qualquer classe ou objeto
•Não precisamos saber quais métodos ou propriedades estão definidas quando escrevemos o código, em vez disso, podemos descobrir esta informação em tempo real, o que torna possível escrever corretores de erro genéricos, serializadores, etc.

Examinando Classes
•Para determinar se uma classe existe, usamos a função class_exists(), que recebe uma string e retorna um valor booleano
•Alternativamente, podemos usar a função get_declared_classes(), que retorna um array de classes definidas e checar se nome da classe está no array retornado:
$doesClassExist = class_exists(classname);
$classes = get_declared_classes();
$doesClassExist = in_array(classname, $classes);

Examinando Classes
•Podemos descobrir os métodos e propriedades que existem em uma classe (incluindo os herdados de superclasses) usando as funções get_class_methods() e get_class_vars()
•Estas funções recebem o nome da classe e retornam um array:
$methods = get_class_methods(classname);
$properties = get_class_vars(classname);
•O nome da classe pode ser uma palavra, uma string ou uma variável:
$class = "Person";
$methods = get_class_methods($class);
$methods = get_class_methods(Person); // o mesmo
$methods = get_class_methods("Person"); // o mesmo

Examinando Classes
•O array retornado por get_class_methods() é uma lista simples de nomes de métodos
•O array associativo retornado por get_class_vars() mapeia nomes de propriedades em valores, incluindo propriedades herdadas
•Um truque de get_class_vars() é que ele retorna apenas propriedades que possuam valores padrões e estão visíveis no escopo atual, não há maneira de descobrir propriedades não inicializadas
•Utilize get_parent_class() para descobrir a classe pai de uma classe:
$superclass = get_parent_class(classname);

Exemplo
function displayClasses() { $classes = get_declared_classes(); foreach ($classes as $class) { echo "Showing information about {$class} "; echo "Class methods: "; $methods = get_class_methods($class); if (!count($methods)) { echo "None "; } else { foreach ($methods as $method) { echo "{$method}() "; } }

Exemplo
function displayClasses() {
foreach ($classes as $class) {
echo "Showing information about {$class} ";
echo "Class methods: ";
$methods = get_class_methods($class);
if (!count($methods)) {
echo "None ";
}
else {
foreach ($methods as $method) {
echo "{$method}() ";
}
}
echo "Class properties: ";
$properties = get_class_vars($class);
if (!count($properties)) {
echo "None ";
}
else {
foreach(array_keys($properties) as $property) {
echo "${$property} ";
}
}
echo "<hr />";
}
}

Examinando um Objeto
•Para descobrir a classe a qual um objeto pertence, primeiro devemos nos certificar que se trata de um objeto através da função is_object(), e então podemos descobrir a classe com a função get_class():
$isObject = is_object(var);
$classname = get_class(object);
•Antes de chamar um método de um objeto, podemos garantir que ele existe através da função method_exists():
$methodExists = method_exists(object, method);
•Chamar um método indefinido causa um erro de runtime

•A função get_object_vars() retorna um array com as propriedades atribuídas em um objeto:
$array = get_object_vars(object);
•Exemplo:
class Person {
public $name;
public $age;
}
$fred = new Person;
$fred->name = "Fred";
$props = get_object_vars($fred);
// array('name' => "Fred", 'age' => NULL);

•A função get_parent_class() aceita tanto um objeto como um nome de classe, retornando o nome da classe pai ou FALSE, se não existir:
class A {}
class B extends A {}
$obj = new B;
echo get_parent_class($obj);
echo get_parent_class(B);
A
A

Funções de Exemplo
// retorna um array de métodos callable
// incluindo métodos herdados
function getCallableMethods($object) {
$methods = get_class_methods(get_class($object));
if (get_parent_class($object)) {
$parent_methods = get_class_methods(
get_parent_class($object));
$methods = array_diff($methods, $parent_methods);
}
return $methods;
}

// retorna um array de métodos herdados function getInheritedMethods($object) { $methods = get_class_methods(get_class($object)); if (get_parent_class($object)) { $parentMethods = get_class_methods( get_parent_class($object)); $methods = array_intersect($methods, $parentMethods); } return $methods; }

// retorna um array de superclasses
function getLineage($object) {
if (get_parent_class($object)) {
$parent = get_parent_class($object);
$parentObject = new $parent;
$lineage = getLineage($parentObject);
$lineage[] = get_class($object);
}
else {
$lineage = array(get_class($object));
}
return $lineage;
}

// retorna um array de subclasses
function getChildClasses($object) {
$children = array();
foreach ($classes as $class) {
if (substr($class, 0, 2) == '__') {
continue;
}
$child = new $class;
if (get_parent_class($child) == get_class($object)) {
$children[] = $class;
}
}
return $children;
}

Serialização
•Serialização de um objeto significa a sua conversão para uma representação bytestream que pode ser armazenada em um arquivo
•Isto é útil para dados persistentes, por exemplo, sessões PHP automaticamente armazenam e recuperam objetos
•Serialização em PHP é quase sempre automática, feita através das funções serialize() e unserialize():
$encoded = serialize(something);
$something = unserialize(encoded);
•Serialização é mais comumente utilizada em sessões PHP, que manipula a serialização automaticamente
–Tudo que precisamos fazer é informar ao PHP quais variáveis queremos rastrear e ele automaticamente irá preservá-las entre as visitas às páginas do site

Serialização
•PHP tem dois ganchos para objetos durante os processos de serialização e de-serialização: __sleep() e __wakeup()
–Esses métodos são usados para notificar os objetos
–Objetos podem ser serializados se não possuírem esses métodos, no entanto não serão notificados sobre o processo
•O método __sleep() é chamado em um objeto antes da serialização
–Ele pode fazer qualquer limpeza necessária para preservar o estado do objeto, como fechar conexão com banco de dados, escrever ou salvar dados persistentes, etc.
–Ele deve retornar um array contendo os nomes dos dados que precisam ser escritos no bytestream
–Se retornar um array vazio, nenhum dado é escrito

Serialização
•Contrariamente, o método __wakeup() é chamado em um objeto imediatamente após ele ser criado a partir de um bytestream
–Ele pode executar qualquer ação necessária, como reabrir a conexão com o banco de dados e outras tarefas de inicialização
•O exemplo a seguir mostra uma classe de objetos Log, que possui dois métodos úteis:
–write() para adicionar uma mensagem a um arquivo de log
–read() para buscar o conteúdo atual do arquivo de log
–Ela usa __wakeup() para reabrir o arquivo de log e __sleep() para fechar arquivo

Exemplo
class Log {
private $filename;
private $fh;
function __construct($filename) {
$this->filename = $filename;
$this->open();
}
function open() {
$this->fh = fopen($this->filename, 'a') or
die("Can't open {$this->filename}");
}
function write($note) {
fwrite($this->fh, "{$note}n");
}

Exemplo
class Log { private $filename; private $fh; function __construct($filename) { $this->filename = $filename; $this->open(); } function open() { $this->fh = fopen($this->filename, 'a') or die("Can't open {$this->filename}"); } function write($note) { fwrite($this->fh, "{$note}n"); }
function read() {
return join('', file($this->filename));
}
function __wakeup() {
$this->open();
}
function __sleep() {
// write information to the account file
fclose($this->fh);
return array("filename");
}
}

Usando Log.php em front.php
<?php
include_once "Log.php";
session_start();
?>
<html><head><title>Front Page</title></head>
<body>
<?php
$now = strftime("%c");
if (!session_is_registered('l')) {
$logger = new Log("/tmp/persistent_log");
session_register('l');
$logger->write("Created $now");
echo("Created session and persistent log object.");
}

Usando Log.php em front.php
<?php
include_once "Log.php";
session_start();
?>
<html><head><title>Front Page</title></head>
<body>
<?php
$now = strftime("%c");
if (!session_is_registered('l')) {
$logger = new Log("/tmp/persistent_log");
session_register('l');
$logger->write("Created $now");
echo("Created session and persistent log object.");
}
$logger->write("Viewed first page {$now}");
echo "The log contains:";
echo nl2br($logger->read());
?>
<a href="next.php">Move to the next page</a>
</body></html>

next.php
<?php include_once "Log.php"; session_start(); ?> <html><head><title>Next Page</title></head> <body> <?php $now = strftime("%c"); $logger->write("Viewed page 2 at {$now}"); echo "The log contains:"; echo nl2br($logger->read()); echo ""; ?> </body></html>

Curso de PHP - Objetos

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Destaque

Destaque (20)

Semelhante a Curso de PHP - Objetos

Semelhante a Curso de PHP - Objetos (20)

Mais de Fabio Moura Pereira

Mais de Fabio Moura Pereira (17)

Último

Último (20)

Curso de PHP - Objetos