A brief description of using interfaces, abstract classes, and common base classes to implement 'interface-oriented programming' and 'coupling methods' in PHP

Copy code The code is as follows:
 
/* 
I am learning and doing it at the same time. I publish it to facilitate my own reading. I also publish it with the guidance of experts. Welcome the guidance of experts... 
[Tip] This example passed the test without error
[Scenario Design] 
Simulates the computer motherboard IDE interface, for example: the storage that the motherboard can access often includes optical drives, hard disks, flash memory, etc., 
For convenience , it is necessary to set the same interface for these different memories. 
This example also assumes that an unprecedented alien memory with a unique access method is also added to the motherboard for access. 
So a coupled design pattern needs to be adopted.
[The main description of this example] 
1. The so-called "interface" mode is achieved through three methods: interface, abstract class, and general class inheritance. This illustrates: 
A. Subclass objects can be used as parent classes. Object is used because the subclass is a special parent class﻿﻿! 
B. Please pay attention to the base class writing method of interface, abstract class and general class inheritance in these three implementation methods! 
2. The interface mode is really a contract! 
3. "Coupling design pattern" of programming!
*/ 
//---------------------------------------- ------------------------------- 
/*[Method 1] Interface implementation method:*/ 
interface readandwrite { 
function read(); 
function write(); 
} 
class motherboard{ 
private $storage; 
function __construct(readandwrite $obj){ 
$this ->storage=$obj; 
} 
function read(){ 
$this->storage->read(); 
} 
function write(){ 
$this->storage->write(); 
} 
} 
class flash implements readandwrite{ 
function __construct(){ 
echo "I am flash memory:} 
function read(){ 
echo "Start reading data...
"; 
} 
function write(){ 
echo "Start storing data..."; 
} 
} 
class yingpan implements readandwrite{ 
function __construct(){ 
echo "I am a hard disk ：
"; 
} 
function read(){ 
echo "Start reading data...
"; 
} 
function write( ){ 
echo "Start storing data..."; 
} 
} 
class disco implements readandwrite{ 
function __construct(){ 
echo "I am a CD:
"; 
} 
function read(){ 
echo "Start reading data...
"; 
} 
function write(){ 
echo "Start storing data..."; 
} 
} 
//----------- -------------------------------------------------- --------- 
/*[Method 2] Abstract class implementation: 
abstract class readandwrite{ 
abstract function read(); 
abstract function write(); 
} 
class motherboard{ 
private $storage; 
function __construct(readandwrite $obj){ 
$this->storage=$obj; 
} 
function read() { 
$this->storage->read(); 
} 
function write(){ 
$this->storage->write(); 
} 
} 
class flash extends readandwrite{ 
function __construct(){ 
echo "I am flash: 
"; 
} 
function read(){ 
echo "Start reading data...
"; 
} 
function write(){ 
echo "Start storing data..."; 
} 
} 
class yingpan extends readandwrite{ 
function __construct(){ 
echo "I am the hard disk: 
"; 
} 
function read(){ 
echo "Start reading data...
"; 
} 
function write(){ 
echo "Start storing data...} 
} 
class disco extends readandwrite{ 
function __construct(){ 
echo "I am a disc: 
"; 
} 
function read(){ 
echo "Start reading data...
"; 
} 
function write(){ 
echo "Start storing data... ."; 
} 
} 
*/ 
//------------------------- --------------------------------------------- 
// [Method 3] General class inheritance implementation method: 
/* 
class readandwrite{ 
function read(){ 
echo "reading............" ; 
} 
function write(){ 
echo "writing............"; 
} 
} 
class motherboard{ 
private $storage; 
function __construct(readandwrite $obj){ 
$this->storage=$obj; 
} 
function read(){ 
$this-> storage->read(); 
} 
function write(){ 
$this->storage->write(); 
} 
} 
class flash extends readandwrite{ 
function __construct(){ 
echo "I am flash memory: 
"; 
} 
function read(){ 
echo "Start reading data.... ..
"; 
} 
function write(){ 
echo "Start storing data..."; 
} 
} 
class yingpan extends readandwrite{ 
function __construct(){ 
echo "I am a hard disk: 
"; 
} 
function read(){ 
echo "Start reading data ...
"; 
} 
function write(){ 
echo "Start storing data..."; 
} 
} 
class disco extends readandwrite{ 
function __construct(){ 
echo "I am a CD: 
"; 
} 
function read(){ 
echo " Start reading data...
"; 
} 
function write(){ 
echo "Start storing data..."; 
} 
} 
*/ 
//---------------------------------- ------------------------------------ 
/* 
【Coupling Mode】 
The coupling mode is to combine two classes with different standards (in this example, the interface, abstract class, ordinary base class and alien storage have different access methods), 
 achieve the same standard through an intermediate converter, Just like a transfer line - this example is to convert the Rdata and Wdata methods of the unknown class into read and write methods to achieve the same access methods as the interface, abstract class and ordinary base class in this example. In this example The intermediate converter is the 
Apdater class.
Since only one class can be inherited in PHP but multiple interfaces can be inherited, three coupling methods have been produced: 
Method 1: The intermediate converter Apdater class inherits abstract classes or ordinary base classes, but since PHP only inherits A class can be inherited, so define an unknown object of the alien memory class in the Apdater 
 class, and convert 
 the access method by overloading the access method of the inherited abstract class or ordinary base class. To achieve the purpose of the same access method. 
Method 2: The intermediate converter Apdater class inherits the alien memory class unknown and interface. At this time, you can directly use the access methods of the Apdater class 
(parent::Rdata() and parent::Wdata()—— The way a subclass calls the parent class method in PHP), and implements the interface specified method, 
 to convert the access method to achieve the same access method. 
Method three: Same as method one, except that it inherits (implements) the interface; 
*/ 
//-------------------- -------------------------------------------------- 
/* 
[Method 1] 
*/ 
/* 
class unknow{ 
function __construct(){ 
echo "I It is an alien storage unknown to people on Earth. I have a different access method from Earth's storage: 
"; 
} 
function Rdata(){ 
echo " I'm reading now...
"; 
} 
function Wdata(){ 
echo "I'm writing now..." ; 
} 
} 
class Adpater extends readandwrite{ 
private $obj; 
function __construct(unknow $x){ 
$this->obj=$x; 
} 
function read(){ 
$this->obj->Rdata(); 
} 
function write(){ 
$this->obj-> Wdata(); 
} 
} 
*/ 
//-------------------------- ------------------------------------------ 
/* 
 [Method 2] 
class unknow{ 
function __construct(){ 
echo "I am an alien memory unknown to people on earth. I have a memory different from the memory on earth. Access method: 
"; 
} 
function Rdata(){ 
echo "I'm reading now...
"; 
} 
function Wdata(){ 
echo "I'm writing now..."; 
} 
} 
class Adpater extends unknown implements readandwrite { 
function read(){ 
parent::Rdata(); 
} 
function write(){ 
parent::Wdata(); 
} 
} 
*/ 
//----------------------------------------- ------------------------------- 
/* 
【Method 3】 
*/ 
class unknow{ 
function __construct(){ 
echo "I am an alien storage unknown to people on earth. I have a different access method from the storage on earth: < /font>
"; 
} 
function Rdata(){ 
echo "I'm reading now...
"; 
} 
 function Wdata(){ 
echo "I'm writing now..."; 
} 
} 
class Adpater implements readandwrite{ 
private $obj; 
function __construct(unknow $x){ 
$this->obj=$x; 
} 
function read(){ 
$this->obj->Rdata( ); 
} 
function write(){ 
$this->obj->Wdata(); 
} 
} 
//[Program body call] 
echo "Object-oriented programming - interface"; 
$storage1=new flash( ); 
$computer=new motherboard($storage1); 
$computer->read(); 
$computer->write(); 
$storage2=new yingpan(); 
$computer=new motherboard($storage2); 
$computer->read(); 
$computer->write(); 
$storage3=new disco(); 
$computer=new motherboard($storage3); 
$computer->read(); 
$computer->write(); 
$un_storage=new unknow(); 
$ apdaterx=new Adpater($un_storage); 
$computer=new motherboard($apdaterx); 
$computer->read(); 
$computer->write(); 
? > 
A brief description of using interfaces, abstract classes, and common base classes to implement 'interface-oriented programming' and 'coupling methods' in PHP_PHP Tutorial
