面向物件

【類和物件的基本使用】
類的宣告
呼叫 屬性、方法

    //宣告類

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

標籤：PHP

上一篇：電子商城專案開發（前臺功能模塊開發）

下一篇：PHP目錄操作（附封裝好的目錄操作函式檔案）