web-dev-qa-db-fra.com

Qu'est-ce qu'une classe en PHP?

J'ai de sérieux problèmes pour comprendre PHP les cours d'un livre. Ils semblent très difficiles. Quel est leur but et comment fonctionnent-ils?

phpclass
68
Strawberry

En bref , une classe est un modèle pour un objet. Et un objet encapsule l'état et la responsabilité conceptuellement liés de quelque chose dans votre application et offre généralement une interface de programmation avec laquelle interagir avec ceux-ci. Cela favorise la réutilisation du code et améliore la maintenabilité.

Imaginez un verrou:

namespace MyExample;

class Lock
{
    private $isLocked = false;

    public function unlock()
    {
        $this->isLocked = false;
        echo 'You unlocked the Lock';
    }
    public function lock()
    {
        $this->isLocked = true;
        echo 'You locked the Lock';
    }
    public function isLocked()
    {
        return $this->isLocked;
    }
}

Ignorez immédiatement les déclarations namespace, private et public.

La classe Lock est un modèle pour tous les verrous de votre application. Un verrou peut être verrouillé ou déverrouillé, représenté par la propriété$isLocked. Puisqu'il ne peut avoir que ces deux états, j'utilise un booléen (true ou false) pour indiquer quel état s'applique. Je peux interagir avec le verrou grâce à ses méthodeslock et unlock, qui changeront l'état en conséquence. La méthode isLocked me donnera l'état actuel du verrou. Maintenant, lorsque vous créez un objet (également souvent appelé instance) à partir de ce plan, il encapsulera un état unique, par exemple.

$aLock = new Lock; // Create object from the class blueprint
$aLock->unlock();  // You unlocked the Lock
$aLock->lock();    // You locked the Lock

Créons un autre verrou, encapsulant également son propre état

$anotherLock = new Lock;
$anotherLock->unlock(); // You unlocked the Lock

mais comme chaque objet/instance encapsule son propre état, le premier verrou reste verrouillé

var_dump( $aLock->isLocked() );       // gives Boolean true
var_dump( $anotherLock->isLocked() ); // gives Boolean false

Désormais, toute la responsabilité de garder un verrou verrouillé ou déverrouillé est englobée dans la classe Lock. Vous n'avez pas besoin de le reconstruire à chaque fois que vous voulez verrouiller quelque chose et si vous voulez changer le fonctionnement d'un verrou, vous pouvez le changer dans le plan de verrouillage au lieu de toutes les classes avoir un verrou, par exemple une porte:

class Door
{
    private $lock;
    private $connectsTo;

    public function __construct(Lock $lock)
    {
        $this->lock = $lock;
        $this->connectsTo = 'bedroom';
    }
    public function open()
    {
        if($this->lock->isLocked()) {
            echo 'Cannot open Door. It is locked.';
        } else {
            echo 'You opened the Door connecting to: ', $this->connectsTo;
        }
    }
}

Désormais, lorsque vous créez un objet Door, vous pouvez lui affecter un objet Lock. Étant donné que l'objet Lock gère toute la responsabilité de savoir si quelque chose est verrouillé ou déverrouillé, la porte n'a pas à s'en soucier. En fait, tous les objets qui peuvent utiliser un verrou n'auraient pas à s'en soucier, par exemple un coffre

class Chest
{
    private $lock;
    private $loot;

    public function __construct(Lock $lock)
    {
        $this->lock = $lock;
        $this->loot = 'Tons of Pieces of Eight';
    }
    public function getLoot()
    {
        if($this->lock->isLocked()) {
            echo 'Cannot get Loot. The chest is locked.';
        } else {
            echo 'You looted the chest and got:', $this->loot;
        }
    }
}

Comme vous pouvez le voir, la responsabilité du coffre est différente de celle d'une porte. Un coffre contient du butin, tandis qu'une porte sépare les pièces. Vous pouvez coder l'état verrouillé ou déverrouillé dans les deux classes, mais avec une classe Lock distincte, vous n'êtes pas obligé et pouvez réutiliser le verrou.

$doorLock = new Lock;
$myDoor = new Door($doorLock);

$chestLock = new Lock;
$myChest new Chest($chestLock);

Le coffre et la porte ont maintenant leurs serrures uniques. Si la serrure était une serrure magique qui peut exister à plusieurs endroits en même temps, comme en physique quantique, vous pouvez attribuer la même serrure à la fois à la poitrine et à la porte, par ex.

$quantumLock = new Lock;
$myDoor = new Door($quantumLock);
$myChest new Chest($quantumLock);

et lorsque vous unlock() le $quantumLock, la porte et le coffre seraient déverrouillés.

Bien que j'admette que les verrous quantiques sont un mauvais exemple, il illustre le concept de partage d'objets au lieu de reconstruire l'état et la responsabilité partout. Un exemple réel pourrait être un objet de base de données que vous passez aux classes en utilisant ​​la base de données.

Notez que les exemples ci-dessus ne montrent pas comment accéder à la serrure d'un coffre ou d'une porte pour utiliser les méthodes lock() et unlock(). Je laisse cela comme un exercice pour que vous vous entraîniez (ou quelqu'un d'autre pour ajouter).

Vérifiez également Quand utiliser self over $ this? pour une explication plus approfondie des classes et des objets et comment travailler avec eux

Pour quelques ressources supplémentaires, vérifiez

198
Gordon

Je sais que vous avez demandé une ressource, pas une explication, mais voici quelque chose par ce que j'ai compris l'implémentation de base des classes:

Imaginez la classe comme modèle de construction. Un croquis de base à quoi devrait ressembler un bâtiment. Lorsque vous allez réellement le construire, vous changez certaines choses pour qu'il ressemble à ce que votre client veut (propriétés dans le cas de la classe ). Vous devez maintenant concevoir comment les choses à l'intérieur du bâtiment vont se comporter ( méthodes ). Je vais le montrer sur un exemple simple.

Classe de construction:

/**
 * Constructs a building.
 */
class Building
{
    private $name;
    private $height;


    public function __construct( $name, $height )
    {
        $this->name = $name;
        $this->height = $height;
    }

    /**
     * Returns name of building.
     * 
     * @return string
     */
    public function getName( )
    {
        return $this->name;
    }


    public function elevatorUp( )
    {
        // Implementation
    }


    public function elevatorDown( )
    {
        // Implementation
    }


    public function lockDoor( )
    {
        // Implementation
    }
}

Appel de la classe:

// Empire State Building
$empireStateBuilding = new Building( "Empire State Building", 381 );

echo $empireStateBuilding->getName( );
$empireStateBuilding->lockDoor( );


// Burj Khalifa
$burjKhalifa = new Building( "Burj Khalifa", 828 );

echo $burjKhalifa->getName( );
$burjKhalifa->lockDoor( );

Copiez-le, exécutez-le sur votre hôte local et essayez de faire quelques changements. En cas de questions, n'hésitez pas à me demander. Si vous ne trouvez pas cela utile, utilisez simplement les liens des affiches précédentes, ce sont des tutoriels assez solides.

13
Ondrej Slinták

Pour vous offrir une vue sous un autre angle, si vous le permettez (en fonction de votre expérience personnelle). Vous devez ressentir "le besoin de POO" avant de pouvoir réellement comprendre de quoi il s'agit - à mon humble avis, les ressources d'apprentissage devraient venir après cela.

On aurait essentiellement "besoin" d'être coincé dans des difficultés structurelles lors de l'écriture d'un logiciel relativement volumineux écrit dans un style procédural (par opposition à orienté objet, désolé si quelqu'un n'est pas d'accord avec le terme). D'ici là, il/elle pourrait essayer de restructurer le code en objets pour mieux l'organiser et, naturellement, en savoir plus sur OOP en détail. Encore une fois, c'est mon expérience personnelle et cela m'a amené à comprendre plus rapide que n'importe quel livre.

Juste mes deux cents.

2
Jaya Wijaya