PHP环境安装
根据你环境选择Windows或者Linux版本与位数,我选择的是Windows64位; 传送门: https://www.xp.cn/download.html
phpstudy使用
当我们写好php文件以后怎么查看效果呢? 我们启动apache然后进行配置,选择网站目录并且放置php文件到WWW/目录下面,默认访问路径是localhost/你的php文件.php;
PHP语法
语言标记 表示这一段是PHP代码;通过cgi请求PHP解释器处理;
echo输出语句
print_r 打印
var_dump打印数据类型和值
1 2 $jiushiboy=true; var_dump($jiushiboy);
PHP嵌套到HTML
1 2 3 4 5 6 7 8 9 10 11 <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Document</title> </head> <body> <?php echo '我是嵌套的代码'; ?> <?php echo '我也是嵌套的代码'; ?> </body> </html>
结束符 ; PHP的代码结束符跟Java中一样是以;结束一行代码;
PHP注释
1 2 3 4 5 # 单行注释 // 单行注释 /* 我是多行注释 */
变量声明
1 2 3 4 5 6 7 8 9 /* 变量名命名规则: 1.开头不能用数字; 2.中间不能有空格; */ <?php $jiushiboy='我是九世'; echo $jiushiboy; ?>
引号作用
1 2 3 4 5 6 7 8 9 /* 单引号里面的是文本内容; 双引号里面可以是文本和变量; */ <?php $jiushiboy = '九世'; $name = "我是{$jiushiboy}"; # 输出结果为: 我是jiushiboy ?>
转义字符
1 2 3 4 5 <?php # 如果你输出的文本需要用到符号就需要使用\符号进行转义; $jiushiboy = "我是\"九世\"你呢"; echo $jiushiboy; ?>
PHP常量
1 2 3 define('JIUSHIBOY','jiushiboy.github.io'); echo JIUSHIBOY; # 代码效果输出为: jiushiboy.github.io
PHP数据类型
类型
描述
布尔型Boolean
true和false
整型Integer
0-无限大
浮点型Float
带小数的数字
字符串String
汉字、英文、符号等
数组Array
存储多个值的容器
对象Object
对象
空值NULL
没有值的意思
PHP函数 php的一些功能和方法称为函数; php拥有1000多个内建的函数;
函数
描述
is_bool()
判断是否是布尔型
is_int()
判断是否是整型
is_float()
判断是否是浮点型
is_string()
判断是否是字符串
is_null()
判断是否是空
isset()
判断变量是否有值
empty()
判断变量是否为空
unset()
释放变量
PHP运算符
运算符
描述
+
相加
-
相减
*
相乘
/
相除
%
取余
++
加加
–
减减
.
连接、用在字符串
PHP比较运算符
运算符
描述
>
大于
>=
大于等于
<
小于
<=
小于等于
==
等等
!=
不等
===
恒等
!==
恒不等
PHP逻辑运算符
运算符
描述
and和&&
与
or和||
或
xor
或异
!
非
流程控制
三元运算符
1 2 $jiushiboy=100; var_dump($jiushiboy>=100 ? '九世' : 'boy');
if
1 2 3 4 $jiushiboy=100; if($jiushiboy>=100){ var_dump('条件成立,九世说你是猪'); }
if else
1 2 3 4 5 6 $jiushiboy=100; if($jiushiboy>=100){ var_dump('大于等于100,你就是猪'); }else{ var_dump('条件不成立,你直接就是猪'); }
if else if else
1 2 3 4 5 6 7 8 9 10 11 # 只要一个条件成立了,就不会继续往下执行 $jiushiboy=100; if($jiushiboy>=20){ var_dump('大于等于20,就吃个饭'); }else if($jiushiboy>=50){ var_dump('大于等于50,就看个电影'); }else if($jiushiboy>=70){ var_dump('买一束花,等一个人'); }else{ var_dump('自己慢慢玩'); }
Switch case default
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 /* ①当第一个case符合条件 执行第一个case中的代码然后跳出switch不再执行; ②如果第一个不匹配则继续往下找,如果都没有就执行default; ③如果你的case之后没有写break; 那么就代表你执行完当前case的代码不跳出switch,继续执行下面的case,直到遇到break跳出; */ $jiushiboy=100; switch($jiushiboy){ case $jiushiboy>=40: echo '买一盆花'; break; case jiushiboy>=100: echo '吃一顿好的'; break; default: echo '洗洗睡了'; break; }
while循环
1 2 3 4 5 6 7 8 9 10 11 12 13 /* 首先定义一个变量为1; while循环条件第一次的时候是1<=100; 然后输出当前变量的数值,第一次是1; 然后变量++的意思是加1; 也就是每次循环完变量都会加1; 这个循环最终会循环100次; */ $jiushiboy=1; while($jiushiboy<=100){ echo $jiushiboy; $jiushiboy++; }
do while循环
1 2 3 4 5 6 7 8 9 /* do while这个循环有点特别,不管你的条件成不成立,他始终会执行最少一次; 如果while里面的条件成立,则继续执行do{}中的代码; */ $jiushiboy=1; do{ echo $jiushiboy; }while($jiushiboy<1);
for循环
1 2 3 4 5 6 /* 循环输出十次 */ for($int=0;$int<10;$int++){ echo $int; }
continue
1 2 3 4 5 6 7 8 9 10 11 /* 结束当前循环进入下一次循环; 在while和for里都可以使用; 表示在第五次循环的时候,停止第五次循环,直接进入第六次循环; */ for($int=0;$int<10;$int++){ if($int==4){ continue; } var_dump($int); }
break
1 2 3 4 5 6 7 8 #参考switch的用法 #在for循环和while循环中如果只是单个循环,那么遇到break;将跳出整个循环语句; for($int=0;$int<10;$int++){ if($int==4){ break; } }
PHP数组
创建空的数组
1 2 3 4 5 # $符号后面的字母随便起,如果不懂可以参考命名规范; $array1=array(); var_dump($array1); $array2=[]; var_dump(array2);
创建索引数组
1 2 3 4 5 6 7 8 9 10 /* 如果你是新手不知道索引(也称下标)的意思那么我解释一下; 数组你可以理解为一个盒子; 索引你可以理解为盒子里面东西的一个标识,表示里面东西的位置,索引默认是从0开始的,0表示第一个; 调用方式也就是数组[索引]; */ $array1=array('九世','jiushiboy.top','jiushiboy.vip'); var_dump($array1[0]); $array2=['九世','jiushiboy.top']; var_dump($array2[1]);
创建关联数组
1 2 3 4 5 6 7 8 /* 按照key取对应的值; */ $array1=('jiushi'=>'九世','jiushitop'=>'九世的博客') var_dump($array1["jiushi"]); $array2=['jiushi'=>'九世','jiushitop'=>'九世的博客']; print_r($array2);
PHP多维数组 Ps: 最好不要超过三层;
1 2 3 4 5 6 7 8 9 10 $jiushiboy=array( array( 'name'=>'jiushi' ), array( 'name'=>'文' ) ); echo $jiushiboy[0]['name'];
PHP数组循环
1 2 3 4 5 6 7 8 9 10 11 $jiushiboy=array('九世'=>'jiushi','你听'=>'等风十载'); # 普通遍历 foreach($jiushiboy as $jiushi){ echo $jiushi; echo '<hr>'; } # key和value便利 foreach($jiushiboy as $jiushi=>$boy){ echo $jiushi.'---'.$boy; echo '<hr>'; }
循环多维数组
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 /* 简单来说就是先便利外面的一层集合,再便利里面的集合; */ $jiushiboy = [ [ 'name' => '九世', 'age' => 999 ], [ 'name' => '文', 'age' => 998 ] ]; foreach( $jiushiboy as $k=>$v ){ foreach ($v as $key => $value) { echo $value; echo '<hr>'; } }
PHP函数
字符串函数
函数
描述
strtolower()
将字符串转为小写
strtoupper()
将字符串转为大写
strlen()
字符串长度
trim()
去除字符串首尾的空白字符
ltrim()
去除字符串最前的空白字符
rtrim()
去除字符串最后的空白字符
str_replace()
字符串替换
strpbrk()
在字符串中查找一组字符是否存在
explode()
将字符串分割为数组
implode()
将数组元素组合为字符串
md5()
将字符串进行md5加密
1 2 3 4 5 6 7 8 9 10 # 1.字符串替换str_replace();第一个参数是要被替换的字符,第二个参数是替换成什么值; $jiushiboy='jiushiboy'; echo str_replace('boy','',$jiushiboy); # 2.查找字符是否存在,第二个参数是要查找的字符 echo strpbrk($jiushiboy,'jiu'); # 3.将字符串切割成数组,第一个参数意思是以什么切割 $str ='jiu,shi,boy'; echo explode(',',$str);
数组函数
函数
描述
count()
数组中的数量
array_merge()
将两个数组合成一个
in_array()
数组中是否有指定的值
sort()
对数值数组进行升序
rsort()
对数值数组进行降序
array_unique()
移除数组中重复的值
array_push()
将一个或多个元素插入数组末尾
array_pop()
删除数组的最后一个元素
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 # 数组长度 $jiushiboy=array('jiushi'=>'九世'); echo count($jiushiboy); # 数组合并 $jiushi=['jiushiboy.top','九世的博客']; $arrays=array_merge($jiushiboy,$jiushi); print_r($arrays); # 数组中是否有匹配的值 echo in_array('九世的博客',$jiushi); # 数组升序 sort($arrays); print_r($arrays); # 移除数组中重复的值,自己放个一样的值 print_r(array_unique($jiushi)); # 数组末尾添加 array_push($jiushi,'文'); print_r($jiushi);
函数分类
函数分类
描述
String
字符串处理函数
Array
数组函数允许您访问和操作数组
MySQLi
允许您访问 MySQL 数据库服务器
Date
服务器上获取日期和时间
Filesystem
允许您访问和操作文件系统
Mail
数学函数能处理 integer 和 float 范围内的值
HTTP
允许您在其他输出被发送之前,对由 Web 服务器
Calendar
日历扩展包含了简化不同日历格式间转换的函数
Directory
允许您获得关于目录及其内容的信息
Error
允许您对错误进行处理和记录
Filter
进行验证和过滤
FTP
过文件传输协议 (FTP) 提供对文件服务器的客户端访问
MySQL
允许您访问 MySQL 数据库服务器
SimpleXML
允许您把 XML 转换为对象
Zip
压缩文件函数允许我们读取压缩文件
自定义函数
1 2 3 4 5 6 7 8 9 # 方法括号里的是参数默认值设置使用='默认值' # return 是返回出去的值; function jiushi($str1,$str2='九世'){ echo '我是jiushi的方法,参数1:'.$str1.'------参数2:'.$str2; return $str2; } # 因为使用了return有了返回值,才能使用变量接收到值; $jiushi=jiushi('九世','boy'); echo $jiushi;
PHP类与对象
类的三大特性:
封装:把对象的属性和方法都放在一个类里面;
继承:以原有的类为基础,创建一个新类,继承父类从而有了父类的代码(不一定是全部);
多态:允许将子类类型的指针赋给父类型的指针,达到向上转型; 需要用到的数据库:
1 2 3 4 5 6 7 8 9 10 11 12 13 # 此时你需要有MySQL的经验,如果没有.... CREATE TABLE `user` ( `uid` int(11) unsigned NOT NULL AUTO_INCREMENT COMMENT '用户ID', `name` varchar(50) NOT NULL COMMENT '姓名', `age` smallint(3) unsigned NOT NULL COMMENT '年龄', PRIMARY KEY (`uid`) ) ENGINE=MyISAM AUTO_INCREMENT=7 DEFAULT CHARSET=utf8; INSERT INTO `user` VALUES ('1', '九世', '38'); INSERT INTO `user` VALUES ('2', '文', '50'); INSERT INTO `user` VALUES ('3', '张三', '33'); INSERT INTO `user` VALUES ('4', '李四', '68');
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 # 自动连接数据库,这只是一个Demo,不需要你一下就看懂,你先看看 # 学完后面的知识再往这瞧瞧差不多就懂了 class jiushi{ // 连接参数 public $dsn; public $user; public $password; // 连接属性 public $pdo; // 连接方法 public function connect(){ $this->pdo=new PDO($this->dsn,$this->user,$this->password); } // 实例化对象时自动调用连接方法 public function __construct($dsn,$user,$password){ $this->dsn=$dsn; $this->user=$user; $this->password=$password; $this->connect(); } // 析构方法 public function __destruct(){ $this.pdo=null; } } # 这里host=localhost 代表本机ip,dbname是你数据库里面的数据库名称; $db=new jiushi('mysql:host=localhost;dbname=db2019','root','123'); if($db->pdo){ echo '连接成功~<hr/>'; } $stmt=$db->pdo->prepare('select * from payment'); $stmt->execute(); foreach($stmt->fetchAll(PDO::FETCH_ASSOC) as $user){ print_r($user); echo '<br>'; }
类是什么? 假如车是一个类型,很抽象啊,你也不知道具体是什么车,那具体的如保时捷911这就是具体的实例对象; 类可以理解为一个分类,这个类是什么类,类里面有什么,通过类创建出对象;
1 2 3 4 5 6 7 8 9 10 11 # 创建一个动物类 class Animal{} # 实例化类 $cat=new Animal(); //猫 $dog=new Animal(); //狗 # 同一个类,new出来的对象是不一样的; var_dump($cat===$dog); # 监测cat对象是否是动物类型; var_dump($cat instanceof Animal);
类属性
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 # PHP中定义类属性必须带有修饰符否则报错; /* 在我们定义类属性的时候,我们需要给定访问修饰符,设置他的作用域; 类属性的修饰符: public 公共的,本类,类外,子类都可以访问; private 私有的,只能本类访问; protected 受保护的,本类,子类能访问; */ class Person{ public $name='九世'; public $sex='男'; } # 说了那么多在PHP怎么调用类属性呢? $jiushi=new Person(); echo $jiushi->name; # 那么如何给类属性赋值呢? $jiushi->name='九世boy'; echo $jiushi->name;
类方法(行为) 你可以把方法理解为你要做什么事情; 关键字: self(当前类)、$this(当前类的实例)
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 class Person{ public $name='九世'; public $sex='男'; public function getName(){ # $this相当于本类的实例,直接调用当前类的属性 return '姓名:'.$this->name; } public function getSelfSex(){ # 相当于new了一个当前类的实例,new就是新建一个实例 $jiushi=new self(); return '性别:'.$jiushi->sex; } } # 实例化对象 $jiushi = new Person(); # 调用方法 echo $jiushi->getName(); echo $jiushi->getSelfSex();
构造方法
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 class Person{ # 定义类属性 public $name; public $sex; # 定义构造方法,这里一定要注意下划线不是是两个; public function __construct($name,$sex){ $this->name=$name; $this->sex=$sex; } # 普通方法 public function getInfo(){ return '名字:'.$this->name.'----性别:'.$this->sex; } } # 实例化,通过构造方法传入参数完成赋值; $jiushi=new Person('九世','男'); echo $jiushi->getInfo();
析构方法(类执行完之前执行)
1 2 3 4 5 class Person{ public function __destruct(){ echo '这个类要执行完了'; } }
类的继承
子类可以重写父类的方法;
继承只能单继承,不能继承多个父类;
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 # 编写父类 class jiushi{ // 属性 public $name; public $sex; // 构造 public function __construct($name,$sex){ $this->name=$name; $this->sex=$sex; } public function getInfo(){ return '姓名:'.$this->name.'----性别:'.$this->sex; } } # 编写子类继承父类 关键字extends class boy extends jiushi{ # 子类调用父类的构造方法 public function __construct($name,$sex){ parent::__construct($name,$sex); } # 重写方法其实很简单,也就是父类定义一个方法,你在子类里面重新写一遍,但是方法名,入参,且访问修饰符不能小于父类; } # 实例化子类boy,因为继承关系会拥有父类的方法; $jiushiboy=new boy('九世','男'); echo $jiushiboy->getInfo();
封装
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 class Woman{ // 属性 public $name; // 姓名 protected $age; // 年龄 private $wages; // 工资 // 构造方法 public function __construct($name, $age, $wages){ $this->name = $name; $this->age = $age; $this->wages = $wages; } } // 类实例化 $obj = new Woman('九世',998,500000); echo $obj->name, '<br>'; // 继承后访问 class Star extends Woman{ public function info(){ echo $this->name, '<br>'; echo $this->age, '<br>'; } } // 类实例化 $obj1 = new Star('baby',28,400000); echo $obj1->name, '<br>'; echo $obj1->info();
静态属性及静态方法 为什么普通方法里面放静态的属性等会报错,静态随着类的加载而加载,也就是说静态比实例先加载,这就好比你爸都没出生会有你吗?
静态可以共用,因为静态在内存中只有一份;
静态在程序执行完之后会释放资源;
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 class People{ // 属性 public $name; // 属性 public $age; // 属性: 静态属性 public static $country = '中国'; // 构造方法 public function __construct($name, $age){ $this->name = $name; $this->age = $age; // $this->country = $country; // 会报错 // 尽管可以在构造方法中初始化静态属性,但不建议这样做,否则静态属性,无法在对象之间共享 } // 对象方法 public function getInfo1(){ // 这个方法可以用对象访问,方法中访问了静态属性,实现了类属性在对象中的共享 // return $this->name . '年龄是: ' . $this->age. '国家是:' . $this->country; // 这样会报错 return $this->name . '年龄是: ' . $this->age. '国家是:' . self::$country; } // 类方法: 静态方法 public static function getInfo2(){ // 静态方法是类方法, 不能用对象调用,所以内部也不允许使用对象引用$this // 如果静态方法中,一定要用到对象属性或方法,可以用参数传入 return $this->name . '年龄是: ' . $this->age . '国家是:' . self::$country; } // 静态方法: 以方法传参方式调用对象属性/方法 public static function getInfo3($name,$age){ // return $this->name; // 会报错,在静态方法里,不能访问非静态成员 // 可以用self调用,也可以用本类名调用。 最好在本类用self,在外部用类名 return $name . '年龄是: ' . $age . '国家是:' . Demo1::$country; } } $obj = new People('九世',233); echo $obj->name, '<br>'; echo $obj->age, '<br>'; // echo $obj->country, '<br>'; //会报错 echo People::$country; // 应该以这种方式访问静态属性 echo '<br>'; echo $obj->getInfo1(), '<br>'; // echo $obj->getInfo2(), '<br>'; // 会报错 // echo People::getInfo2(), '<br>'; // 会报错 echo People::getInfo3($obj->name,$obj->age); echo '<br>'; // 对象不能访问静态属性,但是可以访问静态方法 echo $obj->getInfo3($obj->name,$obj->age); // 静态成员可以重新赋值。在创建很多对象,值不会因为创建的对象改变。 People::$country = 'china'; $obj1 = new People('九世',998); echo People::$country; echo '<hr>';
常量
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 # define 顶一个常量,第一个参数是常量名,第二个参数是参数值; define('COUNTRY','中国'); class People{ // 类常量其实也是类属性,但是只能用类访问 // 类常量值不能修改, const COUNTRY = '中国'; public static $sex = '男'; private $name; public function __construct($name){ $this->name = $name; } public function getInfo(){ // 类常量在类里面,访问方式与类属性是一样的 return $this->name.'的性别是:' . self::$sex.',国籍是: ' . self::COUNTRY; } } $obj = new People('九世'); // 访问属性 echo People::$sex, '<br>'; // 访问常量 echo People::COUNTRY, '<br>'; echo $obj->getInfo(); echo '<hr>'; // 修改属性 People::$sex = '保密'; // 修改常量: 报错 因为常量不能修改 //People::COUNTRY = '日本'; // 可以看到类属性:$sex发生了变化 echo $obj->getInfo(); echo '<hr>';
自动加载
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 /* spl_autoload_register(callback);通过回调自动加载外部文件; __DIR__魔术常量 */ # 查看当前脚本所在的目录逗号是必须加的也可以换成. echo __DIR__,'<br>'; # 假设我们需要加载很多个php文件 include __DIR__ . '/inc/Test1.php'; include __DIR__ . '/inc/Test2.php'; include __DIR__ . '/inc/Test3.php'; # 像这种方式导入属实太慢那么问题来了就开始解决 # php标准函数库中提供了一个自动加载文件的注册函数 # 这个函数,在当前脚本引用一个未加载的文件时, 会自动调用它的回调方法来加载这个文件 spl_autoload_register(function ($class){ // include __DIR__ . '/inc/Test1.php'; // 将include中的类名Test1用变量替换掉,这样就实现了最简单的自动加载 // 后面我们会使用命名空间来完善这个函数,目前大家先理解到这里即可 include __DIR__ . '/inc/'.$class.'.php'; }); # 但是不要忘记创建命名空间 <?php namespace inc; class Test1{ public static function get(){ return __CLASS__ . ' 类, 加载成功~~'; } }
抽象类 abstract 修饰类就是抽象类,修饰方法就是抽象方法但是不能有方法体;
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 abstract class a{ public $name; public function __construct($name){ $this->name = $name; } // 只要类里面有一个抽象方法,那这个类就必须是抽象类 public function af(){ echo $this->name; } // 抽象方法不能有方法体也就是这个花括号{} abstract public function aff(); } // 抽象类只能由子类继承实现 // 我们就用b类,继承 a抽象类 class b extends a{ // b类 继承 a抽象类后:必须把a抽象类 ,里面的抽象方法,重新写一遍(实现) public function aff(){ echo $this->name; } } // 实现后,我们可以调用子类,进行实例化,然后调用成员方法和成员变量。 $a = new b('九世'); // 为什么抽象类里的af方法能调用呢,因为它是普通方法。 $a->af(); echo '<br/>'; // 这里的方法为什么能调用呢? 因为b类,继承了a抽象类的方法后:实现成为普通类。 $a->aff();
接口 接口使用关键字 interface 定义 类使用implements 实现接口
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 interface jiushi{ const NAME = '就是'; public function setName($name); public function setSex($sex); } class boy implements jiushi{ public $name; public $sex; // 构造方法 public function __construct($name='九世', $sex='男'){ $this->name = $name; $this->sex = $sex; } // 必须实现设置名称的接口方法 public function setName($name){ $this->name = $name; } // 必须实现设置性别的接口方法 public function setSex($sex){ $this->sex = $sex; } // 类中自定义的对象方法 public function getInfo(){ return $this->name . $this->sex . ' <br>'; } } $jiushi = new boy(); echo $boy->getInfo(); $boy->setName('九世啊'); $boy->setSex('男的'); echo $boy->getInfo(); echo '<hr>';
后期静态绑定 使用这个以后实例方法种也能调用静态方法了;
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 class A{ public static function who(){ echo 111; } public function test(){ // 注意: static:: 除了可以用在静态方法中, 也可以用在普通对象方法中 static::who(); } } // B继承了A,重写A类里面的who方法。 class B extends A{ public static function who(){ echo 222; } } $a = new B(); echo $a->test();
类相关的关键字
关键字
类外声明
声明类
声明属性
声明方法
描述
const
√
定义常量
extends
√
子类继承父类的关键字
public
√
√
声明属性声明方法
protected
√
√
受保护的
private
√
√
私有的
abstract
√
√
定义抽象类
final
√
√
类不能被继承
interface
√
定义接口
implements
√
实现接口
parent::
访问父类
$this
访问本类
self::
访问静态
static::
后期静态绑定
namespace::
创建命名空间
PHP命名空间
命名空间与java中的包名是一个意思
主要解决了php 全局成员的命名冲突的问题
也就是说不同的命名空间下面的类名是可以一样的,属性名方法名都能一样,但是命名空间不能一样;
命名空间定义
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 namespace jiushi; # 在jiushi空间中定义三个全局成员 class JiuShi {} function hello(){ return 'Hello 九世'; } const JIUSHI = '九世的博客'; # 完整类名 echo JiuShi::class . '<br>'; echo hello() . '<br>'; echo JIUSHI . '<hr>'; # ------------以上是一个命名空间,两个请看下面--------------- namespace one; # 在one空间中定义全局成员 class Pig {} function hello(){ return 'Hello 九世'; } const SITE = '九世贤'; # 完整类名 echo Pig::class . '<br>'; echo hello() . '<br>'; echo SITE . '<hr>'; namespace two; class Pig {} function hello(){ return 'Hello 文'; } const SITE = '是文某人'; # 完整类名 echo Pig::class . '<br>'; echo hello() . '<br>'; echo SITE . '<br>'; # 如果你要在当前的命名空间访问另外一个命名空间的成员 # 从根空间开始,根空间: "\" echo '<br>'; # 指定从根开始\哪个命名空间\哪个成员 echo \one\Pig::class . '<br>'; echo \one\hello() . '<br>'; echo \one\SITE . '<hr>';
Ps:不建议一个脚本里面声明多个命名空间; 如何优雅的定义多个命名空间呢?
1 2 3 4 5 6 7 8 9 10 # 使用花括号{}将你这一个命名空间里的成员等全部包起来, namespace jiushi{ class JiuShi{} } # 如何定义全局的命名空间呢,不指定命名空间的名称就相当于定义全局命名空间 namespace{ class Teacher{} }
子命名空间
1 2 3 4 5 6 7 8 # 创建命名空间 namespace jiushiboy{ } # 创建子命名空间,用反斜杠区分 namespace jiushiboy\com{ }
空间类文件自动加载 str_replace();字符函数替换,将空间符替换成路径分隔符 DIRECTORY_SEPARATOR;路径分隔符常量 spl_autoload_register();自动加载函数
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 spl_autoload_register(function ($class){ // 这里将"\"替换成路径分隔符, 推荐使用常量:DIRECTORY_SEPARATOR,而不是"/",可苑跨平台支持 $path = str_replace('\\', DIRECTORY_SEPARATOR, $class); // 相对路径 // $path = $path . '.php'; // 绝对路径 $path = __DIR__ . '/' . $path . '.php'; // 不是文件或文件不存在,则抛出异常 if (!(is_file($path) && file_exists($path))) { throw new \Exception('不是文件或文件不存在'); } require $path; });
空间别名
1 2 3 4 5 # 如果你要使用别的命名空间下面的类去new的话你觉得名字路径什么的太长了 # 假设\jiushiboy\com\ 命名空间下有一个jiushi类,想起一个别名该如何操作? # use关键字和AS关键字完成起别名操作; use \jiushiboy\com\jiushi AS j1; $jiushi=new j1();