PHP OO

时间：2010-09-30 来源：kang !

什么东西学的再好，不用总会忘记，复习下...

Simple Example

public、protected、private、__get、__set:

public 表示全局，类内部外部子类都可以访问
protected表示受保护的，只有本类或子类或父类中可以访问
private表示私有的，只有本类内部可以使用

class T{
    private $a = 10;
    private $b = 100;
    protected $c = 1;
    
    public function __get($n){
        echo $n;
    }
    public function __set($n, $v){
        echo $n . '-' . $v;
    }        
    public function usechild(){
        $this->show();
    }        
    public function getName(){
        return 'T';
    }
}

class M extends T{
    public $d = 1000;
    public function show(){
        echo $this->d . '-' . $this->c;
    }
    
    public function getName(){
        return 'M'.parent::getName();
    }
}        
class N {
    public function getName(){
        return M::getName();
    }
}
// __get() __set()
$t = new T();
$t->a;                //'a'
$t->c = 'value';    // 'c-value'

// extends
$m = new M();
$m->usechild();        //1000-1

// overload
$n = new N();
echo $n->getName();    //'MT'

abstract

类中至少有一个抽象方法
抽象方法前需要加abstract
抽象方法无需{}
继承后重载的方法，必须同抽象方法的参数个数相同
本身都不能被实例化，必须被继承
继承后，需要把所有抽象方法重载在才可使用

abstract class C1{
    abstract function fun1();
    abstract function fun2($n, $v);
}

class C2 extends C1 {
    public function fun1(){}
    public function fun2($a, $b){
        //参数书目必须一致
        return $a . $b;
    }
}
$c2 = new C2();

static const final

static 通过self访问, 可在static fun 或普通函数中访问
const 通过self访问, 可在static fun 或普通函数中访问
static fun 不能访问非static或const变量

class S{
    static $n = 1;
    public $m = 10;
    const J = 100;
    public function getj(){
        echo self::J ;
    }
    static function getm(){
        echo $this->$m;        
        // $s = new S(); $s->getm();
        // 'error'
        // 访问不到非static const变量
        // 想象JS就OK了
    }
    static function getn(){
        echo self::$n;
        echo self::J ;
    }
}
echo S::$n;        //1
S::getn();        //1
$s = new S();
$s->getj();

interface

类中全部为抽象方法
方法前不需要加abstract
接口抽象方法必须为public
成员属性必须为常量
本身都不能被实例化，必须被继承或者引用
继承或引用，需要把所有抽象方法重载才可使用
方法无需{}
继承后重载的方法，必须同抽象方法的参数个数相同

interface I{
    const N = 1;
    function fun($n, $v);
    function fun2();
}
class II implements I {
    function fun($a, $b){}
    function fun2(){}
}

$ii = new II();

多态

语言具有根据对象的类型不同，使用不同方式的处理

instanceof：用来测定一个给定对象是否来自制定的类

class A{}
class B extends A{}

$b = new B();
if($b instanceof A){
    echo 'A';    // 'A'
}
if($b instanceof B){
    echo 'B';    // 'B'
}