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

Question

J'ai de gros problèmes pour comprendre les classes PHP d'un livre. Elles semblent très difficiles. Quel est leur but et comment fonctionnent-elles ?

Answer 1

En bref Une classe est le plan d'un objet. Un objet encapsule l'état et la responsabilité conceptuels d'un élément de votre application et offre généralement une interface de programmation permettant d'interagir avec ces éléments. Cela favorise la réutilisation du code et améliore la maintenabilité.

---

Imaginez une serrure :

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;
    }
}

Ignorer les namespace , private y public déclaration en ce moment.

La classe Lock est un modèle pour tous les Locks de votre application. Un verrou peut être verrouillé o déverrouillé représenté par le propriété $isLocked . Comme il ne peut avoir que ces deux états, j'utilise un booléen ( true o false ) pour indiquer l'état qui s'applique. Je peux interagir avec le verrou par l'intermédiaire de sa fonction méthodes lock y unlock qui changera l'état en conséquence. Le site isLocked me donnera l'état actuel du verrou. Maintenant, lorsque vous créez un objet (aussi souvent appelé un instance ) de ce blueprint, il encapsulera un état unique, par ex.

$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, qui encapsule é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

Maintenant, la responsabilité entière de garder un verrou verrouillé ou déverrouillé est encaspulée dans la classe Lock. Il n'est pas nécessaire de la reconstruire à chaque fois que l'on veut verrouiller quelque chose et si l'on veut modifier le fonctionnement d'un verrou, on peut le faire dans le blueprint du verrou au lieu de toutes les classes. ayant une serrure, 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 Porte, vous pouvez lui attribuer un objet Serrure. Puisque 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 une serrure n'ont 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 constater, la responsabilité du Coffre est différente de celle d'une porte. Un coffre contient du butin, tandis qu'une porte sépare des pièces. Vous pourriez coder l'état verrouillé ou déverrouillé dans les deux classes, mais avec une classe Lock distincte, vous n'avez pas à le faire et pouvez réutiliser le Lock.

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

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

Les coffres et les portes ont maintenant leurs propres serrures. Si le verrou était un verrou magique pouvant exister à plusieurs endroits en même temps, comme dans la physique quantique, vous pourriez attribuer le même verrou au coffre et à la porte, par ex.

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

et quand vous unlock() le site $quantumLock la porte et le coffre seront déverrouillés.

J'admets que les serrures quantiques sont un mauvais exemple, mais il illustre le concept de partage d'objets au lieu de reconstruire l'état et la responsabilité partout. Un exemple du monde 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 la fonction lock() y unlock() méthodes. Je vous laisse le soin d'y réfléchir (ou d'ajouter quelqu'un d'autre).

Vérifiez également Quand utiliser self plutôt que $this ? pour une explication plus approfondie des classes et des objets et de la manière de travailler avec eux.

Pour des ressources supplémentaires, consultez

• http://en.wikipedia.org/wiki/Object-oriented_programming
• http://www.php.net/manual/en/language.oop5.php
• http://www.tuxradar.com/practicalphp
• http://www.phpro.org/tutorials/Object-Oriented-Programming-with-PHP.html
• http://articles.sitepoint.com/article/object-oriented-php

Answer 2

Je sais que vous avez demandé une ressource, pas une explication, mais voici quelque chose par ce que j'ai compris de la mise en œuvre de base des classes :

Imaginez la classe comme un modèle de construction. Un croquis de base de ce à quoi devrait ressembler un bâtiment. Lorsque vous allez le construire, vous changez certaines choses pour qu'il ressemble à ce que votre client veut (propriétés dans le cas de classe ). Maintenant, vous devez 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
    }
}

Appeler 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( );

Il suffit de le copier, de l'exécuter sur votre serveur local et d'essayer d'effectuer quelques changements. Si vous avez des questions, n'hésitez pas à me les poser. Si vous ne trouvez pas cela utile, utilisez simplement les liens des posters précédents, ce sont des tutoriels assez solides.

Answer 3

Pour offrir un point de vue d'un autre angle si je peux me permettre (basé sur une expérience personnelle). Vous devez ressentir "le besoin de la POO" avant de pouvoir réellement comprendre ce dont il s'agit - IMHO, les ressources d'apprentissage devraient venir après cela.

Une personne aurait fondamentalement "besoin" d'être coincée dans des difficultés structurelles lors de l'écriture d'un morceau relativement grand de logiciel écrit dans un style procédural (par opposition à orienté objet, désolé si quelqu'un n'est pas d'accord avec le terme). À ce moment-là, il/elle pourrait essayer de restructurer le code en objets pour mieux l'organiser et, naturellement, en apprendre davantage sur la POO en détail. Encore une fois, c'est mon expérience personnelle et cela m'a permis de comprendre plus rapidement que n'importe quel livre.

Juste mes deux centimes.

Answer 4

Les classes sont les ébauches d'objets, avec le nom de la classe. Voiture est la classe. Nous définissons la variable et la méthode dans la classe. La classe est définie avec les accolades. À l'intérieur des accolades, vous pouvez définir la variable, la méthode, les propriétés et la fonction. Vous pouvez définir la méthode et la variable dans les accolades de la classe en fonction de vos besoins.

classe car{

}

foreach( get_declared_classes() as $class){

echo ($class)."<br>";

}

get_declared_classes() est une fonction prédéfinie en php qui retourne un tableau des noms des classes déclarées.