PHP全棧學習筆記8

時間  2019-12-08
標籤 php 學習 筆記 欄目 PHP 简体版
原文   原文鏈接

PHP全棧學習筆記8

面向對象的基本概念，面向對象編程，oop，面向對象，面向對象的分析，面向對象的設計，面向對象的編程，什麼是類。php

類，屬性和方法，類，對象，面向對象編程的三大特色。特色，封裝性，繼承性，多態性。css

封裝性，也能夠稱爲信息隱藏。
繼承性就是派生類（子類）自動繼承一個或多個基類（父類）中的屬性與方法，並能夠重寫或添加新的屬性或方法。
多態性是指同一個類的不一樣對象，使用同一個方法能夠得到不一樣的結果，這種技術稱爲多態性。html

類的定義，成員方法，類的實例化，成員變量，類常量，構造方法和析構方法，繼承和多態的實現，數據的隱藏，靜態變量。數據庫

類的定義：編程

<?php
class SpoObject{            //定義類
    //…
}
?>

成員方法：數組

<?php
    class SportObject{
        function beatBasketball()($name,$height,$avoirdupois,$age,$sex){    //聲明成員方法
            echo "姓名：".$name;   //方法實現的功能
    
        }
    }
?>

類的實例化:dom

對象名 -> 成員方法

成員變量
類中的變量，也稱爲成員變量函數

關鍵字 成員變量名
對象名 -> 成員變量oop

類常量
常量就是不會改變的量，是一個恆值。
定義常量使用關鍵字const
輸出格式：學習

類名::常量名

構造方法和析構方法

void __construct([mixed args [,…]])
void __destruct ( void )

示例：

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>成員變量</title>
<style type="text/css">
<!--
body,td,th {
    font-size: 12px;
}
body {
    margin-left: 10px;
    margin-top: 10px;
    margin-right: 10px;
    margin-bottom: 10px;
}
-->
</style></head>
<body>
<?php
class SportObject{
    public $name;                               //定義成員變量
    public $height;                             //定義成員變量
    public $avoirdupois;                        //定義成員變量
    
    public function bootFootBall($name,$height,$avoirdupois){               //聲明成員方法
        $this->name=$name;
        $this->height=$height;
        $this->avoirdupois=$avoirdupois;
        if($this->height<185 and $this->avoirdupois<85){
            return $this->name."，符合踢足球的要求!";            //方法實現的功能
        }else{
            return $this->name."，不符合踢足球的要求!";           //方法實現的功能
        }
    }
}
$sport=new SportObject();           //實例化類，並傳遞參數
echo $sport->bootFootBall('1','185','80');                              //執行類中的方法
?>

</body>
</html>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>成員方法</title>
<style type="text/css">
<!--
body,td,th {
    font-size: 12px;
}
body {
    margin-left: 10px;
    margin-top: 10px;
    margin-right: 10px;
    margin-bottom: 10px;
}
-->
</style></head>
<body>
<?php
    class SportObject{
        function beatBasketball($name,$height,$avoirdupois,$age,$sex){              //聲明成員方法
            if($height>180 and $avoirdupois<=100){
                return $name."，符合打籃球的要求!";          //方法實現的功能
            }else{
                return $name."，不符合打籃球的要求!";         //方法實現的功能
            }
        }
    }
    $sport=new SportObject();
    echo $sport->beatBasketball('1','185','80','20週歲','男');
?>
</body>
</html>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>常量</title>
<style type="text/css">
<!--
body,td,th {
    font-size: 12px;
}
body {
    margin-left: 10px;
    margin-top: 10px;
    margin-right: 10px;
    margin-bottom: 10px;
}
-->
</style></head>
<body>
<?php
class SportObject{
    const BOOK_TYPE = '計算機圖書';
    public $object_name;                        //圖書名稱
    function setObjectName($name){              //聲明方法setObjectName()
        $this -> object_name = $name;           //設置成員變量值
    }
    function getObjectName(){                   //聲明方法getObjectName()
        return $this -> object_name;
    }
}
$c_book = new SportObject();                        //實例化對象
$c_book -> setObjectName("PHP類");               //調用方法setObjectName
echo SportObject::BOOK_TYPE."->";                   //輸出常量BOOK_TYPE
echo $c_book -> getObjectName();                //調用方法getObjectName
?>
</body>
</html>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>構造方法</title>
<style type="text/css">
<!--
body,td,th {
    font-size: 12px;
}
body {
    margin-left: 10px;
    margin-top: 10px;
    margin-right: 10px;
    margin-bottom: 10px;
}
-->
</style></head>
<body>
<?php
class SportObject{
    public $name;                               //定義成員變量
    public $height;                             //定義成員變量
    public $avoirdupois;                        //定義成員變量
    public $age;                                //定義成員變量
    public $sex;                                //定義成員變量
    public function __construct($name,$height,$avoirdupois,$age,$sex){              //定義構造方法
        $this->name=$name;                      //爲成員變量賦值
        $this->height=$height;                  //爲成員變量賦值
        $this->avoirdupois=$avoirdupois;        //爲成員變量賦值
        $this->age=$age;                        //爲成員變量賦值
        $this->sex=$sex;                        //爲成員變量賦值
    }
    public function bootFootBall(){             //聲明成員方法
        if($this->height<185 and $this->avoirdupois<85){
            return $this->name."，符合踢足球的要求!";            //方法實現的功能
        }else{
            return $this->name."，不符合踢足球的要求!";           //方法實現的功能
        }
    }
}
$sport=new SportObject('1','185','80','20','男');            //實例化類，並傳遞參數
echo $sport->bootFootBall();                                //執行類中的方法

?>

</body>
</html>

析構方法，是對象被銷燬時被調用的，做用是釋放內存。

void __destruct ( void )
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>析構方法</title>
</head>
<body>
<?php
class SportObject{
    public $name;                               //定義成員變量
    public $height;                             //定義成員變量
    public $avoirdupois;                        //定義成員變量
    public $age;                                //定義成員變量
    public $sex;                                //定義成員變量
    public function __construct($name,$height,$avoirdupois,$age,$sex){              //定義構造方法
        $this->name=$name;                      //爲成員變量賦值
        $this->height=$height;                  //爲成員變量賦值
        $this->avoirdupois=$avoirdupois;        //爲成員變量賦值
        $this->age=$age;                        //爲成員變量賦值
        $this->sex=$sex;                        //爲成員變量賦值
    }
    public function bootFootBall(){             //聲明成員方法
        if($this->height<185 and $this->avoirdupois<85){
            return $this->name."，符合踢足球的要求!";            //方法實現的功能
        }else{
            return $this->name."，不符合踢足球的要求!";           //方法實現的功能
        }
    }
    function __destruct(){
        echo "<p><b>對象被銷燬，調用析構函數。</b></p>";
    }
}
$sport=new SportObject('1','185','80','20','男');            //實例化類，並傳遞參數
//unset($sport);    

?>
</body>
</html>

繼承和多態的實現

全部成員變量和方法
構造函數
先調用子類中的方法
去調用父類中的構造方法

class subClass extends superClass{
…
}

多態存在兩種形式：覆蓋和重載。

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>繼承的實現</title>
<style type="text/css">
</head>
<body>
<?php
/*  父類  */
class SportObject{
    public $name;                               //定義姓名成員變量
    public $age;                                //定義年齡成員變量
    public $avoirdupois;                        //定義體重成員變量
    public $sex;                                //定義性別成員變量
    public function __construct($name,$age,$avoirdupois,$sex){              //定義構造方法
        $this->name=$name;                      //爲成員變量賦值
        $this->age=$age;                        //爲成員變量賦值
        $this->avoirdupois=$avoirdupois;        //爲成員變量賦值
        $this->sex=$sex;                        //爲成員變量賦值
    }
    function showMe(){                          //定義方法
        echo '這句話不會顯示。';
    }
}
/*  子類BeatBasketBall  */
class BeatBasketBall extends SportObject{               //定義子類，繼承父類
    public $height;                                     //定義身高成員變量
    function __construct($name,$height){                //定義構造方法
        $this -> height = $height;                      //爲成員變量賦值
        $this -> name = $name;                          //爲成員變量賦值
    }
    function showMe(){                                  //定義方法
        if($this->height>185){
            return $this->name."，符合打籃球的要求!";            //方法實現的功能
        }else{
            return $this->name."，不符合打籃球的要求!";           //方法實現的功能
        }
    }
}
/*  子類WeightLifting  */
class WeightLifting extends SportObject{                        //繼承父類
    function showMe(){                                          //定義方法
        if($this->avoirdupois<85){
            return $this->name."，符合舉重的要求!";             //方法實現的功能
        }else{
            return $this->name."，不符合舉重的要求!";            //方法實現的功能
        }
    }
}


//實例化對象
$beatbasketball = new BeatBasketBall('','190');             //實例化子類
$weightlifting = new WeightLifting('','185','80','20','男');
echo $beatbasketball->showMe()."<br>";                          //輸出結果
echo $weightlifting->showMe()."<br>";
?>
</body>
</html>

繼承的實現

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>繼承的實現</title>
<style type="text/css">
</head>
<body>
<?php
/*  父類  */
class SportObject{
    public $name;                               //定義姓名成員變量
    public $age;                                //定義年齡成員變量
    public $avoirdupois;                        //定義體重成員變量
    public $sex;                                //定義性別成員變量
    public function __construct($name,$age,$avoirdupois,$sex){              //定義構造方法
        $this->name=$name;                      //爲成員變量賦值
        $this->age=$age;                        //爲成員變量賦值
        $this->avoirdupois=$avoirdupois;        //爲成員變量賦值
        $this->sex=$sex;                        //爲成員變量賦值
    }
    function showMe(){                          //定義方法
        echo '這句話不會顯示。';
    }
}
/*  子類BeatBasketBall  */
class BeatBasketBall extends SportObject{               //定義子類，繼承父類
    public $height;                                     //定義身高成員變量
    function __construct($name,$height){                //定義構造方法
        $this -> height = $height;                      //爲成員變量賦值
        $this -> name = $name;                          //爲成員變量賦值
    }
    function showMe(){                                  //定義方法
        if($this->height>185){
            return $this->name."，符合打籃球的要求!";            //方法實現的功能
        }else{
            return $this->name."，不符合打籃球的要求!";           //方法實現的功能
        }
    }
}
/*  子類WeightLifting  */
class WeightLifting extends SportObject{                        //繼承父類
    function showMe(){                                          //定義方法
        if($this->avoirdupois<85){
            return $this->name."，符合舉重的要求!";             //方法實現的功能
        }else{
            return $this->name."，不符合舉重的要求!";            //方法實現的功能
        }
    }
}


//實例化對象
$beatbasketball = new BeatBasketBall('','190');             //實例化子類
$weightlifting = new WeightLifting('','185','80','20','男');
echo $beatbasketball->showMe()."<br>";                          //輸出結果
echo $weightlifting->showMe()."<br>";
?>
</body>
</html>

重載:
傳遞的參數個數不一樣，調用不一樣的方法，返回不一樣的值。

<?php 
    class C{
        function __call($name,$num){        //調用不存在的方法
        echo "方法名稱：" . $name . "<p>";       //輸出方法名
        echo "參數存在個數：" . count($num) . "<p>";   //輸出參數個數
            if (count($num) == 1){  //根據參數個數調用不一樣的方法
                echo $this->list1($a);  
            }
            if (count($num) == 2){  //根據參數個數調用不一樣的方法
                echo $this->list2($a,$b);
            }
        }
        public function list1($a){      //定義方法
            return "這是list1函數";
        }
        public function list2($a,$b){   //定義方法
            return "這是list2函數";
        }
    }
$a = new C;                 //類的實例化
$a->listshow(1,2);              //調用方法，傳遞參數
?>
關鍵字::變量名/常量名/方法名
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>僞變量$this</title>
</head>
<body>
<?php
    class example{
        function exam(){
            if(isset($this)){
                echo '$this的值爲：'.get_class($this);
            }else{
                echo '$this未定義';
            }
        }
    }
    $class_name = new example();
    $class_name->exam();
?>
</body>
</html>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>「::」操做符</title>
</head>
<body>
<?php
class Book{
    const NAME = 'computer';                            //常量NAME
    function __construct(){                             //構造方法
        echo '本月圖書類冠軍爲：'.Book::NAME.' ';        //輸出默認值
    }
}
class l_book extends Book{                              //Book類的子類
    const NAME = 'foreign language';                    //聲明常量
    function __construct(){                             //子類的構造方法
        parent::__construct();                          //調用父類的構造方法
        echo '本月圖書類冠軍爲：'.self::NAME.' ';        //輸出本類中的默認值
    }
}
$obj = new l_book();                                    //實例化對象
?>
</body>
</html>

parent: 能夠調用父類中的成員變量，成員方法和常量。

self:能夠調用當前類中的靜態成員和常量。

類名:能夠調用本類中的變量，常量和方法。

數據隱藏

public（公共成員）
private（私有成員）
protected（保護成員）

public, private, protected, static, final

靜態變量（方法）

關鍵字::靜態成員
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>private關鍵字</title>
</head>
<body>
<?php
class Book{
    private $name = 'computer';                         //聲明私有變量$name
    public function setName($name){                     //設置私有變量
        $this -> name = $name;
    }
    public function getName(){                          //讀取私有變量
        return $this -> name;
    }
}
class LBook extends Book{                               //Book類的子類  
}
$lbook = new LBook();                                   //實例化對象
echo '正確操做私有變量的方法：';
$lbook -> setName("PHP");                   //對私有變量進行操做
echo $lbook -> getName();
echo '<br>直接操做私有變量的結果：';                    //對私有變量進行操做
echo Book::$name;
?>
</body>
</html>

private只能在所屬類的內部被調和修改，不能夠在類外被訪問。

protected修飾的類成員，能夠在本類和子類中被調用，其餘地方不能夠被調用。

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>protected關鍵字</title>
</head>
<body>
<?php
class Book{
    protected $name = 'computer';                       //聲明保護變量$name
}
class LBook extends Book{                               //Book類的子類
    public function showMe(){
        echo '對於protected修飾的變量，在子類中是能夠直接調用的。如：$name = '.$this -> name;
    }
}
$lbook = new LBook();                                   //實例化對象
$lbook -> showMe();
echo '<p>但在其餘的地方是不能夠調用的，不然：';           //對私有變量進行操做
$lbook -> name = 'history';
?>
</body>
</html>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>protected關鍵字</title>
</head>
<body>
<?php
class Book{
    protected $name = 'computer';                       //聲明保護變量$name
}
class LBook extends Book{                               //Book類的子類
    public function showMe(){
        echo '對於protected修飾的變量，在子類中是能夠直接調用的。如：$name = '.$this -> name;
    }
}
$lbook = new LBook();                                   //實例化對象
$lbook -> showMe();
echo '<p>但在其餘的地方是不能夠調用的，不然：';           //對私有變量進行操做
$lbook -> name = '會報錯，這裏就錯了';
?>
</body>
</html>

靜態變量：

關鍵字::靜態成員

self，在類內部調用 靜態成員所使用

在靜態方法中，只能調用靜態變量，不能調用普通變量，而普通方法能夠調用靜態變量。

對象被銷燬後，仍然保存被修改的靜態數據。

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>靜態變量的使用</title>
</head>
<body>
<?php
class Book{                                     //Book類
    static $num = 0;                            //聲明一個靜態變量$num，初值爲0
    public function showMe(){                   //申明一個方法
        echo '您是第'.self::$num.'位訪客';        //輸出靜態變量
        self::$num++;                           //將靜態變量加1
    }
}
$book1 = new Book();                            //實例化對象$book1
$book1 -> showMe();                             //調用showMe()方法
echo "<br>";
$book2 = new Book();                            //實例化對象$book2;
$book2 -> showMe();                             //再次調用showMe()方法
echo "<br>";
echo '您是第'.Book::$num.'爲訪客';                //直接使用類名調用靜態變量
?>
</body>
</html>

運行效果是：

您是第0位訪客
您是第1位訪客
您是第2位訪客

對象的高級應用

final關鍵字，抽象類，接口的使用，克隆對象，對象比較，對象類型檢測，魔術方法。

不能夠被繼承，不能有子類
final class class_name{
//…
}

final function method_name() 不能夠重寫和覆蓋
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>final類</title>
></head>
<body>
<?php
    final class SportObject{
        function  __construct(){
            echo '不能被繼承，不能有子類';
        }
    }
    class MyBook extends SportObject{
        static function exam(){
            echo "會報錯的";
        }
    }
    MyBook::exam();
?>
</body>
</html>

抽象類，是不能被實例化的類，只能做爲父類來使用:

abstract class AbstractName{
…
}

抽象類，同樣有成員變量，成員方法，抽象類至少包含一個抽象方法，抽象方法沒有方法體，其功能在子類完成。

abstract function abstractName();
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>抽象類</title>
</head>
<body>
<?php
    abstract class CommodityObject{                         //定義抽象類
        abstract function service($getName,$price,$num);    //定義抽象方法
    }
    class MyBook extends CommodityObject{               //定義子類，繼承抽象類
        function service($getName,$price,$num){     //定義方法
            echo '您購買的商品是'.$getName.'，該商品的價格是：'.$price.' 元。';
            echo '您購買的數量爲：'.$num.' 本。';
            echo '如發現缺頁，請在3日內更換。';
        }
    }
    class MyComputer extends CommodityObject{           //定義子類繼承父類
        function service($getName,$price,$num){         //定義方法
            echo '您購買的商品是'.$getName.'，該商品的價格是：'.$price.' 元。';
            echo '您購買的數量爲：'.$num.' 臺。';
            echo '如發生非人爲質量問題，請在3個月內更換。';
        }
    }
    $book = new MyBook();                   //實例化子類
    $computer = new MyComputer();           //實例化子類
    $book -> service('PHP',5,3);    //調用方法
    echo '<p>';
    $computer -> service('XX本',800,1);      //調用方法
    
    
?>
</body>
</html>

接口

interface InterfaceName{
    function interfaceName1();
    function interfaceName2();
    …
}

class SubClass implements InterfaceName1，InterfaceName2{
    function interfaceName1(){  //功能實現
}
    function interfaceName2(){  //功能實現
}
    …
}
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>接口</title>
</head>
<body>
<?php
    interface MPopedom{
        function popedom();
    }
    interface MPurview{
        function purview();
    }
    class Member implements MPurview{
        function purview(){
            echo '會員';
        }
    }
    class Manager implements MPurview,MPopedom{
        function purview(){
            echo '管理員擁有所有權限。';
        }
        function popedom(){
            echo '管理員尚未的權限';
        }
    }
    $member = new Member();
    $manager = new Manager();
    $member -> purview();
    echo '<p>';
    $manager -> purview();
    $manager ->popedom();
?>
</body>
</html>

克隆對象

$object1 = new ClassName();
$object2 = clone $object1;

__clone()方法,調用__clone()方法，能夠克隆出來的對象的一些行爲及屬性

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>對象的引用</title>
</head>
<body>
<?php
class SportObject{                                  //類SportObject
    private $object_type = 'book';              //聲明私有變量$object_type，並賦初值等於「book」
    public function setType($type){             //聲明成員方法setType，爲變量$object_type賦值
        $this -> object_type = $type;
    }
    public function getType(){                  //聲明成員方法getType，返回變量$object_type的值
        return $this -> object_type;
    }
}
$book1 = new SportObject();                     //實例化對象$book1
$book2 = $book1;                                //使用普通數據類型的方法給對象$book2賦值
$book2 -> setType('computer');                  //改變對象$book2的值
echo '對象$book1的值爲：'.$book1 -> getType();    //輸出對象$book1的值
?>

</body>
</html>

對象比較
兩個等號「==」是比較兩個對象的內容
3個等號「===」是比較對象的引用地址

對象類型檢測
instanceof操做符能夠檢測當前對象是屬於哪一個類

ObjectName instanceof ClassName

魔術方法

__construct()、__destruct()和__clone()
__set()和__get()方法
__call()方法
__sleep()和__wakeup()方法
__toString()方法
__autoload()方法

__call()方法包含兩個參數，即方法名和方法參數
方法參數是以數組形式存在的

_set()方法包含兩個參數，分別表示變量名稱和變量值

__get()方法有一個參數，表示要調用的變量名

使用serialize()函數能夠實現序列化對象
unserialize()函數能夠從新還原一個被serialize()函數序列化的對象

__sleep()方法能夠清除對象並返回一個該對象中全部變量的數組

__wakeup()方法則是恢復在序列化中可能丟失的數據庫鏈接及相關工做

__toString()方法將對象轉化爲字符串

對象的比較

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>對象的比較</title>
</head>
<body>
<?php
    class SportObject{
        private $name;
        function __construct($name){
            $this -> name = $name;
        }
    }
    $book = new SportObject('book');
    $cloneBook = clone $book;
    $referBook = $book;
    if($cloneBook == $book){
        echo '兩個對象的內容相等<br>';
    }
    if($referBook === $book){
        echo '兩個對象的引用地址相等<br>';
    }
?>
</body>
</html>

對象的比較

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>對象的比較</title>
</head>
<body>
<?php
    class SportObject{
        private $name;
        function __construct($name){
            $this -> name = $name;
        }
    }
    $book = new SportObject('book');
    $cloneBook = clone $book;
    $referBook = $book;
    if($cloneBook == $book){
        echo '兩個對象的內容相等<br>';
    }
    if($referBook === $book){
        echo '兩個對象的引用地址相等<br>';
    }
?>
</body>
</html>

對象類型檢測

instanceof操做符能夠檢測當前對象是屬於哪一個類

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>對象類型檢測</title>
</head>
<body>
<?php
class SportObject{}
class MyBook extends SportObject{
    private $type;
}
$cBook = new MyBook();
if($cBook instanceof MyBook)
    echo '對象$cBook屬於MyBook類<br>';
if($cBook instanceof SportObject)
    echo '對象$cBook屬於SportObject類<br>';
?>
</body>
</html>

測試結果：

對象$cBook屬於MyBook類

對象$cBook屬於SportObject類

魔術方法：
__set()和__get()方法

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>__set()和__get()方法</title>
</head>
<body>
<?php
class SportObject
{
    private $type = ' ';
    public function getType(){
        return $this -> type;
    }
    private function __get($name){
        if(isset($this ->$name)){
            echo '變量'.$name.'的值爲：'.$this -> $name.'<br>';
        }
        else{
            echo '變量'.$name.'未定義，初始化爲0<br>';
            $this -> $name = 0;
        }
    }
    private function __set($name, $value){
        if(isset($this -> $name)){
            $this -> $name = $value;    
            echo '變量'.$name.'賦值爲：'.$value.'<br>';
        }else{
            $this -> $name = $value;
            echo '變量'.$name.'被初始化爲：'.$value.'<br>';
        }
    }
}
$MyComputer = new SportObject();
$MyComputer -> type = 'DIY';
$MyComputer -> type;
$MyComputer -> name;
?> 
</body>
</html>

變量type賦值爲:DIY
變量type的值爲:DIY
變量name未定義，初始化爲0
變量name被初始化爲：0

__call()方法

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>__call()方法</title>
</head>
<body>
<?php
class SportObject
{
    public function myDream(){
        echo '調用的方法存在，直接執行此方法。<p>';
    }
    public function __call($method, $parameter)
    {
        echo '若是方法不存在，則執行__call()方法。<br>';
        echo '方法名爲：'.$method.'<br>';
        echo '參數有：';
        var_dump($parameter);
    }
}
$MyLife = new SportObject();
$MyLife -> myDream();
$MyLife -> mDream('how','what','why');
?> 
</body>
</html>

__sleep()和__wakeup()方法

__sleep()方法能夠清除對象並返回一個包含對象中全部變量的數組。

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>__sleep()和__wakeup()方法</title>
</head>
<body>
<?php
class SportObject{
    private $type = 'DIY';
    public function getType(){
        return $this -> type;
    }
    public function __sleep(){
        echo '使用serialize()函數將對象保存起來，能夠存放到文本文件、數據庫等地方<br>';
        return $this;
    }
    public function __wakeup(){
        echo '當須要該數據時，使用unserialize()函數對已序列化的字符串進行操做，將其轉換回對象<br>';
    }
}
$myBook = new SportObject();
$i = serialize($myBook);
echo '序列化後的字符串：'.$i.'<br>';
$reBook = unserialize($i);
echo '還原後的成員變量：'.$reBook -> getType();
?> 
</body>
</html>

__toString()方法

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>__toString()方法</title>
</head>
<body>
<?php
class SportObject{
    private $type = 'DIY';
    public function __toString(){
        return $this -> type;
    }
}
$myComputer = new SportObject();
echo '對象$myComputer的值爲：';
echo  $myComputer;
?> 
</body>
</html>

__autoload()方法自動實例化須要使用的類

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>__autoload()方法自動實例化須要使用的類</title>
</head>
<body>
<?php
    function __autoload($class_name){
        $class_path = $class_name.'.class.php';
        if(file_exists($class_path)){
            include_once($class_path);
        }else
            echo '類路徑錯誤。';
    }
    $myBook = new SportObject("江山代有人才出　各領風騷數百年");
    echo $myBook;
?>
</body>
</html>

<?php
class SportObject{
    private $cont;
    public function __construct($cont){
        $this -> cont = $cont;
    }
    public function __toString(){
        return $this -> cont;
    }
}
?>

中文字符串的截取類

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>中文字符串的截取類</title>
</head>
<body>
<?php 
class MsubStr{
    function csubstr($str, $start, $len) {              //$str指的是字符串,$start指的是字符串的起始位置，$len指的是長度。
    $strlen = $start + $len;                            //用$strlen存儲字符串的總長度（從字符串的起始位置到字符串的總長度）
    for($i = 0; $i < $strlen; $i ++) {                  //經過for循環語句,循環讀取字符串
        if (ord ( substr ( $str, $i, 1 ) ) > 0xa0) {    //若是字符串中首個字節的ASCII序數值大於0xa0,則表示爲漢字
            $tmpstr .= substr ( $str, $i, 2 );          //每次取出兩位字符賦給變量$tmpstr，即等於一個漢字
            $i ++;                                      //變量自加1
        } else {                                        //若是不是漢字，則每次取出一位字符賦給變量$tmpstr
            $tmpstr .= substr ( $str, $i, 1 );
        }
    }
    return $tmpstr;                                     //輸出字符串
    }
}
$mc=new MsubStr();                                      //類的實例化
?> 
<table width="204" height="195" border="0" cellpadding="0" cellspacing="0" background="images/bg.JPG">
  <tr>
    <td width="25" height="37">&nbsp;</td>
    <td width="157">&nbsp;</td>
    <td width="22">&nbsp;</td>
  </tr>
  <tr>
    <td height="30">&nbsp;</td>
    <td><?php 
            $string="關注！";
            if(strlen($string)>10){
                echo substr($string,0,9)."...";
            }else{
                echo $string;
            }
        ?>
    </td>
    <td>&nbsp;</td>
  </tr>
  <tr>
    <td height="30">&nbsp;</td>
    <td><?php 
            $string="關注";
            if(strlen($string)>10){
                echo substr($string,0,9)."...";
            }else{
                echo $string;
            }
        ?></td>
    <td>&nbsp;</td>
  </tr>
  <tr>
    <td height="30">&nbsp;</td>
    <td>
        <?php 
            $strs="關注";
            if(strlen($string)>10){
                echo $mc ->csubstr($strs, "0" , "9")."...";
            }else{
                echo $strs;
            }
        ?>
    </td>
    <td>&nbsp;</td>
  </tr>
  <tr>
    <td height="30">&nbsp;</td>
    <td><?php 
            $strs="關注";
            if(strlen($string)>30){
                echo $mc ->csubstr($strs, "0" , "20")."...";
            }else{
                echo $strs;
            }
        ?>
    </td>
    <td>&nbsp;</td>
  </tr>
  <tr>
    <td height="38">&nbsp;</td>
    <td>&nbsp;</td>
    <td>&nbsp;</td>
  </tr>
</table>
</body>
</html>

<?php 
class MsubStr{
    function csubstr($str, $start, $len) { //$str指的是字符串,$start指的是字符串的起始位置，$len指的是長度。
    $strlen = $start + $len; //用$strlen存儲字符串的總長度（從字符串的起始位置到字符串的總長度）
    for($i = 0; $i < $strlen; $i ++) { //經過for循環語句,循環讀取字符串
        if (ord ( substr ( $str, $i, 1 ) ) > 0xa0) { //若是字符串中首個字節的ASCII序數值大於0xa0,則表示爲漢字
            $tmpstr .= substr ( $str, $i, 2 ); //每次取出兩位字符賦給變量$tmpstr，即等於一個漢字
            $i ++; //變量自加1
        } else { //若是不是漢字，則每次取出一位字符賦給變量$tmpstr
            $tmpstr .= substr ( $str, $i, 1 );
        }
    }
    return $tmpstr; //輸出字符串
}
}

?>
<?php
class changecode{
    private $str;
    private $input;
    private $output;
    function __construct($input='',$output='gb2312'){
        $this->input = $input;
        $this->output = $output;
    }
    protected function chgcode($str){
        if($this->input != ''){
            $this->str = iconv($input,$output,$str);
        }else{
            $this->str = mb_convert_encoding($str,$output);
        }
    }
    function getStr($str){
        $this->chgcode($str);
        return $this->str;
    }
    function setInput($input){
        $this->input = $input;
    }
    function setOutput($output){
        $this->output = $output;
    }
    function getInput(){
        return $this->input;
    }
    function getOutput(){
        return $this->output;
    }
}
?>

結言

好了，歡迎在留言區留言，與你們分享你的經驗和心得。

感謝你學習今天的內容，若是你以爲這篇文章對你有幫助的話，也歡迎把它分享給更多的朋友，感謝。

感謝！承蒙關照！您真誠的讚揚是我前進的最大動力！

image

image

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程