复制代码代码如下所示：
< PHP
*
边学边做，并释放为方便阅读，多征求专家意见并释放，欢迎高手指点……
{这个例子通过测试是正确的
{场景设计}
模拟计算机主板的IDE接口，如：主板可以存取内存，常有光驱、硬盘、闪存等。
为了方便起见，有必要为这些不同的内存设置相同的接口。
这个例子还假设在主板上访问一个前所未有的、不寻常的对外部星存储的访问。
因此需要一个耦合的设计模式。
{这个例子是主要的故事}
1、通过接口、抽象类、一般类继承三种方式实现所谓的接口模式，从而加以解释：
A，子类对象可以用作父类对象，因为子类是一个特殊的父类！
请注意接口、抽象类和一般类继承的三个实现的基本类。
2，接口模式实际上是一个合同！
3，程序设计的耦合设计模式！
* /
/ / ----------------------------------------------------------------------
{方法} * *接口：*
接口readandwrite {
函数读取（）；
函数写入（）；
}
类主板{
私有存储；
功能__construct（readandwrite $ obj）{
美元->存储= $ obj；
}
函数读取（）{
$ < >存储>读取（）；
}
函数写入（）{
$ < >存储>写入（）；
}
}
类的FLASH实现readandwrite {
功能__construct（）{
我是快闪记忆体：；
}
函数读取（）{
开始读取数据…；
}
函数写入（）{
开始存储数据…；
}
}
类实现了readandwrite {营盘
功能__construct（）{
答：我是一个硬盘：；
}
函数读取（）{
开始读取数据…；
}
函数写入（）{
开始存储数据…；
}
}
类实现了readandwrite {迪斯科
功能__construct（）{
我是一个光盘：；
}
函数读取（）{
开始读取数据…；
}
函数写入（）{
开始存储数据…；
}
}
/ / ----------------------------------------------------------------------
{两个类实现：
抽象类readandwrite {
抽象函数读取（）；
抽象函数写（）；
}
类主板{
私有存储；
功能__construct（readandwrite $ obj）{
美元->存储= $ obj；
}
函数读取（）{
$ < >存储>读取（）；
}
函数写入（）{
$ < >存储>写入（）；
}
}
类Flash扩展readandwrite {
功能__construct（）{
我是快闪记忆体：；
}
函数读取（）{
开始读取数据…；
}
函数写入（）{
开始存储数据…；
}
}
类营盘延伸readandwrite {
功能__construct（）{
答：我是一个硬盘：；
}
函数读取（）{
开始读取数据…；
}
函数写入（）{
开始存储数据…；
}
}
课堂延伸readandwrite {迪斯科
功能__construct（）{
我是一个光盘：；
}
函数读取（）{
开始读取数据…；
}
函数写入（）{
开始存储数据…；
}
}
* /
/ / ----------------------------------------------------------------------
{三} /一般类实现：
*
类readandwrite {
函数读取（）{
读……；
}
函数写入（）{
回声写作……；
}
}
类主板{
私有存储；
功能__construct（readandwrite $ obj）{
美元->存储= $ obj；
}
函数读取（）{
$ < >存储>读取（）；
}
函数写入（）{
$ < >存储>写入（）；
}
}
类Flash扩展readandwrite {
功能__construct（）{
我是快闪记忆体：；
}
函数读取（）{
开始读取数据…；
}
函数写入（）{
开始存储数据…；
}
}
类营盘延伸readandwrite {
功能__construct（）{
答：我是一个硬盘：；
}
函数读取（）{
开始读取数据…；
}
函数写入（）{
开始存储数据…；
}
}
课堂延伸readandwrite {迪斯科
功能__construct（）{
我是一个光盘：；
}
函数读取（）{
开始读取数据…；
}
函数写入（）{
开始存储数据…；
}
}
* /
/ / ----------------------------------------------------------------------
*
{耦合模式}
耦合模式是两类不同的标准（接口、抽象类、普通基类和外部星存储有不同的访问方法）。
利用中间转换器来达到同样的标准，就像一个连接线，这个例子是把RDATA，对未知的类数据的方法。
读写方法用于实现与本例的接口、抽象类和普通基类相同的访问方法。本例的中间转换器就是这样的。
Apdater class.
由于PHP只能继承一个类，但可以继承多个接口，所以产生了三种耦合方法。
方法一：中间转换器apdater类继承抽象类或普通的基类，但因为PHP只能继承一个类，所以在Apdater
该类定义了一个外星记忆类未知对象，并使用存取方法抽象类或一个共同的基类，超载。
同一访问方法的目的是替换访问方法。
方法二：中间转换器apdater类继承的外部记忆类未知的界面，并且可以使用apdater类直接在这个时候。
（家长：：RDATA（）和家长：：数据（）的方式，PHP中子类调用父类）和接口规则的实施，
将访问方法转换为相同的访问方法。
方法三：与方法相同，只对继承（实现）接口；
* /
/ / ----------------------------------------------------------------------
*
{方法1 }
* /
*
类未知{
功能__construct（）{
我是一个未知的地球外部记忆，我有一个不同的方式访问地球的记忆；
}
功能的RDATA（）{
我现在正在读……；
}
功能数据（）{
我现在在写……；
}
}
类适配器延伸readandwrite {
私人$ obj；
功能__construct（未知X元）{
美元-> obj = X元；
}
函数读取（）{
美元->对象-> RDATA（）；
}
函数写入（）{
美元->对象->数据（）；
}
}
* /
/ / ----------------------------------------------------------------------
*
{方法二}
类未知{
功能__construct（）{
我是一个未知的地球外部记忆，我有一个不同的方式访问地球的记忆；
}
功能的RDATA（）{
我现在正在读……；
}
功能数据（）{
我现在在写……；
}
}
类适配器扩展实现readandwrite {未知
函数读取（）{
家长：：RDATA（）；
}
函数写入（）{
家长：：数据（）；
}
}
* /
/ / ------------------------------------------------------------------------
*
{方法三}
* /
类未知{
功能__construct（）{
我是一个未知的地球外部记忆，我有一个不同的方式访问地球的记忆；
}
功能的RDATA（）{
我现在正在读……；
}
功能数据（）{
我现在在写……；
}
}
类适配器实现了readandwrite {
私人$ obj；
功能__construct（未知X元）{
美元-> obj = X元；
}
函数读取（）{
美元->对象-> RDATA（）；
}
函数写入（）{
美元->对象->数据（）；
}
}
主程序调用
面向对象编程接口；
新的Flash存储美元=（）；
电脑=美元新主板（$存储）；
$计算机>读取（）；
$计算机>写入（）；
存储2美元=新营盘苗族彝族白族乡（）；
计算机=新的主板美元（美元存储2）；
$计算机>读取（）；
$计算机>写入（）；
存放=新迪斯科（美元）；
计算机=新的主板美元（美元存放）；
$计算机>读取（）；
$计算机>写入（）；
un_storage美元=新的未知（）；
apdaterx美元=新的适配器（$ un_storage）；
电脑=美元新主板（$ apdaterx）；
$计算机>读取（）；
$计算机>写入（）；
>