Classes e Objetos PHP

Neste tutorial, você aprenderá a escrever código de maneira orientada a objetos no PHP.

O que é programação orientada a objetos

A programação orientada a objetos (OOP) é um modelo de programação baseado no conceito de classe e objeto. Diferente da programação procedural, que se concentra em escrever processos ou funções que executam operações em dados, a programação orientada a objetos se concentra em criar objetos que contêm tanto dados quanto funções.

Em comparação com a programação procedural ou procedural, a programação orientada a objetos tem várias vantagens. As mais importantes são listadas a seguir:

• Isso fornece uma estrutura modular clara para o programa.

• Isso pode ajudar você a seguir o princípio 'Não Repeita-se' (DRY), tornando seu código mais fácil de manter, modificar e depurar.

• Isso permite criar comportamentos mais complexos com menos código, menos tempo de desenvolvimento e uma alta reutilização.

As seções a seguir descreverão como classes e objetos funcionam no PHP.

Entenda classe e objeto

Classe e objeto são duas das principais facetas da programação orientada a objetos. A classe é uma coleção independente de variáveis e funções que colaboram para executar uma ou mais tarefas específicas, enquanto o objeto é uma instância única da classe.

Uma classe atua como um modelo ou blueprint a partir do qual podem ser criados muitos objetos individuais. Ao criar um único objeto, embora algumas propriedades de cada objeto possam ter valores diferentes, elas herdam as propriedades e comportamentos genéricos comuns.

Por exemplo, considere a classe como o plano de blueprint de uma casa. O blueprint em si não é a casa, mas o plano detalhado da casa. E os objetos são como as casas construídas de acordo com esse blueprint. Podemos construir várias casas idênticas com o mesmo blueprint, mas cada casa pode ter diferentes pinturas, revestimentos e famílias internas, como mostrado na figura a seguir.

Pode-se declarar uma classe usando a palavra-chave class, seguida do nome da classe e um par de chaves curly ({}), como mostrado no exemplo a seguir.

Vamos criar um arquivo PHP chamado Recangle.php e coloque o seguinte código de exemplo nele, para separar o código da classe do resto do programa. Em seguida, basta incluir o arquivo Recangle.php onde necessário para usá-lo.

<?php
class Rectangle
{
　　　　//Declarar propriedades
　　　　public $length = 0;
　　　　public $width = 0;
　　　　
　　　　//求周长的方法
　　　　public function getPerimeter(){
　　　　　　　　return (2　*　($this->length　+　$this->width));
　　　　}
　　　　
　　　　//求面积的方法
　　　　public function getArea(){
　　　　　　　　return ($this->length　*　$this->width);
　　　　}
}
?>

A palavra-chave public antes das propriedades e métodos no exemplo acima é umaModificadores de acessoisto indica que a propriedade ou método pode ser acessado de qualquer lugar. Vamos saber mais sobre isso mais tarde neste capítulo.

Crie outro arquivo PHP chamado test.php e coloque o seguinte código nele.

<?php
//包含类定义
class Rectangle
{
　　　　//Declarar propriedades
　　　　public $length = 0;
　　　　public $width = 0;
　　　　
　　　　//求周长的方法
　　　　public function getPerimeter(){
　　　　　　　　return (2　*　($this->length　+　$this->width));
　　　　}
　　　　
　　　　//求面积的方法
　　　　public function getArea(){
　　　　　　　　return ($this->length　*　$this->width);
　　　　}
}
　
//Crie um novo objeto a partir da classe Rectangle
$obj = new Rectangle;
　
//Obter valor da propriedade do objeto
echo $obj->comprimento;　//　Saída: 0
echo $obj->largura;　//　Saída: 0
　
//Definir valor da propriedade do objeto
$obj->comprimento =　30;
$obj->largura =　20;
　
//Ler novamente os valores das propriedades do objeto para mostrar as alterações
echo $obj->comprimento;　//　Saída:　30
echo "<br>";
echo $obj->largura;　//　Saída:　20
　
　
//Chamar método do objeto
echo $obj->getPerimeter();　//　Saída:　100
echo "<br>";
echo $obj->getArea();　//　Saída:　600
?>

O símbolo de seta (->) é uma construção de OOP usada para acessar as propriedades e métodos contidos em um objeto específico. Enquanto o pseudo-variável $this fornece uma referência ao objeto chamado (ou seja, o objeto ao qual o método pertence).

Quando se usa múltiplas instâncias da mesma classe, a verdadeira força da programação orientada a objetos se torna evidente, como mostrado no exemplo a seguir:

<?php
//包含类定义
class Rectangle
{
　　　　//Declarar propriedades
　　　　public $length = 0;
　　　　public $width = 0;
　　　　
　　　　//求周长的方法
　　　　public function getPerimeter(){
　　　　　　　　return (2　*　($this->length　+　$this->width));
　　　　}
　　　　
　　　　//求面积的方法
　　　　public function getArea(){
　　　　　　　　return ($this->length　*　$this->width);
　　　　}
}
　
//Crie múltiplos objetos a partir da classe Rectangle
$obj1　= new Rectangle;
$obj2　= new Rectangle;
　
//Chame os métodos dos dois objetos
echo $obj1->getArea();　//Saída: 0
echo $obj2->getArea();　//Saída: 0
　
//Defina $obj1Valores das propriedades
$obj1->comprimento =　30;
$obj1->largura =　20;
　
//Defina $obj2Valores das propriedades
$obj2->comprimento =　35;
$obj2->largura =　50;
　
//Chame novamente os métodos dos dois objetos
echo $obj1->getArea();　//Saída:600
echo "<br>";
echo $obj2->getArea();　//Saída:1750
?>

Como mostrado no exemplo acima, chamar o método getArea() em diferentes objetos faz com que ele opere em diferentes conjuntos de dados. Cada instância de objeto é completamente independente, com suas próprias propriedades e métodos, portanto, mesmo que pertençam à mesma classe, podem ser operados de forma independente.

使用构造函数和析构函数

为了简化面向对象的编程，PHP提供了一些魔术方法，当对象中发生某些操作时，这些方法会自动执行。

例如，每当创建新对象时，魔术方法__construct()（称为构造函数）都会自动执行。 同样，魔术方法__destruct()（称为析构函数）在对象被销毁时会自动执行。 销毁对象后，析构函数将清除分配给该对象的所有资源。

<?php
class MyClass
{
　　　　//　Construtor
　　　　public function __construct(){
　　　　　　　　echo 'Classe "' . __CLASS__ . '" iniciada<br>';
　　　　}
　　　　
　　　　//　析构函数
　　　　public function __destruct(){
　　　　　　　　echo '类 "' . __CLASS__ . '" 已销毁<br>';
　　　　}
}
　
//创建一个新对象
$obj = new MyClass;
　
//在文件末尾输出消息
echo "到达文件末尾。";
?>

O código PHP do exemplo acima produzirá a seguinte saída:

类 "MyClass" 已启动
到达文件末尾。
类 "MyClass" 已销毁

脚本结束时将自动调用析构函数。但是，要显式触发析构函数，可以使用PHP unset()函数销毁对象，如下所示：

<?php
class MyClass
{
　　　　//　Construtor
　　　　public function __construct(){
　　　　　　　　echo 'Classe "' . __CLASS__ . '" iniciada<br>';
　　　　}
　　　　
　　　　//　析构函数
　　　　public function __destruct(){
　　　　　　　　echo '类 "' . __CLASS__ . '" 已销毁<br>';
　　　　}
}
　
//创建一个新对象
$obj = new MyClass;
　
//　销毁对象
unset($obj);
　
//在文件末尾输出消息
echo "到达文件末尾。";
?>

现在，以上示例中的PHP代码将产生以下输出：

类 "MyClass" 已启动
类 "MyClass" 已销毁
到达文件末尾。

通过继承扩展类

类可以使用extends关键字继承另一个类的属性和方法。继承的过程称为继承。这可能是使用面向对象的编程模型背后的最强大原因。

<?php
//包含类定义
class Rectangle
{
　　　　//Declarar propriedades
　　　　public $length = 0;
　　　　public $width = 0;
　　　　
　　　　//求周长的方法
　　　　public function getPerimeter(){
　　　　　　　　return (2　*　($this->length　+　$this->width));
　　　　}
　　　　
　　　　//求面积的方法
　　　　public function getArea(){
　　　　　　　　return ($this->length　*　$this->width);
　　　　}
}
　
//根据现有的类定义一个新的类
class Square extends Rectangle
{　　　
　　　　//方法来测试矩形是否也是正方形
　　　　public function isSquare(){
　　　　　　　　if($this->length == $this->width){
　　　　　　　　　　　　return true;　//　É um quadrado
　　　　　　　　} else {
　　　　　　　　　　　　return false;　//Não é um quadrado
　　　　　　　　}
　　　　}
}
　
//Criar um novo objeto a partir da classe Square
$obj = new Square;
　
//　Definir valor da propriedade do objeto
$obj->comprimento =　20;
$obj->largura =　20;
　
//　Chamar método do objeto
if($obj->isSquare()){
　　　　echo "A área do quadrado é";
} else {
　　　　echo "A área do retângulo é";
};
echo $obj->getArea();
?>

O código PHP do exemplo acima produzirá a seguinte saída:

A área do quadrado é　400

Como você pode ver no exemplo acima, apesar da definição da classe Square não conter explicitamente o método getArea() nem as propriedades $length e $width, a instância da classe Square pode usá-las, porque elas são herdadas da classe pai Rectangle.

Controle da visibilidade de atributos e métodos

Ao usar a classe, você até pode usar palavras-chave de visibilidade para limitar o acesso aos seus atributos e métodos, para melhor controle. Existem três palavras-chave de visibilidade (do mais visível ao menos visível): public, protected, private, que determinam como e de onde acessar e modificar atributos e métodos.

• public - As propriedades ou métodos públicos podem ser acessados de qualquer lugar dentro e fora da classe. Isso é o padrão de visibilidade de todos os membros da classe em PHP.
  

• protected - As propriedades ou métodos protegidos podem ser acessados a partir da classe em si ou de subclasses ou classes herdadas (ou seja, classes que extendem essa classe).
  

• private - As propriedades ou métodos privados só podem ser acessados a partir da classe que os definiu. Mesmo subclasses ou classes herdadas não podem acessar propriedades ou métodos privados.

O exemplo a seguir lhe mostrará como essa visibilidade realmente funciona:

<?php
//Definição de classe
class Automobile
{
　　　　//Declarar propriedades
　　　　public $combustível;
　　　　protected $engine;
　　　　private $transmission;
}
class Car extends Automobile
{
　　　　//　Construtor
　　　　public function __construct(){
　　　　　　　　echo 'Classe "' . __CLASS__ . '" iniciada<br>';
　　　　}
}
　
//Criar um objeto a partir da classe Automobile
$automobile = new Automobile;
　
//Tente configurar as propriedades do objeto $automobile
$automobile->combustível = 'Petróleo';　//　ok
$automobile->motor = ''1500 cc';　//　erro fatal
$automobile->transmission = 'Manual';　//　erro fatal
　
//Criar objeto a partir da classe Car
$car = new Car;
　
//Tente definir a propriedade do objeto $car
$car->combustível = 'Diesel';　//　ok
$car->motor = ''2200 cc';　//　erro fatal
$car->transmission = 'Automático';　//　undefined
?>

Propriedades e métodos estáticos

Além da visibilidade, propriedades e métodos também podem ser declarados como estáticos (estáticos), o que os torna acessíveis sem a instância da classe. Você pode usar o operador de resolução de escopo (::) para acessar propriedades e métodos estáticos, conforme mostrado a seguir: ClassName::$property e ClassName::method().

Embora possam ser usados métodos estáticos, não é possível acessar propriedades declaradas como estáticas através de objetos da classe, como mostrado no exemplo a seguir:

<?php
//Definição de classe
class HelloClass
{
　　　　//Declarar propriedade estática
　　　　public static $greeting = "Hello World!";
　　　　
　　　　//Declarar método estático
　　　　public static function sayHello(){
　　　　　　　　echo self::$greeting;
　　　　}
}
//Tente acessar propriedades e métodos estáticos diretamente
echo HelloClass::$greeting;　//Saída: Hello World!
HelloClass::sayHello();　//Saída: Hello World!
　
//Tente acessar propriedades e métodos estáticos através do objeto
$hello = new HelloClass;
echo $hello->greeting;　//　Aviso Rígido
$hello->sayHello();　//Saída: Hello World!
?>

Na exemplo anterior, a palavra-chave self representa 'a classe atual'. Ela nunca começa com o símbolo de dólar ($) e sempre começa com o operador de resolução de escopo (::), por exemplo self :: $ name.

A palavra-chave self é diferente da palavra-chave this, ela representa 'o objeto atual' ou 'a instância atual da classe'. Esta palavra-chave sempre começa com o símbolo de dólar ($) seguido por-> operadores (por exemplo $ this-> nome）。

Esperamos que você já tenha compreendido os conceitos básicos da programação orientada a objetos. Você encontrará mais exemplos de OOP nas partes sobre PHP e banco de dados MySQL.