1、常用術語說明

class 類
object 對象
new 實例化
member 類成員
method 方法，成員函數
property 屬性，成員變量
constant 類常量

2、類的構造

class ClassName{            //class關鍵字加類名
    //類中只能有三種成員：屬性、類常量、方法，不限數量
    //成員變量（屬性）
    public $var;            //普通屬性，只能通過對象訪問，聲明時必須使用訪問控制修飾符
    public static $s_var = 0;    //靜態屬性，使用static關鍵字修飾的屬性
    const PI  = 3.14;        //
 
類常量，聲明時必須使用const關鍵字修飾並賦值，其值不可修改

    //成員方法
    function fn0(){
        //普通成員方法
        echo ‘普通成員方法運行了<br>‘;
    }
    static function fn1(){
        //靜態方法
        echo self::$s_var.‘靜態方法運行了<br>‘;    //類似$this,在類內部使用self關鍵字代表當前類名
    }
    public function __construct($var){
        //構造方法，對象實例化時自動調用該方法
 

        $this->var = $var;    //$this表示當前對象
        echo ‘構造方法運行了<br>‘;
    }
    public function __destruct(){
        //析構方法，對象銷毀時自動調用該方法
        echo ‘析構方法運行了<br>‘;
    }
    public function __clone(){
        //克隆方法，克隆對象時自動調用該方法
        echo ‘克隆方法運行了<br>‘;
    }
}


$c = new ClassName(‘test‘);        //
 
對象實例化
echo $c->var.‘<br>‘;            //訪問對象屬性$obj->var
$c->var = ‘update‘;                //修改對象屬性
$c->new_var = ‘add‘;            //新增對象屬性
var_dump($c);echo ‘<br>‘;        
unset($c->new_var);                //刪除對象屬性
var_dump($c);echo ‘<br>‘;        
$c->fn0();                        //調用成員方法
echo ClassName::PI.‘<br>‘;         //訪問類常量，使用:類名::類常量名
echo ClassName::$s_var.‘<br>‘;    //訪問靜態屬性，使用:類名::$靜態屬性名
ClassName::fn1();                //調用靜態方法

3、成員修飾符

3.1、關鍵字：

類常量，不可修改性const（修飾屬性）,類常量只能通過類訪問：類名加範圍解析操作符（雙冒號::）
靜態成員-static（修飾屬性和方法），靜態成員只能通過類訪問
不可繼承性final（修飾類和方法）

3.2、訪問控制符

public：表示公有的，其修飾的屬性和方法可以在類內和類外訪問，可以被繼承
protected：表示受保護的，，其修飾的屬性和方法只可以在類內訪問，可以被繼承
privated：表示私有的，其修飾的屬性和方法只可以在類內訪問，不可以被繼承

屬性前一定要加一個訪問控制修飾符，類常量不用加訪問控制修飾符，方法前可以不加訪問控制修飾符，默認是public

4、對象值傳遞

對象的賦值操作是引用賦值，即：當將對象a的值賦值給對象b時，a和b指向內存中同一個地址

如果需要實現真正的復制，可以使用對象克隆方法：$b = clone $a;

私有化__clone方法可以禁止對象被克隆：private function __clone(){}

5、類的加載

類的訪問必須保證類在內存中已經存在，所有在使用類之前需要將包含類的PHP文件加載到內存，本質是文件加載。

手動加載：

if(!class_exists(‘Man‘)){
    //類不存在，加載
    include_once ‘Man.php‘;
}
new Man();

自動加載：

php7以前：

function __autoload($class_name){
    //假設有多個類放在多個文件夾中
    //先嘗試去a文件夾中尋找類
    $file = ‘a/‘.$class_name.‘.class.php‘;
    if(file_exists($file)){
        include_once $file;
        exit;
    }
    //再嘗試去b文件夾中尋找類
    $file = ‘b/‘.$class_name.‘.class.php‘;
    if(file_exists($file)){
        include_once $file;
        exit;
    }
    //以此類推，直到找到類或找完所有包含類的文件夾為止
}
$d = new Dog();   //實例化Dog類，系統自動調用__autoload函數

php7以後：

function my_autoload($class_name){
    $file = ‘a/‘.$class_name.‘.class.php‘;
    if(file_exists($file)){
        include_once $file;
        exit;
    }
    $file = ‘b/‘.$class_name.‘.class.php‘;
    if(file_exists($file)){
        include_once $file;
        exit;
    }
}
spl_autoload_register(‘my_autoload‘);
$d = new Dog(); 

也可以分開多個加載函數：

function a_autoload($class_name){
    $file = ‘a/‘.$class_name.‘.class.php‘;
    if(file_exists($file)){
        include_once $file;
    }
}
function b_autoload($class_name){
    $file = ‘b/‘.$class_name.‘.class.php‘;
    if(file_exists($file)){
        include_once $file;
    }
}
spl_autoload_register(‘a_autoload‘);
spl_autoload_register(‘b_autoload‘);
$d = new Dog();   

自動加載類：

class Autoload{
    public static function loadA($class_name){
        $file = ‘a/‘.$class_name.‘.class.php‘;
        if(file_exists($file)){
            include_once $file;
        }
    }
    public static function loadB($class_name){
        $file = ‘b/‘.$class_name.‘.class.php‘;
        if(file_exists($file)){
            include_once $file;
        }
    }
}
spl_autoload_register(array(‘Autoload‘,‘loadA‘));
spl_autoload_register(array(‘Autoload‘,‘loadB‘));
$d = new Dog(); 

6、設計模式

單例模式：一個類有且僅有一個對象，例如操作系統中的資源管理器，目的是為了保護資源的唯一性

class Singleton{
    //使用一個靜態屬性保存生產出來的對象
    private static $object = NULL;
    //私有化構造方法
    private function __construct(){}
    //類入口
    public static function getInstance(){
        if(!(self::$object instanceof self)){
            self::$object = new self();
        }
        return self::$object;
    }
    //私有化克隆方法，防止克隆產生新對象
    private function __clone(){}
}
//實例化兩個對象
$s = Singleton::getInstance();
$s1 = Singleton::getInstance();
var_dump($s,$s1);    //檢測到是同一個對象

工廠模式factory：

由一個地方生產對象，其他位置就不需要額外實例化對象，從而可以方便後期代碼統一維護（改名），方便隱藏真實的類結構。

工廠模式針對相似模型的統一產出，要有一批具有類似功能的類，其本質是相似的大類下的小類

靜態工廠（生產對象時需要知道類名）：

class Man{
    public function display(){
        echo ‘Man<br>‘;
    }
}
class Woman{
    public function display(){
        echo ‘Woman<br>‘;
    }
}
class Child{
    public function display(){
        echo ‘Child<br>‘;
    }
}
class HumanFactory{
    public static function getInstance($class_name){
        return new $class_name();
    } 
}
$m = HumanFactory::getInstance(‘Man‘);
$w = HumanFactory::getInstance(‘Woman‘);
$c = HumanFactory::getInstance(‘Child‘);
$m->display();
$w->display();
$c->display();

匿名工廠（生產對象時需要知道類名對應的符號）：

class HumanFactory{
    public static function getInstance($flag){
        switch ($flag) {
            case ‘m‘:
                return new Man();
            case ‘w‘:
                return new Woman();
            case ‘c‘:
                return new Child();
            default:
                return null;
        }
        
    } 
}
$m = HumanFactory::getInstance(‘m‘);
$w = HumanFactory::getInstance(‘w‘);
$c = HumanFactory::getInstance(‘c‘);

PHP面向對象編程入門