标签OOP下的文章

Jerry Bendy 发布于 01月21, 2014

一张图讲述PHP面向对象基础

这张图片还是我在群里偶然发现的,概括得挺全面,涉及到PHP面向对象的基本用法、面象对象的基本概念、辅助函数、反射等等,源文件名是PHP5OOP思维导图.jpg

不过这张图只适合初学PHP面向对象的人继续对其加深印象,已经会使用面向对象的应该继续深入学习PHP高级面向对象及设计模式,这些也就不适用了。

先贴个小图,后面再附上大图的地址:

php5_oop_base

 

完整大图地址

阅读全文 »

Jerry Bendy 发布于 12月31, 2013

PHP高级面向对象:__call()详解

这是我写的第一篇面向对象的高级教程,主要思路来源于《深入PHP:面向对象、模式与实践》,我感觉这本书写得很好,我才读了三分之一就感觉获益匪浅。这次我要写的的关于PHP的魔法函数__call()的用法(语文是数学老师教的,文字可能太啰嗦,请见谅)。

class foo{
    function __call($name, $param){
        echo '你调用的函数名是' . $name;
        echo '调用参数是' . $parma;
    }
}

$bar = new foo();
foo->abc();

很多教程都会给出如上这样的__call的基本使用方法,也就是在外部调用一个类里面不存在的函数时(注意是函数,而不是属性,如果是属性的话应该用__get()),PHP系统会自动寻找类中是否存在__call()方法,如果这个方法存在的话就会把这次调用的函数名和参数列表发送给__call()方法,其中参数列表会以数组的形式传递。

我们要做的就是在在__call()方法中处理PHP传递而来的方法名和参数,显然这对组合模式非常有利。

__call()最大的用途就是在类中包含另一个类时,例如我们有一个类product,它包含所有产品的信息:

class Product {
    protected $_pid;
    protected $_name;
    protected $_cost;

    function __call($name, $params){
        if(preg_match('/(.*)_(.*)/i', $matchs)){
            if(isset($matchs[1]) && isset($matchs[2])){
                if($matchs[1] == 'get'){
                    $attr = '_' . $matchs[2];
                    return $this->$attr;
                } elseif ($matchs[1] == 'set'){
                    $attr = '_' . $matchs[2];
                    $this->$attr = $parmas[0];
                }
            }
        } else {
            echo '您请求的函数不存在';
        }
    }
}

$foo = new Product();
$foo->set_name('candy');
echo $foo->get_name;

上面的代码或许在类中保存多个属性时非常有用,但PHP已经有了更方便的__get()__set(),关于这两个魔法函数这里就不细述了,如果需要某个属性不被这种调用修改的话(如pid),可以通过修改它的前缀的方式来避免。

但这不是__call()的最好用法,__call()在许多时候只有和call_user_func()call_user_func_array()搭配使用才能达到最佳效果,即在类中包含另一个对象的实例时,或者需要在一个类中调用另一个类的方法时,参见以下代码(代码源自我做的一个相册程序,使用CI框架,类Image_model是在CI中直接调用的接口类,另外的虚拟类和两个延伸类则用于在Image_model中被调用):

class Image_model extends CI_Model {
    //用来保存Image_handle的实例
    private $_image_handle;

    function __construct(){
        parent::__construct();

        switch($this->config->item('image_handle')){
            case 'local':
                $this->_image_handle = new Local_image_handle();
                break;
            case 'bae':
                $this->_image_handle = new Bae_image_handle();
                break;
            case 'sae':
                $this->_image_handle = new Sae_image_handle();
                break;
            default:
                show_error('参数错误');
        }
    }

    /**
    * 在CALL魔法函数中查找要调用的方法是否存在,如果存在可以直接
    * 调用对应类中的方法,这里用到call_user_func_array()
    */
    function __call($name, $params){
        if(method_exists($this->_image_handle, $name){
            call_user_func_array(array($this->_image_handle, $name), $params);
        } else {
            show_error ('你调用的方法不存在');
        }
    }
}

/**
* 这里定义一个虚拟的接口类image_handle
* 这个类存在的意义就是在外部调用image_handle的方法时
* 可以保证这个方法是一定存在的,这样可以避免很多错误
*/
abstrct class Image_handle {
    function get_content();
    function get_mime_type();
    // ......
}

/**
* Image_handle的本地实现
*/
class Local_image_handle extends Image_handle {
    function get_content(){
        //......
    }
    function get_mime_type(){
        //......
    }
}

/**
* Image_handle的BAE实现
*/
class Bae_image_handle extends Image_handle {
    function get_content(){
        //......
    }
    function get_mime_type(){
        //......
    }
}

以上基本阐释了__call()和call_user_func_array的用法,call_user_func_array接受两个数组作为参数,第一个数组有两个参数,即要调用的类的名称(或类的实例)和要调用的方法名,第二个参数即是要传递给该方法的参数列表,具体可参见PHP官方文档。

阅读全文 »

Jerry Bendy 发布于 07月30, 2013

PHP类实例教程(二十四):PHP5类中的多态

多态这个概念,在Java中指的是变量可以指向的对象的类型,可是变量声明类型的子类。对象一旦创建,它的类型是不变的,多态的是变量。在PHP5中,变量的类型是不确定的,一个变量可以指向任何类型的数值、字符串、对象、资源等。我们无法说PHP5中多态的是变量。

我们只能说在PHP5中,多态应用在方法参数的类型提示位置。

一个类的任何子类对象都可以满足以当前类型作为类型提示的类型要求。

所有实现这个接口的类,都可以满足以接口类型作为类型提示的方法参数要求。

简单的说,一个类拥有其父类、和已实现接口的身份。

通过实现接口实现多态

<?php
class User  
{   // User接口  
    public function  getName() {  
    }  
}  
class NormalUser extends User  
{   // 继承自User类  
    private $name;  
    public function getName() {  
        return $this->name;
    }  
    public function setName($_name) {  
        $this->name = $_name;
    }  
}  
class UserAdmin  
{   //操作  
    public static function  ChangeUserName(User $_user, $_userName) {  
        $_user->setName($_userName);
    }  
}  
$normalUser = new NormalUser();  
UserAdmin::ChangeUserName($normalUser,"Tom");   //这里传入的是 NormalUser的实例  
echo $normalUser->getName();
?>

使用接口与组合模拟多继承

通过组合模拟多重继承。

在PHP中不支持多重继承,如果我们向使用多个类的方法而实现代码重用有什么办法么?

那就是组合。在一个类中去将另外一个类设置成属性。

下面的例子,模拟了多重继承。

接口实例

写一个概念性的例子。 我们设计一个在线销售系统,用户部分设计如下: 将用户分为,NormalUser, VipUser, InnerUser 三种。要求根据用户的不同折扣计算用户购买产品的价格。并要求为以后扩展和维护预留空间。

<?php
interface User  
{  
    public function getName();  
    public function setName($_name);  
    public function getDiscount();  
}  
abstract class AbstractUser implements User  
{  
    private $name = "";  
    protected  $discount = 0;  
    protected  $grade = "";  
    function __construct($_name) {  
        $this->setName($_name);
    }  
    function getName() {  
        return $this->name;
    }  
    function setName($_name) {  
    $this->name = $_name;
    }  
    function getDiscount() {  
        return $this->discount;
    }  
    function getGrade() {  
        return $this->grade;
    }  
}  
class NormalUser extends AbstractUser  
{  
    protected $discount = 1.0;  
    protected $grade = "Normal";  
}  
class VipUser extends AbstractUser  
{  
    protected $discount = 0.8;  
    protected $grade = "VipUser";  
}  
class InnerUser extends AbstractUser  
{  
    protected $discount = 0.7;  
    protected $grade = "InnerUser";  
}  
interface Product  
{  
    function getProductName();  
    function getProductPrice();  
}  
interface Book extends Product  
{  
    function getAuthor();  
}  
class BookOnline implements Book  
{  
    private $productName;  
    protected $productPrice;  
    protected $Author;  
    function __construct($_bookName) {  
        $this->productName = $_bookName;
    }  
    function getProductName() {  
        return $this->productName;
    }  
    function getProductPrice() {  
        $this->productPrice = 100;
        return $this->productPrice;
    }  
    public function getAuthor() {  
        $this->Author = "chenfei";
        return $this->Author;
    }  
}  
class Productsettle  
{  
    public static function finalPrice(User $_user, Product $_product, $number) {  
        $price = $_user->getDiscount() * $_product->getProductPrice() * $number;
        return $price;  
    }  
}  
$number = 10;  
$book = new BookOnline("设计模式");  
$user = new NormalUser("tom");  
$price = Productsettle::finalPrice($user, $book, $number);  
$str = "您好,尊敬的" . $user->getName() . "<br />";
$str .= "您的级别是" . $user->getGrade() . "<br />";
$str .= "您的折扣是" . $user->getDiscount() . "<br />";
$str .= "您的价格是" . $price;  
echo $str;  
?>

 

转自:http://blog.csdn.net/klinghr/article/details/5213022

阅读全文 »

Jerry Bendy 发布于 07月28, 2013

PHP类实例教程(二十一):PHP类接口的继承

一个接口可以继承自另外的接口。PHP5中的类是单继承,但是接口很特殊。一个接口可以继承自多个接口。

一个接口继承其它接口时候,直接继承父接口的静态常量属性和抽象方法。

在PHP5中,接口是可以继承自另外一个接口的。这样代码的重用更有效了。

要注意只有接口和接口之间使用 继承关键字extends。

类实现接口必须实现其抽象方法,使用实现关键字 implements。

接口实现继承

要注意只有接口和接口之间使用 继承关键字extends。

类实现接口必须实现其抽象方法,使用实现关键字 implements。

这个例子定义接口User,User有两个抽象方法getName和setName。又定义了接口VipUser,继承自User接口,并增加了和折扣相关的方法getDiscount。最后定义了类 Vip ,实现了VipUser接口。并实现了其中的三个方法。

<?php
interface User
{
    function getName();
    function setName($_name);
}
interface VipUser extends User
{
    function getDiscount(); //此处添加了一个抽象的方法
}
class Vip implements VipUser
{
    private $name;
    private $discount = 0.8;    //折扣变量
    function getName() {
        return $this->name;
    }
    function setName($_name) {
        $this->name = $_name;
    }
    function getDiscount() {
        return $this->discount;
    }
}
?>

 

转自:http://blog.csdn.net/klinghr/article/details/5213009

阅读全文 »

Jerry Bendy 发布于 07月28, 2013

PHP类实例教程(二十二):类型提示

PHP是弱类型语言,向方法传递参数时候也不太区分类型。这样的使用会引起很多的问题,PHP开发者认为,这些问题应该是由代码书写者在书写代码时进行检验以避免。没有类型提示很危险。

<?php
class NormalUser  
{  
    /* 
    * 其它相关代码..省略........ 
    */  
    private $age;  
    public function setAge($_age) {  
        $this->age = $_age;
    }   
    public function getAge() {  
        return $this->age ;
    }  
}  
$normalUser = new NormalUser();  
$normalUser->setAge("I am tom"); //这里我们传输一个非数值
echo "age is " . $normalUser->getAge();  //注意输出结果不是我想要的类型
?>

原始类型的类型判

PHP中提供了一些函数,来判断数值的类型。我们可使用is_numeric()。判断是否是一个数值或者可转换为数值的字符串。

其它相关的还有is_bool()、is_int()、is_float()、is_integer()、is_numeric()、is_string()、is_array() 和 is_object()。

于是代码有了修改

<?php
class NormalUser
{
    /*
    * 其它相关代码..省略........
    */
    private $age;
    public function setAge($_age) {
        if (is_numeric($_age)) {
            $this->age = $_age;
        }
    }
    public function getAge() {
        return $this->age ;
    }
}
$normalUser = new NormalUser();
$normalUser->setAge("I am tom");     //这里我们传输一个非数值.
echo "age is " . $normalUser->getAge();  //看到这里的结果为空.
echo  "<br />";
$normalUser->setAge("100");
echo "age is " . $normalUser->getAge();  // 这里就有了结果.
?>

向方法内传递对象

如果传递的参数是一个对象呢?

下面的代码用起来很正常。

<?php
class NOrmalUser
{
    private $name;
    function setName($_name) {
        $this->name = $_name;
    }
    function getName() {
        return $this->name;
    }
}
class UserAdmin
{
    //这里定义的参数,第一个是User类的实例,第二个是要设置的名字
    static function changeName($_user, $_name) {
        $_user->setName($_name);
    }
}
$normalUser = new NOrmalUser();
UserAdmin::changeName($normalUser, "tom");
echo "username is " . $normalUser->getName();
?>

 

转自:http://blog.csdn.net/klinghr/article/details/5213016

阅读全文 »

Jerry Bendy 发布于 07月28, 2013

PHP类实例教程(二十三):PHP抽象类实现接口

抽象类实现接口,可以不实现其中的抽象方法,而将抽象方法的实现交付给具体能被实例化的类去处理。

<?php
interface User
{
 function getName();
 function setName($_name);
}
 //此处只是实现了一个接口的一个方法
abstract class abatractNormalUser implements User
{
 protected $name;
 function getName() {
  return $this->name;
 }
}
 //这里实现了接口的另外一个方法
class NormalUser extends abatractNormalUser
{
 function setName($_name) {
  $this->name = $_name;
 }
}
$normaluser = new NormalUser();
$normaluser->setName("tom");
echo "name is " . $normaluser->getName();
?>

 

阅读全文 »

Jerry Bendy 发布于 07月27, 2013

PHP类实例教程(十七):abstract类和abstract方法

可以使用abstract来修饰一个类或者方法。

用abstract修饰的类表示这个类是一个抽象类,用abstract修饰的方法表示这个方法是一个抽象方法。

抽象类不能被实例化。

抽象方法是只有方法声明,而没有方法的实现内容。

abstract 抽象类

可以使用abstract来修饰一个类。

用abstract修饰的类表示这个类是一个抽象类。

抽象类不能被实例化。

这是一个简单抽象的方法,如果它被直接实例化,系统会报错。

<?php
//定义一个抽象类  
abstract class User  
{  
    public function __toString() {  
        return get_class($this);  
    }   
}  
//实例化这个类会出现错误  
echo new User();  
?>

下面例子的 NormalUser 继承自 User类,就可以被实例化了。

<?php
//定义一个抽象类  
abstract class User  
{  
    public function __toString() {  
        return get_class($this);  
    }   
}  
//实例化这个类会出现错误  
echo new User();  
class NormalUser extends User  
{  
}  
$a = new NormalUser();  
echo "这个类" . $a . "的实例";  
?>

单独设置一个抽象类是没有意义的,只有有了抽象方法,抽象类才有了血肉。下面介绍抽象方法。

abstract 抽象方法

用abstract修饰的类表示这个方法是一个抽象方法。

抽象方法,只有方法的声明部分,没有方法体。

抽象方法没有 {} ,而采用 ; 结束。

一个类中,只要有一个抽象方法,这个类必须被声明为抽象类。

抽象方法在子类中必须被重写。

下面是一个抽象类,其中有两个抽象方法,分别是 setSal() 和 getSal()。用来取回 $sal 员工的工资。

<?php
abstract class User  
{  
    protected $sal = 0;  
    //这里定义的抽象方法。  
    //注意抽象方法没有方法体,而且方法结束使用 ; 号。  
    abstract function getSal();  
    abstract function setSal();  
    //定义它的__tostring方法  
    public function __toString() {  
        return get_class($this);  
    }   
}   
?>

既然User类不能被直接继承,我们写一个NormalUser类继承自User类。当我们写成如下代码时,系统会报错。 这个错误告诉我们,在 User类中有两个抽象方法,我们必须在子类中重写这两个方法.

<?php
abstract class User  
{  
    protected $sal = 0;  
    //这里定义的抽象方法。  
    //注意抽象方法没有方法体,而且方法结束使用 ; 号。  
    abstract function getSal();  
    abstract function setSal();  
    //定义它的__tostring方法  
    public function __toString() {  
        return get_class($this);  
    }   
}  
class NormalUser extends User  
{  
}  
?>

下面例子,重写了这两个方法,虽然方法体里面 {} 的内容是空的,也算重写了这个方法。注意看重写方法的参数名称,这里只要参数数量一致就可以,不要求参数的名称必须一致。

<?php
abstract class User  
{  
    protected $sal = 0;  
    //这里定义的抽象方法。  
    //注意抽象方法没有方法体,而且方法结束使用;号。  
    abstract function getSal();  
    abstract function setSal();  
    //定义它的__tostring方法  
    public function __toString() {  
        return get_class($this);  
    }   
}  
class NormalUser extends User  
{  
    function getSal() {  
    }  
    function setSal($sal) {   
    }  
}  
    //这样就不会出错了。  
?>

下面19-21行,三种写重写的方式都会报错。

19行,缺少参数。

20行,参数又多了。

21行,参数类型不对。(这种写法在以后章节介绍)

一个类中,如果有一个抽象方法,这个类必须被声明为抽象类。

下面这个类不是抽象类,其中定义了一个抽象方法,会报错。

<?php
class User
{
    protected $sal = 0;
    //这里定义的抽象方法。
    //注意抽象方法没有方法体,而且方法结束使用;号。
    abstract function getSal();
    abstract function setSal();
    //定义它的__tostring方法
    public function __toString() {
        return get_class($this);
    } 
}
    //这个类中有两个抽象方法,如果这个类不是抽象的。会报错
?>

抽象类继承抽象类

抽象类继承另外一个抽象类时,不用重写其中的抽象方法。

抽象类中,不能重写抽象父类的抽象方法。

这样的用法,可以理解为对抽象类的扩展

下面的例子,演示了一个抽象类继承自另外一个抽象类时,不需要重写其中的抽象方法。

<?php
abstract class User
{
    protected $sal = 0;
    abstract function getSal();
    abstract function setSal($sal); 
}
abstract class VipUser extends User
{
}
?>

抽象类在被继承后,其中的抽象方法不能被重写。

如果发生重写,系统会报错。

<?php
abstract class User
{
    protected $sal = 0;
    abstract function getSal();
    abstract function setSal($sal); 
}
abstract class VipUser extends User
{
    abstract function setSal(); 
}
?>

抽象类继承抽象类,目的对抽象类的扩展。

<?php
abstract class User
{
    protected $sal = 0;
    abstract function getSal();
    abstract function setSal($sal); 
}
abstract class VipUser extends User
{
    protected $commision = 0;
    abstract function getCommision();
    abstract function setCommision();
}
?>

在PHP5.1中,抽象类中支持静态抽象方法。下面这个例子,看到静态抽象方法可以声明。实现这个方法时,必须是静态的方法。

静态抽象方法

在PHP5.1中,抽象类中支持静态抽象方法。下面这个例子,看到静态抽象方法可以声明。实现这个方法时,必须是静态的方法。

<?php
abstract class User
{
    protected static  $sal = 0;
    static abstract function getSal();
    static abstract function setSal($sal); 
}
class VipUser extends User
{
    static function getSal() {
        return self::$sal;
    }
    static function setSal($sal) {
        self::$sal = $sal;
    }
}
VipUser::setSal(100);
echo "you sal is " . VipUser::getSal();
?>

 

转自:http://blog.csdn.net/klinghr/article/details/5212952

阅读全文 »

Jerry Bendy 发布于 07月27, 2013

PHP类实例教程(十八):设计模式之模版模式

抽象类的应用就是典型的模版模式,先声明一个不能被实例化的模版,在子类中去依照模版实现具体的应用。

模版模式实例

我们写这样一个应用:

银行计算利息,都是利率乘以本金和存款时间,但各种存款方式计算利率的方式不同,所以,在账户这个类的相关方法里,只搭出算法的骨架,但不具体实现。具体实现由各个子类来完成。

<?php
//程序设计模式的模块部分
abstract class LoadAccount
{
    //利息,本金
    protected $interest, $fund;
    public function calculateInterest() {
        //取得利率
        $this->interest = getInterestRate();
        //用于计算利息的算法:本金*利率,但是利率的算法实现并没有在这个类中实现
        $this->interest = $this->getFund() * $this->getInterstRate();
        return $this->interest;
    }
    private function getFund() {
        return $this->fund;
    }
    //.......
    /*
    * 不同类型的存款的利率不同,因此,
    * 不在这个父类中实现率的计算方法,
    * 而将他推迟到子类中实现
    */
    protected abstract function getInterstRate();
}
?>

所有和计算利息的类都继承自这个类,而且必须实现其中的 getInterestRate() 方法,这种用法就是模版模式。

阅读全文 »

Jerry Bendy 发布于 07月27, 2013

PHP类实例教程(十九):PHP类接口的定义与规范

接口(interface)是抽象方法和静态常量定义的集合。

接口是一种特殊的抽象类,这种抽象类中只包含抽象方法和静态常量。

接口中没有其它类型的内容。

接口的定义

我们先写接口的定义,后面几节再介绍接口的意义。

下面的例子是接口的一个简单写法。

<?php
interface 接口名  
{   
}  
?>

下面的例子定义了一个接口 User ,这个接口中有两个抽象方法,getName() 和setName()。能看到接口的写法和类很相似。

<?php
interface User  
{  
    function setName($name);  
    function getName();   
}  
?>

接口中的抽象方法

注意,在接口中只能有抽象方法。如果在接口中出现了非抽象方法,会报错如下: Interface function User::setName() cannot contain body in ……….

<?php
interface User  
{  
    function setName($name);  
    function getName(){}    //这个地方是一个非抽象方法,会报错   
}  
?>

接口中抽象方法的修饰和访问权限

在接口中的抽象方法只能是public的,默认也是public权限。并且不能设置成 private 或者 protected 类型。否则会报错如下: Access type for interface method User::setName() must be omitted in —on line — (在接口中,访问类型必须忽略。)

<?php
interface User  
{  
    function setName($name);  
    private function getName(); //不允许带修饰符,此处如果换成protected也会出错  
}  
?>

即使abstract 和 final 修饰符也不能修饰接口中的抽象的方法。

接口中的静态抽象方法

在接口中可以使用静态抽象方法。在PHP5.2中,不建议在抽象类中使用静态抽象方法。而接口中依然保留了静态抽象方法。

<?php
interface User  
{  
    function setName($name);  
    static function getName() {  
    }   
}  
?>

接口中的静态常量

在接口中可以定义静态常量。而且不用static修饰就是静态的常量。

<?php
interface User  
{  
    const MAX_GRADE = 99;   //此处不用声明,就是一个静态常量  
    function setName($name);  
    static function getName() {  
    }   
}  
?>

 

转自:http://blog.csdn.net/klinghr/article/details/5212976

阅读全文 »

Jerry Bendy 发布于 07月27, 2013

PHP类实例教程(二十):PHP类接口的实现接口

类实现接口要使用 implements 。类实现接口要实现其中的抽象方法。一个类可以实现多个接口。

一个类可以使用 implements 实现接口,甚至可以实现多个接口。

大部分的书说,这样是为了实现PHP的多继承。为什么呢?

PHP5是单继承的,一个类只可以继承自一个父类。接口可以实现多个,这样就是多继承了。

这样说有些道理。但,既然接口里面的方法没有方法体,所谓的多继承又有什么意义?

接口的意义在于后面一节继续说的多态。

使用implements实现接口

使用implements来实现一个接口。如果实现接口而没有实现其中的抽象方法,会报错如下。

Fatal error: Interface function User::getName() cannot contain body in C:/wamp/www/tt.php on line 5

<?php
interface User  
{  
    const MAX_GRADE = 99;   //此处不用声明,就是一个静态常量  
    function setName($name);  
    static function getName() {  
    }   
}  
class NoumalUser implements User  
{  
}  
?>

实现接口要实现方法。注意静态变量的使用。

<?php
interface User  
{  
    const MAX_GRADE = 99;   //此处不用声明,就是一个静态常量  
    function setName($name);  
    function getName();   
}  
//实现接口  
class NoumalUser implements User  
{  
    private $name;  
    function getName() {  
        return $this->name;
    }  
    function setName($_name) {  
        $this->name = $_name;
    }   
}  
$normalUser = new NoumalUser(); //创建对象  
$normalUser->setName("http://www.isstudy.com");
echo "URL is " . $normalUser->getName();
echo "<br />";
echo "MAX_GRADE is " . NoumalUser::MAX_GRADE;   //静态常量  
?>

实现多个接口

一个类可以实现多个接口。只要使用 , 号将多个接口链接起来就可以。

<?php
interface User
{
    const MAX_GRADE = 99;   //此处不用声明,就是一个静态常量
    function setName($name);
    function getName();
}
interface administrator
{
    function setBulletin($_bulletin) ;
}
//多个接口
class NoumalUser implements User, administrator
{
    private $name;
    function getName() {
        }
    function setName($_name) {
        }
    function setBulletin($_setBulletin) {
    }
}
?>

继承并实现接口

<?php
class Student
{
    protected $grade;
    public function getGrade() {
        return $this->grade;
    }
}
interface  User
{
    function getName();
    function setName($_name);
}
//只有管理员可以设置公告
interface Administrator
{
    function setBulletin($_bulletin);
}
//为了节省版面,下面方法只写空的实现.不写具体内容了
class StudentAdmin extends Student implements User, Administrator
{
    function getName() {
    }
    function setName($_name) {
    }
    function setBulletin($_bulletin) {
    }
}
$s = new StudentAdmin();
echo $s->getGrade();
echo $s->getName();
echo $s->setBulletin("公告内容");
?>

 

转自: http://blog.csdn.net/klinghr/article/details/5212997

阅读全文 »