PHP环境安装

根据你环境选择Windows或者Linux版本与位数,我选择的是Windows64位;
传送门: https://www.xp.cn/download.html

phpstudy使用

当我们写好php文件以后怎么查看效果呢?
我们启动apache然后进行配置,选择网站目录并且放置php文件到WWW/目录下面,默认访问路径是localhost/你的php文件.php;

PHP语法

语言标记

表示这一段是PHP代码;通过cgi请求PHP解释器处理;

1
2
3
<?php

?>

echo输出语句

1
echo 'Hello World';
1
print_r(1);

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();