Home esercizi php metodi e proprieta statiche

Esercizi Metodi e Proprietà Statiche PHP

Ecco degli esercizi semplici con soluzione per praticare l’utilizzo delle proprietà e metodi statici delle classi in PHP.

Esercizio 1

Creare una classe "Contatore" con una proprietà statica "valore" e un metodo statico "incrementa()" che incrementa il valore del contatore di 1 ogni volta che viene chiamato.

<?php
class Contatore {
    public static $valore = 0;

    public static function incrementa() {
        self::$valore++;
    }
}

echo Contatore::$valore; // Output: 0
Contatore::incrementa();
echo Contatore::$valore; // Output: 1
Contatore::incrementa();
echo Contatore::$valore; // Output: 2
?>

Esercizio 2

Creare una classe "Configurazione" con una proprietà statica "opzioni" che contiene un array di opzioni di configurazione e un metodo statico "getOpzione($chiave)" che restituisce il valore dell'opzione corrispondente alla chiave specificata.

<?php
class Configurazione {
    public static $opzioni = array(
        'lingua' => 'italiano',
        'tema' => 'scuro',
        'dimensione_font' => '12px'
    );

    public static function getOpzione($chiave) {
        if (array_key_exists($chiave, self::$opzioni)) {
            return self::$opzioni[$chiave];
        }
        return null;
    }
}

echo Configurazione::getOpzione('lingua'); // Output: italiano
echo Configurazione::getOpzione('tema'); // Output: scuro
echo Configurazione::getOpzione('dimensione_font'); // Output: 12px
echo Configurazione::getOpzione('colore_sfondo'); // Output: null
?>

Esercizio 3

Creare una classe "Logger" con una proprietà statica "livello" e un metodo statico "registra($messaggio)" che registra il messaggio di log solo se il livello di log è impostato su "debug".

<?php
class Logger {
    public static $livello = 'debug';

    public static function registra($messaggio) {
        if (self::$livello == 'debug') {
            echo $messaggio;
        }
    }
}

Logger::registra('Messaggio di debug'); // Output: Messaggio di debug
Logger::$livello = 'info';
Logger::registra('Messaggio di info'); // Nessun output
?>

Esercizio 4

Creare una classe "Matematica" con un metodo statico "somma($numeri)" che restituisce la somma dei numeri passati come parametro.

<?php
class Matematica {
    public static function somma($numeri) {
        return array_sum($numeri);
    }
}

echo Matematica::somma(array(2, 4, 6)); // Output: 12
echo Matematica::somma(array(1, 3, 5, 7)); // Output: 16
?>

Esercizio 5

Creare una classe "Database" con una proprietà statica "connessione" che rappresenta la connessione al database e un metodo statico "connetti()" che stabilisce la connessione al database.

<?php
class Database {
    public static $connessione;

    public static function connetti() {
        self::$connessione = /* Logica per la connessione al database */;
    }
}

Database::connetti();
?>

Esercizio 6

Creare una classe "Cache" con una proprietà statica "dati" che contiene i dati memorizzati nella cache e un metodo statico "salvaDati($chiave, $valore)" che salva un valore nella cache utilizzando la chiave specificata.

<?php
class Cache {
    public static $dati = array();

    public static function salvaDati($chiave, $valore) {
        self::$dati[$chiave] = $valore;
    }
}

Cache::salvaDati('chiave1', 'valore1');
Cache::salvaDati('chiave2', 'valore2');
echo Cache::$dati['chiave1']; // Output: valore1
echo Cache::$dati['chiave2']; // Output: valore2
?>

Esercizio 7

Creare una classe "Utente" con una proprietà statica "ruolo" che rappresenta il ruolo dell'utente e un metodo statico "verificaAccesso()" che verifica se l'utente ha accesso alle risorse protette.

<?php
class Utente {
    public static $ruolo;

    public static function verificaAccesso() {
        if (self::$ruolo == 'amministratore') {
            echo "Accesso consentito!";
        } else {
            echo "Accesso negato!";
        }
    }
}

Utente::$ruolo = 'amministratore';
Utente::verificaAccesso(); // Output: Accesso consentito!

Utente::$ruolo = 'utente_normale';
Utente::verificaAccesso(); // Output: Accesso negato!
?>

Esercizio 8

Creare una classe "Configurazione" con una proprietà statica "valori" che contiene un array associativo di valori di configurazione e un metodo statico "impostaValore($chiave, $valore)" che imposta un valore di configurazione utilizzando la chiave specificata.

<?php
class Configurazione {
    public static $valori = array(
        'lingua' => 'italiano',
        'tema' => 'scuro',
        'dimensione_font' => '12px'
    );

    public static function impostaValore($chiave, $valore) {
        self::$valori[$chiave] = $valore;
    }
}

Configurazione::impostaValore('lingua', 'inglese');
Configurazione::impostaValore('tema', 'chiaro');
echo Configurazione::$valori['lingua']; // Output: inglese
echo Configurazione::$valori['tema']; // Output: chiaro
?>

Esercizio 9

Creare una classe "Contatore" con una proprietà statica "valore" e un metodo statico "azzera()" che reimposta il valore del contatore a 0.

<?php
class Contatore {
    public static $valore = 0;

    public static function azzera() {
        self::$valore = 0;
    }
}

Contatore::$valore = 10;
echo Contatore::$valore; // Output: 10
Contatore::azzera();
echo Contatore::$valore; // Output: 0
?>

Esercizio 10

Creare una classe "Matematica" con un metodo statico "moltiplica($numeri)" che restituisce il prodotto dei numeri passati come parametro.

<?php
class Matematica {
    public static function moltiplica($numeri) {
        $risultato = 1;
        foreach ($numeri as $numero) {
            $risultato *= $numero;
        }
        return $risultato;
    }
}

echo Matematica::moltiplica(array(2, 3, 4)); // Output: 24
echo Matematica::moltiplica(array(1, 2, 3, 4, 5)); // Output: 120
?>