面向对象

【类和对象的基本使用】
类的声明
调用 属性、方法

    //声明类

    class Cat
    {
        //定义属性
        public $name = '咪咪';
        public $sex = null;
        //定义方法
        public function jiao()
        {
            echo '喵喵~';
        }
    }

    //实例化
    $c1 = new Cat();
    var_dump($c1);

    //调用 属性、方法
    echo $c1->name;
    $c1->jiao();

    $c1->sex = '母';
    echo $c1->sex;

传递赋值和引用赋值

    $a = 'abc';

    $b = $a;//传递赋值
    $c = &$a;//引用赋值

    var_dump($a);//abc
    var_dump($b);//abc
    var_dump($c);//abc

    $a = 'qq';

    var_dump($a);//qq
    var_dump($b);//abc
    var_dump($c);//qq

对象的传递赋值

    class MyClass
    {
        public $str = 'abc';
    }

    $a = new MyClass(); //$a 存的是对象的标识符

    $b = $a;//传递赋值 把标识符 赋值给 $b


    var_dump($a);//$str = 'abc'
    var_dump($b);//$str = 'abc'

    $a->str = '456';//对象的属性改变了
    //$a $b 存的 仍是 对象标识符
    var_dump($a);//str = '456'
    var_dump($b);//str = '456'


    $a = 123;
    var_dump($a);//int 123
    var_dump($b);//对象标识符str = '456'

对象的引用赋值

    class MyClass
    {
        public $str = 'abc';
    }

    $a = new MyClass(); //$a 存的是对象的标识符

    $b = &$a;//引用赋值 把$a的引用 赋值给 $b

    var_dump($a);//str = 'abc'
    var_dump($b);//str = 'abc'

    $a->str = '123';
    var_dump($a);//str = '123'
    var_dump($b);//str = '123'

    $a = 123;
    var_dump($a);//int 123
    var_dump($b);//int 123

【封装】
访问控制 public protected private

    class MyClass
    {
        public $a = 'public';
        protected $b = 'protected';
        private $c = 'private';
        
        public function test()
        {
            //类内部调用
            echo $this->a;//public
            echo $this->b;//protected
            echo $this->c;//private
        }
    }


    $obj = new MyClass;
    //类外  以 对象的方式调用
    echo $obj->a;//public
    echo $obj->b;//报错
    echo $obj->c;//报错

    $obj->test();

构造函数：对象被实例化时调用

    class MyClass
    {
        public function __construct()
        {
            echo '调用了__construct <br>';
        }
    }

    $obj1 = new MyClass;//调用了__construct
    $obj2 = new MyClass();//调用了__construct

析构函数：对象被销毁时调用

    class MyClass
    {
        public function __destruct()
        {
            echo '对象被销毁了';
        }
    }

    $obj = new MyClass();

    $obj = null;//对象被销毁了
    unset($obj);//对象被销毁了
    exit('结束掉');//结束掉对象被销毁了

静态属性与静态方法 static

    class MyClass
    {
        public static $a = 'static';
        
        public $b = '123123';
        
        public static function func1()
        {
            echo '静态方法调用';
            echo MyClass::$a;
            echo self::$a;
            echo '<hr>';
            MyClass::func2();
            echo '<hr>';
            self::func2();
            //不可以用$this去调用
            //echo $this->$a;//Fatal error
            //$this->func2();
        }
        public static function func2()
        {
            echo 'this is static func2';
        }
        
        public function func3()
        {
            echo 'this is func3';
            echo '静态属性';
            echo MyClass::$a;
            echo self::$a;
            echo '<hr>';
            echo MyClass::func2();
            echo self::func2();
            
            //echo $this->a;//去调用静态属性 失败
            $this->func2();
        }
        
    }

    echo MyClass::$a;
    echo MyClass::$b;//非静态调用失败
    MyClass::func1();

    $obj = new MyClass();
    echo $obj->a;//对象使用-> 去调用静态属性 失败
    echo $obj->b;
    $obj->func1();
    $obj->func3();

常量const

    class MyClass
    {
        public static $a = 'abc';
        const NUM = 123;
    }


    echo MyClass::$a;
    echo MyClass::NUM;

    MyClass::$a = 'def';
    echo MyClass::$a;

    MyClass::NUM = 456; //报错，常量一经定义不能修改

属性的重载：不可访问的属性

    class Person
    {
        public $name='小芳';
        protected $age=18;//protected不可在外部访问

        //触发了不可访问的属性
        public function __get($n)
        {
            if($n == 'age'){
                return $this->age;
            }else{
                return '瞎问什么啊';
            }

        }
        
        public function __set($n,$v)
        {
            echo '触发了设置不可访问的属性'.$n.'值为'.$v;
            $this->$n = $v;
        }
        
        public function __isset($n)
        {
            echo '判断一个不可访问的属性是否存在'.$n;
        }
        
        public function __unset($n)
        {
            echo '销毁一个不可访问的属性'.$n;
        }
        
    }

    $xiao = new Person();

    echo $xiao->age;//18
    echo $xiao->xxx;//瞎问什么啊

    $xiao->age = 11;//设置不可访问的属性age值为11
    echo $xiao->age;//11

    isset($xiao->age);//判断一个不可访问的属性是否存在age
    unset($xiao->age);//销毁一个不可访问的属性age
    isset($xiao->age);//判断一个不可访问的属性是否存在age

方法重载：不可访问的方法

    class MyClass
    {
        
        protected function func($n)
        {
            echo '这是一个不可访问的方法';
            echo '参数是'.$n;
        }
        
        public function __call($name,$arg)
        {
            echo '触发了不可访问的方法';
            var_dump($name);//方法名称  func
            var_dump($arg);//参数
    //        array(2) {
    //                [0] =>
    //          string(3) "aaa"
    //                [1] =>
    //          int(123)
    //        }
        }

        protected static function func2()
        {
            echo '受保护的静态方法';
        }
        
        public static function __callStatic($name,$arg)
        {
            echo '调用了不可访问的静态方法';
            var_dump($name);//func2
            var_dump($arg);
    //        array(4) {
    //                [0] =>
    //          int(1)
    //          [1] =>
    //          int(2)
    //          [2] =>
    //          int(3)
    //          [3] =>
    //          int(4)
    //        }
        }
    }

    $obj = new MyClass();
    $obj->func('aaa',123);
    //触发了不可访问的方法

    MyClass::func2(1,2,3,4);
    //调用了不可访问的静态方法

【继承】
类的继承

    class FatherClass
    {
        public $a = 'public';
        protected $b = 'protected';
        private $c = 'private';
        
        public function func1()
        {
            echo 'public func';
        }
        
        protected function func2()
        {
            echo 'protected func';
        }
        
        private function func3()
        {
            echo 'private func';
        }
    }


    class SonClass extends FatherClass
    {
        public function test()
        {
            $this->func1();//public方法可以被继承
            $this->func2();//protected方法可以被继承
            //$this->func3();//Fatal error：private方法不可以被继承
        }
    }

    $obj = new SonClass();
    echo $obj->a;//public
    //echo $obj->b;  //fatal error
    //echo $obj->c;     //Notice

    //$obj->func1();
    //$obj->func2();  //fatal error
    //$obj->func3();   //fatal error

    $obj->test();
    //public func protected func

类的重写

    class Father
    {
        public function shuo()
        {
            echo 'a a o o';
        }
    }

    class Son extends Father
    {
        public function shuo()
        {
            echo 'hello';
        }
        
        public function test()
        {
            $this->shuo();
            parent::shuo();
        }
    }

    $obj = new Son();
    $obj->shuo();//hello
    $obj->test();//helloa a o o

final 修饰类 则该类不能被继承

    class Father
    {
        final public function test()  //final 声明之后不能被重写
        {
            echo 'hello';
        }
    }

    class Son extends Father
    {
        
        public function test()
        {
            echo '你好';
        }
    }

    $obj = new Son();
    $obj->test();//报错

【多态】
抽象类abstract

    abstract class MyAbsClass
    {
        public $name = '张三';
        public $age;
        public function test()
        {
            echo 'hello';
        }
        abstract public function func();
    }

    class ChildClass extends MyAbsClass
    {
        public function func()
        {
            
        }
    }

    abstract class SonClass extends MyAbsClass
    {

    }

接口interface

    interface MyInterface
    {
        const NUM = 123;
        public function func();
        public function test();
    }

    class MyClass implements MyInterface
    {
        public function func(){
            
        }
        public function test(){
            echo 'hello';
        }
    }

    abstract class MyAbsClass implements MyInterface
    {
        abstract function func();
        abstract function test();
    }

【条件约束和自动加载】
接口的继承

    interface Ainter
    {
        public function func();
    }

    interface Binter extends Ainter
    {
        public function test();
    }



    class MyClass implements Binter
    {
        public function test()
        {
            
        }
        
        public function func()
        {
            
        }
    }

判断是否属于某个类的实例

    interface A
    {
        public function func();
    }

    abstract class B implements A
    {
        abstract public function func();
    }

    class C extends B
    {
        public function func()
        {
            echo 'ok';
        }
    }

    class D extends B
    {
        public function func()
        {
            echo '好的';
        }
    }

    /*
    B实现了 A
    C、D继承自B
    C、D是兄弟
    */

    $obj1 = new C();
    $obj2 = new D();
    $arr = [1,2,3];

    //是否属于D的实例
    function test(D $n)
    {
        echo 'ok';
    }
    //是否属于A的实例
    function test2(A $n)
    {
        echo 'ok';
    }

    test($obj2);//ok
    //test($obj1);//不属于D的实例
    test2($obj1);//ok
    test2($obj2);//ok

自动加载__autoload

    function __autoload($a)
    {
        include 'myclassfolder/'.$a.'.class.php';
    }

    class A extends B
    {
        
    }

注册自动装载函数

    function myloader($a)
    {
        include 'myclassfolder/'.$a.'.class.php';
    }
    /*
    有三个参数
    参数1：需要注册的自动装载函数
    参数2： 如果没有找到参数1的函数 是否抛出异常错误
    参数3： 是否把参数1的函数添加到队列之首
    */
    spl_autoload_register('myloader',true,true);

    class A extends B
    {
        
    }

注册自动装载类

    class MyLoader
    {
        public static function l($a)
        {
            include 'myclassfolder/'.$a.'.class.php';
        }
    }
    //['MyLoader','l']
    //spl_autoload_register 第一个参数以数组方式传入
    spl_autoload_register(['MyLoader','l'],true,true);

    class A extends B
    {
        
    }

初始化时自动装载

    class MyLoader
    {
        public function l($a)
        {
            include 'myclassfolder/'.$a.'.class.php';
        }
        
        public function init(){
            //['MyLoader','l']
            //spl_autoload_register 第一个参数以数组方式传入
            spl_autoload_register([$this,'l'],true,true);
        }
    }

    $obj = new MyLoader();
    $obj->init();
    class A extends B
    {
        
    }

【命名空间】
命名空间（函数案例）

    namespace A;
    function time(){
        echo 'my time function <br>';
    }


    namespace B;
    function time(){
        echo 'my space B time function <br>';
    }


    time();// namespace B time()
    \A\time();// namespace A time()
    \B\time();// namespace B time()
    echo \time(); //    \全局空间

命名空间（类案例）

    namespace A\B;
    class MyClass
    {
        public function __construct()
        {
            echo '空间A\B 中的类 实例化了 <br>';
        }
    }

    namespace A;
    class MyClass
    {
        public function __construct()
        {
            echo '空间A 中的类 实例化了 <br>';
        }
    }

    $obj = new MyClass();// 非限定名称
    $obj = new \A\B\MyClass();// 完全限定名称
    $obj = new \A\MyClass();// 完全限定名称
    $obj = new B\MyClass();//限定名称

打印当前命名空间

    echo __NAMESPACE__;

来源：https://www.cnblogs.com/chenyingying0/p/12187828.html