PHP - Classes and Objects

Benvenuti, aspiranti programmatori! Oggi ci immergeremo nel mondo affascinante delle classi e degli oggetti in PHP. Non preoccupatevi se questi termini sembrano un po' spaventosi - alla fine di questa lezione, sarete in grado di creare le vostre classi e oggetti come un professionista!

Cos'è una Classe e un Oggetto?

Prima di immergerci nel codice, capiremo cos'è una classe e un oggetto. Immaginate di costruire una casa. La classe sarebbe come il progetto della casa, mentre l'oggetto sarebbe la casa reale costruita da quel progetto. Potete creare molte case (oggetti) da un singolo progetto (classe).

Definire una Classe in PHP

Iniziamo creando la nostra prima classe PHP. Creeremo una semplice classe Car.

<?php
class Car {
// Proprietà della classe
public $brand;
public $color;

// Metodo della classe
public function startEngine() {
return "Vroom! The $this->color $this->brand is starting.";
}
}
?>

Ecco una spiegazione dettagliata:

1. Iniziamo con la parola chiave class, seguita dal nome della nostra classe (in questo caso, Car).
2. All'interno della classe, definiamo le proprietà (variabili) come $brand e $color.
3. Definiamo anche un metodo (funzione) chiamato startEngine().

Creare Oggetti da una Classe

Ora che abbiamo la nostra classe Car, creiamo alcuni oggetti auto!

<?php
// Creazione di oggetti auto
$myCar = new Car();
$myCar->brand = "Toyota";
$myCar->color = "Red";

$friendsCar = new Car();
$friendsCar->brand = "Honda";
$friendsCar->color = "Blue";

// Utilizzo del metodo dell'oggetto
echo $myCar->startEngine();
echo $friendsCar->startEngine();
?>

Output:

Vroom! The Red Toyota is starting.
Vroom! The Blue Honda is starting.

Ecco cosa sta succedendo:

1. Utilizziamo la parola chiave new per creare oggetti dalla nostra classe Car.
2. Impostiamo le proprietà di ciascun oggetto utilizzando l'operatore freccia (->).
3. Chiamiamo il metodo startEngine() su ciascun oggetto.

Metodo Costruttore

Ora rendiamo la nostra classe un po' più sofisticata aggiungendo un costruttore. Un costruttore è un metodo speciale che viene chiamato quando viene creato un oggetto.

<?php
class Car {
public $brand;
public $color;

// Costruttore
public function __construct($brand, $color) {
$this->brand = $brand;
$this->color = $color;
}

public function startEngine() {
return "Vroom! The $this->color $this->brand is starting.";
}
}

// Creazione di oggetti auto con costruttore
$myCar = new Car("Toyota", "Red");
$friendsCar = new Car("Honda", "Blue");

echo $myCar->startEngine();
echo $friendsCar->startEngine();
?>

Il costruttore ci permette di impostare brand e color quando creiamo l'oggetto, rendendo il nostro codice più pulito ed efficiente.

Eredità

Una delle funzionalità potenti della programmazione orientata agli oggetti (OOP) è l'eredità. Permette di creare una nuova classe basata su una classe esistente. Creiamo una classe ElectricCar che eredita dalla nostra classe Car.

<?php
class ElectricCar extends Car {
public $batteryLife;

public function __construct($brand, $color, $batteryLife) {
parent::__construct($brand, $color);
$this->batteryLife = $batteryLife;
}

public function chargeBattery() {
return "The $this->color $this->brand is charging. Current battery life: $this->batteryLife%";
}
}

$teslaModel3 = new ElectricCar("Tesla", "White", 80);
echo $teslaModel3->startEngine();
echo $teslaModel3->chargeBattery();
?>

Output:

Vroom! The White Tesla is starting.
The White Tesla is charging. Current battery life: 80%

Qui, ElectricCar eredita tutte le proprietà e i metodi di Car e aggiunge la sua proprietà ($batteryLife) e metodo (chargeBattery()).

Modificatori di Accesso

Nell'OOP, possiamo controllare la visibilità delle proprietà e dei metodi utilizzando i modificatori di accesso. Ce ne sono tre:

Modificatore	Descrizione
public	Accessibile da ovunque
protected	Accessibile all'interno della classe e dalle classi derivate
private	Accessibile solo all'interno della classe

Modifichiamo la nostra classe Car per utilizzare questi:

<?php
class Car {
protected $brand;
private $engineStarted = false;

public function __construct($brand) {
$this->brand = $brand;
}

public function startEngine() {
$this->engineStarted = true;
return "The $this->brand's engine is now running.";
}

public function isEngineRunning() {
return $this->engineStarted;
}
}

$myCar = new Car("Toyota");
echo $myCar->startEngine();
echo $myCar->isEngineRunning() ? "Engine is running" : "Engine is off";
// Questo causerebbe un errore: echo $myCar->engineStarted;
?>

Ora, $brand è protetto (accessibile nelle classi figlie), $engineStarted è privato (accessibile solo nella classe Car), e i nostri metodi rimangono pubblici.

Conclusione

Congratulazioni! Avete appena compiuto i vostri primi passi nel mondo della Programmazione Orientata agli Oggetti con PHP. Abbiamo coperto classi, oggetti, costruttori, eredità e modificatori di accesso. Questi concetti formano la base dell'OOP e vi serviranno bene man mano che continuate il vostro viaggio di programmazione.

Ricordate, la pratica rende perfetti. Provate a creare le vostre classi, esperimentate con diverse proprietà e metodi, e non abbiate paura di fare errori - è così che impariamo! Buon codice!

Credits: Image by storyset