PHP OO

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

Simple Example

public、protected、private、__get、__set:

• public 表示全局，类内部外部子类都可以访问
• protected表示受保护的，只有本类或子类或父类中可以访问
• private表示私有的，只有本类内部可以使用，在子类内也不可以访问
• 父类的成员，无论是public、protected或private，在子类内都可以覆盖。但子类的访问权限必须高于或等于父类，即父类为protected，子类该成员必须为protected或public。访问权限public > protected > private

• __get($var)：当访问private、protected或不存在的成员变量时，会调用该函数，public则不会。
• __set($var, $val)：第一个参数变量名，第二个参数变量值。当为private、protected或不存在的变量设置值时，会调用该函数，public则不会。

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

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

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

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

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'
}

其他细节

• 普通的成员方法如果定义的名字和类名相同，那么就变成构造方法