细学设计模式一（组合与继承）

<?php
abstract class Lesson{
    protected $duration;
    const FIXED = 1;
    const TIMED = 2;
    private $costtype;
    
    function __construct($duration,$costtype){
        $this->duration = $duration;
        $this->costtype = $costtype;
    }
    
    function cost(){
        switch ($this->costtype){
            case self::TIMED :
                return (5*$this->duration);
                break;
            case self::FIXED:
                return 30;
                break;
            default :
                $this->costtype = self::FIXED;
                return 30;
        }
    }
    
    function chargeType()
    {
        switch ($this->costtype)
        {
            case self::TIMED:
                return "hourly rate";
                break;
            case self::FIXED:
                return "fixed rate";
                break;
            default :
                $this->costtype = self::FIXED;
                return "fixed rate";
        }
    }
    
    //Lesson的更多方法
}

class Lecture extends Lesson{
    //Lecture特定的实现
}

class Seminar extends Lesson{
    //Seminar特定的实现
}

//下面如何使用这些类
$lecture = new Lecture(5,Lesson::FIXED);
print "{$lecture->cost()},{$lecture->chargeType()} 
";//30,fixed rate

$seminar = new Seminar(3,Lesson::TIMED);
print "{$seminar->cost()},{$seminar->chargeType()} 
";//15,hourly rate

使用组合：使用策略模式（strategy）来解决条件语句

<?php
abstract class Lesson{
    private $duration;
 
    private $costStrategy;
    
    function __construct($duration,CostStrategy $strategy)
    {
        $this->duration = $duration;
        $this->costStrategy = $strategy;
    }
    
    function cost()
    {
        return $this->costStrategy->cost($this);//“委托”另外的类中的方法去执行
    }
    
    function chargeType()
    {
        return $this->costStrategy->chargeType();//“委托”另外的类中的方法去执行
    }
    
    
    function getDuration()
    {
        return $this->duration;
    }

    //Lesson的更多方法
}

class Lecture extends Lesson{
    //Lecture 特定的实现
}

class Seminar extends Lesson{
    //Seminar 特定的实现
}


abstract class CostStrategy{
    abstract function cost(Lesson $lesson);
    
    abstract function chargeType();
}

class TimedCostStrategy extends CostStrategy{
    function cost(Lesson $lesson)
    {
        return ($lesson->getDuration()*5);
    }
    
    function chargeType()
    {
        return "hourly rate";
    }
}

class FixedCostStrategy extends CostStrategy{
    function cost(Lesson $lesson)
    {
        return 30;
    }
    
    function chargeType()
    {
        return "fixed rate";
    }
}

$lessons[] = new lecture(4,new TimedCostStrategy());
$lessons[] = new Seminar(4,new FixedCostStrategy());

foreach ($lessons as $lesson)
{
    print "lesson charge: {$lesson->cost()} ";
    print "charge type: {$lesson->chargeType()} 
";
}

//lesson charge: 20 charge type: hourly rate 
//lesson charge: 30 charge type: fixed rate