Palavra-chave class em PHP - Definir Classes e Objetos

A Palavra-chave `class` em PHP

A palavra-chave class define uma classe — um modelo que descreve os dados (propriedades) e o comportamento (métodos) compartilhados por um grupo de objetos. Em seguida, você cria objetos individuais (também chamados de instâncias) a partir desse modelo com o operador new. As classes são a base da programação orientada a objetos (POO) em PHP: elas permitem agrupar estado e lógica relacionados em uma única unidade reutilizável, em vez de espalhar variáveis e funções avulsas.

Esta página aborda como declarar uma classe, adicionar propriedades e métodos, inicializar objetos com um construtor, controlar o acesso com modificadores de visibilidade, compartilhar dados com constantes e membros estáticos, e reutilizar comportamento por meio de herança.

Sintaxe

Uma declaração de classe começa com a palavra-chave class, seguida de um nome e um corpo entre chaves:

<?php

class MyClass {
  // Properties and methods go here
}

Por convenção, nomes de classes usam PascalCase (MyClass, BankAccount). Um nome de classe não pode ser uma palavra reservada do PHP, e o corpo — mesmo que vazio — deve usar chaves. Definir uma classe não faz nada por si só; ela só se torna útil quando você cria um objeto a partir dela.

Propriedades e métodos

Uma propriedade é uma variável que pertence a um objeto. Um método é uma função que pertence a uma classe. Dentro de um método, a variável especial $this refere-se ao objeto atual, portanto $this->name lê (ou escreve) a propriedade name desse objeto:

<?php

class User {
  public string $name;          // a property

  public function greet(): string {   // a method
    return "Hi, I'm {$this->name}";
  }
}

$u = new User();
$u->name = "Ada";               // set the property on this object
echo $u->greet();               // Hi, I'm Ada

Observe o operador -> (não .) para acessar membros, e que você escreve $this->name, nunca $this->$name.

O construtor

Definir cada propriedade manualmente é verboso e sujeito a erros. O método __construct() é executado automaticamente quando um objeto é criado, permitindo que você exija e atribua valores iniciais em uma única etapa. Os argumentos que você passa para new são encaminhados para o construtor:

<?php

class Car
{
  public $make;
  public $model;
  public $year;

  public function __construct($make, $model, $year)
  {
    $this->make = $make;
    $this->model = $model;
    $this->year = $year;
  }

  public function describe(): string
  {
    return "{$this->year} {$this->make} {$this->model}";
  }
}

$myCar = new Car("Ford", "Mustang", 2022);
echo $myCar->describe();   // 2022 Ford Mustang

Veja construtor PHP para mais detalhes, incluindo a promoção de propriedades no construtor.

Visibilidade

Cada propriedade e método tem uma visibilidade que controla onde pode ser acessado:

public — acessível de qualquer lugar (o padrão se você omitir).
protected — acessível apenas dentro da classe e suas subclasses.
private — acessível apenas dentro da classe que o declara.

Ocultar o estado interno com private e expô-lo por meio de métodos é chamado de encapsulamento:

<?php

class BankAccount
{
  private float $balance = 0;     // cannot be touched directly from outside

  public function deposit(float $amount): void
  {
    $this->balance += $amount;
  }

  public function getBalance(): float
  {
    return $this->balance;
  }
}

$acc = new BankAccount();
$acc->deposit(100);
echo $acc->getBalance();   // 100

Mais detalhes em modificadores de acesso PHP.

Constantes e membros estáticos

Use a palavra-chave const para valores que nunca mudam e a palavra-chave static para dados e métodos que pertencem à própria classe, e não a um objeto específico. Ambos são acessados com o operador de resolução de escopo :::

<?php

class Circle
{
  const PI = 3.14159;          // class constant
  public static int $count = 0; // shared across all instances

  public function __construct()
  {
    self::$count++;            // increment the shared counter
  }
}

new Circle();
new Circle();

echo Circle::PI;        // 3.14159
echo PHP_EOL;
echo Circle::$count;    // 2

Veja constantes de classe PHP e métodos estáticos PHP.

Herança

Uma classe pode extends outra para reutilizar e especializar seu comportamento. A classe filha herda as propriedades e métodos da classe pai, e pode substituí-los:

<?php

class Animal
{
  public function speak(): string
  {
    return "The animal makes a sound.";
  }
}

class Dog extends Animal
{
  public function speak(): string   // overrides the parent method
  {
    return "The dog barks.";
  }
}

echo (new Animal())->speak();   // The animal makes a sound.
echo PHP_EOL;
echo (new Dog())->speak();      // The dog barks.

Para uma cobertura mais aprofundada, veja herança PHP, e para classes que definem um contrato sem implementação, classes abstratas e interfaces.

Exemplo completo

O exemplo executável a seguir combina um construtor com métodos getter e demonstra herança com substituição de método:

<?php

// Example 1
class Car
{
  public $make;
  public $model;
  public $year;

  public function __construct($make, $model, $year)
  {
    $this->make = $make;
    $this->model = $model;
    $this->year = $year;
  }

  public function getMake()
  {
    return $this->make;
  }

  public function getModel()
  {
    return $this->model;
  }

  public function getYear()
  {
    return $this->year;
  }
}

$myCar = new Car("Ford", "Mustang", 2022);
echo "Make: " . $myCar->getMake() . PHP_EOL;
echo "Model: " . $myCar->getModel() . PHP_EOL;
echo "Year: " . $myCar->getYear() . PHP_EOL;

// Output:
// Make: Ford
// Model: Mustang
// Year: 2022

// Example 2
class Animal
{
  public function speak()
  {
    echo "The animal speaks.";
  }
}

class Dog extends Animal
{
  public function speak()
  {
    echo "The dog barks.";
  }
}

$myAnimal = new Animal();
$myDog = new Dog();
$myAnimal->speak();
$myDog->speak();

// Output:
// The animal speaks.
// The dog barks.

Experimente Você Mesmo »

O Exemplo 1 constrói objetos com um construtor e lê seu estado por meio de getters; o Exemplo 2 mostra uma subclasse Dog substituindo o método speak() herdado de Animal.

Resumo

A palavra-chave class define um modelo; o operador new cria objetos a partir dele.
Propriedades armazenam os dados de um objeto, métodos definem seu comportamento, e $this refere-se ao objeto atual dentro de um método.
__construct() inicializa um objeto no momento em que é criado.
public, protected e private controlam onde os membros podem ser acessados.
const e static pertencem à própria classe; acesse-os com ::.
extends permite que uma classe herde e substitua o comportamento de outra.

Para uma visão mais ampla de como essas peças se encaixam, veja classes e objetos PHP.

Prática

Quais são as principais características de uma classe em PHP?

Uma classe é um modelo para criar objetos.Uma classe pode conter propriedades e métodos.Uma classe em PHP pode conter apenas métodos.Uma classe pode ser definida em qualquer lugar do programa.Uma classe não pode incluir variáveis ou constantes.

A Palavra-chave class em PHP