学习设计模式原则之依赖倒置原则，代码笔记

1初步

<?php
//学习设计模式之依赖倒置原则
header("content-type:text/html;charset=utf8");
echo "设计模式-依赖倒置原则<br/>";
//小明要吃米饭
/**
* 
*/
 class Man
 {
   public function eat()
   {
      echo "小明开始吃米饭了";
   }
 }


 //下面是客户端测试代码
 $xiaoming = new Man;
 $xiaoming->eat();
?>

输出：小明开始吃米饭了

2 抽象吃饭

<?php
//学习设计模式之依赖倒置原则
header("content-type:text/html;charset=utf8");
echo "设计模式-依赖倒置原则<br/>";
 class Man
 {
   //人只有一个功能：吃饭
   public function chifan(EatRice $eatRice)
   {
      $eatRice->eat();
   }
 }
 class EatRice
 {
   public function eat(){
      echo "吃米饭了";
   }
 }
 $xiaoming = new Man;
 $xiaoming->chifan(new EatRice);

设计模式-依赖倒置原则

吃米饭了

3 小明尝试吃别的

<?php
//学习设计模式之依赖倒置原则
header("content-type:text/html;charset=utf8");
echo "设计模式-依赖倒置原则<br/>";
class Man
{
   //人只有一个功能：吃饭
   public function chifan(EatRice $eatRice)
   {
      $eatRice->eat();
   }
}
class EatRice
{
   public function eat(){
      echo "吃米饭了";
   }
}
/*
代码完美运行，现在，小明想吃面条了，好的，吃面条的逻辑抽象出来，产生吃面条的类
*/
/**
* 
*/
class EatNoddles
{
   public function eat()
   {
      echo "吃面条了";
   }
}
$xiaoming = new Man;
$xiaoming->chifan(new EatRice);

<?php
//学习设计模式之依赖倒置原则
header("content-type:text/html;charset=utf8");
echo "设计模式-依赖倒置原则<br/>";
class Man
{
   //人只有一个功能：吃饭
   public function chifan(EatRice $eatRice)
   {
      $eatRice->eat();
   }
}
class EatRice
{
   public function eat(){
      echo "吃米饭了";
   }
}
/*
代码完美运行，现在，小明想吃面条了，好的，吃面条的逻辑抽象出来，产生吃面条的类
*/
/**
* 
*/
class EatNoddles
{
   public function eat()
   {
      echo "吃面条了";
   }
}
$xiaoming = new Man;
$xiaoming->chifan(new EatRice);

设计模式-依赖倒置原则
吃米饭了

/*
但是我们无法让小明吃面条，如果给Man类的chifan方法传入EatNoddles $eatNodlles 仍旧会输出“吃米饭了”,因为Man类的chifan方法中写死了$eatRice->chifan(),只能去实例化eatRice类的chifan方法,但是小明不可能天天吃面条，怎么办呢，用接口解决
*/

4 利用接口实现

<?php
//学习设计模式之依赖倒置原则
header("content-type:text/html;charset=utf8");
echo "设计模式-依赖倒置原则<br/>";
/*
但是我们无法让小明吃面条，如果给Man类的chifan方法传入EatNoddles $eatNodlles 仍旧会输出“吃米饭了”,因为Man类的chifan方法中写死了$eatRice->chifan(),只能去实例化eatRice类的chifan方法,但是小明不可能天天吃面条，怎么办呢，用接口解决
*/
/*
我们先来定义一个饭的接口
*/
interface Food
{
   //是饭就能被吃
   public function eat();
}


/*
下面先做个面条的类，面条类实现了interface Food,他必须有个方法eat
*/
class Noddles implements Food
{
   public function eat()
   {
      echo "吃面条了";
   }
}
/*
再做一个烤肉类，和面条类一样
*/
class Barbecue implements Food
{
   public function eat()
   {
      echo "吃烤肉了";
   }
}
/*
再做一个汉堡类，同上
*/
class Hamburger implements Food
{
   public function eat()
   {
      echo "吃汉堡了";
   }
}
/*
再做一个米饭类，同上
*/
class Rice implements Food
{
   public function eat()
   {
      echo "吃米饭了";
   }
}




/*
我们来定义一个chifan的interface接口
*/
interface Chifan
{
   //chifan的interface只需要有一个功能约束吃饭，而不用管吃什么饭
   public function chifan(Food $food);
}
/*
下面我们做个Man，有吃的功能
*/
class Man implements Chifan
{
   public function chifan(Food $food)
   {
      $food->eat();
   }
}




/*
终于要开吃了
*/

$xiaoming = new Man;
//吃米饭
$xiaoming->chifan(new Rice);
//吃汉堡
$xiaoming->chifan(new Hamburger);
//吃烤肉
$xiaoming->chifan(new Barbecue);
//吃面条
$xiaoming->chifan(new Noddles);

/*
代码完美执行，从现在开始，小明想吃什么，只需要做个这种食物的类，实现food接口就可以了
*/

?>

输出：

设计模式-依赖倒置原则
吃米饭了吃汉堡了吃烤肉了吃面条了