面向對象

【類和對象的基本使用】
類的聲明
調用 屬性、方法

    //聲明類

    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__;