關於【類】的有關題

時間 2019-11-30

標籤關於有關简体版

原文原文鏈接

一：類的定義php

1.求數據平均數的例子html

class Stat
{
    public static function getAvg ($arryNum) //定義靜態方法來求平均值
    {
        $totalNum = count($arryNum); //得到數字總數
        if ($totalNum == 0) { //若是數字個數爲0則返回null
            return null;
        } else {
            $sum = 0; //用變量$sum保存全部數字的和
            for ($i = 0; $i < $totalNum; $i ++) { //經過循環計算全部數字的和
                $sum += $arryNum[$i];
            }
            return $sum / $totalNum; //返回平均數
        }
    }
}

<?php 

   include 'Stat.php';  //包含數據統計類
    $arrayNum = explode(',', $_POST['nums']);   //將提交數字保存到數組中
    echo '該組數字的平均數爲' . Stat::getAvg($arrayNum);   //調用統計類的靜態方法getAvg()求平均數
}
?>

2.使用重載方法實現不一樣數據類型的運算數組

*創建父類，並在該類中定義統計方法execstat()方法，這個方法只有計算兩個數和的功能app

class StatParent //定義數據統計父類
{
    public function execStat ($var0, $var1) //定義數據統計方法
    {
        return intval($var0 + $var1); //返回2個數的和
    }
}

定義stat類繼承自statparent類，在該類中重寫統計方法execstat()，根據傳遞的數值，實現值類型的求和和字符串的拼接函數

<?php
require 'StatParent.php';
class Stat extends StatParent
{
    public function execStat ($var0, $var1) //重寫數據統計方法
    {
        return is_numeric($var0) && is_numeric($var1) ? intval($var0 + $var1) : $var0 . $var1; //若是爲數字則計算數字的和,不是數字則鏈接2個參數
    }
}

*is_numeric()方法用於判斷指定內容是否是數字類型或字符串類型post

<?php 
    require 'Stat.php';  //包含數值統計類
    $stat = new Stat();  //實例數值統計類
    echo '統計結果爲：' . $stat->execStat($_POST['txt1'], $_POST['txt2']);  //輸出統計結果
}
?>

3.使用$this關鍵字調用汽車類自身的方法學習

<?php
class Car //定義汽車類
{
    private $colorFlag; //顏色標識
    private $typeFlag; //類型標識
    public function __construct ($colorFlag, $typeFlag) //構造方法
    {
        $this->colorFlag = $colorFlag; //顏色標識初始化
        $this->typeFlag = $typeFlag; //類型標識初始化
    }
    public function getColor () //定義獲取顏色方法
    {
        switch ($this->colorFlag) { //使用switch語句根據不用顏色得到標識得到顏色
            case 0:
                $color = '紅色';
                break;
            case 1:
                $color = '白色';
                break;
            case 2:
                $color = '黑色';
                break;
            default:
                $color = '寶石藍';
        }
        return $color;
    }
    public function getType () //定義得到汽車類型方法
    {
        switch ($this->typeFlag) { //根據類型標識得到汽車類型
            case 0:
                $type = '奔馳';
                break;
            case 1:
                $type = '寶馬';
                break;
            case 2:
                $type = '奧迪';
                break;
            default:
                $type = '捷達';
        }
        return $type;
    }
    public function getInfo () //得到汽車信息
    {
        return '個人汽車是' . $this->getColor() . $this->getType(); //調用類內方法返回汽車信息
    }
}

<?php 
    require 'Car.php';  //包含汽車類
    $colorFlag = $_POST['color'];   //得到表單提交的顏色標識
    $typFlag = $_POST['type'];       //得到表單提交的類別標識
    $car = new Car($colorFlag, $typFlag);  //對汽車類進行實現化
    echo $car->getInfo();   //打印汽車信息
}
?>

*在類體內部，使用$this關鍵字訪問被private、protected、public所修飾的屬性和方法測試

4.使用self關鍵字調用學生類自身的靜態方法ui

<?php
class Student
{
    public static function study ()   //定義學習方法
    {
        return '學習';
    }
    public static function read ()    //定義讀書方法
    {
        return '讀書';
    }
    public function getAllMethod ()   //定義getAllMethod()來得到類中全部方法
    {
        return '學生能夠' . self::study() . '、' . self::read();
    }
}

 <?php
   $student = new Student();
   echo $student->getAllMethod(); 
   ?>

5.汽車類中的剎車方法和顏色屬性this

<?php 
class Car
{
    public $color;    //汽車顏色屬性
    
    public function __construct($color){   //構造方法
        $this->color = $color;  //汽車顏色初始化
    }
    
    public function stop(){    //定義汽車剎車方法
        return "汽車執行了剎車方法";
    }
}

<?php
$color = '紅色';
$car = new Car($color);
echo '汽車的顏色爲 － ' . $car->color.'<br/>';
echo '行駛過程當中 － ' . $car->stop();
?>

6.學生類中使用構造方法爲學生信息初始化

*構造方法是類中的一個特殊函數，當建立一個類的實例時，將會自動調用類的構造方法

構造方法沒有返回值類型和返回值，這是由於構造方法是在建立對象時自動調用的，並非一個獨立的函數，所以沒有返回值。

構造方法的主要功能是實現對類的初始化工做

創建一個二維數組，存數據

<?php
$students = array(
    0 => array('0312310', '小明', '16', '北京西城區') ,
    1 => array('0312311', '小張', '16', '北京宣武區') ,
    2 => array('0312312', '小趙', '17', '北京海淀區')
);

定義學生類

<?php
class Student
{
    private $id; //學生ID
    private $name; //學生名稱
    private $age; //學生年齡
    private $address; //學生住址
    public function __construct ($id, $name, $age, $address) //構造方法，對學生信息初始化
    {
        $this->id = $id;
        $this->name = $name;
        $this->age = $age;
        $this->address = $address;
    }
    public function getId () //得到學生ID
    {
        return $this->id;
    }
    public function getName () //得到學生名稱
    {
        return $this->name;
    }
    public function getAge () //得到學生年齡
    {
        return $this->age;
    }
    public function getAddress () //得到學生住址
    {
        return $this->address;
    }
}

用for循環，遍歷數據

<?php 
require 'arrayDb.php';
require 'Student.php';
$count = count($students);
?>    
<table border="0" align="center" cellpadding="0" cellspacing="1" bgcolor="#009933">
  <tr>
    <td width="100" height="22" bgcolor="#009933"><font color="#FFFFFF">學號</font></td>
    <td width="100" bgcolor="#009933"><font color="#FFFFFF">姓名</font></td>
    <td width="100" bgcolor="#009933"><font color="#FFFFFF">年齡</font></td>
    <td width="200" bgcolor="#009933"><font color="#FFFFFF">住址</font></td>
  </tr>
<?php 
for ($i=0; $i<$count; $i++){
    $stu = $students[$i];
    $student = new Student($stu[0], $stu[1], $stu[2], $stu[3]); 
?>  
  <tr>
    <td height="22" bgcolor="#FFFFFF"><?= $student->getId()?></td>
    <td bgcolor="#FFFFFF"><?= $student->getName()?></td>
    <td bgcolor="#FFFFFF"><?= $student->getAge()?></td>
    <td bgcolor="#FFFFFF"><?= $student->getAddress()?></td>
  </tr>
<?php 
}
?>  
</table>

7.圓類中使用const關鍵字定義圓周率常量

<?php
class Circle
{
    const PI = '3.14'; //定義圓周率爲3.14，也可使用pi()函數
    private $radius; //圓半徑
    public function __construct ($radius)
    { //構造方法，實現對圓半徑初始化
        $this->radius = $radius;
    }
    public function getArea ()
    { //獲取圓面積
        return self::PI * pow($this->radius, 2);
    }
}

<?php 

    require_once 'Circle.php';
    $circle = new Circle(2);
    echo '該圓的面積爲：'.$circle->getArea();

?>

*類常量屬於類自己並且區分大小寫，在類體內和靜態方法同樣，都使用self關鍵字加::對常量進行引用

*pow()方法：pow(x,y)，pow() 函數返回 x 的 y 次方。

二：類的訪問修飾符

8.public修飾，成爲公有方法和屬性，公有方法能夠被類實例的對象在類的內部和類的子類中調用

<?php
//定義汽車類Car
class Car
{
    public function run () //定義行駛方法
    {
        return '行駛';
    }
    public function getStatus () //定義返回汽車狀態方法
    {
        return '汽車目前正在' . $this->run();
    }
}
//定義小汽車類SmallCar，並使其繼承汽車類Car
class SmallCar extends Car
{
    public function smallCarRun () //定義小汽車行駛方法
    {
        return '小汽車' . $this->run();
    }
}

<?php 
require 'Car.php';
$car = new Car();
echo '（1）經過汽車類對象調用汽車類的行駛方法的結果：<br/>';
echo $car->run() . '<br/>';
echo '（2）經過汽車類的getStatus()方法調用汽車行駛方法的結果：<br/>';
echo $car->getStatus() . '<br/>';
echo '（3）經過汽車類的子類調用汽車類的汽車行駛方法的結果：<br/>';
$smallCar = new SmallCar();
echo $smallCar->smallCarRun() . '<br/>';
?>

9.使用private關鍵字定義汽車的顏色屬性

private修飾，成爲私有方法和屬性，私有方法能夠在類體內被調用，但不能夠被類實例的對象和類的子類所調用

<?php
class Car //定義汽車類Car
{
    private $color; //汽車顏色
    public function __construct ($color) //構造方法對類中屬性初始化
    {
        $this->color = $color; //汽車顏色初始化
    }
    public function getColor () //定義得到汽車顏色的方法
    {
        return $this->color; //返回汽車顏色
    }
}

<?php 
require 'Car.php';  //包含汽車類
$color = '紅色';   //指定汽車顏色
$car = new Car($color);   //對汽車類實例化
//echo '經過類實例的對象調用類的私有屬性的結果：<br/>';
//echo @'汽車顏色是：'.$car->color.'<br/>' or die('不能經過類的對象調用類中的私有方法<br/>');
echo '在類中的方法中調用類的私有屬性的結果：<br/>';
echo '汽車顏色是：'.$car->getColor().'<br/>';  //打印汽車顏色
?>

10.使用protected關鍵字定義汽車的保修年限

*protected修飾，成爲保護成員和方法，保護成員能夠在類體內以及類的子類中被調用，但不能夠在類體外被調用

<?php
class Car //定義汽車類Car
{
    protected $repairTime; //汽車保修時間屬性
    public function __construct ($repairTime) //構造方法對汽車的保修時間進行初始化
    {
        $this->repairTime = $repairTime;
    }
    public function getRepairTime () //得到汽車保修時間的方法
    {
        return $this->repairTime;
    }
}
class SmallCar extends Car //定義汽車類的子類SmallCar
{
    public function __construct ($repairTime)
    {
        parent::__construct($repairTime); //調用父類構造方法對保修時間屬性進行初始化
    }
    public function getSmallCarRepairTime () //調用父類的保修時間屬性
    {
        return $this->repairTime;
    }
}

<?php 
require 'Car.php';  //包含汽車類
$repairTime = 3;      //定義保修年限
$car = new Car($repairTime);   //對汽車類實例化
//echo '經過類實例的對象直接調用類中的保護成員的結果<br/>';
//echo '汽車保修年限爲：'.$car->repairTime.'年<br/>';
echo '在類體內調用保護成員的結果<br/>';
echo '汽車保修年限爲：'.$car->getRepairTime().'年<br/>';
echo '在類子類中調用保護成員的結果<br/>';
$repairTime = 5;      //定義保修年限
$smallCar = new SmallCar($repairTime);
echo '小汽車保修年限爲：'.$smallCar->getSmallCarRepairTime().'年<br/>';
?>

三：.類的繼承：經過類的繼承能夠擴展父類的功能

11.蘋果子類繼承水果父類

<?php
class Fruit //定義水果類
{
    private $color; //顏色屬性
    private $shape; //形狀屬性
    public function __construct ($color, $shape) //構造方法對水果類初始化
    {
        $this->color = $color;
        $this->shape = $shape;
    }
    public function getColor () //得到水果顏色
    {
        return $this->color;
    }
    public function getShape () //得到水果形狀
    {
        return $this->shape;
    }
}
class Apple extends Fruit //蘋果類繼承水果類
{
    public function __construct ($color, $shape) //構造方法對類進行初始化
    {
        parent::__construct($color, $shape);
    }
}

 <?php 
   require 'Fruit.php';
   $apple = new Apple($_POST['color'], $_POST['shape']);
   echo '　　<font color="blue">我看見的蘋果是：'.$apple->getColor().'，'.$apple->getShape().'的</font>';
   ?>

*final關鍵字：若是父類中使用final關鍵字修飾的方法，在子類中是不能被重寫的。若是一個類使用final修飾，則該類不能被繼承

12.使用parent關鍵字調用父類的方法

*使用parent關鍵字不只能夠調用父類的普通方法，並且能夠經過調用父類的構造方法實現對父類的初始化。

*parent關鍵字不只能夠調用父類的普通成員，並且能夠加「：：」調用父類的靜態成員。

<?php
class Car //定義汽車類
{
    public function run () //定義行駛方法
    {
        return '行駛';
    }
}
class SmallCar extends Car //定義小汽車類，使之繼承自汽車類
{
    public function smallCarRun () //定義小汽車行駛方法
    {
        return '小汽車能夠' . parent::run();
    }
}

<?php
require 'Car.php';  //包含汽車類
$car = new Car();  //對汽車類進行實例化
echo $car->run() . '<br/>'; //調用汽車類行駛方法
$smallCar = new SmallCar();  //實例小汽車類
echo $smallCar->smallCarRun();  //調用小汽車類的行駛方法
?>

13.蘋果子類中覆蓋水果父類的方法

<?php
class Fruit //定義水果類
{
    public function getColor () //得到水果顏色
    {
        return '不一樣的水果顏色不一樣，沒法肯定';
    }
}
class Apple extends Fruit //蘋果類繼承水果類
{
    private $color; //定義蘋果顏色屬性
    public function __construct ($color) //構造方法對類進行初始化
    {
        $this->color = $color;
    }
    public function getColor () //得到水果顏色
    {
        return '蘋果的顏色是' . $this->color;
    }
}

 <?php 
require 'Fruit.php';
$fruit = new Fruit();
echo $fruit->getColor().'<br/>';
$apple = new Apple('紅色');
echo $apple->getColor();
   ?>

四：抽象類和接口

*抽象類：不能被實例化，只能被其餘類所繼承。抽象類的定義是在class前面加abstract。

*接口是爲了實現一種特定功能而預留的相似類的一種類型，只容許定義常量和方法，而且這裏的方法沒有任何的功能實現。

14.美食抽象類

<?php
abstract class Food //美食類
{
    private $material; //烹製材料
    public function __construct ($material) //父類構造方法
    {
        $this->material = $material;
    }
    public function getMaterial () //得到美食材料方法
    {
        return $this->material;
    }
}
class Bread extends Food //麪包類繼承美食類
{
    public function __construct ($material) //子類構造方法
    {
        parent::__construct($material);
    }
}

 <?php 
require 'Food.php';
$material = '麪粉';
//$food = new Food($material);
//echo $food->getMaterial().'<br/>';
$bread = new Bread($material);
echo '製做麪包的材料是：'.$bread->getMaterial().'<br/>';
   ?>

15.學生類多重接口的實現

*在php中接口使用關鍵字interface聲明，而且在類內部不能有屬性，只能有方法，而且不能在方法中定義任何功能代碼，例如：

定義接口：

interface name
{
public function fun1();
private function fun2();
}

接口定義完成後，能夠在定義類時使用關鍵字implements實現一個或者多個接口，所實現的多個接口名稱之間使用逗號分隔：

class Myclass implements interface1,interface2,interface3
{
須要實現各個接口中所聲明的方法
}

例子：

<?php
interface Property_Id                            //編號接口
{
    public function setId ($id);                    //方法聲明
    public function getId ();
}
interface Property_Name                        //名稱接口
{
    public function setName ($name);             //方法聲明
    public function getName ();
}
class Student implements Property_Id, Property_Name        //定義學生類，使其同時實現Property_Id和Property_Name兩個接口
{
    private $id;                                       //編號屬性
    private $name;                                    //名稱屬性
    public function setId ($id)                           //實現接口中的各個方法
    {
        $this->id = $id;
    }
    public function getId ()
    {
        return $this->id;
    }
    public function setName ($name)
    {
        $this->name = $name;
    }
    public function getName ()
    {
        return $this->name;
    }
}

 <?php 

    require 'Student.php';  //包含學生類
    $student = new Student();    //對學生類進行實例化
    $student->setId($_POST['id']);  //設定學生ID
    $student->setName($_POST['name']);  //設定學生名稱
    echo '<font color="green">當前學生的學號是：'.$student->getId().'　姓名是：'.$student->getName().'</font>';  //打印學生信息

    ?>

*require和include的區別

只要程序運行就會將require語句所包含的文件包含進來，而include語句則是在執行到該語句時包含指定文件。

五：類的多態：經過多態能夠爲類提供功能上的多種實現，php中經過繼承或者接口實現類的多態

16.經過繼承實現多態

<?php
abstract class Animal //定義動物類
{
    public function walk () //定義動物類中的行走方法
    {
        return '動物能行走';
    }
}
class Penguin extends Animal //定義企鵝類，並使其繼承自動物類
{
    public function walk () //重寫父類中的walk()方法
    {
        return '企鵝能夠直立行走';
    }
}
class Insect extends Animal //定義昆蟲類，並使其繼承自動物類
{
    public function walk () //重寫父類中的walk()方法
    {
        return '昆蟲能夠爬行';
    }
}

<?php 
require 'Animal.php';
$penguin = new Penguin();
echo $penguin->walk();
echo '<br/>';
$insect = new Insect();
echo $insect->walk();
?>

*企鵝類和昆蟲類雖然都重寫了父類的walk（）方法，可是打印出的結果卻不同

17.經過接口實現多態

<?php
interface Animal //定義動物接口
{
    public function walk (); //聲明行走的方法
}
class Penguin implements Animal //定義企鵝類，並使其實現動物接口
{
    public function walk () //重寫父類中的walk()方法
    {
        return '企鵝能夠直立行走';
    }
}
class Insect implements Animal //定義昆蟲類，並使其實現動物接口
{
    public function walk () //重寫父類中的walk()方法
    {
        return '昆蟲能夠爬行';
    }
}

<?php 
require 'Animal.php';
$penguin = new Penguin();
echo $penguin->walk();
echo '<br/>';
$insect = new Insect();
echo $insect->walk();
?>

*抽象類和接口的區別：

在定義上，在抽象類中能夠對方法所實現的功能進行具體定義，而在接口中只能對方法進行聲明，不能具體實現方法的功能。

在用法上，繼承抽象類的子類能夠重寫父類的方法，或經過實例後的對象直接調用父類中的方法，而實現接口的類中，必須包含所實現接口的全部方法

六：經常使用關鍵字

18.使用final關鍵字防止類被繼承

<?php
class Fruit               //定義水果類
{
    private $color;         //定義顏色屬性
    public function __construct ($color)       //經過構造方法對顏色屬性進行初始化
    {
        $this->color = $color; 
    }
    public function getColor ()   //得到水果顏色的方法
    {
        return $this->color;
    }
}
final class Apple extends Fruit  //定義final型的蘋果類，使之繼承子水果累
{
    private $shape;  //定義形狀屬性
    public function __construct ($color, $shape)  //構造函數
    {
        parent::__construct($color);  //調用父類構造方法
        $this->shape = $shape;  //對形狀屬性進行初始化
    }
    public function getShape ()  //得到蘋果的形狀方法
    {
        return $this->shape;
    }
}
/*
class Test extends Apple {      //定義一個Test測試類，使之繼承final形的Apple類
    
}
*/

<?php 
    require 'Fruit.php';
    $apple = new Apple($_POST['color'], $_POST['shape']);
    echo '<font color="red">蘋果是'.$apple->getColor().$apple->getShape().'的</font>';

?>

19.使用static關鍵字定義類的靜態成員

<?php
class Math //定義數值計算類
{
    public static function add ($num1, $num2) //相加的方法
    {
        return $num1 + $num2;
    }
    public static function sub ($num1, $num2) //相減的方法
    {
        return $num1 - $num2;
    }
    public static function multi ($num1, $num2) //相乘的方法
    {
        return $num1 * $num2;
    }
    public static function div ($num1, $num2) //相除的方法
    {
        try {
            if ($num2 == 0) { //若是除數爲0,則拋出異常
                throw new Exception('除數不能爲0');
            } else {
                return $num1 / $num2;
            }
        } catch (Exception $e) {
            return $e->getMessage(); //若是除數爲0,則給出錯誤提示
        }
    }
}

<body>
<br />
<div
    style="width: 200px; padding: 3px; color: blue; clear: both; background-color: #E9F9C4; border: 1px solid #648B05; text-align: left; line-height: 30px;">
數值計算器：<br />
<form name="form1" method="post" action="<?=$_SERVER['PHP_SELF']?>"><input
    type="text" name="num1" class="input" size="20" /><br />
<select name="type">
    <option value="">運算類別</option>
    <option value="+">+</option>
    <option value="-">-</option>
    <option value="*">*</option>
    <option value="/">/</option>
</select><br />
<input type="text" name="num2" class="input" size="20" /> <input
    type="submit" value="求值" /></form>
<?php
if (isset($_POST['num1']) && trim($_POST['num1']) != '') { //判斷是否提交了表單
    require 'Math.php'; //包含Math.php文件
    $num1 = $_POST['num1'];  //得到提交的數字
    $num2 = $_POST['num2'];
    switch ($_POST['type']) { 
        case '+':   //進行加運算
            $result = Math::add($num1, $num2);
            break;
        case '-':  //進行減運算
            $result = Math::sub($num1, $num2);
            break;
        case '*': //進行乘運算
            $result = Math::multi($num1, $num2);
            break;
        case '/': //進行除運算
            $result = Math::div($num1, $num2);
            break;
    }
    echo '結果：' . $result;  //打印計算結果
}
?>
    </div>
</body>
</html>

20.使用clone關鍵字實現對象的克隆

<?php
class Sheep
{
    private $color; //顏色屬性
    public function setColor ($color) //設置顏色的方法
    {
        $this->color = $color;
    }
    public function getColor () //得到顏色的方法 
    {
        return '羊的顏色是' . $this->color;
    }
}

<?php
require 'Sheep.php'; //包含Sheep.php文件
$sheep = new Sheep();  //對Sheep類進行實例化
/*
$sheep->setColor('白色');   //設置羊的顏色
echo $sheep->getColor();  //打印羊的顏色
$sheep1 = $sheep;   //將$sheep對象賦值給新對象$sheep1
echo '<br/>';
$sheep1->setColor('灰色');//經過新對象$sheep1調用設置顏色的方法
echo $sheep->getColor();  //打印羊的顏色
*/

$sheep->setColor('白色');  //設置羊的顏色
echo $sheep->getColor();   //打印羊的顏色
$sheep1 = clone $sheep;  //克隆$sheep對象，產生一個新的$sheep1對象
echo '<br/>';
$sheep1->setColor('灰色');  //經過新克隆的$sheep1對象調用Sheep類中的setColor()方法
echo $sheep->getColor(); //打印羊的顏色
?>

21.使用instanceof關鍵字，檢測當前對象是屬於哪一個類

<?php
class Apple //定義蘋果類
{
    public function getColor () //得到蘋果顏色方法
    {
        return '紅色';
    }
}
class Orange //定義桔子類
{
    public function getColor () //得到桔子顏色方法
    {
        return '橙色';
    }
}

<?php
require 'Fruit.php';  //包含水果類
function getColor ($obj)   //定義根據對象類型得到相應水果顏色的方法
{
    if ($obj instanceof Apple) {  //判斷是否爲蘋果實例的對象
        $str = '蘋果是：';
    } elseif ($obj instanceof Orange) {  //判斷是否爲桔子實例的對象
        $str = '桔子是：';
    }
    return $str . $obj->getColor();  //打印結果
}
$apple = new Apple();  //對蘋果類進行實例化
$orange = new Orange();  //對桔子類進行實例化
echo getColor($apple) . '<br/>';   //打印蘋果顏色
echo getColor($orange);  //打印桔子顏色
?>

*is_a()函數判斷指定的對象是否屬於某類或其子類的對象。

七：魔術方法：

22.使用__set()方法爲類中未聲明的屬性賦值

<?php
class Book //定義圖書類
{
    private $name; //書名
    private $page; //頁碼
    private $writer; //做者
    private $price; //價格
    private $other; //其餘信息
    public function setName ($name) //設置書名
    {
        $this->name = $name;
    }
    public function getName () //得到書名
    {
        return $this->name;
    }
    public function setPage ($page) //設置頁碼
    {
        $this->page = $page;
    }
    public function getPage () //得到頁碼
    {
        return $this->page;
    }
    public function setWriter ($writer) //設置做者
    {
        $this->writer = $writer;
    }
    public function getWriter () //得到做者
    {
        return $this->writer;
    }
    public function setPrice ($price) //設置價格
    {
        $this->price = $price;
    }
    public function getPrice () //得到價格
    {
        return $this->price;
    }
    public function __set ($name, $value)
    {
        $this->other = $value;
    }
    public function getOther ()
    {
        return $this->other;
    }
}

定義數據

<?php 
require 'Book.php';
$arrayBook = array(                          //圖書信息數組，用於模擬圖書信息表
    array('name'=>'《PHP從基礎到**》', 'page'=>'650', 'writer'=>'小張、小潘、小王','price'=>'58'),
    array('name'=>'《PHP函數**》', 'page'=>'800', 'writer'=>'小潘、小王','price'=>'80'),
    array('name'=>'《PHP範例**》', 'page'=>'700', 'writer'=>'小李、小懂','price'=>'85'),
    array('name'=>'《PHP實戰**》', 'page'=>'750', 'writer'=>'小郭、小劉','price'=>'75')
);

打印結果

<?php 
require 'db.php';
foreach ($arrayBook as $key => $aBook) {
    $book = new Book();
    $book->setName($aBook['name']);
    $book->setPage($aBook['page']);
    $book->setWriter($aBook['writer']);
    $book->setPrice($aBook['price']);
    $book->bz = '備註';
?>

<div style="width:100%; <?php if($key < count($arrayBook)-1){?>border-bottom:1px solid #0463BD;<?php } ?> clear:both;">
    <div style="width:160px; height:22px; line-height:22px; text-align:left; float:left;">
    　<?php echo $book->getName()?>
    </div>
    <div style="width:160px; height:22px; line-height:22px; border-left:1px solid #0463BD; float:left;">
    <?php echo $book->getPage()?>
    </div>
    <div style="width:160px; height:22px; line-height:22px; border-left:1px solid #0463BD; float:left;">
    <?php echo $book->getWriter()?>
    </div>
    <div style="width:160px; height:22px; line-height:22px; border-left:1px solid #0463BD; float:left;">
    <?php echo $book->getPrice()?>
    </div>
    <div  style="width:156px; height:22px; line-height:22px; border-left:1px solid #0463BD; float:left;">
    <?php echo $book->getOther()?>
    </div>
</div>
<?php }?>
</div>

23.使用__get()方法獲取未定義屬性的名稱

<?php
class Apple
{
    private $color; //顏色
    private $shape; //形狀
    private $weight; //重量
    public function __construct ($color, $shape, $weight) //構造方法
    {
        $this->color = $color;
        $this->shape = $shape;
        $this->weight = $weight;
    }
    public function getProperty ()
    {
        return '這個蘋果重' . $this->weight . '，是' . $this->color . '，' . $this->shape . '的！';
    }
    public function __get ($name)
    { //使用__get()方法彈出未定義屬性的提示
        echo '<script>alert("在類中未定義屬性' . $name . '！");</script>';
    }
}

<?php
require 'Apple.php';
$apple = new Apple('紅色', '圓形', '0.4kg');
echo $apple->getProperty();
echo $apple->produceArea;
?>

24.使用__call()方法打印類中未定義方法的信息

<?php
class Book //圖書類
{
    private $name; //書名
    private $price; //價格
    public function __construct ($name, $price) //構造方法
    {
        $this->name = $name;
        $this->price = $price;
    }
    public function __call ($name, $arguments) //__call()方法
    {
        echo $name . '方法未定義';
    }
    public function getProperty () //得到圖書信息的方法
    {
        return $this->name . '的價格是' . $this->price . '元';
    }
}

<?php
require 'Book.php';  //包含Book.php文件
$bookName = '《PHP範例**》';   //書名
$price = '85';  //價格
$book = new Book($bookName, $price);  //對Book類進行實例化
echo $book->getProperty() . '<br/>';  //打印圖書屬性
$book->getInfo($bookName, $price);   //調用類中未定義的getInfo()方法
?>

25.使用__tostring()方法將類的實例轉換爲字符串

<?php
class Circle //計算圓面積類
{
    private $radius; //圓半徑屬性
    public function __construct ($radius) //構造方法
    {
        $this->radius = $radius;
    }
    public function __toString () //定義__toString()方法
    {
        return "圓的面積是：" . (string) number_format((pi() * pow($this->radius, 2)), 2);
    }
}

<?php
require 'Circle.php';
$radius = 2;
echo '圓的半徑是：'.$radius.'<br/>';
echo new Circle($radius);
?>

*number_format()函數對數字進行格式化輸出

26.使用__isset()方法提示未定義的屬性信息

<?php
class Person
{
    private $name;   // 名稱
    private $age;  //年齡
    private $weight;  //體重
    public function setName ($name) //設置名稱
    {
        $this->name = $name;
    }
    public function getName () //得到名稱
    {
        return $this->name;
    }
    public function setAge ($age)//設置年齡
    {
        $this->age = $age;
    }
    public function getAge ()  //得到年齡
    {
        return $this->age;
    }
    public function setWeight ($weight)//設置體重
    {
        $this->weight = $weight;
    }
    public function getWeight ()  //得到體重
    {
        return $this->weight;
    }
    public function __isset ($name)  //定義__isset()方法
    {
        echo '在類中未定義屬性' . $name;
    }
}

<?php 
require 'Person.php';  //包含Person.php文件
$person = new Person();  //實例Person類
$person->setName('小明');   //設置名稱
$person->setAge('12'); //設置年齡
$person->setWeight('45公斤'); //設置體重
isset($person->sex);   //判斷是否在類中定義了sex屬性
echo '<br/>';  //換行
echo $person->getName().'的年齡是：'.$person->getAge().'歲，體重是：'.$person->getWeight() ;  //打印信息
?>

27.使用__unset()方法提示未定義的屬性信息

<?php
class Car
{
    private $brand; //品牌
    private $color; //顏色
    public function __construct ($brand, $color) //構造方法
    {
        $this->brand = $brand;
        $this->color = $color;
    }
    public function __unset ($name) //定義__unset()方法
    {
        echo '在' . __CLASS__ . '類中未定義' . $name . '屬性';
    }
}

<?php 
require 'Car.php';  //包含Car.php文件
$car = new Car('奧迪', '黑色'); //使用new關鍵字實例Car類
unset($car->price);  //使用函數unset()釋放Car類中未定義的屬性price
?>

*魔術常量：

__CLASS__:返回當前類的名稱

__LINE__返回當前php腳本的當前行的行號

__FILE__返回當前php腳本的完整路徑和文件名

__FUNCTION__返回當前函數的名稱

__METHOD__返回當前類中成員方法的名稱

28.使用__autoload__方法自動導入類文件

類文件：

<?php
class Apple //蘋果類
{
    public function getColor () //得到蘋果顏色方法
    {
        return '蘋果是紅色的';
    }
}

<?php
class Orange //桔子類
{
    public function getColor () //得到桔子顏色的方法
    {
        return '桔子是橙色的';
    }
}

導入代碼

<?php
function __autoload ($className)
{
    $file = dirname(__FILE__) . '/class/' . $className . '.php';
    if (! file_exists($file)) {
        return false;
    } else {
        require_once $file;
    }
}

<?php 
require 'autoload.php';
$apple = new Apple();
$orange = new Orange();
echo $apple->getColor() . '<br/>';
echo $orange->getColor();
?>

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。