PHP面向对象

<?php

//封装 __set() __get() __isset() __unset()
//__get()函数==>表示调用私有属性，如果是访问一般成员属性则不会调用该方法
/*class Person{
    private $age;
    function __get($var){
        echo "哈哈哈".$var;//var代表被调用的变量
        return $this->$var;
    }
}
$p=new Person();
echo $p->age;
class Person{
    private $name;
    private $age;
    function __get($var){
        if($var=="name")
        return $this->name;
        if($var=="age")
        return $this->age;
    }
    function __set($var,$value){
        if($var=="name")
        return $this->name=$value;
        if($var=="age")
        return $this->age=$value;
    }
}
class Student extends Person{
    function Say($avr){
        echo $this->name."说".$avr;
    }
}
$s=new Student();
$s->__set("name","张");
$s->Say("哈哈哈哈");
//Static属性==>本类名调用可以使用self，但在外部还得用类名调用
class person{
    var $name;
    static $country="中国";
    function Say(){
        echo "我是".self::$country."人";//person::$country
    }
}
$p=new person();
person::$country="外星";
$p->Say();
//static方法  以下俩种方法都可以调用静态方法
class person{
    var $name;
    static $country="中国";
    function Say(){
        echo "我是".self::$country."人";
    }
}
person::Say();//推荐使用
$p=new person();
$p->Say();
//const  常量修饰符
class person{
    var $name="我";
    const COUNTRY="中国";//常量无法更改值
    function Say(){
        echo "我是".self::COUNTRY."人";
    }
}
person::Say();
//__tostring()函数==>被定义的时候必须返回一个字符串的值
class person{
    var $name="我";
    function __toString(){
        return "这是一个对象类型，无法直接输出";
    }
}
$p=new person();
echo $p;
//__clone()函数==>克隆出一个新的对象，这两个对象的内容一样，但在堆中的地址不一样
class person{
    var $name="我";
    function __Clone(){
$this->name="是clone出来的副本";
            }
}
$p=new person();
$e=new person();
$e=clone $p;
echo $p->name;
echo $e->name;
//__call()函数==>可以避免程序崩溃，只输出一个提示内容
class person{
    var $name="我";
    function __call($funname,$args){//第一个参数为调用的方法名。第二个参数为调用方法时传递的参数。
        echo $funname."方法不存在<br>";
        print_r($args);
    }
}
$p=new person();
$p->fun(1,2,3);
echo "<br>程序未崩溃";
//抽象方法，一个类里面有抽象方法就是抽象类，抽象类不能被实例化，只能被继承实现
abstract class Demo{
    abstract function fun1();
    function fun2(){
        echo "哈哈哈";
    }
}
class Test extends Demo{
    function fun1(){
        echo "覆盖抽象方法";
    }
}
//Test::fun1();
$t=new Test();
$t->fun1();
//接口是一种特殊的抽象类。
//所有的成员属性必须是常量，所有的方法都是抽象的，所有的成员都必须是public 
class Demo{
    
}
interface lone{
    const B="hhhh";
    function fun();
}
class one extends Demo implements lone{
    function fun(){
        echo "哈哈哈哈";
    }
}

one::fun();*/