常见的编程思想

面向过程思想

通过程序的执行顺序为主线开发代码

优点：简单，易学，上手快。

缺点：多人合作不方便

面向对象思想

以组成项目的对象为主线进行开发。在面向对象的思想里面，所有的事物都看成对象。

优点：多人合作方便，代码冗余很少

缺点：学起来比面向过程复杂。

面向对象简介

OOP：面向对象编程（Object Oriented Programming），OOP，面向对象编程

OOAD：OOA和OOD

OOA: 面向对象分析(Object-Oriented Analysis,OOA)

OOD: 面向对象设计（Object-Oriented Design，OOD）

对象

对象是由属性和方法组成的

属性的本质就是变量

方法的本质就是函数

类

类是所有对象共同的属性和方法的组合。

我们在开发时候是通过调用对象的方法或属性来实现某个效果，要调用方法必须先有对象，要想有对象必须先有类。

开发顺序：类——（实例化）对象——调用对象的方法和属性。

类和对象的关系

通过类可以创建多个对象，类就类似于模具，一个模具制造很多形状一致的对象。

类是有父类和子类之分的

再比如：老师是类，语文老师也是类，老师是父类，语文老师是子类。

在PHP中实现类

语法

class 类名{

//属性

//方法

//常量

}

类名的命名规则

1. 以字母、下划线开头，后面跟的是字母、数字、下划线
2. 一般用帕斯卡命名法
3. 不能用PHP关键字做类名
4. 类名不区分大小写

实例化对象

实例化：创造实例（对象）的过程

通过new关键字实例化

$对象名=new 类名()

例题

对象的传递

对象的传递的地址传递

操作属性

对象调用属性和方法使用“->”，

语法：

对象名->属性

对象名->方法名()

<?php

//类

class Student {

public $name; //语法结构：访问修饰符+变量名

}

//实例化

$stu1=new Student; //类名后不加()也可以

$stu2=new Student(); //类名后加()也可以

$stu1->name=’tom’; //操作1、给属性赋值

echo $stu1->name,'<br>’; //tom //操作2、显示属性的值

$stu1->add=’beijing’; //操作3、给stu1对象添加add属性

unset($stu2->name); //操作4、删除stu2对象的name属性

var_dump(isset($stu1->name));//bool(true) //操作5：判断属性是否存在

定义方法

语法结构

访问修饰符 function 方法名(参数){

//方法体

}

例题

对象的比较

全等：指向同一个对象是全等

相等：只要属于同一个类，结构和属性值都一致才相等

访问修饰符

用来修饰属性和方法，控制属性和方法的权限

例题一

脚下留心：一般来说，属性都是私有的，通过公有的方法对私有的属性进行赋值和取值。这样做可以在方法中对数据进行过滤，提高数据安全性。

<?php

class Student {

public $name; //私有属性

public $sex; //私有属性

//通过公有的方法进行赋值

public function setInfo($name,$sex) {

if($sex!=’男’ && $sex!=’女’){

echo ‘性别只能是男或女<br>’;

return;

}

$this->name=$name; //$this表示调用当前方法的对象

$this->sex=$sex;

}

//通过公有的方法进行取值

public function getInfo() {

echo ‘姓名：’.$this->name,'<br>’;

echo ‘性别：’.$this->sex.'<hr>’;

}

}

//调用

header(‘Content-Type:text/html;charset=utf-8’);

$stu1=new Student;

$stu1->setInfo(‘tom’,’男’);

$stu1->getInfo();

$stu2=new Student;

$stu2->setInfo(‘berry’,’女’);

$stu2->getInfo();

$this

$this在方法的内部使用，表示调用当前方法的对象。

构造函数

普通方法不调用就不执行

构造函数也叫构造方法，在实例化对象的时候自动调用执行

语法一：

Public function __construct(){

}

脚下留心：__construct()前面是两个下划线。

语法二：和类名同名的函数是构造函数

Public function 类名(){

}

例题

脚下留心：推荐使用__construct(),因为__construct()的优先级最高。

构造函数用来初始化成员变量

成员变量就是属性

析构函数

当对象销毁的时候自动调用

语法

Public function __destruct(){

}

代码

脚下留心：

1. 构造函数和析构函数是PHP自己调用，不能手动调用
2. 构造函数可以带有参数，析构函数不能带有参数。

多学一招：数据的存储和销毁分为两种情况:先进先出（队列）

先进后出（出入栈）

对象在内存中的分布

对象的本质就是复杂变量

类的本质就是复杂的数据类型

分析如下代码

<?php

class Student {

private $name;

private $sex;

public function show() {

echo ‘i am a student<br>’;

}

}

$stu1=new Student(); //将堆区的地址付给栈区的$stu1

$stu1->show();

$stu2=new Student();

$stu2->show();

在内存中结构

堆区特点：体积大，查询速度慢

栈区特点：体积小，查询速度快

基本数据类型的数据都存放在栈区中；复杂数据类型都存储在堆区中，但是堆区中的地址保存到栈区中。

继承

1. 代码具有层次结构
2. 子类继承了父类的属性和方法，实现了代码的可重用性。

语法

Class 子类 extends 父类{

}

继承的例题

<?php

//父类

class Person {

public $name=’tom’;

public function show() {

echo ‘i am a boy!’;

}

}

//子类

class Student extends Person {

}

//测试

$stu=new Student();

echo $stu->name,'<br>’;

$stu->show();

分析：$stu->name执行过程，首先在Student中寻找$name,如果找到就访问，如果找不到，就到Person类中找$name。

调用父类的属性和方法

在子类中通过$this关键字可以调用父类属性和方法

调用父类的构造方法

总结一句话：如果子类有构造方法就调用子类的，如果子类没有就调用父类的。

通过parent::__construct()调用父类的构造函数

Parent表示父类的名字

给父类传递参数

<?php

//父类

class Person {

protected $name;

protected $sex;

public function __construct($name,$sex) {

$this->name=$name;

$this->sex=$sex;

}

}

//子类

class Student extends Person {

private $score;

public function __construct($name,$sex,$score) {

parent::__construct($name,$sex);//调用父类的构造函数

$this->score=$score;

}

public function show() {

echo “姓名：{$this->name}<br>”;

echo “性别：{$this->sex}<br>”;

echo “成绩：{$this->score}<br>”;

}

}

//测试

header(‘Content-Type:text/html;charset=utf-8’);

$stu=new Student(‘tom’,’男’,88);

$stu->show();

运行结果

parent表示父类的名字

提醒：使用parent关键字可以降低程序的耦合性。

protected（受保护的）

protected修饰的在整个继承链上访问

$this

$this表示当前对象的引用（地址）

封装

通过访问修饰符来封装，有选择性的提供数据。

多态

多种形态，多态分为两种，方法重写和方法重载，PHP不支持方法重载

方法重写

子类重写了父类的同名方法

规则：

1. 子类中的方法必须和父类中的方法同名
2. 子类可以拥有和父类不同数量的参数

1. 子类中覆盖的方法不能比父类中被覆盖的方法更加严格

方法重载

通过参数的个数来区分不同的方法，PHP不支持。

面向对象的三大特性

1. 封装，通过访问修饰符来实现封装
   1. Public
   2. Private
   3. protected
2. 继承：子类继承了父类的属性和方法
3. 多态：多种形态
   1. 方法重写
   2. 方法重载（PHP不支持）

私有属性的继承和重写

私有属性可以被继承，但是不能被重写

思考如下例题

方法修饰符

1. static：静态的
2. final：最终的
3. abstract：抽象的

static修饰符

1. static修饰属性叫静态属性，static修饰方法叫静态方法
2. 静态属性在加载类的时候分配空间（普通属性在实例化的时候分配空间）,所以不需要实例化就可以访问
3. 因为静态成员属于类，不属于某个对象，所以通过类名来调用静态成员
   1. 类名::静态属性
   2. 类名::静态方法()
4. 静态成员在内存中就一份。

多学一招： 由于普通方法在加载类的时候也加载了，所以也可以通过静态调用的方式来调用普通方法。

静态成员可以被继承

静态延时绑定

static也可以表示类名，表示调用当前访问的对象所属的类。

self：当前类的名字

self总是表示当前类的名字

final修饰符

final修饰的类不能被继承

final修饰的方法不能被重写

abstract修饰符

1. abstract修饰的方法叫抽象方法，abstract修饰的类叫抽象类
2. 只有方法的声明，没有方法的实现称为抽象方法。
3. 一个类中只要只要有一个方法是抽象方法，这个类必须是抽象类

1. 抽象类不可以被实例化，必须在子类中重新实现抽象方法
2. 抽象方法的作用：用来定义命名规范的。

<?php

//类中只要有一个方法是抽象的，这个类就是抽象类

abstract class Goods {

protected $name; //商品名

public function setName($name) {

$this->name=$name;

}

public abstract function show(); //只有方法的声明，没有方法的实现

}

//手机类继承商品类

class Mobile extends Goods {

public function show() { //实现父类的抽象方法

echo $this->name,'<br>’;

}

}

//图书类继承商品类

class Book extends Goods {

public function show() { //实现父类的抽象方法

echo “《{$this->name}》<br>”;

}

}

//测试

header(‘Content-Type:text/html;charset=utf-8’);

$mobile=new Mobile();

$mobile->setName(‘iPhone7’);

$mobile->show();

$book=new Book();

$book->setName(‘PHP入门与精通’);

$book->show();

多学一招：类中一个抽象方法都没有也可以声明成抽象类。可以通过这种方法阻止类的实例化。

接口（interface）

1. 如果一个类中所有的方法都是抽象方法，这个类就可以声明成接口。
2. 使用interface关键字声明接口
3. 接口中的抽象方法只能是public的，默认也是public。
4. 接口不能继承，而是实现接口（implements）
5. abstract和final不能修饰接口中的抽象方法
6. 接口的作用也是用来定义命名规范

类不允许多重继承

一个父类可以有多个子类

一个子类不能有多个父类（只有c++可以多重继承，其他语言都不允许多重继承。）

多学一招：为什么很多语言不支持多重继承，因为多重继承容易产生二义性。

接口的多重实现

继承类同时实现接口

必须是先继承类再实现接口

类常量

常量也是加载代码的时候加载，所以也是通过类名来方法

类常量用const声明

const常量也可以放在接口中（接口中只能放抽象方法和常量）

参数约束

1. 参数约束在PHP5.3以后才支持
2. 只能约束对象，不能约束基本类型

父类可以指向子类的引用

父类可以保存子类对象的地址

<?php

class Person {

}

class Student extends Person {

}

class Employee extends Person {

}

function show(Person $obj) {

}

//测试

show(new Student);

show(new Employee);

分页功能

知识点：select * from 表名 limit 起始位置，记录数

起始位置从0开始。

分析：起始位置和页码的关系

一页放10条记录（$pagesize=10）

推导公式：$startno(起始位置)=($pageno-1)*$pagesize;

分析：总共有多少页

推导公式：$pagecount=ceil($rowcount/$pagesize)

实现第一步：输出页码

点击页码——获取页码——通过页码获取页码的内容

代码实现

//第一步：获取总记录数

$sql=”select count(*) from contents where title=$titleid”;

$rs=mysql_query($sql);

$rows=mysql_fetch_row($rs);

$rowcount=$rows[0]; //获取到总记录数

//第二步：求得总页数

$pagesize=10; //页码大小

$pagecount=ceil($rowcount/$pagesize); //求得总页数

在页码底部循环输出页码

<tr>

<td colspan=’3′>

<?php for($i=1;$i<=$pagecount;$i++):?>

<?php if($pageno==$i):?>

<span class=”pageno”><?php echo $i?></span> &nbsp;

<?php else:?>

<a href=”?pageno=<?php echo $i?>&titleid=<?php echo $titleid?>”><?php echo $i?></a>&nbsp;

<?php endif;?>

<?php endfor;?>

<a href=”?pageno=1&titleid=<?php echo $titleid?>”>【首页】</a>

<a href=”?pageno=<?php echo $pageno-1?>&titleid=<?php echo $titleid?>”>【上一页】</a>

<a href=”?pageno=<?php echo $pageno+1?>&titleid=<?php echo $titleid?>”>【下一页】</a>

<a href=”?pageno=<?php echo $pagecount?>&titleid=<?php echo $titleid?>”>【末页】</a>

</td>

</tr>

实现第二步：获取页码，并取出当前页面中的内容

代码

//第三步：获取当前页的内容

$pageno=isset($_GET[‘pageno’])?$_GET[‘pageno’]:1; //获取当前页码

$pageno=$pageno<1?1:$pageno; //如果页码小于1，定位到第一页

$pageno=$pageno>$pagecount?$pagecount:$pageno; //页码大于总页数，定位到最后一页

$startno=($pageno-1)*$pagesize; //计算当前页的起始位置

$sql=”select * from contents where title=$titleid limit {$startno},{$pagesize}”;

$rs=mysql_query($sql);

完整代码

<!doctype html>

<html>

<head>

<meta charset=”utf-8″>

<title>无标题文档</title>

<style type=”text/css”>

table{

width:980px;

}

table,td,th{

border:solid 1px #000;

margin:auto;

font-size:14px;

}

.pageno{

font-size:24px;

color:#FF0000;

}

</style>

</head>

<body>

<?php

//连接数据库

mysql_connect(‘localhost’,’root’,’root’) or die(‘数据库连接失败’);

mysql_select_db(‘jokedb’);

mysql_query(‘set names utf8’);

?>

<!–显示分类–>

<?php

$rs=mysql_query(‘select * from title’);

?>

<table>

<tr>

<?php

$n=0;

while($rows=mysql_fetch_assoc($rs)):

?>

<td><a href=”?titleid=<?php echo $rows[‘Id’]?>”><?php echo $rows[‘Title’]?></a></td>

<?php

if(++$n%9==0)

echo ‘</tr><tr>’;

endwhile;

?>

</tr>

</table>

<!–显示内容–>

<?php

$titleid=isset($_GET[‘titleid’])?$_GET[‘titleid’]:1;

//第一步：获取总记录数

$sql=”select count(*) from contents where title=$titleid”;

$rs=mysql_query($sql);

$rows=mysql_fetch_row($rs);

$rowcount=$rows[0]; //获取到总记录数

//第二步：求得总页数

$pagesize=10; //页码大小

$pagecount=ceil($rowcount/$pagesize); //求得总页数

//第三步：获取当前页的内容

$pageno=isset($_GET[‘pageno’])?$_GET[‘pageno’]:1; //获取当前页码

$pageno=$pageno<1?1:$pageno; //如果页码小于1，定位到第一页

$pageno=$pageno>$pagecount?$pagecount:$pageno; //页码大于总页数，定位到最后一页

$startno=($pageno-1)*$pagesize; //计算当前页的起始位置

$sql=”select * from contents where title=$titleid limit {$startno},{$pagesize}”;

$rs=mysql_query($sql);

?>

<table>

<tr>

<th>编号</th> <th>内容</th> <th>作者</th>

</tr>

<?php while($rows=mysql_fetch_assoc($rs)):?>

<tr>

<td><?php echo $rows[‘Id’]?></td>

<td><?php echo $rows[‘Contents’]?></td>

<td><?php echo $rows[‘Author’]?></td>

</tr>

<?php endwhile;?>

<!–输出页码–>

<tr>

<td colspan=’3′>

<?php for($i=1;$i<=$pagecount;$i++):?>

<?php if($pageno==$i):?>

<span class=”pageno”><?php echo $i?></span> &nbsp;

<?php else:?>

<a href=”?pageno=<?php echo $i?>&titleid=<?php echo $titleid?>”><?php echo $i?></a>&nbsp;

<?php endif;?>

<?php endfor;?>

<a href=”?pageno=1&titleid=<?php echo $titleid?>”>【首页】</a>

<a href=”?pageno=<?php echo $pageno-1?>&titleid=<?php echo $titleid?>”>【上一页】</a>

<a href=”?pageno=<?php echo $pageno+1?>&titleid=<?php echo $titleid?>”>【下一页】</a>

<a href=”?pageno=<?php echo $pagecount?>&titleid=<?php echo $titleid?>”>【末页】</a>

</td>

</tr>

</table>

</body>

</html>

回顾

1. 多态：多种形态
2. 多态分为：方法重载和方法重写
   1. 方法重写：之类重写了父类的同名方法
      1. 规则：
         1. 子类重写的方法必须和父类名字一样
         2. 可以具有不同个数的参数，但是严格标准必须是个数一样
         3. 子类中覆盖的方法不能比父类更加严格
   2. 方法重载：在同一个类中有多个同名的方法，通过不同的参数个数和参数类型区分不同方法。PHP不支持方法重载。
3. 私有属性可以继承，但不能被重写
4. 方法修饰符
   1. Static（静态的）
      1. Static可以修饰属性和方法
      2. 静态成员在加载类的分配空间
      3. 静态成员在内存中只有一份，属于类，不属于某个对象
      4. 通过类名来调用静态成员 类名::静态成员
      5. 静态成员也是可以被继承的
      6. Static也可以表示类名，表示调用当前方法对象的所属的类
   2. Final（最终的）
      1. Final修饰的方法不能被重写
      2. Final修饰的类不能被继承
   3. Abstract（抽象的）
      1. 只有方法的声明，没有方法的实现成为抽象方法
      2. 一个类中只要有一个方法是抽象方法这个类必须是抽象类
      3. 没有抽象方法的类也可以声明成抽象类
      4. 抽象类不可以被实例化，抽象方法必须在子类中重新实现
      5. 抽象方法是用来定义方法的命名规范的
5. Self：总是表示当前类的类名
6. 接口
   1. 如果一个类中所有的方法都是抽象类，这个类可以声明成接口
   2. 使用interface关键字
   3. 通过implements关键字实现接口
   4. 接口中所有的方法都是抽象的，公有的
   5. 不能使用abstract和final来修饰接口中的方法
   6. 类不允许多重继承，接口可以多种实现
7. 类常量
   1. 使用const关键字声明
   2. Const常量可以放在类和接口中
8. 参数约束：只能约束对象
9. 父类可以指向子类的引用。

思考：如何实现C可以调用A和B中的方法

类的自动加载

在项目层面上类文件规则

1. 一个文件中只能有一个类
2. 文件名和类名同名
3. 文件名以.class.php结尾

场景（一个文件中需要用到3个类）

1. 创建Goods.class.php页面

<?php

//商品类

abstract class Goods {

protected $name;

final public function setName($name) {

$this->name=$name;

}

abstract function getName();

}

1. 创建Book.class.php页面

<?php

//图书类

class Book extends Goods {

public function getName() { //重写了父类的方法

echo “《{$this->name}》<br>”;

}

}

1. 创建Mobile.class.php

<?php

//手机类

class Mobile extends Goods {

public function getName() {

echo $this->name,'<br>’;

}

}

1. 在PHP页面中使用上面的3个类

问题：在代码之前要引入需要的类。如果页面中需要用到很多的类，这样引入就很麻烦了。

类的自动加载

当页面执行的时候，通过PHP核心程序（zend engine）判断用户需要用到那个类，如果没有找到该类，就会自动调用__autoload()函数，并且以缺少的类名做为参数传递到__autoload()函数中，我们只要在__autoload()函数中加载需要的类即可。

通过缺少的类名加载类文件

在类文件保存地址规则的情况下使用

把类的地址映射到数组中然后加载

适合在类文件保存不规则的时候使用

clone和__clone()

clone：用来创建一个对象

__clone()：当调用clone指令的时候自动执行__clone()函数

<?php

class Student {

//执行clone指令的时候自动调用__clone()方法

public function __clone() {

echo ‘你调用了clone指令<br>’;

}

}

header(‘Content-Type:text/html;charset=utf-8’);

$stu1=new Student;

$stu2=clone $stu1; //创建一个新的对象

var_dump($stu1);echo ‘<br>’;

var_dump($stu2);

总结：创建对象的方式：

1. 实例化
2. clone

单例模式

一个类只能创建一个对象

阻止类实例化的方法

1. 抽象方法（可以阻止在类的外部和内部实例化）
2. 私有的构造函数（阻止在类的外部实例化）

判断对象是否属于某个类

通过三私一公来实现

<?php

/**

*单例模式，三私一公

*/

class MySQL {

//保存MySQL的单例

private static $instance;

//阻止在类的外部实例化对象

private function __construct() {

}

//阻止在类的外部clone对象

private function __clone() {

}

//获取MySQL的单例

public static function getInstance() {

if(!self::$instance instanceof self) //静态属性中保存的对象是否属于MySQL类

self::$instance= new self(); //实例化对象对象

return self::$instance;

}

}

//测试

$db1=MySQL::getInstance();

$db2=MySQL::getInstance();

var_dump($db1); // object(MySQL)#1 (0) { } 

echo ‘<br>’;

var_dump($db2); // object(MySQL)#1 (0) { } 

项目层面的单例模式

多个对象的单例

工厂模式

传递不同的参数，返回不同的对象

<?php

class ProductA {

public function show() {

echo ‘获取A商品<br>’;

}

}

class ProductB {

public function show() {

echo ‘获取B商品<br>’;

}

}

//工厂模式(传递不同的参数获取不同的对象)

class Factory {

public static function create($num) {

switch($num%2) {

case 1:

return new ProductA();

case 0:

return new ProductB;

}

}

}

//测试

header(‘Content-Type:text/html;charset=utf-8’);

$objA=Factory::create(10);

$objB=Factory::create(15);

$objA->show(); //获取B商品

$objB->show(); //获取A商品

策略模式

传递不同的参数调用不同的策略（方法）

<?php

class Walk {

public function method() {

echo ‘走着去学校<br>’;

}

}

class Bus {

public function method() {

echo ‘坐车去学校<br>’;

}

}

class Bike {

public function method() {

echo ‘骑车去学校<br>’;

}

}

//策略模式，传递不同的对象，调用不同的方法

class Strategy {

public function go($obj) {

$obj->method();

}

}

//测试

header(‘Content-Type:text/html;charset=utf-8’);

$strategy=new Strategy();

$strategy->go(new Walk()); //走着去学校

$strategy->go(new Bus()); //坐车去学校

$strategy->go(new Bike()); //骑车去学校

魔术方法

已经学过的魔术方法

__construct()：构造函数，当实例化对象的时候自动调用

__destruct()：析构函数，当对象销毁的时候自动调用

__clone()：当调用clone指令的时候自动调用

__toString()和__invoke()

__tostring()：当对象作为字符串使用的时候自动执行

__invoke()：当将对象作为函数使用的时候自动执行

__set()、__get()、__isset()

1、__set($key,$value)：当给无法访问的属性赋值的时候自动调用

2、__get($key)：当给无法访问的属性取值的时候自动调用

3、__isset($key)：当判断无法访问的属性是否存在

4、__unset($key)：当销毁无法访问的属性的时候自动调用

总结：给私有属性赋值的方法

1. 通过公有的方法给私有属性赋值
2. 通过构造函数给私有属性赋值
3. 通过魔术方法__set()赋值，__get()取值

<?php

class Student {

private $name;

private $age;

/**

*当给无法访问的属性赋值的时候自动调用

*@param $key string 属性名

*@param $value string 属性值

*/

public function __set($key,$value) {

if($key==’age’ && !($value>=20 && $value<=30)){

echo ‘年龄必须在20~30之间<br>’;

return;

}

$this->$key=$value;

}

/**

*当给无法访问的属性取值的时候自动调用

*@param $key string 属性名

*/

public function __get($key) {

return $this->$key;

}

/**

*当判断无法访问的属性是否存在

*/

public function __isset($key) {

return isset($this->$key);

}

/**

*当销毁无法访问的属性的时候自动调用

*/

public function __unset($key) {

unset($this->$key);

}

}

header(‘Content-Type:text/html;charset=utf-8’);

$stu=new Student;

$stu->name=’tom’; //给私有属性赋值

$stu->age=25;

echo ‘姓名：’.$stu->name,'<br>’; //获取私有属性的值

echo ‘年龄：’.$stu->age,'<br>’;

var_dump(isset($stu->name)); //判断私有属性是否存在

echo ‘<br>’;

unset($stu->name); //销毁私有属性

var_dump($stu);

__call()、 __callStatic()

<?php

class Student {

/**

*当调用无法访问的属性的时候自动调用

*@param $name string 方法名

*@param $args array 参数数组

*/

public function __call($name,$args) {

echo “对象中没有'{$name}’的方法<br>”;

echo ‘你传递”‘.implode(‘,’,$args).'”参数给我也没用<hr>’;

}

/**

*当调用无法访问的静态方法的时候自动调用

*/

public static function __callstatic($name,$args) {

echo “对象中没有'{$name}’这个静态方法<br>”;

echo ‘你传递”‘.implode(‘,’,$args).'”参数给我也没用<hr>’;

}

}

header(‘Content-Type:text/html;charset=utf-8’);

$stu=new Student;

$stu->show(10,20); //调用无法访问的方法

Student::connect(); //调用无法访问的静态方法

__sleep()和 __wakeup()

__sleep()：在序列化的时候自动调用

__wakeup()；在反序列化的时候自动调用

<?php

class Student {

private $name;

private $sex;

private $add;

/**

*在调用serialize时候自动调用

*作用：只保留需要序列化的属性

*/

public function __sleep() {

return array(‘name’,’sex’); //返回需要序列化的属性

}

/**

*在调用unserialize时候自动调用

*作用：初始化对象的值

*/

public function __wakeup() {

$this->name=’tom’;

$this->sex=’男’;

$this->add=’中国’;

}

}

header(‘Content-Type:text/html;charset=utf-8’);

$stu=new Student;

$str=serialize($stu);

echo $str,'<hr>’;

$stu=unserialize($str);

print_r($stu);

序列化（serialize）和反序列化（unserialize）

思考：能否将数组和对象永久保存？

答：可以，但是必须先序列化

序列化就是将数组或对象变成一个字符串序列

数组序列化和反序列化

序列化

反序列化

对象序列化和反序列化

序列化

反序列化

发现可以反序列化，但是类名没有反编译出来，解决方法在反序列化之前引入对应的类就可以了

foreach遍历对象

foreach遍历只能遍历到可以访问到的属性

迭代器（Iterator）

场景：一个班级有60个学生，如何遍历这个班？

解决：

Iterator是PHP内置的接口，定义了5个抽象方法，只要实现了这5个抽象方法，迭代器就可以工作了。

例题

<?php

//班级类

class MyClass implements Iterator {

private $list=array(‘tom’,’berry’,’ketty’,’rose’); //学生数组

//复位数组

public function rewind() {

reset($this->list);

}

//判断当前指针是否有效

public function valid() {

return key($this->list)!==null;

}

//返回当前键

public function key() {

return key($this->list);

}

//返回当前值

public function current() {

return current($this->list);

}

//指针下移

public function next() {

next($this->list);

}

}

//测试

$class=new MyClass();

foreach($class as $key=>$val) {

echo $key,’-‘,$val,'<br>’;

}

通过单例模式封装MySQL数据库操作类

实现功能

1. 连接数据库
2. 查询数据

需要注意的点：

1. 一个方法只实现一个功能，方法的功能越单一越好，这样可以最大限度的实现代码的可重用性。

代码

<?php

/**

*MySQL数据库操作类(单例模式实现)

*/

class MySQLDB {

private $host; //主机地址

private $port; //端口号

private $user; //用户名

private $pwd; //密码

private $dbname; //数据库名称

private $charset; //支付编码

private static $instance; //保存MySQLDB的实例

//阻止在类的外部实例化

private function __construct($config) {

$this->initParam($config);

$this->connect();

$this->selectDb();

$this->setCharSet();

}

//阻止在类的外部调用clone指令

private function __clone() {

}

//获取MySQLDB类的单例

public static function getInstrance($config=array()) {

if(!self::$instance instanceof self)

self::$instance=new self($config);

return self::$instance;

}

//初始化数据

private function initParam($config) {

$this->host=isset($config[‘host’])?$config[‘host’]:’127.0.0.1′;

$this->port=isset($config[‘port’])?$config[‘port’]:’3306′;

$this->user=isset($config[‘user’])?$config[‘user’]:”;

$this->pwd=isset($config[‘pwd’])?$config[‘pwd’]:”;

$this->dbname=isset($config[‘dbname’])?$config[‘dbname’]:’data’;

$this->charset=isset($config[‘charset’])?$config[‘charset’]:’utf8′;

}

//连接数据库

private function connect() {

if(!$link=@mysql_connect(“{$this->host}:{$this->port}”,$this->user,$this->pwd))

$this->showMessage();

}

//选择数据库

private function selectDb() {

if(!mysql_select_db(“$this->dbname”))

$this->showMessage();

}

//设置字符编码

private function setCharSet() {

if(!@mysql_query(“set names {$this->charset}”)){

$this->showMessage();

}

}

//显示错误的方法

private function showMessage($sql=”) {

if($sql!=”)

echo ‘错误SQL语句：’.$sql,'<br>’;

echo ‘错误信息：’.mysql_error(),'<br>’;

echo ‘错误编号：’.mysql_errno(),'<br>’;

exit;

}

//执行SQL语句的方法

private function query($sql) {

if($rs=mysql_query($sql))

return $rs;

$this->showMessage($sql);

}

//拼接函数名

private function createFunction($type) {

$allow=array(‘assoc’,’row’,’array’);

if(!in_array($type,$allow))

$type=’assoc’;

return ‘mysql_fetch_’.$type;

}

//获取二维表的数据

public function getAll($sql,$type=’assoc’) {

$fn=$this->createFunction($type);

$rs=$this->query($sql);

$array=array();

while($rows=$fn($rs)) {

$array[]=$rows;

}

return $array;

}

}

header(‘Content-Type:text/html;charset=utf-8’);

//测试

$config=array(

‘user’ => ‘root’,

‘pwd’ => ‘root’,

‘dbname’=> ‘jokedb’,

);

$mysql=MySQLDB::getInstrance($config);

$rs=$mysql->getAll(‘select * from title’,’aa’);

echo ‘<pre>’;

var_dump($rs);

命名空间

命名空间介绍

如果一个项目很大，项目中由很多文件组成，如何有序的组织这些文件就是一个大问题，PHP提供了命名空间来解决。

多学一招：

C#语言中也是通过“命名空间”来解决的

Java语言通过“包”来解决的。

命名空间的声明与使用

通过namespace来声明命名空间

多级命名空间

<?php

namespace China\ShangHai\PuDong; //多级命名空间

function getInfo() {

echo ‘我是中国人<br>’;

}

namespace USA\Washington;

function getInfo() {

echo ‘I am a America<br>’;

}

//调用

header(‘Content-Type:text/html;charset=utf-8’);

getInfo(); //I am a America

\China\ShangHai\PuDong\getInfo(); //我是中国人

访问空间元素的三种方法

1. 非限定名称访问（类似于相对路径）
2. 完全限定名称访问（绝对路径）
3. 【部分】限定名称访问（相对路径）

引入命名空间（use）

分析：PuDong\getInfo()如何调用的？

第一步：通过命名空间拼接，拼接成\ USA\Washington\ PuDong\getInfo()，但是在这个地址下找不到此函数，所以继续执行第二步

第二步：由于引入了China\ShangHai\PuDong命名空间，又可以拼接成China\ShangHai\PuDong\ getInfo()，这个地址是可以找到函数的，所以调用此函数。

引入类（use）

通过use关键字引入类

给类取别名（as）

如果引入的类和已经存在的类同名，就会报错，我们可以引入类的同时给类取别名

<?php

namespace China\ShangHai\PuDong;

class Person {

public $name=’中国人’;

}

namespace USA\Washington;

class Person{

public $name=’美国人’;

}

header(‘Content-Type:text/html;charset=utf-8’);

use China\ShangHai\PuDong\Person as P; //引入类,并给类取别名

$person=new P();

echo $person->name; //中国人

公共命名空间

如果PHP文件中没有namespace关键字声明，该文件的元素都在“公共命名空间”下，访问公共命名空间用“\”。

命名空间的注意事项

1. 命名空间中可以放函数，类，const常量

1. 在第一个namespace之前不能有任何的代码，header()也不行。

1. 包含文件不能改变当前的命名空间

用文件的地址做命名空间，通过命名空间就可以实现自动加载类

1. 在Framework/Core文件夹下创建Student.class.php

<?php

namespace Framework\Core;

class Student {

public function show() {

echo ‘Core\Student\show()<br>’;

}

}

1. 在Framework/Lib文件夹下创建Student.class.php

<?php

namespace Framework\Lib;

class Student {

public function show() {

echo ‘Lib\Student\show()<br>’;

}

}

1. 在php中通过命名空间实现自动加载类

异常处理（Exception）

使用的关键字

try：检测代码中的异常

catch：捕获抛出的异常

throw：抛出异常

Exception：PHP内置的异常类

Exception异常类中的方法

Exception是基础异常类，该类提供了一些方法

异常的例题

自定义异常，捕获多个异常

PHP只提供了异常类，没有提供具体的某种异常，比如年龄异常，邮件异常等。

自定义异常必须继承Exception类，Exception类是所有异常类的父类。

<?php

//空异常

class NullException extends Exception {

}

//年龄异常

class AgeException extends Exception {

}

if(isset($_POST[‘button’])) {

$name=$_POST[‘name’];

$age=$_POST[‘age’];

try

{

if($name==”)

throw new NullException(‘姓名不能为空’); //抛出空异常

if($age==”)

throw new NullException(‘年龄不能为空’); //抛出空异常

if(!($age>=10 && $age<=20))

throw new AgeException(‘年龄必须在10-20之间’); //抛出年龄异常

}

catch(NullException $e)

{

echo $e->getMessage();

}

catch(AgeException $e)

{

echo $e->getMessage();

}

catch(Exception $e){ //必须放在所有的catch的最后

echo $e->getMessage();

}

}

?>

<form method=”post” action=””>

姓名： <input type=”text” name=”name”> <br />

年龄： <input type=”text” name=”age”> <br />

<input type=”submit” name=”button” value=”提交”>

</form>

介绍netbeans

安装netbeans

在安装netbeans之前必须先安装jdk（java开发包）

安装JDK后，再下一步，下一步安装netbeans.。

使用netbeans

双击netbeans图标

继续如下操作

创建完毕后，在虚拟目录的文件夹中多了一个“nbproject”文件夹，此文件夹用来让netbeans软件管理虚拟目录的，不是项目文件夹。在最后项目上传到服务器的时候要将此文件夹删除。

反射（Reflection）

反射的概念

程序可以访问、检测和修改它本身状态或行为的一种能力

反射的作用

获取对象对应的类中的属性，方法，参数，注释等封闭的信息，主要用来了解类、方法等内部结构。

反射的分类

了解如下几个反射类即可。

使用反射类（了解内容）

通过反射了解类的内部结构

语法：

ReflectionClass::export(类名);

例题

通过上面的例题可以得出结论，PHP最顶层的父类是一个空类，代码

class stdClass{

}

通过反射获取类中的属性、方法、常量

<?php

class Student{

const PI=3.14;

public $name=’tom’;

private $sex=’f’;

public function show(){

}

}

//通过反射获取类中的成员

$info= new ReflectionClass(‘Student’); //实例化反射类对象，此对象中包含了Student类中的信息

//获取常量信息

$const=$info->getConstants(); //获取所有常量,返回常量数组

$const=$info->getConstant(‘PI’); //获取PI常量

//获取方法信息

$method=$info->getMethods(); //获取所有方法,返回方法信息数组

$method=$info->getMethod(‘show’); //获取show()方法信息

//获取属性信息

$propty=$info->getProperties(); //获取所有属性信息

$propty=$info->getProperty(‘sex’); //获取sex属性

var_dump($propty);

通过反射实例化对象

newInstance()就是用来实例化对象，构造函数需要几个参数，就通过newInstance()传递几个参数。

通过反向代理调用类方法

正向代理：局域网中所有电脑通过服务器访问外网，局域网中电脑感受到服务器的存在，这种代理是正向代理

反向代理

将上面的理论平移到反射中来

A调用A的方法：正向代理

通过反射，A调用B的方法：反向代理