objetos - ¿Qué es una clase en PHP?

php class example

Question

Tengo problemas serios para entender las clases de PHP de un libro. Parecen muy difíciles. ¿Cuál es su propósito y cómo funcionan?

Answer 1

Para ofrecer una vista desde otro ángulo, si puedo, por favor (en base a la experiencia personal). Necesita sentir "la necesidad de OOP" antes de poder entender realmente de qué se trata. En mi humilde opinión, los recursos de aprendizaje deberían venir después de esto.

Uno básicamente "necesitaría" estar atascado en dificultades estructurales al escribir un software relativamente grande escrito en estilo de procedimiento (en lugar de Orientado a Objetos, disculpe si alguien está en desacuerdo con el término). Para entonces, él / ella podría tratar de reestructurar el código en objetos para organizarlo mejor y, naturalmente, aprender más sobre OOP en detalle. Una vez más, esta es mi experiencia personal y me ayudó a comprender más rápido que cualquier libro.

Solo mis dos centavos.

Answer 2

Sé que solicitaste un recurso, no una explicación, pero aquí hay algo por lo que entendí la implementación básica de las clases:

Imagina la clase como una plantilla de construcción. Un boceto básico de cómo debe verse un edificio. Cuando va a construirlo realmente, cambia algunas cosas para que parezca que su cliente quiere (propiedades en caso de clase ). Ahora debe diseñar cómo se comportarán las cosas dentro del edificio ( métodos ). Voy a mostrarlo en un simple ejemplo.

Clase de construcción:

/**
 * 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
    }
}

Llamando a la clase:

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

Solo cópielo, ejecútelo en su servidor local e intente realizar algunos cambios. En caso de cualquier pregunta, solo pregúntame. Si no encuentra esto útil, solo use los enlaces de los carteles anteriores, estos son tutoriales bastante sólidos.

Answer 3

En pocas palabras , una clase es un plan para un objeto. Y un objeto encapsula el estado y la responsabilidad relacionados conceptualmente de algo en su aplicación y generalmente ofrece una interfaz de programación con la que interactuar con ellos. Esto fomenta la reutilización del código y mejora el mantenimiento.

Imagina una cerradura:

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

Ignora el namespace , public declaración private y public este momento.

La clase Lock es un plan para todos los bloqueos en su aplicación. Un bloqueo puede estar bloqueado o desbloqueado , representado por la propiedad $isLocked . Como solo puede tener estos dos estados, utilizo un booleano ( true o false ) para indicar qué estado aplica. Puedo interactuar con el bloqueo a través de su método de lock y unlock , que cambiará el estado en consecuencia. El método isLocked me dará el estado actual del Lock. Ahora, cuando crea un objeto (también denominado a menudo instancia ) desde este plano, encapsulará un estado único, por ejemplo

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

Vamos a crear otro bloqueo, también encapsulando su propio estado

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

pero debido a que cada objeto / instancia encapsula su propio estado, el primer bloqueo permanece bloqueado

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

Ahora toda la responsabilidad de mantener un bloqueo bloqueado o desbloqueado se encasilla dentro de la clase de bloqueo. No tiene que reconstruirlo cada vez que quiere bloquear algo y si desea cambiar la forma en que funciona un candado, puede cambiarlo en el plano de Bloqueo en lugar de que todas las clases tengan un candado, por ejemplo, una puerta:

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

Ahora cuando crea un objeto Door puede asignarle un objeto Lock. Como el objeto Lock maneja toda la responsabilidad de si algo está bloqueado o desbloqueado, la puerta no tiene que preocuparse por esto. De hecho, cualquier objeto que pueda usar un candado no debería preocuparse, por ejemplo, un cofre

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

Como puede ver, la responsabilidad del Cofre es diferente de la de una puerta. Un cofre contiene botín, mientras que una puerta separa las habitaciones. Puede codificar el estado bloqueado o desbloqueado en ambas clases, pero con una clase de bloqueo separada, no es necesario y puede reutilizar el bloqueo.

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

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

Cofre y puerta ahora tienen sus cerraduras únicas. Si el bloqueo era un bloqueo mágico que puede existir en varios lugares al mismo tiempo, como en la física cuántica, podría asignar el mismo bloqueo tanto al cofre como a la puerta, p. Ej.

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

y cuando unlock() $quantumLock , tanto la Puerta como el Cofre estarían desbloqueados.

Aunque admito que Quantum Locks es un mal ejemplo, ilustra el concepto de compartir objetos en lugar de reconstruir el estado y la responsabilidad en todas partes. Un ejemplo del mundo real podría ser un objeto de base de datos que pase a clases utilizando la base de datos.

Tenga en cuenta que los ejemplos anteriores no muestran cómo llegar a la cerradura de un cofre o una puerta para usar los métodos lock() y unlock() . Dejo esto como un ejercicio para que te ejercites (o que alguien más lo agregue).

También verifique cuándo usar self over $ this? para una explicación más detallada de Clases y Objetos y cómo trabajar con ellos

Para algunos recursos adicionales, verifique

• 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