O que é uma classe em PHP?
3 answers
Em poucas palavras , Uma classe é um modelo para um objecto. E um objeto encapsula Estado conceitualmente relacionado e responsabilidade de algo em sua aplicação e geralmente oferece uma interface de programação com a qual interagir com eles. Isso promove a reutilização de código e melhora a manutenção.
Imagina uma fechadura.
namespace MyExample;
class Lock
{
private $isLocked = false;
public function unlock()
{
$this->isLocked = false;
echo 'You unlocked the Lock';
}
public function lock()
{
$this->isLocked = true;
echo 'You locked the Lock';
}
public function isLocked()
{
return $this->isLocked;
}
}
Ignora o namespace, private e declaração agora mesmo.
$isLocked. Uma vez que só pode ter estes dois estados, eu uso um booleano (true ou false) para indicar que estado se aplica. Posso interagir com a fechadura através dos seus métodos. lock e unlock, que mudará o estado em conformidade. O método isLocked dar-me-á o estado actual da fechadura. Agora, quando você cria um objeto (também muitas vezes referido como um A partir deste projecto, encapsulará um estado único, por exemplo.
$aLock = new Lock; // Create object from the class blueprint
$aLock->unlock(); // You unlocked the Lock
$aLock->lock(); // You locked the Lock
$anotherLock = new Lock;
$anotherLock->unlock(); // You unlocked the Lock
Mas como cada objecto / instância encapsula o seu próprio estado, a primeira fechadura fica bloqueada
var_dump( $aLock->isLocked() ); // gives Boolean true
var_dump( $anotherLock->isLocked() ); // gives Boolean false
class Door
{
private $lock;
private $connectsTo;
public function __construct(Lock $lock)
{
$this->lock = $lock;
$this->connectsTo = 'bedroom';
}
public function open()
{
if($this->lock->isLocked()) {
echo 'Cannot open Door. It is locked.';
} else {
echo 'You opened the Door connecting to: ', $this->connectsTo;
}
}
}
class Chest
{
private $lock;
private $loot;
public function __construct(Lock $lock)
{
$this->lock = $lock;
$this->loot = 'Tons of Pieces of Eight';
}
public function getLoot()
{
if($this->lock->isLocked()) {
echo 'Cannot get Loot. The chest is locked.';
} else {
echo 'You looted the chest and got:', $this->loot;
}
}
}
$doorLock = new Lock;
$myDoor = new Door($doorLock);
$chestLock = new Lock;
$myChest new Chest($chestLock);
$quantumLock = new Lock;
$myDoor = new Door($quantumLock);
$myChest new Chest($quantumLock);
E quando tu, a porta e o peito estariam destrancados.
Embora admita que as fechaduras quânticas são um mau exemplo, ilustra o conceito de partilha de objectos em vez de reconstruir o estado e a responsabilidade por todo o lado. Um exemplo do mundo real pode ser um objeto de banco de dados que você passa para classes usando a base de dados.Note que os exemplos acima não mostram como chegar à fechadura de um cofre ou de uma porta para usar os métodos lock() e unlock(). Deixo isto como um exercício para o seu exercício (ou outra pessoa para adicionar).
Verifique também quando usar self acima de $isto? para uma explicação mais aprofundada das Classes e objectos e como trabalhar com eles
Para alguns recursos adicionais ver
Classe de construção:
/**
* Constructs a building.
*/
class Building
{
private $name;
private $height;
public function __construct( $name, $height )
{
$this->name = $name;
$this->height = $height;
}
/**
* Returns name of building.
*
* @return string
*/
public function getName( )
{
return $this->name;
}
public function elevatorUp( )
{
// Implementation
}
public function elevatorDown( )
{
// Implementation
}
public function lockDoor( )
{
// Implementation
}
}
Chamando a classe:
// Empire State Building
$empireStateBuilding = new Building( "Empire State Building", 381 );
echo $empireStateBuilding->getName( );
$empireStateBuilding->lockDoor( );
// Burj Khalifa
$burjKhalifa = new Building( "Burj Khalifa", 828 );
echo $burjKhalifa->getName( );
$burjKhalifa->lockDoor( );
Para oferecer uma vista de outro ângulo, se me permite (com base na experiência pessoal). Você precisa sentir "a necessidade de OOP" antes que você possa realmente entender o que é tudo sobre - IMHO, os recursos de aprendizagem devem vir depois disso.
Seria basicamente "necessário" ficar preso em dificuldades estruturais quando se escreve um software relativamente grande escrito em estilo processual (ao contrário de orientada a objetos, desculpe se alguém discorda do termo). Até lá, podia tentar reestruturar o código em objetos para melhor organizá-lo e, naturalmente, saber mais sobre o OOP em detalhes. Mais uma vez, esta é a minha experiência pessoal e me levou a entender mais rápido do que qualquer livro.
Só a minha opinião.