gopher学习php：php知识总结(更新ing) | php 技术论坛-江南app体育官方入口

[toc]

php的安装

这里安装的是7.3

brew tap shivammathur/php
brew install shivammathur/php/[email protected]
brew link [email protected]

第一个php程序

老规则，来一个hello.php

 echo "hello, world\n";
?>

直接在命令行运行一下命令

php hello.php

输入输出

输入

输入可以使用readline("请输入内容:")函数

$input = readline("请输入内容:");
echo $input."\n";
?>

输出

输出我们可以使用echo或者print，当然还有其他方式

echo "hello, iceymoss\n";
print "hello, iceymoss\n";
?>

这里需要注意，我们不能直接使用echo打印数组，可以使用print_r()

数据类型

php的数据类型有：字符串，整型，浮点，布尔，数组，对象，null,资源类型，使用var_dump()会返回变量的数据类型和值，在日常开发调制中使用较多。

如果只需要获取数据类型，可以使用

<?php
echo gettype(1.23);   //输出：double% 
?>

字符串

直接看实例：

<?php
 $x = "hello, world";
 echo $x;   //输出：hello, world
 echo "\n";
 $x = "iceymoss";
 echo $x; //输出：iceymoss
 echo "\n";
 //连接字符串
 $str = "hello" . "world";
 echo $str;  //输出：helloworld
 echo "\n";
 $a = "abc";
 $b = "cdef$a";
 echo $b;  //输出：cdefabc  
 $a = "abc";
 $b = 'cdef$a';
 echo $b;  //输出：cdef$a
?>

整数

$x = 1234;
var_dump($x);
$x = -432;
var_dump($x);
$x = 0x8c;
var_dump($x);
$x = 047;
var_dump($x);  //会自动转为十进制输出
?>

输出：

int(1234)
int(-432)
int(140)
int(39)

浮点

$x = 10.3434;
var_dump($x);
$x = 2.4e3;
var_dump($x);
$x = 8e-5;
var_dump($x);
?>

输出：

float(10.3434)
float(2400)
float(8.0e-5)

布尔

$x = false;
$x = true
?>

数组

数组可以在一个变量中存储多个值。

在以下实例中创建了一个数组， 然后使用 php var_dump() 函数返回数组的数据类型和值：

$cars=array("volvo","bmw","toyota");
$arr = ["boo", "kill", "lis"];
var_dump($cars);
var_dump($arr);
?>

输出：

array(3) {
  [0]=>
  string(5) "volvo"
  [1]=>
  string(3) "bmw"
  [2]=>
  string(6) "toyota"
}
array(3) {
  [0]=>
  string(3) "boo"
  [1]=>
  string(4) "kill"
  [2]=>
  string(3) "lis"
}

对象

对象数据类型也可以用于存储数据。

在 php 中，对象必须声明。

首先，你必须使用class关键字声明类对象。类是可以包含属性和方法的结构。

然后我们在类中定义数据类型，然后在实例化的类中使用数据类型，看实例：

class car
{
    var $color;
    var $weight;
    var $price;
    function __construct($color = "green", $weight = 2.5, $price = 13434.532423) {
        $this->color = $color;
        $this->price = $price;
        $this->weight = $weight;
    }
    function what_color() {
        return $this->color;
    }
    function what_weight() {
        return $this->weight;
    }
    function what_price() {
        return $this->price;
    }
}
//实例化对象
$xiaomisu7 = new car("blue", 1.5, 9.9999);
echo $xiaomisu7->price;
$xiaomisu7->price = 19.9999;
echo "\n";
print_r($xiaomisu7);
?>

null

$x = "hello";
$x = null;
var_dump($x);
echo "\n";
$arr = [54, 23, 12, 34];
$arr = null;
var_dump($arr);
?>

eof 使用说明

php eof(heredoc)是一种在命令行shell（如sh、csh、ksh、bash、powershell和zsh）和程序语言（像perl、php、python和ruby）里定义一个字符串的方法。

使用概述：

• 1. 必须后接分号，否则编译通不过。
• 2. eof 可以用任意其它字符代替，只需保证结束标识与开始标识一致。
• 3. 结束标识必须顶格独自占一行(即必须从行首开始，前后不能衔接任何空白和字符)。
• 4. 开始标识可以不带引号或带单双引号，不带引号与带双引号效果一致，解释内嵌的变量和转义符号，带单引号则不解释内嵌的变量和转义符号。
• 5. 当内容需要内嵌引号（单引号或双引号）时，不需要加转义符，本身对单双引号转义，此处相当与q和qq的用法

实例：

echo <<<eof
        
        
我的第一个段落。
eof;
// 结束需要独立一行且前后不能空格
echo "\n";
$name="runoob";
$a= <<<eof
        "abc"$name
        "123"
eof;
// 结束需要独立一行且前后不能空格
echo $a;
?>

运算符

php 算术运算符

实例:

$x=10;
$y=6;
echo ($x  $y); // 输出16
echo "\n";  // 换行
echo ($x - $y); // 输出4
echo "\n";  // 换行
echo ($x * $y); // 输出60
echo "\n";  // 换行
echo ($x / $y); // 输出1.6666666666667
echo "\n";  // 换行
echo ($x % $y); // 输出4
echo "\n";  // 换行
echo -$x;  //输出-10
?>

php 赋值运算符

在 php 中，基本的赋值运算符是 =。它意味着左操作数被设置为右侧表达式的值。也就是说，$x = 5 的值是 5。

实例：

$y=20;
$y = 100;
echo $y; // 输出120
echo "\n";  // 换行
$z=50;
$z -= 25;
echo $z; // 输出25
echo "\n";  // 换行
$i=5;
$i *= 6;
echo $i; // 输出30
echo "\n";  // 换行
$j=10;
$j /= 5;
echo $j; // 输出2
echo "\n";  // 换行
$k=15;
$k %= 4;
echo $k; // 输出3
echo "\n";  // 换行
?>

php 递增/递减运算符

实例：

$x=10;
echo $x; // 输出11
$y=10;
echo $y; // 输出10
$z=5;
echo --$z; // 输出4
$i=5;
echo $i--; // 输出5
?>

php 比较运算符

比较操作符可以让您比较两个值：

实例：

$x=100;
$y="100";
var_dump($x == $y);
echo "\n";
var_dump($x === $y);
echo "\n";
var_dump($x != $y);
echo "\n";
var_dump($x !== $y);
echo "\n";
$a=50;
$b=90;
var_dump($a > $b);
echo "\n";
var_dump($a < $b);
?>

php 比较运算符

比较操作符可以让您比较两个值：

php 逻辑运算符

三元运算符

另一个条件运算符是”?:”（或三元）运算符 。

语法格式

(expr1) ? (expr2) : (expr3) 

对 expr1 求值为 true 时的值为 expr2，在 expr1 求值为 false 时的值为 expr3。

自 php 5.3 起，可以省略三元运算符中间那部分。表达式 expr1 ?: expr3 在 expr1 求值为 true 时返回 expr1，否则返回 expr3。

实例：

// 普通写法
$username = isset($_get['user']) ? $_get['user'] : 'nobody';
echo $username, php_eol;
// php 5.3  版本写法
$username = $_get['user'] ?: 'nobody';
echo $username, php_eol;
?>

条件语句

实例1：

$age  = readline("输入年龄：");
if ($age < 18) {
    echo "未成年人禁止入内！";
}
?>

实例2：

$gender = readline("请输入您的性别：");
if ($gender == "男") {
    echo "你的编号：1";
} else if ($gender == "女") {
    echo "你的编号：0";
} else {
    echo "你的编号为：-1";
}
?>

switch 语句

实例：

$favcolor="red";
switch ($favcolor)
{
    case "red":
        echo "你喜欢的颜色是红色!";
        break;
    case "blue":
        echo "你喜欢的颜色是蓝色!";
        break;
    case "green":
        echo "你喜欢的颜色是绿色!";
        break;
    default:
        echo "你喜欢的颜色不是 红, 蓝, 或绿色!";
}
?>

数组

在php中数组有三种类型：

• 数值数组 - 带有数字 id 键的数组
• 关联数组 - 带有指定的键的数组，每个键关联一个值 （类比go中的map)
• 多维数组 - 包含一个或多个数组的数组

数值数组

实例1：

$city = array("广州", "深圳", "北京", "上海");
echo $city[0];  //广州
echo $city[2];  //北京
echo count($city); //4
//遍历数组
for ($i = 0; $i < count($city); $i) {
    echo $city[$i];
    echo "\n";
}
?>

php 关联数组

关联数组是使用您分配给数组的指定的键的数组。

这里有两种创建关联数组的方法：

$age=array("peter"=>"35","ben"=>"37","joe"=>"43");

or:

$age['peter']="35";
$age['ben']="37";
$age['joe']="43";

随后可以在脚本中使用指定的键：

$age=array("iceymoss"=>18,"peter"=>"35","ben"=>"37","joe"=>"43");
foreach($age as $x=>$x_value)
{
    echo "key=" . $x . ", value=" . $x_value;
    echo "\n";
}
?>

数组排序函数

php 数组排序函数：

• sort() - 对数组进行升序排列
• rsort() - 对数组进行降序排列
• asort() - 根据关联数组的值，对数组进行升序排列
• ksort() - 根据关联数组的键，对数组进行升序排列
• arsort() - 根据关联数组的值，对数组进行降序排列
• krsort() - 根据关联数组的键，对数组进行降序排列

实例：

$city = array(99, 10, 100, 10);
sort($city);
print_r($city);
$age=array("iceymoss"=>18,"peter"=>35,"ben"=>37,"joe"=>43);
ksort($age);
print_r($age);
krsort($age);
print_r($age);
?>

循环

php循环有以下种类：

• while - 只要指定的条件成立，则循环执行代码块
• do…while - 首先执行一次代码块，然后在指定的条件成立时重复这个循环
• for - 循环执行代码块指定的次数
• foreach - 根据数组中每个元素来循环代码块

while循环

实例：

$i = 0;
while($i < 100) {
    echo $i;
    echo "\n";
    $i;
}
?>

do…while语句

实例：

$i = 0;
do {
    $i;
    echo $i;
    echo "\n";
}
while($i < 10);
?>

for 循环

实例：计算100的和

$sum = 0;
for($i = 0; $i <= 100; $i) {
    $sum = $i;
}
echo $sum;
?>

foreach 循环

主要用来遍历数组，实例：

$arr = array(1, 2, 3, 4);
foreach($arr as $value) {
    echo "value:$value". php_eol;
}
$x = array("google","runoob","taobao");
foreach ($x as $value)
{
    echo $value . php_eol;
}
$x = ["chinese" => 120, "math" => 145, "english" =>130];
foreach ($x as $key => $value) {
    echo "$key: $value" . php_eol;
}
?>

函数

命名方式和大部分编程语言一样：

• 函数的名称应该提示出它的功能
• 函数名称以字母或下划线开头（不能以数字开头）

实例：

function hello() {
    echo "hello, function";
}
hello();
?>

函数-参数

直接填写形参即可，不需要像静态语言那样添加数据类型。

实例：

function add($x, $y) {
    echo $x  $y;  //输出：120
}
add(100, 20) 
?>

函数 - 返回值

如需让函数返回一个值，请使用 return 语句。

实例：

function add($x, $y) {
    return $x  $y;
}
echo add(100, 20);  //输出：120
?>

变量函数

这个就有点像go中的函数类型， 例如：

package main
import "fmt"
func getname(name string) func() string {
    return func() string {
        return name
    }
}
func main() {
    name := getname("iceymoss")
    n := name() //在指定地方执行
    fmt.println(n)
}

php的这样的，实例：

//function add($x, $y) {
//    return $x   $y;
//}
//
//echo add(100, 20);
function foo(){
    echo "in foo()
\n";
}
function bar($arg = '')
{
    echo "in bar(); argument was '$arg'.
\n";
}
// 使用 echo 的包装函数
function echoit($string)
{
    echo $string;
}
$func = 'foo';
$func();        // 调用 foo()
$func = 'bar';
$func('test');  // 调用 bar()
$func = 'echoit';
$func('test');  // 调用 echoit()
?>

魔术常量

有八个魔术常量它们的值随着它们在代码中的位置改变而改变。

例如 line 的值就依赖于它在脚本中所处的行来决定。这些特殊的常量不区分大小写，如下：

line

文件中当前行号，实例：

echo '这是第 " '  . __line__ . ' " 行'; //输出：这是第 " 3 " 行
?>

file

文件的完整路径和文件名。如果用在被包含文件中，则返回被包含的文件名。

实例：

echo '该文件位于 " '  . __file__ . ' " ';  //输出：该文件位于 " /users/iceymoss/php/learnphp/magic_const.php " 
?>

dir

文件所在的目录。如果用在被包括文件中，则返回被包括的文件所在的目录。

实例：

echo '该文件位于 " '  . __dir__ . ' " '; //输出：该文件位于 " /users/iceymoss/php/learnphp " 
?>

namespace

namespace myproject;
echo '命名空间为："', __namespace__, '"'; // 输出 "myproject"
?>

命名空间

菜鸟教程：php 命名空间(namespace)是在 php 5.3 中加入的，目的是解决重名问题，php中不允许两个函数或者类出现相同的名字，否则会产生一个致命的错误。

php 命名空间可以解决以下两类问题：

1. 用户编写的代码与php内部的类/函数/常量或第三方类/函数/常量之间的名字冲突。

2. 为很长的标识符名称(通常是为了缓解第一类问题而定义的)创建一个别名（或简短）的名称，提高源代码的可读性。

定义命名空间

默认情况下，所有常量、类和函数名都放在全局空间下，就和php支持命名空间之前一样。

命名空间通过关键字namespace 来声明。如果一个文件中包含命名空间，它必须在其它所有代码之前声明命名空间。

语法格式如下:

  
// 定义代码在 'myproject' 命名空间中  
namespace myproject;  
// ... 代码 ...  

也可以在同一个文件中定义不同的命名空间代码，如：

  
namespace myproject;
const connect_ok = 1;
class connection { /* ... */ }
function connect() { /* ... */  }
namespace anotherproject;
const connect_ok = 1;
class connection { /* ... */ }
function connect() { /* ... */  }
?>  

对于多个命名空间，可以这样优化：

namespace myproject {
    const connect_ok = 1;
    class connection { /* ... */ }
    function connect() { /* ... */  }
}
namespace anotherproject {
    const connect_ok = 1;
    class connection { /* ... */ }
    function connect() { /* ... */  }
}
?>

面向对象

三大特征

• 封装（encapsulation）：指将对象的属性和方法封装在一起，使得外部无法直接访问和修改对象的内部状态。通过使用访问控制修饰符（public、private、protected）来限制属性和方法的访问权限，从而实现封装。
• 继承（inheritance）：指可以创建一个新的类，该类继承了父类的属性和方法，并且可以添加自己的属性和方法。通过继承，可以避免重复编写相似的代码，并且可以实现代码的重用。
• 多态（polymorphism）：指可以使用一个父类类型的变量来引用不同子类类型的对象，从而实现对不同对象的统一操作。多态可以使得代码更加灵活，具有更好的可扩展性和可维护性。在 php 中，多态可以通过实现接口（interface）和使用抽象类（abstract class）来实现。

面向对象内容

• 类 − 定义了一件事物的抽象特点。类的定义包含了数据的形式以及对数据的操作。
• 对象 − 是类的实例。
• 成员变量 − 定义在类内部的变量。该变量的值对外是不可见的，但是可以通过成员函数访问，在类被实例化为对象后，该变量即可成为对象的属性。
• 成员函数 − 定义在类的内部，可用于访问对象的数据。
• 继承 − 继承性是子类自动共享父类数据结构和方法的机制，这是类之间的一种关系。在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并加入若干新的内容。
• 父类 − 一个类被其他类继承，可将该类称为父类，或基类，或超类。
• 子类 − 一个类继承其他类称为子类，也可称为派生类。
• 多态 − 多态性是指相同的函数或方法可作用于多种类型的对象上并获得不同的结果。不同的对象，收到同一消息可以产生不同的结果，这种现象称为多态性。
• 重载 − 简单说，就是函数或者方法有同样的名称，但是参数列表不相同的情形，这样的同名不同参数的函数或者方法之间，互相称之为重载函数或者方法。
• 抽象性 − 抽象性是指将具有一致的数据结构（属性）和行为（操作）的对象抽象成类。一个类就是这样一种抽象，它反映了与应用有关的重要性质，而忽略其他一些无关内容。任何类的划分都是主观的，但必须与具体的应用有关。
• 封装 − 封装是指将现实世界中存在的某个客体的属性与行为绑定在一起，并放置在一个逻辑单元内。
• 构造函数 − 主要用来在创建对象时初始化对象， 即为对象成员变量赋初始值，总与new运算符一起使用在创建对象的语句中。
• 析构函数 − 析构函数(destructor) 与构造函数相反，当对象结束其生命周期时（例如对象所在的函数已调用完毕），系统自动执行析构函数。析构函数往往用来做”清理善后” 的工作（例如在建立对象时用new开辟了一片内存空间，应在退出前在析构函数中用delete释放）。

类定义

class phpclass {
  var $var1;
  var $var2 = "constant string";
  function myfunc ($arg1, $arg2) {
     [..]
  }
  [..]
}
?>

解析如下：

• 类使用 class 关键字后加上类名定义。
• 类名后的一对大括号({})内可以定义变量和方法。
• 类的变量使用 var 来声明, 变量也可以初始化值。
• 函数定义类似 php 函数的定义，但函数只能通过该类及其实例化的对象访问。

实例：

class site {
    /* 成员变量 */
    var $url;
    var $title;
    /* 成员函数 */
    function seturl($par){
        $this->url = $par;
    }
    function geturl(){
        echo $this->url . php_eol;
    }
    function settitle($par){
        $this->title = $par;
    }
    function gettitle(){
        echo $this->title . php_eol;
    }
}
$runoob = new site; //实例化，new一个对象
$taobao = new site;
$google = new site;
// 调用成员函数，设置标题和url
$runoob->settitle( "菜鸟教程" );
$taobao->settitle( "淘宝" );
$google->settitle( "google 搜索" );
$runoob->seturl( 'www.runoob.com' );
$taobao->seturl( 'www.taobao.com' );
$google->seturl( 'www.google.com' );
// 调用成员函数，获取标题和url
$runoob->gettitle();
$taobao->gettitle();
$google->gettitle();
$runoob->geturl();
$taobao->geturl();
$google->geturl();
?>

构造函数

构造函数是一种特殊的方法。主要用来在创建对象时初始化对象， 即为对象成员变量赋初始值，在创建对象的语句中与 new 运算符一起使用。

function __construct( $par1, $par2 ) {
        $this->url = $par1;
        $this->title = $par2;
    }

实例：

class site {
    /* 成员变量 */
    var $url;
    var $title;
    function __construct( $par1, $par2 ) {
        $this->url = $par1;
        $this->title = $par2;
    }
    /* 成员函数 */
    function seturl($par){
        $this->url = $par;
    }
    function geturl(){
        echo $this->url . php_eol;
    }
    function settitle($par){
        $this->title = $par;
    }
    function gettitle(){
        echo $this->title . php_eol;
    }
}
$runoob = new site('www.runoob.com', '菜鸟教程');
$taobao = new site('www.taobao.com', '淘宝');
$google = new site('www.google.com', 'google 搜索');
// 调用成员函数，获取标题和url
$runoob->gettitle();
$taobao->gettitle();
$google->gettitle();
$runoob->geturl();
$taobao->geturl();
$google->geturl();
?>

析构函数

析构函数(destructor) 与构造函数相反，当对象结束其生命周期时（例如对象所在的函数已调用完毕），系统自动执行析构函数。

php 5 引入了析构函数的概念，这类似于其它面向对象的语言，其语法格式如下：

void __destruct ( void )

实例：

class mydestructableclass {
    function __construct() {
        print "构造函数\n";
        $this->name = "mydestructableclass";
    }
    function __destruct() {
        print "销毁 " . $this->name . "\n";
    }
}
$obj = new mydestructableclass(); 
?>

输出：

构造函数
销毁 mydestructableclass

继承

php 使用关键字 extends 来继承一个类，php 不支持多继承，格式如下：

class child extends parent {
   // 代码部分
}

实例：

class site {
    /* 成员变量 */
    var $url;
    var $title;
    function __construct( $par1, $par2 ) {
        $this->url = $par1;
        $this->title = $par2;
    }
    /* 成员函数 */
    function seturl($par){
        $this->url = $par;
    }
    function geturl(){
        echo $this->url . php_eol;
    }
    function settitle($par){
        $this->title = $par;
    }
    function gettitle(){
        echo $this->title . php_eol;
    }
}
// 子类扩展站点类别
class child_site extends site
{
    var $category;
    function setcate($par)
    {
        $this->category = $par;
    }
    function getcate()
    {
        echo $this->category . php_eol;
    }
}
$child = new child_site('www.runoob.com', '菜鸟教程');
$child->geturl();
$child->gettitle();
$child->setcate("apply");
$child->getcate();
?>

输出：

www.runoob.com
菜鸟教程
apply

方法重写

如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。

实例中重写了 geturl 与 gettitle 方法：

class site {
    /* 成员变量 */
    var $url;
    var $title;
    function __construct( $par1, $par2 ) {
        $this->url = $par1;
        $this->title = $par2;
    }
    /* 成员函数 */
    function seturl($par){
        $this->url = $par;
    }
    function geturl(){
        echo $this->url . php_eol;
    }
    function settitle($par){
        $this->title = $par;
    }
    function gettitle(){
        echo $this->title . php_eol;
    }
}
// 子类扩展站点类别
class child_site extends site
{
    var $category;
    function setcate($par)
    {
        $this->category = $par;
    }
    function getcate()
    {
        echo $this->category . php_eol;
    }
    function geturl() {
        echo $this->url . php_eol;
        return $this->url;
    }
    function gettitle(){
        echo $this->title . php_eol;
        return $this->title;
    }
}
$child = new child_site('www.runoob.com', '菜鸟教程');
$url = $child->geturl();
$title = $child->gettitle();
$child->setcate("apply");
$child->getcate();
echo "data:$url, $title"

访问控制

php 对属性或方法的访问控制，是通过在前面添加关键字 public（公有），protected（受保护）或 private（私有）来实现的。

• public（公有）：公有的类成员可以在任何地方被访问。
• protected（受保护）：受保护的类成员则可以被其自身以及其子类和父类访问。
• private（私有）：私有的类成员则只能被其定义所在的类访问。

属性的访问控制

类属性必须定义为公有，受保护，私有之一。如果用 var 定义，则被视为公有。

实例：

/**
 * define myclass
 */
class myclass
{
    public $public = 'public';
    protected $protected = 'protected';
    private $private = 'private';
    function printhello()
    {
        echo $this->public;
        echo $this->protected;
        echo $this->private;
    }
}
$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;
        echo $this->protected;
        echo $this->private;
    }
}
$obj2 = new myclass2();
echo $obj2->public; // 这行能被正常执行
echo $obj2->private; // 未定义 private
echo $obj2->protected; // 这行会产生一个致命错误
$obj2->printhello(); // 输出 public、protected2 和 undefined
?>

方法的访问控制

类中的方法可以被定义为公有，私有或受保护。如果没有设置这些关键字，则该方法默认为公有。

/**
 * define myclass
 */
class myclass
{
    // 声明一个公有的构造函数
    public function __construct() { }
    // 声明一个公有的方法
    public function mypublic() { }
    // 声明一个受保护的方法
    protected function myprotected() { }
    // 声明一个私有的方法
    private function myprivate() { }
    // 此方法为公有
    function foo()
    {
        $this->mypublic();
        $this->myprotected();
        $this->myprivate();
    }
}
$myclass = new myclass;
$myclass->mypublic(); // 这行能被正常执行
$myclass->myprotected(); // 这行会产生一个致命错误
$myclass->myprivate(); // 这行会产生一个致命错误
$myclass->foo(); // 公有，受保护，私有都可以执行
/**
 * define myclass2
 */
class myclass2 extends myclass
{
    // 此方法为公有
    function foo2()
    {
        $this->mypublic();
        $this->myprotected();
        $this->myprivate(); // 这行会产生一个致命错误
    }
}
$myclass2 = new myclass2;
$myclass2->mypublic(); // 这行能被正常执行
$myclass2->foo2(); // 公有的和受保护的都可执行，但私有的不行
class bar 
{
    public function test() {
        $this->testprivate();
        $this->testpublic();
    }
    public function testpublic() {
        echo "bar::testpublic\n";
    }
    private function testprivate() {
        echo "bar::testprivate\n";
    }
}
class foo extends bar 
{
    public function testpublic() {
        echo "foo::testpublic\n";
    }
    private function testprivate() {
        echo "foo::testprivate\n";
    }
}
$myfoo = new foo();
$myfoo->test(); // bar::testprivate 
                // foo::testpublic
?>

常量

可以把在类中始终保持不变的值定义为常量。在定义和使用常量的时候不需要使用 $ 符号。

常量的值必须是一个定值，不能是变量，类属性，数学运算的结果或函数调用。

自 php 5.3.0 起，可以用一个变量来动态调用类。但该变量的值不能为关键字（如 self，parent 或 static）。

class myclass
{
    const constant = '常量值';
    function showconstant() {
        echo  self::constant . php_eol;
    }
}
echo myclass::constant . php_eol;
$classname = "myclass";
echo $classname::constant . php_eol; // 自 5.3.0 起
$class = new myclass();
$class->showconstant();
echo $class::constant . php_eol; // 自 php 5.3.0 起
?>

[更多参考][

说明

学习php是跟着的，代码自己都实现了一遍，大部分内容参考

本作品采用《cc 协议》，转载必须注明作者和本文链接