PHP快速入門

整理一些PHP最基本的語法，旨在快速入門。

 

PHP的print

<?php

     # First Example

     print <<<END

     This uses the "here document" syntax to output

     multiple lines with $variable interpolation. Note

     that the here document terminator must appear on a

     line with just a semicolon no extra whitespace!

     END;
     # Second Example

     print "This spans

     multiple lines. The newlines will be

     output as well";

?>

對於打印多行的情況，可以使用上面的2種方法；另外PHP中的注釋分為單行注釋和多行注釋，單行注釋使用“#”或C語言的注釋方法，多行注釋使用C語言的注釋方法。

 

PHP print和echo語句

echo 和 print 區別:

• echo - 可以輸出一個或多個字符串
• print - 只允許輸出一個字符串，返回值總為 1

提示：echo 輸出的速度比 print 快， echo 沒有返回值，print有返回值1。

 

PHP的變量

（1）所有變量在 PHP 標有一個美元符號($)。

（2）PHP 變量沒有內在類型——一個變量事先不知道是否會用於存儲數字或字符串。

（3）變量在第一次賦值給它的時候被創建，PHP 可以自動地從一個類型轉換成另一個類型。

（4）PHP 一共有八種數據類型可以供我們用來構造變量：

• 整型：是整數,沒有小數點,像 4195。
• 浮點型：浮點數,如 3.14159 或 49.1。
• 布爾值：只有兩個可能值或真或假。
• 空：是一種特殊的類型只有一個值:空。
• 字符串類型：字符序列,像'PHP 支持字符串操作'
• 數組：有命名和索引所有值的集合。
• 對象：是程序員定義類的實例化，可以打包其他類型的值和屬於這個類的函數。

  <?php
  class Car
  {
      var $color;
      function Car($color="green") {
        $this->color = $color;
      }
      function what_color() {
        return $this->color;
      }
  }
  
  function print_vars($obj) {
     foreach (get_object_vars($obj) as $prop => $val) {
       echo "\t$prop = $val\n";
     }
  }
  
  // instantiate one object
  $herbie = new Car("white");
  
  // show herbie properties
  echo "\herbie: Properties\n";
  print_vars($herbie);
  
  ?>  

  運行結果：

  \herbie: Properties
          color = white
    

  get_object_var($object)，返回一個數組。獲取$object對象中的屬性，組成一個數組

• 資源：特殊變量持有引用外部資源到 PHP(如數據庫連接)。

 

PHP的變量賦值多行內容

也可以用上面類似的方法給變量賦值多行的語句內容值。

<?php

$channel =<<<_XML_
    <channel>
    <title>What's For Dinner<title>
    <link>http://menu.example.com/<link>
    <description>Choose what to eat tonight.</description>
    </channel>
_XML_;

echo <<<END
    This uses the "here document" syntax to output
    multiple lines with variable interpolation. Note
    that the here document terminator must appear on a
    line with just a semicolon. no extra whitespace!
    <br />
END;

print $channel;
?>

運行結果：

    This uses the "here document" syntax to output
    multiple lines with variable interpolation. Note
    that the here document terminator must appear on a
    line with just a semicolon. no extra whitespace!

    <channel>
    <title>What's For Dinner<title>
    <link>http://menu.example.com/<link>
    <description>Choose what to eat tonight.</description>

注意tab也是生效了的。

 

全局變量和靜態變量

（1）全局變量：通過將關鍵字 GLOBAL 放在變量前該變量可以被確認為全局變量。

$a 變量在函數外定義，無法在函數內使用，如果要在一個函數中訪問一個全局變量，需要使用 global 關鍵字。該關鍵字用於函數內訪問全局變量。

在函數內調用函數外定義的全局變量，我們需要在函數中的變量前加上 global 關鍵字

<?php

$a = 22;

function change()
{
        GLOBAL $a;
        $a += 2;
}

change();

print $a;
?>

運行結果：

24

PHP 將所有全局變量存儲在一個名為 $GLOBALS[index] 的數組中。 index 保存變量的名稱。這個數組可以在函數內部訪問，也可以直接用來更新全局變量。

上面的代碼也可以寫為下面這種形式：

<?php

$a = 22;

function change()
{
        $GLOBALS['a'] += 2;
}

change();

print $a;
?>

（2）靜態變量：當一個函數完成時，它的所有變量通常都會被刪除。然而，有時候希望某個局部變量不要被刪除。要做到這一點，在第一次聲明變量時使用 static 關鍵字

<?php

function change()
{
        STATIC $a = 0;
        $a += 2;
        print $a;
        print "\n";
}

change();
change();
change();

?>

運行結果：

2
4
6

 

常量

常量和變量之間的區別：

• 常量前面沒有必要寫美元符號（$），在變量前必須編寫一個美元符號。
• 常量只能用 define() 函數定義，而不能通過簡單的賦值語句。
• 常量可以不用理會變量范圍的規則而在任何地方定義和訪問。
• 常量一旦定義就不能被重新定義或者取消定義。
• 可以使用函數 constant()讀取一個常數的值。

<?php

define("MINSIZE", 50);

echo MINSIZE;
echo "\n";

echo constant("MINSIZE"); // same thing as the previous line
echo "\n";

$value = constant("MINSIZE"); 
print $value;
echo "\n";
?>

運行結果：

50
50
50

 

PHP7+ 版本新增整除運算符 intdiv()

<?php

var_dump(intdiv(10, 3));

echo intdiv(10, 3);

?>

運行結果：

int(3)
3

 

PHP比較運算符

除了下表列出的，其余的和C語言類似，不再贅述

運算符	名稱	描述	實例
x == y	等於	如果 x 等於 y，則返回 true	5==8 返回 false
x === y	絕對等於	如果 x 等於 y，且它們類型相同，則返回 true	5==="5" 返回 false
x != y	不等於	如果 x 不等於 y，則返回 true	5!=8 返回 true
x <> y	不等於	如果 x 不等於 y，則返回 true	5<>8 返回 true
x !== y	絕對不等於	如果 x 不等於 y，或它們類型不相同，則返回 true	5!=="5" 返回 true

 

結構控制

有2種方式：if和switch，和C語言類似。

<?php

$d = date("D");
if ($d == "Fri")
        echo "Have a nice weekend!\n"; 
elseif ($d == "Sun")
        echo "Fuck!\n"; 
else
        echo "Have a nice day!\n"; 

?>

運行結果：

Fuck!

 

循環類型

有4種方式：for、while、do...while、foreach，前面3種和C語言中類似，不再贅述了。

foreach 語句用於循環遍歷數組。每進行一次循環，當前數組元素的值就會被賦值給 value 變量，數組指針會逐一地移動以此類推。

<?php

$array = array( 1, 2, 3, 4, 5);
foreach( $array as $value )
{
        echo "Value is $value \n";
}

?>

運行結果：

Value is 1 
Value is 2 
Value is 3 
Value is 4 
Value is 5

 

數組

有三種不同類型的數組，每一個數組的值可以通過一個被稱為數組索引 ID 鍵來訪問。

（1）數字數組：也成為索引數組，數組以一個數字作為索引。值在線性中存儲和訪問。這些數組可以存儲數字、字符串和任何對象但是他們將數字作為索引。默認情況下，數組索引從 0 開始。

<?php

/* First method to create array. */
$numbers = array( 1, 2, 3, 4, 5);
foreach( $numbers as $value )
{
        echo "Value is $value \n";
}
echo "------------------------- \n";

/* Second method to create array. */
$numbers[0] = "one";
$numbers[1] = "two";
$numbers[2] = "three";
foreach( $numbers as $value )
{
        echo "Value is $value \n";
}
echo "------------------------- \n";

/* Third method to create array. */
$aa[0] = "aa0";
$aa[1] = "aa1";
$aa[2] = "aa2";
foreach( $aa as $value )
{
        echo "Value is $value \n";
}

?>

運行結果：

Value is 1 
Value is 2 
Value is 3 
Value is 4 
Value is 5 
------------------------- 
Value is one 
Value is two 
Value is three 
Value is 4 
Value is 5 
------------------------- 
Value is aa0 
Value is aa1 
Value is aa2

通過count()可以獲取數組長度，並且用這個可以更方便的遍歷數組

<?php
$cars = array("Volvo", "BMW", "Toyota");
$arrlength = count($cars);
 
for($x = 0; $x < $arrlength; $x++)
{
    echo $cars[$x];
    echo "<br>";
}
?>

運行結果：

Volvo
BMW
Toyota

（2）關聯數組：數組以字符串作為索引。這個數組存儲元素值與鍵值不是一個嚴格的線性索引順序。數值數組和關聯數組功能非常的相似，他們只是有不同的索引。關聯數組將字符串作為索引，這樣就可以建立一個強大的鍵和值的結構體系。注意: 不要使關聯數組在雙引號內，否則打印它不會返回任何值。

可以將員工的工資存儲在一個數組，用數字索引定義數組並不是最好的選擇。相反，我們可以使用員工的名字作為關聯數組的鍵，將工資作為鍵的值。

<?php
function print_fun($salaries)
{
        echo "Salary of mohammad is ". $salaries['mohammad'] . "\n";
        echo "Salary of qadir is ".  $salaries['qadir']. "\n";
        echo "Salary of zara is ".  $salaries['zara']. "\n";
}

function print_foreach($salaries)
{
        var_dump($salaries);
        foreach ($salaries as $value)
        {
                var_dump($value);
                echo $value. "\n";
        }
}

/* First method to associate create array. */
$salaries = array( 
                "mohammad" => 2000, 
                "qadir" => 1000, 
                "zara" => 500
                );
print_fun($salaries);

/* Second method to create array. */
$salaries['mohammad'] = "high";
$salaries['qadir'] = "medium";
$salaries['zara'] = "low";
print_fun($salaries);

/* third method to create array. */
$salaries['mohammad'] = 1;
$salaries['qadir'] = 2;
$salaries['zara'] = 3;
print_foreach($salaries);
?>

運行結果：

Salary of mohammad is 2000
Salary of qadir is 1000
Salary of zara is 500
Salary of mohammad is high
Salary of qadir is medium
Salary of zara is low
array(3) {
  ["mohammad"]=>
  int(1)
  ["qadir"]=>
  int(2)
  ["zara"]=>
  int(3)
}
int(1)
1
int(2)
2
int(3)
3

上面這種遍歷方法很挫，可以用下面的方法來搞

<?php
function print_fun($salaries)
{
        echo "Salary of mohammad is ". $salaries['mohammad'] . "\n";
        echo "Salary of qadir is ".  $salaries['qadir']. "\n";
        echo "Salary of zara is ".  $salaries['zara']. "\n";
}

function print_foreach($salaries)
{
        var_dump($salaries);
        foreach ($salaries as $key => $value)
        {
                var_dump($key);
                var_dump($value);
                echo "Key=" . $key . ", Value=" . $value. "\n";
        }
}

/* First method to associate create array. */
$salaries = array( 
                "mohammad" => 2000, 
                "qadir" => 1000, 
                "zara" => 500
                );
print_fun($salaries);

/* Second method to create array. */
$salaries['mohammad'] = "high";
$salaries['qadir'] = "medium";
$salaries['zara'] = "low";
print_fun($salaries);

/* third method to create array. */
$salaries['mohammad'] = 1;
$salaries['qadir'] = 2;
$salaries['zara'] = 3;
print_foreach($salaries);
?>

運行結果：

Salary of mohammad is 2000
Salary of qadir is 1000
Salary of zara is 500
Salary of mohammad is high
Salary of qadir is medium
Salary of zara is low
array(3) {
 ["mohammad"]=>
 int(1)
 ["qadir"]=>
 int(2)
 ["zara"]=>
 int(3)
}
string(8) "mohammad"
int(1)
Key=mohammad, Value=1
string(5) "qadir"
int(2)
Key=qadir, Value=2
string(4) "zara"
int(3)
Key=zara, Value=3

（3）多維數組：包含一個或多個數組，數組值可以使用多個索引訪問。在多維數組中，主數組中的每個元素也是一個數組。在子數組中的每個元素也可以是數組等等，多維數組中的值是使用多個索引訪問。

<?php

function print_foreach($marks)
{
        var_dump($marks);
        echo "================================\n";
        foreach ($marks as $value)
        {
                var_dump($value);
                echo "------------------------------\n";
                foreach ($value as $value_inner)
                {
                        echo $value_inner. "\n";
                }
                echo "\n\n";
        }
}

$marks = array( 
                "mohammad" => array
                (
                 "physics" => 35,
                 "maths" => 30,
                 "chemistry" => 3
                ),
                "qadir" => array
                (
                 "physics" => 30,
                 "maths" => 32,
                 "chemistry" => 29
                ),
                "zara" => array
                (
                 "physics" => 31,
                 "maths" => 22,
                 "chemistry" => 39
                )
              );
/* Accessing multi-dimensional array values */
echo "Marks for mohammad in physics : " ;
echo $marks['mohammad']['physics'] . "\n"; 
echo "Marks for qadir in maths : ";
echo $marks['qadir']['maths'] . "\n"; 
echo "Marks for zara in chemistry : " ;
echo $marks['zara']['chemistry'] . "\n"; 

print_foreach($marks);

?>

運行結果：

Marks for mohammad in physics : 35
Marks for qadir in maths : 32
Marks for zara in chemistry : 39
array(3) {
  ["mohammad"]=>
  array(3) {
    ["physics"]=>
    int(35)
    ["maths"]=>
    int(30)
    ["chemistry"]=>
    int(3)
  }
  ["qadir"]=>
  array(3) {
    ["physics"]=>
    int(30)
    ["maths"]=>
    int(32)
    ["chemistry"]=>
    int(29)
  }
  ["zara"]=>
  array(3) {
    ["physics"]=>
    int(31)
    ["maths"]=>
    int(22)
    ["chemistry"]=>
    int(39)
  }
}
================================
array(3) {
  ["physics"]=>
  int(35)
  ["maths"]=>
  int(30)
  ["chemistry"]=>
  int(3)
}
------------------------------
35
30
3


array(3) {
  ["physics"]=>
  int(30)
  ["maths"]=>
  int(32)
  ["chemistry"]=>
  int(29)
}
------------------------------
30
32
29


array(3) {
  ["physics"]=>
  int(31)
  ["maths"]=>
  int(22)
  ["chemistry"]=>
  int(39)
}
------------------------------
31
22
39

重新使用遍歷方法：

<?php

function print_foreach($marks)
{
        var_dump($marks);
        echo "================================\n";
        foreach ($marks as $value_outer)
        {
                var_dump($value_outer);
                echo "------------------------------\n";
                foreach ($value_outer as $key => $value_inner)
                {
                        echo "key = " . $key . ", value = " . $value_inner. "\n";
                }
                echo "\n\n";
        }
}

$marks = array( 
                "mohammad" => array
                (
                 "physics" => 35,
                 "maths" => 30,
                 "chemistry" => 3
                ),
                "qadir" => array
                (
                 "physics" => 30,
                 "maths" => 32,
                 "chemistry" => 29
                ),
                "zara" => array
                (
                 "physics" => 31,
                 "maths" => 22,
                 "chemistry" => 39
                )
              );
/* Accessing multi-dimensional array values */
echo "Marks for mohammad in physics : " ;
echo $marks['mohammad']['physics'] . "\n"; 
echo "Marks for qadir in maths : ";
echo $marks['qadir']['maths'] . "\n"; 
echo "Marks for zara in chemistry : " ;
echo $marks['zara']['chemistry'] . "\n"; 

print_foreach($marks);

?>

運行結果：

Marks for mohammad in physics : 35
Marks for qadir in maths : 32
Marks for zara in chemistry : 39
array(3) {
 ["mohammad"]=>
 array(3) {
   ["physics"]=>
   int(35)
   ["maths"]=>
   int(30)
   ["chemistry"]=>
   int(3)
 }
 ["qadir"]=>
 array(3) {
   ["physics"]=>
   int(30)
   ["maths"]=>
   int(32)
   ["chemistry"]=>
   int(29)
 }
 ["zara"]=>
 array(3) {
   ["physics"]=>
   int(31)
   ["maths"]=>
   int(22)
   ["chemistry"]=>
   int(39)
 }
}
================================
array(3) {
 ["physics"]=>
 int(35)
 ["maths"]=>
 int(30)
 ["chemistry"]=>
 int(3)
}
------------------------------
key = physics, value = 35
key = maths, value = 30
key = chemistry, value = 3
array(3) {
 ["physics"]=>
 int(30)
 ["maths"]=>
 int(32)
 ["chemistry"]=>
 int(29)
}
------------------------------
key = physics, value = 30
key = maths, value = 32
key = chemistry, value = 29
array(3) {
 ["physics"]=>
 int(31)
 ["maths"]=>
 int(22)
 ["chemistry"]=>
 int(39)
}
------------------------------
key = physics, value = 31
key = maths, value = 22
key = chemistry, value = 39

 

PHP數組排序函數

• sort() - 對數組進行升序排列
• rsort() - 對數組進行降序排列
• asort() - 根據關聯數組的值，對數組進行升序排列
• ksort() - 根據關聯數組的鍵，對數組進行升序排列
• arsort() - 根據關聯數組的值，對數組進行降序排列
• krsort() - 根據關聯數組的鍵，對數組進行降序排列

 

字符串

單引號串和雙引號串在 PHP 中的處理是不相同的。雙引號串中的內容可以被解釋而且替換，而單引號串中的內容總被認為是普通字符。

（1）字符串並置運算符：要把兩個變量連接在一起，請使用這個點運算符 (.)

（2）使用 strlen() 函數：strlen() 函數用於計算字符串的長度。

（3）使用 strpos() 函數：strpos() 函數用於在字符串內檢索一段字符串或一個字符。如果在字符串中找到匹配，該函數會返回第一個匹配的位置。如果未找到匹配，則返回 FALSE。

<?php

$txt1="Hello World";
$txt2="1234";
echo $txt1 . " " . $txt2 . "\n";

echo strlen($txt2) . "\n";

echo strpos($txt1, "Wo") . "\n";

?>

運行結果：

Hello World 1234
4
6

 

函數

下面的例子里面包括了引用參數、返回值、默認參數等用法。

<?php
function add($num)
{
        $num += 5;
        return $num;
}

#可以通過在變量名稱前加&符號傳遞一個參數引用變量，在函數調用時或函數定義時
function add_and_modify(&$num)
{
        $num += 6;
        return $num;
}

function default_num($num = 10)
{
        echo $num . "\n";
}

$orignum = 10;
$r1 = add($orignum);
echo $orignum . "\t". $r1 . "\n";
$r2 = add_and_modify($orignum);
echo $orignum . "\t". $r2 . "\n";

default_num();
default_num(20);

?>

運行結果：

10      15
16      16
10
20

 

構造函數和析構函數

構造函數 ，是一種特殊的方法。主要用來在創建對象時初始化對象， 即為對象成員變量賦初始值，總與new運算符一起使用在創建對象的語句中。

PHP 5 允行開發者在一個類中定義一個方法作為構造函數，語法格式如下：

void __construct ([ mixed $args [, $... ]] )

析構函數(destructor) 與構造函數相反，當對象結束其生命周期時（例如對象所在的函數已調用完畢），系統自動執行析構函數。

PHP 5 引入了析構函數的概念，這類似於其它面向對象的語言，其語法格式如下：

void __destruct ( void )

例子如下：

<?php
class MyDestructableClass {
   function __construct() {
       print "構造函數\n";
       $this->name = "MyDestructableClass";
   }

   function __destruct() {
       print "銷毀 " . $this->name . "\n";
   }
}

$obj = new MyDestructableClass();
?>

運行結果：

構造函數
銷毀 MyDestructableClass

 

PHP繼承及訪問控制

PHP 使用關鍵字 extends 來繼承一個類，PHP 不支持多繼承，格式如下：

class Child extends Parent { // 代碼部分 }

訪問控制：

PHP 對屬性或方法的訪問控制，是通過在前面添加關鍵字 public（公有），protected（受保護）或 private（私有）來實現的。

• public（公有）：公有的類成員可以在任何地方被訪問。
• protected（受保護）：受保護的類成員則可以被其自身以及其子類和父類訪問。
• private（私有）：私有的類成員則只能被其定義所在的類訪問。

類屬性必須定義為公有，受保護，私有之一。如果用 var 定義，則被視為公有。

類中的方法可以被定義為公有，私有或受保護。如果沒有設置這些關鍵字，則該方法默認為公有。

<?php
/**
 * Define MyClass
 */
class MyClass
{
    public $public = 'Public';
    protected $protected = 'Protected';
    private $private = 'Private';

    function printHello()
    {
        echo $this->public. "\n";
        echo $this->protected. "\n";
        echo $this->private. "\n";
    }
}

$obj = new MyClass();
//echo $obj->public; // 這行能被正常執行
//echo $obj->protected; // 這行會產生一個致命錯誤
//echo $obj->private; // 這行也會產生一個致命錯誤
$obj->printHello(); // 輸出 Public、Protected 和 Private


/**
 * Define MyClass2
 */
class MyClass2 extends MyClass
{
    // 可以對 public 和 protected 進行重定義，但 private 而不能
    protected $protected = 'Protected2';

    function printHello()
    {
        echo $this->public . "\n";
        echo $this->protected. "\n";
        echo $this->private. "\n";
    }
}

$obj2 = new MyClass2();
//echo $obj2->public; // 這行能被正常執行
//echo $obj2->private; // 未定義 private
//echo $obj2->protected; // 這行會產生一個致命錯誤
$obj2->printHello(); // 輸出 Public、Protected2 和 Undefined

?>

運行結果：

Public
Protected
Private
Public
Protected2
PHP Notice:  Undefined property: MyClass2::$private in /code/main.php on line 38

 

調用父類構造方法

PHP 不會在子類的構造方法中自動的調用父類的構造方法。要執行父類的構造方法，需要在子類的構造方法中調用 parent::__construct() 。

<?php
class BaseClass {
   function __construct() {
       print "BaseClass 類中構造方法" . PHP_EOL;
   }
}
class SubClass extends BaseClass {
   function __construct() {
       parent::__construct();  // 子類構造方法不能自動調用父類的構造方法
       print "SubClass 類中構造方法" . PHP_EOL;
   }
}
class OtherSubClass extends BaseClass {
    // 繼承 BaseClass 的構造方法
}

// 調用 BaseClass 構造方法
$obj = new BaseClass();

// 調用 BaseClass、SubClass 構造方法
$obj = new SubClass();

// 調用 BaseClass 構造方法
$obj = new OtherSubClass();
?>

運行結果：

BaseClass 類中構造方法
BaseClass 類中構造方法
SubClass 類中構造方法
BaseClass 類中構造方法

 

接口

使用接口（interface），可以指定某個類必須實現哪些方法，但不需要定義這些方法的具體內容。

接口是通過 interface 關鍵字來定義的，就像定義一個標准的類一樣，但其中定義所有的方法都是空的。

接口中定義的所有方法都必須是公有，這是接口的特性。

要實現一個接口，使用 implements 操作符。類中必須實現接口中定義的所有方法，否則會報一個致命錯誤。類可以實現多個接口，用逗號來分隔多個接口的名稱。

<?php

// 聲明一個'iTemplate'接口
interface iTemplate
{
    public function setVariable($name, $var);
    public function getHtml($template);
}


// 實現接口
class Template implements iTemplate
{
    private $vars = array();
  
    public function setVariable($name, $var)
    {
        $this->vars[$name] = $var;
    }
  
    public function getHtml($template)
    {
        foreach($this->vars as $name => $value) {
            $template = str_replace('{' . $name . '}', $value, $template);
        }
 
        return $template;
    }
}

 

抽象類

任何一個類，如果它里面至少有一個方法是被聲明為抽象的，那么這個類就必須被聲明為抽象的。

定義為抽象的類不能被實例化。

被定義為抽象的方法只是聲明了其調用方式（參數），不能定義其具體的功能實現。

繼承一個抽象類的時候，子類必須定義父類中的所有抽象方法；另外，這些方法的訪問控制必須和父類中一樣（或者更為寬松）。例如某個抽象方法被聲明為受保護的，那么子類中實現的方法就應該聲明為受保護的或者公有的，而不能定義為私有的。此外方法的調用方式必須匹配，即類型和所需參數數量必須一致。例如，子類定義了一個可選參數，而父類抽象方法的聲明里沒有，則兩者的聲明並無沖突。

<?php
abstract class AbstractClass
{
    // 強制要求子類定義這些方法
    abstract protected function getValue();
    abstract protected function prefixValue($prefix);

    // 普通方法（非抽象方法）
    public function printOut() {
        print $this->getValue() . PHP_EOL;
    }
}

class ConcreteClass1 extends AbstractClass
{
    protected function getValue() {
        return "ConcreteClass1";
    }

    public function prefixValue($prefix) {
        return "{$prefix}ConcreteClass1";
    }
}

class ConcreteClass2 extends AbstractClass
{
    public function getValue() {
        return "ConcreteClass2";
    }

    public function prefixValue($prefix) {
        return "{$prefix}ConcreteClass2";
    }
}

$class1 = new ConcreteClass1;
$class1->printOut();
echo $class1->prefixValue('FOO_') . PHP_EOL;

$class2 = new ConcreteClass2;
$class2->printOut();
echo $class2->prefixValue('FOO_') . PHP_EOL;
?>

運行結果：

ConcreteClass1
FOO_ConcreteClass1
ConcreteClass2
FOO_ConcreteClass2

 

static關鍵字

聲明類屬性或方法為 static(靜態)，就可以不實例化類而直接訪問。

靜態屬性不能通過一個類已實例化的對象來訪問（但靜態方法可以）。

由於靜態方法不需要通過對象即可調用，所以偽變量 $this 在靜態方法中不可用。

靜態屬性不可以由對象通過 -> 操作符來訪問。

自 PHP 5.3.0 起，可以用一個變量來動態調用類。但該變量的值不能為關鍵字 self，parent 或 static。

<?php
class Foo {
  public static $my_static = 'foo';
  
  public function staticValue() {
     return self::$my_static;
  }
}

print Foo::$my_static . PHP_EOL;
$foo = new Foo();

print $foo->staticValue() . PHP_EOL;
?>    

運行結果：

foo
foo

 

Final 關鍵字
PHP 5 新增了一個 final 關鍵字。如果父類中的方法被聲明為 final，則子類無法覆蓋該方法。如果一個類被聲明為 final，則不能被繼承。
以下代碼執行會報錯：

<?php
class BaseClass {
   public function test() {
       echo "BaseClass::test() called" . PHP_EOL;
   }
   
   final public function moreTesting() {
       echo "BaseClass::moreTesting() called"  . PHP_EOL;
   }
}

class ChildClass extends BaseClass {
   public function moreTesting() {
       echo "ChildClass::moreTesting() called"  . PHP_EOL;
   }
}
// 報錯信息 Fatal error: Cannot override final method BaseClass::moreTesting()
?>

 

 

本文參考自：

http://wiki.jikexueyuan.com/project/php/

http://www.runoob.com/php/php-tutorial.html

另外，推薦一個在線運行PHP代碼的網站：

https://tool.lu/coderunner/