OOP IN PHP TERZA PARTE

TYPE HINTING SU OGGETTI

Vediamo con un’immagine come sia possibile fare type hinting al metodo riepilogo della classe corso.

PROPRIETA’ E METODI STATICI

Le proprietà e i metodi utilizzati finora sono membri di istanza, quindi accessibili con la parola chiave $this che lo ricordiamo è un riferimento all’istanza. A volte però potrebbero essere utili proprietà e metodi che non sono specifici di una singola istanza ma che appartengono alla classe stessa. Per creare proprietà e metodi statici usiamo la keyword static. La cosa importante da comprendere è che se siamo all’interno di un metodo statico non stiamo nel concetto delle istanze, sono metodi che appartengono alla classe. Quindi non possiamo usare la keyword $this per accedere a una proprietà. Possiamo però accedere a proprietà statiche con la keyword self che fa riferimento alla classe stessa. Iniziamo con il definire una proprietà statica nel file Corso.php.

ACCEDERE A PROPRIETA’ E METODI STATICI DA SOTTOCLASSI

Spostiamo il metodo info() definito nella classe Corso nella sottoclasse Frontend e vediamo se è possibile accedere alla proprietà $piattaforma definita in Corso.php. Andiamo nella classe index e invochiamo il metodo info() della classe Frontend. L’istruzione echo mostra che è possibile accedere alla proprietà definita nella classe parent. Definiamo ora la stessa proprietà statica nella classe Frontend:

public static string $piattaforma = “Piattaforma Y (di Frontend)“;

Spostiamo nuovamente il metodo info() nella classe Corso.php. Se da index.php invochiamo Frontend::info() accediamo nuovamente alla proprietà $piattaforma definita in Corso.php. Se vogliamo accedere alla proprietà $piattaforma definita in Frontend dalla classe Corso.php usiamo la keyword static. Di casi possibili ce ne sono molti, non avrebbe senso analizzarli tutti, porterebbero solo confusione.

INTERFACCE

Le interfacce sono strumenti simili alle classi astratte, se nelle classi astratte possiamo implementare alcuni metodi nelle interfacce ciò non è possibile. Per dichiarare un’interfaccia usiamo la keyword interface.

I TRAIT

All’interno di un trait possiamo definire proprietà e metodi che saranno utili alle classi che lo utilizzeranno. Usare i trait è come fare copia e incolla delle proprietà e metodi all’interno del trait e incollarli nelle classi che lo utilizzano. All’interno di un trait possiamo utilizzare anche metodi statici e metodi abstract.

CODICE DI ESEMPIO

APPROFONDIMENTO

In PHP, le classi astratte sono classi che non possono essere istanziate direttamente, ma che forniscono una struttura per altre classi. Queste classi servono come base per altre classi, obbligando le classi derivate a implementare alcuni metodi definiti nella classe astratta. La parola chiave abstract viene utilizzata per dichiarare una classe astratta e i metodi astratti al suo interno.

Caratteristiche principali delle classi astratte in PHP:

1. Non possono essere istanziate: Non è possibile creare un’istanza diretta di una classe astratta. La classe astratta è pensata solo come base per altre classi.

2. Metodi astratti: Le classi astratte possono definire metodi astratti, che non contengono implementazione, ma solo la loro firma. Le classi derivate sono obbligate a fornire l’implementazione per tutti i metodi astratti della classe base.

3. Metodi concreti: Una classe astratta può anche contenere metodi concreti, ossia metodi completamente implementati che possono essere utilizzati o sovrascritti nelle classi derivate.

4. Costruttori: Una classe astratta può avere un costruttore che può essere invocato dalle classi figlie usando parent::__construct().

Sintassi di una classe astratta in PHP:

<?php
abstract class Animale {
        // Metodo astratto: le classi derivate devono implementare questo metodo
        abstract public function emettiSuono();

        // Metodo concreto: le classi derivate possono utilizzarlo così com’è o sovrascriverlo
        public function dormi() {
             echo “Zzz…“;
       }
}

class Cane extends Animale {
        // Implementazione del metodo astratto
        public function emettiSuono() {
           echo “Bau!“;
        }
}

class Gatto extends Animale {
        // Implementazione del metodo astratto
        public function emettiSuono() {
             echo “Miao!“;
        }
}

// Uso delle classi derivate
$cane = new Cane();
$cane->emettiSuono(); // Output: Bau!
$cane->dormi(); // Output: Zzz…

$gatto = new Gatto();
$gatto->emettiSuono(); // Output: Miao!
$gatto->dormi(); // Output: Zzz…
?>

Spiegazione:

•La classe Animale è astratta e non può essere istanziata direttamente.

•Definisce un metodo astratto emettiSuono() che deve essere implementato dalle classi derivate (Cane e Gatto).

•Definisce anche un metodo concreto dormi(), che può essere usato così com’è dalle classi derivate.

•Le classi Cane e Gatto estendono Animale e forniscono la propria implementazione del metodo emettiSuono().

Quando usare una classe astratta?

Le classi astratte sono utili quando vuoi definire una struttura comune per un insieme di classi che condividono caratteristiche simili, ma vuoi anche essere sicuro che ogni classe figlia implementi alcuni metodi specifici.

In PHP, final è una parola chiave che viene utilizzata per definire proprietà e metodi che non possono essere sovrascritti nelle classi derivate. L’uso di final è importante per mantenere l’integrità e la consistenza del comportamento di alcune classi o metodi in un’applicazione.

Proprietà final

In PHP, non è possibile dichiarare una proprietà come final direttamente. La parola chiave final viene usata solo per metodi e classi, non per le proprietà. Tuttavia, è possibile usare la visibilità (private, protected, public) per controllare come le proprietà vengono utilizzate o sovrascritte nelle classi derivate.

Metodi final

Un metodo final è un metodo che non può essere sovrascritto in una classe derivata. Se una classe figlia tenta di sovrascrivere un metodo dichiarato come final nella classe genitore, PHP genererà un errore fatale.

Esempio:

class BaseClass {
        final public function sayHello() {
            echo “Hello from BaseClass“;
        }
}

class DerivedClass extends BaseClass {
       // Questo provocherà un errore perché sayHello è final nella classe base
       public function sayHello() {
            echo “Hello from DerivedClass“;
       }
}

In questo esempio, il metodo sayHello() è dichiarato come final nella classe BaseClass, quindi non può essere sovrascritto nella classe DerivedClass.

Classi final

Quando una classe è dichiarata final, significa che non può essere estesa o ereditata da altre classi. Nessuna classe derivata può essere creata da una classe final.

Esempio:

final class BaseClass {
         public function sayHello() {
                 echo “Hello from BaseClass“;
         }
}

// Questo provocherà un errore perché BaseClass è final e non può essere ereditata
class DerivedClass extends BaseClass {
}

In questo caso, la classe BaseClass è dichiarata come final, quindi non può essere estesa da nessun’altra classe, e PHP genererà un errore se si tenta di estenderla.

Riassunto dei concetti chiave:

•Metodi finali: Un metodo definito come final non può essere sovrascritto da una classe derivata.

•Classi finali: Una classe dichiarata final non può essere estesa da altre classi.

•Proprietà finali: Non esiste una sintassi per dichiarare una proprietà come final in PHP; la visibilità può essere utilizzata per controllare l’accesso alle proprietà nelle classi figlie.

In PHP, le proprietà e i metodi statici sono associati a una classe piuttosto che a una specifica istanza di quella classe. Questo significa che possono essere acceduti direttamente tramite il nome della classe, senza dover creare un oggetto di quella classe. Ecco una panoramica dettagliata:

1. Proprietà Statiche

Una proprietà statica è una variabile associata a una classe, accessibile direttamente tramite la classe stessa e non tramite le sue istanze. Viene dichiarata usando la parola chiave static.

Esempio di dichiarazione e utilizzo di una proprietà statica:

class Esempio {
        public static $proprietaStatica = “Valore statico“;

        public static function stampaValore() {
           echo self::$proprietaStatica;
        }
}

// Accesso alla proprietà statica tramite il nome della classe
echo Esempio::$proprietaStatica; // Output: Valore statico

// Modifica della proprietà statica
Esempio::$proprietaStatica = “Nuovo valore”;
Esempio::stampaValore(); // Output: Nuovo valore

Caratteristiche delle proprietà statiche:

•Le proprietà statiche non possono essere accedute tramite un’istanza della classe, ma solo tramite la classe stessa.

•Sono condivise tra tutte le istanze della classe. Se viene modificata la proprietà statica, il cambiamento è riflesso in tutte le istanze della classe.

2. Metodi Statici

Un metodo statico è un metodo che appartiene alla classe e può essere chiamato senza creare un’istanza della classe. Viene dichiarato con la parola chiave static.

Esempio di dichiarazione e utilizzo di un metodo statico:

class Matematica {
     public static function somma($a, $b) {
         return $a + $b;
     }
}

// Chiamata al metodo statico senza creare un’istanza della classe
echo Matematica::somma(3, 4); // Output: 7

Caratteristiche dei metodi statici:

•I metodi statici non possono accedere alle proprietà non statiche della classe (ovvero le proprietà dell’istanza) o usare $this, poiché non c’è un oggetto specifico a cui $this possa fare riferimento.

•Possono però accedere alle proprietà statiche e ad altri metodi statici della stessa classe.

3. Parola chiave self e static

•All’interno di un metodo statico, si usa la parola chiave self per fare riferimento alla classe stessa. self è utile per accedere alle proprietà o ai metodi statici definiti nella stessa classe.

•self fa riferimento alla classe in cui è dichiarato il metodo statico, mentre static fa riferimento alla classe in cui è chiamato il metodo. Questo è importante soprattutto quando si lavora con l’ereditarietà.

Esempio di utilizzo di self e static:

class Base {
        public static function metodo() {
            echo “Metodo nella classe Base“;
        }

        public static function chiamaMetodo() {
           self::metodo(); // Si riferisce al metodo della classe Base
        }
}

class Derivata extends Base {
        public static function metodo() {
             echo “Metodo nella classe Derivata“;
        }
}

Derivata::chiamaMetodo(); // Output: Metodo nella classe Base

Nel caso sopra, self::metodo() all’interno di Base fa riferimento a Base::metodo(), non a Derivata::metodo(), anche se chiamaMetodo() è chiamato tramite Derivata.

Differenza tra self e static:

Se invece si usa static:: al posto di self::, si otterrà il comportamento legato alla classe derivata, sfruttando il Late Static Binding:

class Base {
      public static function metodo() {
          echo “Metodo nella classe Base“;
      }

      public static function chiamaMetodo() {
         static::metodo(); // Utilizza Late Static Binding
      }
}

class Derivata extends Base {
         public static function metodo() {
             echo “Metodo nella classe Derivata“;
         }
}

Derivata::chiamaMetodo(); // Output: Metodo nella classe Derivata

4. Accesso Modificatori (public, protected, private)

•Le proprietà e i metodi statici possono essere dichiarati come public, protected o private, utilizzando i normali modificatori di accesso.

•Un metodo o una proprietà statica dichiarata come private sarà accessibile solo all’interno della classe stessa, mentre una dichiarata come protected sarà accessibile anche dalle classi derivate.

Conclusione

Le proprietà e i metodi statici in PHP sono potenti strumenti che permettono di gestire dati e comportamenti a livello di classe, senza la necessità di creare oggetti. Sono utili per implementare costanti di classe, metodi di utilità (come funzioni matematiche), o proprietà condivise tra tutte le istanze della classe.

LINK AI POST PRECEDENTI

IL LINGUAGGIO PHP

LINK AL CODICE SU GITHUB

GITHUB