Classi e Oggetti PHP

In questo tutorial, imparerai a scrivere codice in modo orientato agli oggetti in PHP.

Cos'è la programmazione orientata agli oggetti

La programmazione orientata agli oggetti (OOP) è un modello di programmazione basato sul concetto di classe e oggetto. A differenza della programmazione procedurale, nella programmazione orientata agli oggetti, l'attenzione è posta sulla creazione di oggetti che contengono sia dati che funzioni.

In confronto con la programmazione tradizionale o procedurale, la programmazione orientata agli oggetti ha molti vantaggi. I più importanti sono elencati di seguito:

• Fornisce una struttura modulare chiara al programma.

• Può aiutarti a seguire il principio 'Non ripetere te stesso' (DRY), rendendo il tuo codice più facile da mantenere, modificare e debuggare.

• It makes it possible to create more complex behaviors with less code, shorter development time, and high reusability.

The following sections will describe how classes and objects work in PHP.

Understanding Classes and Objects

Classes and objects are two main aspects of object-oriented programming. A class is a collection of independent variables and functions that work together to perform one or more specific tasks, and an object is a single instance of a class.

A class acts as a template or blueprint from which many individual objects can be created. When creating a single object, although some properties of each object may have different values, they inherit the same general properties and behaviors.

For example, consider the class as the blueprint of a house. The blueprint itself is not the house, but the detailed plan of the house. And the object is like the actual house built according to the blueprint. We can build several houses of the same type according to the same blueprint, but the interior of each house may have different paint, interior decoration, and families, as shown in the figure below.

You can declare a class using the class keyword, followed by the class name and a pair of curly braces ({}), as shown in the following example.

Let's create a PHP file named Recangle.php and place the following example code in it, so that we can separate our class code from the rest of the program. Then, we can simply include the Recangle.php file to use it anywhere we need.

<?php
class Rectangle
{
　　　　//dichiarazione delle proprietà
　　　　public $length = 0;
　　　　public $width = 0;
　　　　
　　　　// Metodo per calcolare il perimetro
　　　　public function getPerimeter() {
　　　　　　　　return (2 * ($this->length + $this->width));
　　　　}
　　　　
　　　　// Metodo per calcolare l'area
　　　　public function getArea() {
　　　　　　　　return ($this->length * $this->width);
　　　　}
}
?>

The public keyword before the properties and methods in the above example is aAccess ModifiersIt indicates that the property or method can be accessed from anywhere. We will learn more about this later in this chapter.

Create another PHP file named test.php and place the following code in it.

<?php
// Contiene la definizione della classe
class Rectangle
{
　　　　//dichiarazione delle proprietà
　　　　public $length = 0;
　　　　public $width = 0;
　　　　
　　　　// Metodo per calcolare il perimetro
　　　　public function getPerimeter() {
　　　　　　　　return (2 * ($this->length + $this->width));
　　　　}
　　　　
　　　　// Metodo per calcolare l'area
　　　　public function getArea() {
　　　　　　　　return ($this->length * $this->width);
　　　　}
}
　
// Create a new object from the Rectangle class
$obj = new Rectangle;
　
// Get the value of the object's property
echo $obj->length; // Output: 0
echo $obj->width; // Output: 0
　
// Imposta i valori delle proprietà dell'oggetto
$obj->length = 30;
$obj->width = 20;
　
// Leggi di nuovo i valori delle proprietà dell'oggetto per mostrare le modifiche
echo $obj->length; // Output: 30
echo "<br>";
echo $obj->width; // Output: 20
　
　
// Chiama i metodi dell'oggetto
echo $obj->getPerimeter(); // Output: 100
echo "<br>";
echo $obj->getArea(); // Output: 600
?>

Il simbolo freccia (->) è una costruzione OOP utilizzata per accedere alle proprietà e ai metodi contenuti in un oggetto dato. Il pseudo-variabile $this fornisce un riferimento all'oggetto che chiama (ovvero l'oggetto a cui appartiene il metodo).

Quando si utilizzano più istanze della stessa classe, la vera forza della programmazione orientata agli oggetti diventa evidente, come mostrato negli esempi seguenti:

<?php
// Contiene la definizione della classe
class Rectangle
{
　　　　//dichiarazione delle proprietà
　　　　public $length = 0;
　　　　public $width = 0;
　　　　
　　　　// Metodo per calcolare il perimetro
　　　　public function getPerimeter() {
　　　　　　　　return (2 * ($this->length + $this->width));
　　　　}
　　　　
　　　　// Metodo per calcolare l'area
　　　　public function getArea() {
　　　　　　　　return ($this->length * $this->width);
　　　　}
}
　
// Crea più oggetti dalla classe Rectangle
$obj1 = new Rectangle;
$obj2 = new Rectangle;
　
// Chiama i metodi di due oggetti
echo $obj1->getArea(); // Output: 0
echo $obj2->getArea(); // Output: 0
　
// Imposta i valori delle proprietà di $obj1
$obj1->length = 30;
$obj1->width = 20;
　
// Imposta i valori delle proprietà di $obj2
$obj2->length = 35;
$obj2->width = 50;
　
// Chiama i metodi di due oggetti
echo $obj1->getArea(); // Output: 600
echo "<br>";
echo $obj2->getArea(); // Output: 1750
?>

Come mostrato nell'esempio, il chiamare il metodo getArea() su diversi oggetti porta a operazioni su dataset diversi. Ogni istanza di oggetto è completamente indipendente, con propri attributi e metodi, quindi anche se appartengono alla stessa classe, possono essere trattati indipendentemente.

Utilizzo di costruttore e distruttore

Per semplificare la programmazione orientata agli oggetti, PHP fornisce alcuni metodi magici che vengono eseguiti automaticamente quando si verificano alcune operazioni sugli oggetti.

Ad esempio, ogni volta che si crea un nuovo oggetto, il metodo magico __construct() (chiamato costruttore) viene eseguito automaticamente. Allo stesso modo, il metodo magico __destruct() (chiamato distruttore) viene eseguito automaticamente quando l'oggetto viene distrutto. Dopo la distruzione dell'oggetto, il distruttore cancella tutte le risorse assegnate all'oggetto.

<?php
class MyClass
{
　　　　//costruttore
　　　　public function __construct(){
　　　　　　　　echo '   Classe "' . __CLASS__ . '" è stata avviata<br>;
　　　　}
　　　　
　　　　// Funzione di distruttore
　　　　public function __destruct() {
　　　　　　　　echo 'La classe "' . __CLASS__ . '" è stata distrutta<br>';
　　　　}
}
　
// Creare un nuovo oggetto
$obj = new MyClass;
　
// Output del messaggio alla fine del file
echo "Raggiunta la fine del file.";
?>

Il codice PHP dell'esempio sopra produrrà l'output seguente:

La classe "MyClass" è stata avviata
Raggiunta la fine del file.
La classe "MyClass" è stata distrutta

Alla fine dello script viene chiamato automaticamente il distruttore. Tuttavia, per attivare esplicitamente il distruttore, è possibile utilizzare la funzione PHP unset() per distruggere l'oggetto, come mostrato di seguito:

<?php
class MyClass
{
　　　　//costruttore
　　　　public function __construct(){
　　　　　　　　echo '   Classe "' . __CLASS__ . '" è stata avviata<br>;
　　　　}
　　　　
　　　　// Funzione di distruttore
　　　　public function __destruct() {
　　　　　　　　echo 'La classe "' . __CLASS__ . '" è stata distrutta<br>';
　　　　}
}
　
// Creare un nuovo oggetto
$obj = new MyClass;
　
// Distruggere l'oggetto
unset($obj);
　
// Output del messaggio alla fine del file
echo "Raggiunta la fine del file.";
?>

Ora, il codice PHP dell'esempio sopra produrrà il seguente output:

La classe "MyClass" è stata avviata
La classe "MyClass" è stata distrutta
Raggiunta la fine del file.

Estensione della classe attraverso l'ereditarietà

La classe può utilizzare la chiave di estensione per ereditare le proprietà e i metodi di un'altra classe. Il processo di estensione è chiamato ereditarietà. Questo potrebbe essere una delle ragioni più potenti dietro il modello di programmazione orientato agli oggetti.

<?php
// Contiene la definizione della classe
class Rectangle
{
　　　　//dichiarazione delle proprietà
　　　　public $length = 0;
　　　　public $width = 0;
　　　　
　　　　// Metodo per calcolare il perimetro
　　　　public function getPerimeter() {
　　　　　　　　return (2 * ($this->length + $this->width));
　　　　}
　　　　
　　　　// Metodo per calcolare l'area
　　　　public function getArea() {
　　　　　　　　return ($this->length * $this->width);
　　　　}
}
　
// Definizione di una nuova classe basata su una classe esistente
class Square extends Rectangle
{　　　
　　　　// Metodo per testare se il rettangolo è anche un quadrato
　　　　public function isSquare() {
　　　　　　　　if ($this->length == $this->width) {
　　　　　　　　　　　　return true; // È un quadrato
　　　　　　　　else {
　　　　　　　　　　　　return false; // Non è un quadrato
　　　　　　　　}
　　　　}
}
　
// Creazione di un nuovo oggetto dalla classe Square
$obj = new Square;
　
// Impostazione del valore dell'attributo dell'oggetto
$obj->length = 20;
$obj->width = 20;
　
// Chiamata al metodo dell'oggetto
if ($obj->isSquare()) {
　　　　echo "L'area del quadrato è";
else {
　　　　echo "L'area del rettangolo è";
};
echo $obj->getArea();
?>

Il codice PHP dell'esempio sopra produrrà l'output seguente:

L'area del quadrato è 400

Come visto nell'esempio sopra, nonostante la definizione della classe Square non contenga il metodo getArea() né le proprietà $length e $width esplicitamente, l'istanza della classe Square può utilizzarle perché ereditano dalla classe padre Rectangle.

Controllo della visibilità delle proprietà e dei metodi

Quando si utilizza una classe, è possibile utilizzare i modificatori di visibilità per limitare l'accesso agli attributi e ai metodi, per ottenere un migliore controllo. Ci sono tre modificatori di visibilità (dalla più visibile alla meno visibile): public, protected, private, che determinano come e da dove accedere e modificare le proprietà e i metodi.

• public - Le proprietà o i metodi pubblici possono essere acceduti da qualsiasi parte della classe, sia interna che esterna. Questo è il comportamento predefinito di tutti i membri delle classi in PHP.
  

• protected - Le proprietà o i metodi protetti possono essere acceduti solo dalla classe stessa, dalle sottoclassi o dalle classi derivate (cioè le classi che estendono la classe).
  

• private - Le proprietà o i metodi privati possono essere acceduti solo dalla classe che li definisce. Persino le sottoclassi o le classi derivate non possono accedere a proprietà o metodi privati.

Esempio seguente mostrerà come funziona effettivamente questa visibilità:

<?php
// Definizione della classe
class Automobile
{
　　　　//dichiarazione delle proprietà
　　　　public $fuel;
　　　　protected $engine;
　　　　private $transmission;
}
class Car extends Automobile
{
　　　　//costruttore
　　　　public function __construct(){
　　　　　　　　echo '   Classe "' . __CLASS__ . '" è stata avviata<br>;
　　　　}
}
　
//creazione di un oggetto da classe Automobile
$automobile = new Automobile;
　
//prova di impostare le proprietà dell'oggetto $automobile
$automobile->fuel = 'Benzina'; // ok
$automobile->engine = '1500 cc'; // errore fatale
$automobile->transmission = 'Manuale'; // errore fatale
　
//creazione di un oggetto da classe Car
$car = new Car;
　
//prova di impostare le proprietà dell'oggetto $car
$car->fuel = 'Diesel'; // ok
$car->engine = '2200 cc'; // fatal error
$car->transmission = 'Automatic'; // undefined
?>

Proprietà e metodi statici

Oltre alla visibilità, le proprietà e i metodi possono essere dichiarati come statici (statici), il che li rende accessibili senza istanza della classe. Le proprietà e i metodi statici possono essere acceduti utilizzando l'operatore di risoluzione di portata (::), come segue: ClassName::$property e ClassName::method().

Nonostante possano essere utilizzati i metodi statici, non è possibile accedere alle proprietà dichiarate come statiche attraverso l'oggetto della classe, come mostrato negli esempi seguenti:

<?php
// Definizione della classe
class HelloClass
{
　　　　// Dichiarazione della proprietà statica
　　　　public static $greeting = "Hello World!";
　　　　
　　　　// Dichiarazione del metodo statico
　　　　public static function sayHello(){
　　　　　　　　echo self::$greeting;
　　　　}
}
// Tentativo di accedere direttamente alle proprietà e ai metodi statici
echo HelloClass::$greeting; // Output: Hello World!
HelloClass::sayHello(); // Output: Hello World!
　
// Tentativo di accedere alle proprietà e ai metodi statici attraverso l'oggetto
$hello = new HelloClass;
echo $hello->greeting; // Strict Warning
$hello->sayHello(); // Output: Hello World!
?>

Nell'esempio precedente, la parola chiave self rappresenta 'la classe corrente'. Non può iniziare con il simbolo dollaro ($) e inizia sempre con l'operatore :: (ad esempio self::$name).

La parola chiave self è diversa dalla parola chiave this, e rappresenta 'l'oggetto corrente' o 'l'istanza corrente della classe'. Questa parola chiave inizia sempre con il simbolo dollaro ($) seguita dall'operatore -> (ad esempio $this->name).

Speriamo che tu abbia ora compreso i concetti di base della programmazione orientata agli oggetti. Troverai più esempi di OOP nella sezione PHP e MySQL database.