1 <?php
 2 namespcae Demo2;
 3 //假设脚本1 Car.php
 4 // 汽车类
 5 class Car
 6 {
 7   public function drive(){
 8         return ‘开车‘;
 9     }    
10 }
11 //脚本2 Plane.php
12 // 飞机类
13 class Plane
14 {
15   public function drive(){
16         return ‘开飞机‘;
17     }  
18 }
19 //脚本3 Train.php
20 class Train
21 {
22     public function drive(){
23         return ‘开火车‘;
24     }
25 }
26 //脚本4 Travel.php
27 <?php
28 namespace Demo2;use ...;
29 //在一个文件A中调用另一个文件B的类需要加载B文件，这里使用自动加载 
30 require __DIR__ . ‘autoload.php‘;
31 // 旅行
32 class Travel
33 {
34     private $vehicle;
35     public function __construct($vehicle){
36         switch(strtolower($vehicle)){
37             case ‘car‘:
38                $this->vehicle = new Car();
39                 break;
40             case ‘train‘:
41                 $this->vehicle = new Train();
42                 break;
43             case ‘plane‘:
44                 $this->vehicle = new plane();
45                 break;
46        }
47     }
48     public function travelMove(){
49         // 传统做法就是new 对象
50         return $this->vehicle->drive().‘去上班‘
51     }
52 }
53 // 调用
54 echo (new Travel(‘car‘))->travelMove() . PHP_EOL;//开车去上班
55 echo (new Travel(‘train‘))->travelMove() . ‘<br>‘;//开火车去上班
56 echo (new Travel(‘plane‘))->travelMove();//开飞机去上班

<?php
 namespcae Demo2;
 //假设脚本1 Car.php
 // 汽车类
 class Car
 {
   public function drive(){
         return ‘开车‘;
     }    
 }
 //脚本2 Plane.php
 // 飞机类
 class Plane
 {
   public function drive(){
         return ‘开飞机‘;
     }  
 }
 //脚本3 Train.php
 class Train
 {
     public function drive(){
         return ‘开火车‘;
     }
 }
 //脚本4 Travel.php
 <?php
 namespace Demo2;
user ...;
 //在一个文件A中调用另一个文件B的类需要加载B文件，这里使用自动加载
 require __DIR__ . ‘autoload.php‘;
// 工厂类
class Factory
{
    private $instance = null;
    public static function create(){
        switch(strtolower($vehicle)){
             case ‘car‘:
                $this->instance = new Car();
                 break;
             case ‘train‘:
                 $this->instance = new Train();
                 break;
             case ‘plane‘:
                 $this->instance = new plane();
                 break;
        }
        return $this->instance;
    }
}
 // 旅行
 class Travel
{
     private $vehicle;
     public function __construct($vehicle=null){
        // 将原来依赖三个类,变成了依赖一个工厂类
        $this->vehicle = Factory::create($vehicle);
    }
     public function travelMove(){
         // 传统做法就是new 对象
         return $this->vehicle->drive().‘去上班‘
     }
}
// 调用
echo (new Travel(‘car‘))->travelMove() . PHP_EOL;//开车去上班
echo (new Travel(‘train‘))->travelMove() . ‘<br>‘;//开火车去上班
echo (new Travel(‘plane‘))->travelMove();//开飞机去上班

<?php
 namespcae Demo2;
// 接口
class iVehicle{
    public function drive();
}
 //Car.php
 // 汽车类
 class Car implement iVehicle
 {
   public function drive(){
         return ‘开车‘;
     }    
 }
 //脚本2 Plane.php
 // 飞机类
 class Plane implement iVehicle
 {
   public function drive(){
         return ‘开飞机‘;
     }  
 }
 //脚本3 Train.php
 class Train implement iVehicle
 {
     public function drive(){
         return ‘开火车‘;
     }
 }
 //脚本4 Travel.php
 <?php
 namespace Demo2;
user ...;
 //在一个文件A中调用另一个文件B的类需要加载B文件，这里使用自动加载
 require __DIR__ . ‘autoload.php‘;

 // 旅行
 class Travel
{
     private $vehicle;
    // 将原构造方法中实例化依赖对象的过程，交给工厂类完成了
     public function __construct(iVehicle $vehicle=null){
        // 将原来依赖一个工厂类,变成面向接口的抽象工厂模式
        $this->vehicle = $vehicle;
    }
    // 调用外部依赖的对象的方法
     public function travelMove(iVehicle $vehicle){
         return $vehicle->drive().‘去上班‘;
     }
}
// 调用
echo (new Travel())->travelMove(new Car()) . PHP_EOL;//开车去上班
echo (new Travel())->travelMove(new Train()) . ‘<br>‘;//开火车去上班
echo (new Travel())->travelMove(new Plane());//开飞机去上班