Parola chiave class in PHP - Definire classi e oggetti

La parola chiave `class` in PHP

La parola chiave class definisce una classe — uno schema che descrive i dati (proprietà) e il comportamento (metodi) condivisi da un gruppo di oggetti. In seguito si creano singoli oggetti (detti anche istanze) da quello schema tramite l'operatore new. Le classi sono il fondamento della programmazione orientata agli oggetti (OOP) in PHP: permettono di raggruppare stato e logica correlati in un'unica unità riutilizzabile, invece di disperdere variabili e funzioni libere.

Questa pagina illustra come dichiarare una classe, aggiungere proprietà e metodi, inizializzare oggetti con un costruttore, controllare l'accesso con i modificatori di visibilità, condividere dati con costanti e membri statici, e riutilizzare il comportamento tramite l'ereditarietà.

Sintassi

Una dichiarazione di classe inizia con la parola chiave class, seguita da un nome e da un corpo racchiuso tra parentesi graffe:

<?php

class MyClass {
  // Properties and methods go here
}

Per convenzione i nomi delle classi usano il PascalCase (MyClass, BankAccount). Il nome di una classe non può essere una parola riservata di PHP, e il corpo — anche se vuoto — deve utilizzare le parentesi graffe. Definire una classe non fa nulla di per sé; diventa utile solo quando si crea un oggetto da essa.

Proprietà e metodi

Una proprietà è una variabile che appartiene a un oggetto. Un metodo è una funzione che appartiene a una classe. All'interno di un metodo, la variabile speciale $this fa riferimento all'oggetto corrente, quindi $this->name legge (o scrive) la proprietà name di quell'oggetto:

<?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

Nota la freccia -> (non .) per accedere ai membri, e che si scrive $this->name, mai $this->$name.

Il costruttore

Impostare ogni proprietà manualmente è verboso e soggetto a errori. Il metodo __construct() viene eseguito automaticamente quando un oggetto viene creato, consentendo di richiedere e assegnare i valori iniziali in un unico passaggio. Gli argomenti passati a new vengono inoltrati al costruttore:

<?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

Vedi PHP constructor per ulteriori dettagli, inclusa la promozione delle proprietà nel costruttore.

Visibilità

Ogni proprietà e metodo ha una visibilità che controlla dove può essere accessibile:

public — accessibile da qualsiasi punto (il valore predefinito se omesso).
protected — accessibile solo all'interno della classe e delle sue sottoclassi.
private — accessibile solo all'interno della classe che lo dichiara.

Nascondere lo stato interno dietro private ed esporlo tramite metodi si chiama incapsulamento:

<?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

Maggiori dettagli in PHP access modifiers.

Costanti e membri statici

Usa la parola chiave const per valori che non cambiano mai e la parola chiave static per dati e metodi che appartengono alla classe stessa piuttosto che a un singolo oggetto. Entrambi sono accessibili con l'operatore di risoluzione dell'ambito :::

<?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

Vedi PHP class constants e PHP static methods.

Ereditarietà

Una classe può usare extends su un'altra per riutilizzare e specializzare il suo comportamento. La classe figlia eredita le proprietà e i metodi del genitore, e può sovrascriverli:

<?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.

Per una trattazione più approfondita vedi PHP inheritance, e per le classi che definiscono un contratto senza implementazione, abstract classes e interfaces.

Esempio completo

Il seguente esempio eseguibile combina un costruttore con metodi getter e dimostra l'ereditarietà con la sovrascrittura dei metodi:

<?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.

Provalo tu stesso »

L'Esempio 1 costruisce oggetti con un costruttore e ne legge lo stato tramite getter; l'Esempio 2 mostra una sottoclasse Dog che sovrascrive il metodo speak() ereditato da Animal.

Riepilogo

La parola chiave class definisce uno schema; l'operatore new crea oggetti da esso.
Le proprietà contengono i dati di un oggetto, i metodi ne definiscono il comportamento, e $this fa riferimento all'oggetto corrente all'interno di un metodo.
__construct() inizializza un oggetto al momento della sua creazione.
public, protected e private controllano dove i membri sono accessibili.
const e static appartengono alla classe stessa; si accede a loro con ::.
extends permette a una classe di ereditare e sovrascrivere il comportamento di un'altra.

Per un quadro più ampio di come questi elementi si incastrano tra loro, vedi PHP classes and objects.

Esercitazione

Pratica

Quali sono le caratteristiche principali di una classe in PHP?

Una classe è uno schema per la creazione di oggetti.Una classe può contenere proprietà e metodi.Una classe in PHP può contenere solo metodi.Una classe può essere definita in qualsiasi punto del programma.Una classe non può includere variabili o costanti.

La parola chiave class in PHP