概括地说类是对象的蓝图。对象封装了应用程序中与概念相关的状态和职责，并且通常提供与这些对象交互的编程接口。这促进了代码的重用并提高了可维护性。

想象一下Lock：

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

忽略namespace，private和public declaration。

Lock类是应用程序中所有锁的蓝图。锁可以是上锁或解锁，由财产$isLocked由于它只能具有这两种状态，所以我使用布尔(true或false)指示应用哪种状态。我可以通过它和锁互动方法lock和unlock，这将相应地改变状态。isLocked方法将给出锁的当前状态。现在，当你创建一个对象(通常也称为实例)根据这个蓝图，它将封装唯一的状态。

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

让我们创建另一个Lock，也封装它自己的状态

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

但是因为每个对象/实例封装了它自己的状态，所以第一个锁保持锁定

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

现在，保持锁的整个响应性，无论是锁定还是解锁，都是在Lock类中实现的。你不必每次想要锁定某个锁时都重新构建它，如果您想改变锁的工作方式，您可以在Lock的蓝图中而不是在所有的类中更改它有锁，例如门：

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

现在，当你创建一个Door对象时，你可以为它分配一个Lock对象。因为Lock对象处理所有的责任，不管是锁定还是未锁，门不必关心这个问题。事实上，任何可以使用锁的物体都不需要关心，例如Chest

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

正如你所看到的，chest的应激反应与door的不同。箱子里装着赃物，而一扇门隔开了房间。你可以将已锁定或未锁定的状态编码到两个类中，但是使用单独的Lock类，你不需要并且可以重用Lock。

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

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

箱子和门现在有了它们独特的锁。如果锁是一种魔法锁，可以同时存在于多个地方，就像量子物理学中的那样，你可以把同样的锁分配到箱子和门上。

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

当你unlock()大$quantumLock时door和chest都会被打开。

虽然我承认量子锁是一个糟糕的例子，但它说明了共享对象的概念，而不是在各地重建状态和责任。一个真实的例子可以是传递给类的数据库对象。使用数据库。

请注意，上面的示例没有显示如何进入一个箱子或一个门的锁使用lock()和unlock()方法。我把这作为一个练习，让你去锻炼(或者是其他人来补充)。

我知道您要求的是资源，而不是解释，但下面是我对类的基本实现的理解：

把类想象成建筑的模板。一幅建筑应该是什么样的基本草图。当您要实际构建它时，您需要更改一些内容，使其看起来像您的客户想要的(属性)类).现在你必须设计建筑物内的东西将如何表现(方法)。我将在一个简单的例子中展示它。

Building class：

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

Calling the class：

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

只需复制它，在你的本地主机上运行它，并尝试进行一些更改。