PHP面向对象（oop）

1.创建一个类

class Base
{
    public function index()
    {
        echo '这是Base类里面的index方法';
    }
}

class User extends Base
{
    //公开
    public $name;
    //受保护的
    protected $arr;
    //私有属性
    private $_age;
    //静态属性
    public statis $account;
    //定义常量
    const content = '这是常量哦';


    /*
    有三种方法赋值私有的成员变量
    */  

    //构造函数，在类被实例化时调用【1.在构造方法里】
    public function __construct($age,$arr)
    {
        $this->_age = $age;
        $this->arr  = $arr;
    }
    //【2.再编写一个公开方法】
    public function access()
    {
        $str = [];
        return $str = [$this->_age,$this->arr];
    }
    //【3.使用魔术方法】
    /**
     * 访问类中私有属性时自动调用，传递读取属性名，返回$this->属性名
     * @param  [type] $value [description]
     * @return [type]        [description]
     */
    public function __get($value)
    {
        return $this->$value;
    }

    /**
     * 给类的私有属性赋值时自动调用，传递需设置的属性名，属性值
     * @param [type] $key   [description]
     * @param [type] $value [description]
     */
    public function __set($key,$value)
    {
        return $this->$key = $value;
    }

    /**
     * [__destruct description]
     * 析构方法，在类被调用结束时自动调用
     */
    public function __destruct()
    {
        return '销毁变量';
    }


    /**
     * [index description]声明一个普通公开的方法
     * @return [type] [description]
     */
    public function index()
    {
        //想要继承base类里面的方法，两个类的index方法都想起作用，不想重载Base类的index
        parent::index();
        echo '这是一个公开的方法，所有人都可以访问';
        //在类的内部访问静态属性
        self::account;
        echo '<hr />';
        //访问静态方法
        self::make();
        //访问常量
        echo '<hr />';
        self::content;
    }

    /**
     * [save description]受保护的方法
     * @return [type] [description]
     */
    protected function save()
    {
        echo '这是一个受保护的方法，只有在类的内部和子类的（被继承的类的内部可以访问）';    
    }

    /**
     * [edit description]私有的方法
     * @return [type] [description]
     */
    private function edit()
    {
        echo '这是一个受保护的方法，只有在类的内部自己访问';
    }

    /**
     * [make description]静态方法
     * @return [type] [description]
     */
    public static function make()
    {
        echo '这是一个公开的静态方法';
    }

    /**
     * [__call description]__call():调用一个类中未定义的或未公开的方法时自动调用，传递被调用的函数名及参数列表
     * @return [type] [description]
     */
    public function __call($functionName,$functionParams)
    {
        print_r("你调用的方法是".$functionName.'它的参数是'.$functionParams);
    }
}

//类的属性方法的访问
$user = new User();
//访问属性
echo $user->name;
//给属性赋值
$user->name = 'li';
//访问方法
$user->index();
//访问静态属性
User::account;
//访问静态方法
User::make();

/*
抽象类
关键字 abstract
*/
abstract class Good
{
    //在抽象类可以定义属性
    protected $username = 'tianerjun';

    public function __constract()
    {
        echo '这是一个构造方法';
    }

    /*
    （抽象方法）必须是空白的方法
    */
    abstract function index()；

    /*
    在抽象类内可以有写好的方法
    */
    public function save()
    {
        echo '这是抽象类的方法';
    }

    /*
    抽象类的属性在类里面可以使用
    */
    public function edit()
    {
        return $this->username;
    }
}
//抽象类是不可以实例化的，可以被继承，通过extends继承，一个方法只能继承一个抽象类
class Svn extends Good
{

    public function index()
    {
        echo '这是抽象类Good中index方法的实现';
    }

    public function store()
    {
        echo '这是Svn类store方法';
    }
}

$svn = new Svn();

/*
接口
关键字 interface
*/
interface Root
{
    /*
    接口类的方法不用实现
    */
    public function index(){}

    public function save(){}
}
//接口不能被实例化，可以被继承（说继承可能不太合适）它是通过关键字实现的【implements】,一个类可以同时继承多个接口，继承多个接口需要实现父接口中所有未实现的方法

class Blog implements Root
{
    public function index()
    {
        echo '这是接口index方法的实现';
    }

    public function save()
    {
        echo '这是接口save方法的实现';
    }
}

$blog = new Blog();