PHP面向对象 – 使用PDO连接数据库

PDO(php data object)扩展类库为php访问数据库定义了轻量级的、一致性的接口,它提供了一个数据库访问抽象层,这样,无论你使用什么数据库,都可以通过一致的函数执行查询和获取数据,大大简化了数据库的操作,并能够屏蔽不同数据库之间的差异,使用pdo可以很方便地进行跨数据库程序的开发,以及不同数据库间的移植,是将来php在数据库处理方面的主要发展方向,它可以支持mysql,postgresql,oracle,mssql等多种数据库。

PDO安装

1.编辑php.ini文件:

extension=php_pdo.dll

extension=php_pdo_mysql.dll

2.重启apache服务

3.打开phpinfo.php查看是否有pdo

创建PDO对象与连接使用PDO对象

1.创建PDO对象

$dsn = ‘mysql:dbname=testdb;host=127.0.0.1’; //连接MySQL数据库的DSN

$user = ‘dbuser’; //MySQL数据库的用户名

$password = ‘dbpass’; //MySQL数据库的密码

try {

$dbh = new PDO($dsn, $user, $password);

} catch (PDOException $e) {

echo ‘数据库连接失败: ‘ . $e->getMessage();

}

2.设置连接字符集

设置php连接mysql时的客户端字符串和连接字符串集为:

$pdo->exec(“set names utf8”);

或者:

$pdo->query(“set names utf8”);

3.调整PDO行为

setAttribute() //设置PDO行为属性

getAttribute() //得到PDO行为属性值

4.设置错误处理模式

PDO::ATTR_ERRMODE //错误处理模式

PDO::ERRMODE_SILENT:不报错误(忽略)(0)

PDO::ERRMODE_WARNING:以警告的方式报错(1)

PDO::ERRMODE_EXCEPTION:以异常的方式报错(推荐使用)(2)

设置方式:

在构造时初始化错误模式通过pdo对象的setAttribute()方法设置。

$pdo->setAttribute(PDO::ATTR_ERRMODE,PDO::ERRMODE_EXCEPTION);

面向过程

$con->errorCode():SQL语句错误代码

$con->errorInfo():错误信息

面向对象

捕获PDOException异常对象

5.使用PDO执行SQL语句

exec()方法用于执行有影响行数的语句

query()方法用于执行有结果集的语句

下面是栗子:

//连接数据库
$dsn = 'mysql:dbname=xiaofan;host=localhost';
$username = 'root';
$password = '';
try{
	$dbh = new PDO($dsn,$username,$password);
}catch(PDOException $e){
	echo $e->getMessage();
}
$dbh->exec("set names utf8");	//设置php连接mysql时的客户端字符串和连接字符串集

$sql = "insert into users(username,tel) values('xiaoming','123456789')";
$dbh->exec($sql);	//执行插入 删除等影响行数的语句,使用exec()

$sql = "select username,tel from users";
$query = $dbh->query($sql);	//执行查询语句 有结果集的语句,使用query()
$result = $query->fetchAll();	//通过一次调用返回所有结果,结果是以数组形式保存
var_dump($result);

以上是简单的PDO执行方法,而实际中我们会使用下面的PDO预处理方法执行SQL语句。

PDO预处理

PDO预处理相比上面的简单方法最大优势是:防止SQL注入漏洞,有利于网站数据的安全。同时,也有利于多次执行。

1.PDOStatement对象的方法

fetch()  返回结果集的下一行,结果指针下移,到头返回false

fetchAll()  通过一次调用返回所有结果,结果是以数组形式保存

execute()    负责执行一个准备好了的预处理语句

rowCount()    返回使用增、删、改、查操作语句后受影响的行总

bindParam()  将参数绑定到相应的查询占位符上

bindColumn()  将查询结果的字段绑定变量

参数: PDO::FETCH_BOTH (default)、PDO::FETCH_ASSOC、 PDO::FETCH_NUM、PDO::FETCH_OBJ、 PDO::FETCH_COLUMN表示取指定某一列如:$rslist = $stmt->fetchAll(PDO::FETCH_COLUMN,2);取第三列数据

2.准备语句

得到pdo预处理对象的方法:

$sql=“select * from user order by id”;

$sth=$pdo->prepare($sql);

以上代码中的$sth即为预处理对象

在PDO中参数式的SQL语句有两种(预处理sql):

insert into stu(id,name) value(?,?); //?号式(适合参数少的)

insert into stu(id,name) value(:id,:name);//别名式(适合参数多的)

3.绑定参数

A.点位符方式

$stmt->bindParam(1, $name, PDO::PARAM_STR);

B.别名方式

$stmt->bindParam(‘:name’, $name);

这里特别注意:不能传入字符串,必须用变量 $stmt->bindParam(‘:name’,’xiaofan’);这样是错误的

4.执行预处理方式

A.占位符?

$query = “INSERT INTO contactInfo (name, address, phone) VALUES (?, ?, ?)”; $stmt = $dbh->prepare($query);

//传递一个数组为预处理查询中的问号参数绑定值,并执行一次。

$stmt->execute(array(“赵某某”, “海淀区”, “15801688348”));

//再次传递一个数组为预处理查询中的问号参数绑定值,并执行第二次插入数据。 $stmt->execute(array(“孙某某”, “宣武区”, “15801688698”));

B.占位符 :

$query = “INSERT INTO contactInfo (name, address,) VALUES (:name, :address)”;

//调用PDO对象中的prepare()方法准备查询,使用命名参数

$stmt = $dbh->prepare($query);

//传递一个数组为预处理查询中的命名参数绑定值,并执行一次。

$stmt->execute(array(“name”=>”赵某某”,”address”=>”海淀区”));

//再次传递一个数组为预处理查询中的命名参数绑定值,并执行第二次插入数据。

$stmt->execute(array(“name”=>”孙某某”,”address”=>”宣武区”));

5.预处理查询

$query = “SELECT uid, name, phone, email FROM contactInfo WHERE

$stmt = $dbh->prepare($query);   //准备声明好的一个查询

$stmt->execute();          //执行准备好的查询

$stmt->bindColumn(1, $uid);     //通过列位置偏移数绑定变量

$stmt->bindColumn(2, $name);   //通过列位置偏移数绑定变量$name

$stmt->bindColumn(‘phone’, $phone); //绑定列名称到变量$phone上

$stmt->bindColumn(’email’, $email); //绑定列名称到变量$email上

while ($stmt->fetch(PDO::FETCH_BOTH)) {

echo $uid.”\t”.$name.”\t”.$phone.”\t”.$email.”\n”;

}

下面是栗子:

//连接数据库
$dsn = 'mysql:dbname=xiaofan;host=localhost';
$username = 'root';
$password = '';
try{
	$dbh = new PDO($dsn,$username,$password);
}catch(PDOException $e){
	echo $e->getMessage();
}
$dbh->exec("set names utf8");	//设置php连接mysql时的客户端字符串和连接字符串集
//PDO预处理执行
//使用?占位符
$sql = "insert into users(username,tel) values(?,?)";
$stmt = $dbh->prepare($sql);
$arr = array('user1',11111111);
$stmt->execute($arr);

//使用:占位符
$sql = "insert into users(username,tel) values(:username,:tel)";
$stmt = $dbh->prepare($sql);
$arr = array("username"=>"user3","tel"=>"333333333");
$stmt->execute($arr);

//PDO预处理查询
$sql = "select username,tel from users where id > :id";
$stmt = $dbh->prepare($sql);
$stmt->execute(array("id"=>2));
$stmt->bindColumn(1,$username); //通过列位置偏移数绑定变量
$stmt->bindColumn('tel',$tel);	//绑定列名称到变量上
//用while循环获取每行内容
while($stmt->fetch(PDO::FETCH_ASSOC)){
	echo $username.'--'.$tel.'<br>';
}
//也可以直接将结果放入一个数组
$result = $stmt->fetchAll(PDO::FETCH_COLUMN,1);	//获取第二列数据,注意是列不是行
var_dump($result);
//不使用bindColumn绑定方法
while($result = $stmt->fetch(PDO::FETCH_BOTH)){
	echo $result['username'].'--'.$result['tel'].'<br>';
}

PDO事务处理

1.MySQL的事务处理

事务:将多条sql操作(增删改)作为一个操作单元,要么都成功,要么都失败。

MySQL对事务的支持:

被操作的表必须是innoDB类型的表(支持事务)

MySQL常用的表类型:MyISAM(非事务)增删改速度快、InnodB(事务型)安全性高

2.构建事务处理应用程序

开启一次事务:

$pdo->beginTransaction();

提交一次事务:

$pdo->commit();

回滚一次事务:

$pdo->rollback();

注意如下设置:

$pdo->setAttribute(PDO::ATTR_AUTOCOMMIT,0);

$pdo->setAttribute(PDO::ATTR_AUTOCOMMIT,1);

以下是事务提交的栗子

$db->beginTransaction();
try{
$sql = 'INSERT INTO user(username,tel) values(:username,:password)';
$smt = $db->prepare($sql);
$arr = array("username" => "mazi","password" => "963");
if (!$smt->execute($arr)){
	throw new PDOException('first error');
}
$sql = 'INSERT INTO admin(username,tel) values(:username,:password)';
$smt = $db->prepare($sql);
$arr = array("username" => "andy","password" => "951");
if (!$smt->execute($arr)){
	throw new PDOException('second error');
}
$db->commit();
}catch(PDOException $e){
	$db->rollback();
	echo $e->getMessage(). '<br>';	
}

 

PHP面向对象 – 常用函数

class_exists — 检查类是否已定义

格式: bool class_exists ( string $class_name [, bool $autoload ] )

如果由 class_name 所指的类已经定义,此函数返回 TRUE,否则返回 FALSE。

默认将会尝试调用 __autoload,如果不想让 class_exists() 调用 __autoload,可以将 autoload 参数设为 FALSE。

get_class_methods — 返回由类的方法名组成的数组

格式:array get_class_methods ( mixed $class_name )

返回由 class_name 指定的类中定义的方法名所组成的数组。如果出错,则返回 NULL。

从 PHP 4.0.6 开始,可以指定对象本身来代替 class_name

get_class — 返回对象的类名

格式: string get_class ([ object $obj ] )

返回对象实例 obj 所属类的名字。如果 obj 不是一个对象则返回 FALSE

get_object_vars — 返回由对象属性组成的关联数组

格式:array get_object_vars ( object $obj )

返回由 obj 指定的对象中定义的属性组成的关联数组。

get_parent_class — 返回对象或类的父类名

格式:string get_parent_class ([ mixed $obj ] )

如果 obj 是对象,则返回对象实例 obj 所属类的父类名。

is_a — 如果对象属于该类或该类是此对象的父类则返回 TRUE

格式:bool is_a ( object $object , string $class_name )

我们可以使用运算符: instanceof代替上面的is_a操作

method_exists — 检查类的方法是否存在

格式:bool method_exists ( object $object , string $method_name )

如果 method_name 所指的方法在 object 所指的对象类中已定义,则返回 TRUE,否则返回 FALSE。

property_exists — 检查对象或类是否具有该属性

格式:bool property_exists ( mixed $class , string $property )

本函数检查给出的 property 是否存在于指定的类中(以及是否能在当前范围内访问)。

下面是栗子:

function __autoload($classname){
	echo "Class ".$classname." is not exist!<br>";
}
var_dump(class_exists('aclass',false));	//判断类名为aclass的类是否存在
echo '<br>';

class person{
	public $name = 'zhangsan';
	private $age = 20;
	public function say(){}
	public function write(){}
	public function read(){}
}
var_dump(get_class_methods('person'));	//获取类person有哪些成员方法
echo '<br>';
$a = new person();
var_dump(get_class_methods($a));	//用对象一样可以回去类的成员方法
echo '<br>';

$p = new person();
echo get_class($p);	//获取对象的类名
echo '<br>';
print_r(get_object_vars($p));	//获取对象的类成员属性,仅能获取public公有属性
echo '<br>';

class student extends person{
	public $grade = 1;
	public function stu(){}
}
$stu = new student();
echo get_parent_class($stu);	//返回对象的类的父类名称
echo '<br>';
var_dump(is_a($stu,'person'));	//检测对象是否属于某个类或其父类
echo '<br>';
var_dump($stu instanceof person);	//使用运算符 instanceof 可以实现同样的功能
echo '<br>';
var_dump(method_exists($stu,'stu'));	//检测对象类中是否存在某个方法
echo '<br>';
var_dump(property_exists($stu,'grade'));	//检测对象类中是否存在某个属性

 

PHP面向对象 – 异常处理Exception

异常经常被用来处理一些在程序正常执行中遇到的各种类型的错误。比如做数据库链接时,你就要处理数据库连接失败的情况。使用异常可以提高我们程序的容错特性,从而使我们的应用程序更加的稳定和健壮。

PHP5 增加了类似其他语言的异常处理模块。在PHP代码中所产生的异常可被 throw 语句抛出并被 catch 语句捕获。需要进行异常处理的代码都必须放入到 try 代码块内,以便捕获可能存在的异常。每个try至少对应一个 catch 块。使用多个 catch 可以捕获不同的类所产生的异常。当 try 代码块不再抛出异常或者找不到 catch 能匹配所抛出的异常时,PHP 代码就会在跳转到最后一个 catch 的后面继续执行。当然,PHP 允许在 catch 代码块内再次抛出(throw)异常。

预定义异常 Exception

class  Exception{
	protected $message = 'Unknown exception';  // 异常信息
   	protected $code = 0;	// 用户自定义异常代码
    	protected $file;	// 发生异常的文件名
    	protected $line;
    	function __construct($message = null, $code = 0);
    	final function getMessage();	// 返回异常信息
    	final function getCode();	// 返回异常代码
    	final function getFile();	// 返回发生异常的文件名
    	final function getLine();	// 返回发生异常的代码行号
    	final function getTrace();	// backtrace() 数组
    	final function getTraceAsString();	// 已格成化成字符串的 getTrace() 信息
	function __toString();	// 可输出的字符串
}

下面是连接数据库的栗子:

class connectmysql{
	private $host = 'localhost';
	private $username = 'root';
	private $password = '1111';
	protected $conn = NULL;
	public function __CONSTRUCT(){
		$this->conn = mysql_connect($this->host,$this->username,$this->password);
		if(!$this->conn){
			throw new Exception("error: can't connect mysql!",1);	//抛出异常
		}
	}
}
try{
	$mysql = new connectmysql();
}catch(Exception $e){
	echo $e->getMessage().'<br>';
	echo $e->getCode().'<br>';
	echo $e->getFile().'<br>';
	echo $e->getLine().'<br>';
	echo $e.'<br>';
}

 

PHP面向对象 – 抽象类 抽象方法 接口 多态

抽象方法和抽象类

当类中有一个方法,他没有方法体,也就是没有花括号,直接分号结束,象这种方法我们叫抽象方法,必须使用关键字abstract定义。

如: public abstract function fun();

包含这种方法的类必须是抽象类也要使用关键字abstract加以声明。(即使用关键字abstract 修饰的类为抽象类)

抽象类的特点:

不能实例化,也就是不能new成对象

若想使用抽象类,就必须定义一个类去继承这个抽象类,并定义覆盖父类的抽象方法(实现抽象方法)。

接口技术

PHP与大多数面向对象编程语言一样,不支持多重继承,也就是说每个类只能继承一个父类。为了解决这个这个问题,PHP引入了接口,接口的思想是指定了一个实现了该接口的类必须实现的一系列函数。

定义格式:interface  接口名称{

//常量成员    (使用const关键字定义)

//抽象方法    (不需要使用abstract关键字)

}

使用格式:      class   类名   implements   接口名1,接口名2{ … …  }

多态应用

对象的多态性:是指在父类中定义的属性或行为被子类继承之后,可以具有不同的数据类型或表现出不同的行为。这使得同一个属性或行为在父类及其各个子类中具有不同的语义。

 

PHP面向对象 – 串行化 反串行化 __sleep __wakeup

PHP串行化可以把变量包括对象,转化成连续bytes数据,你可以将串行化后的变量存在一个文件里或在网络上传输,然后再反串行化还原为原来的数据。

什么时候使用串行化? 在网络中传输对象的时候 向数据库中保存文件的时候。

全部串行化

1.serialize(对象名) 将指定的类对象串行化 $str=serialize($per) //将per对象串行化,结果返回给$str
2.unserialize(串行化后的返回值) 返回结果是对象 $per=unserialize($str);

局部串行化

3.__sleep() 串行化某对象的部分属性。

4.__wakeup()反串行化时,初始化(其实是修改)对象内容

serialize 串行化与反串行化

class person{
	public $name;
	public $age;
	public function __construct($name,$age){
		$this->name = $name;
		$this->age = $age;
	}
}
$p = new person('lisi',15);
$str = serialize($p);	//串行化,存储对象
setcookie('class',$str);	//串行化的内容可以存储在cookie或者传给其他页面
$unstr = unserialize($_COOKIE['class']);	//反串行化
echo $unstr->name;

局部串行化 __sleep() __wakeup()

__sleep() 串行化某对象的部分属性。

__wakeup()反串行化时,初始化(其实是修改)对象内容

class person{
	public $name;
	public $age;
	public $sex;
	public function __construct($name,$age,$sex){
		$this->name = $name;
		$this->age = $age;
		$this->sex = $sex;
	}
	public function say(){
		echo 'I am '.$this->name.', '.$this->age.' years, '.$this->sex;
	}
	public function __sleep(){
		$arr = array("name","age");
		return $arr;
	}
	public function __wakeup(){
		$this->age = 20;
	}
}
$p = new person('lisi',15,'boy');
$str = serialize($p);	//串行化,存储对象
$unstr = unserialize($str);
echo $unstr->say();

 

PHP面向对象 – 封装性 (public private protected三者区别)及魔术方法__set() __get() __isset() __unset()

封装性是面向对象编程中的三大特性之一,封装就是把对象中的成员属性和成员方法加上访问修饰符,使其尽可能隐藏对象的内部细节,以达到对成员的访问控制(切记不是拒绝访问)。

public private protected三者区别

PHP5支持如下3种访问修饰符:

public (公有的 默认):在类的内部、被继承的子类、外部都可以访问

private (私有的):仅在类的内部访问,不能在被继承的子类及外部访问

protected (受保护的):在类的内部、被继承的子类可以访问,不能在外部访问

示例

<?php 

class person{
	private $name = 'lisi';
	protected $sex = 'man';
	public $age = 20;
	public function say(){
		echo $this->name.'<br>';
		echo $this->sex.'<br>';
		echo $this->age.'<br>';
	}
}
echo $p->name;	//无法获取
echo $p->sex;	//无法获取
echo $p->age;	//可以获取
$p = new person();
$p->say();	//可以全部获取

class stu extends person{
	public function student(){
		echo $this->name.'<br>';
		echo $this->sex.'<br>';
		echo $this->age.'<br>';
	}
}

$ming = new stu();
$ming->student();	//可以获取sex和age,无法获取name

?>

魔术方法

1. __get()魔术方法:在我们尝试访问一个不存在的、私有的或受保护的属性时会被自动调用。它可以接受一个参数,该参数表示访问属性的名字,并且将该属性的值返回。

该魔术方法通常用在创建一个“只读”(在类外部只能可读,但不能修改)的属性来扩展访问控制。如下面的栗子:

//魔术方法 __get 
class person{
	private $name;
	protected $age;
	public function __construct($name = '',$age = 0){
		$this->name = $name;
		$this->age = $age;
	}
	
	public function __get($msname){
		if(isset($this->$msname)){
			return $this->$msname;
		}else{
			return NULL;
		}
	}
	
}

$p = new person('lisi',30);
echo $p->name.'<br>';	//输出 lisi
echo $p->age.'<br>';	//输出 30

2.__set()魔术方法:在我们尝试修改一个不可访问的属性(私有或受保护的)时会被自动调用。它接受两个参数,一个表示属性的名字,另一个表示属性的值。如下面的栗子:

//魔术方法 __set
class person1{
	private $name;
	protected $age;
	public function __construct($name = '',$age = 0){
		$this->name = $name;
		$this->age = $age;
	}	
	public function __set($name,$value){
		$this->$name = $value;
	}	
	public function say(){
		echo '我叫'.$this->name.',今年'.$this->age.'岁<br>';
	}
	
}
$p1 = new person1('lisi',30);
$p1->name = 'zhangsan';
$p1->age = 20;
$p1->say();	//输出 我叫zhangsan,今年20岁

3.__isset()魔术方法:当对一个不可访问的属性调用isset()或empty()函数时会被自动调用,它接受一个参数,表示属性的名字。如下面的栗子:

//魔术方法 __isset()
class person2{
	public $name;
	private $age;
	protected $sex;
	public function __construct($name='',$age=0,$sex='man'){
		$this->name = $name;
		$this->age = $age;
		$this->sex = $sex;
	}
	public function __isset($content){
		echo '外部无法访问此属性,需要调用__isset<br>';
		return isset($this->$content);
	}
	
}

$p2 = new person2('lisi',20,'man');
echo isset($p2->name).'<br>';	//此属性是public 可以直接检测
echo isset($p2->age).'<br>';	//需要调用__isset检测
echo isset($p2->sex).'<br>';	//需要调用__isset检测

4.__unset()魔术方法:在类的外部使用unset()函数销毁一个不可访问的属性时会被自动调用,它接受一个参数,表示属性的名字。如下面的栗子:

//魔术方法 __unset()
class person3{
	public $name;
	private $age;
	protected $sex;
	public function __construct($name='',$age=0,$sex='man'){
		$this->name = $name;
		$this->age = $age;
		$this->sex = $sex;
	}
	public function __unset($content){
		unset($this->$content);
	}
	public function say(){
		echo $this->name.$this->age.$this->sex.'<br>';
	}
	
}

$p3 = new person3('lisi',25,'man');
$p3->say();	//输出结果 lisi25man
unset($p3->age);	//unset私有属性会自动调用__unset方法
$p3->say();	//	输出结果 lisiman

 

PHP面向对象 – 抽象类与实例化 __construct构造方法与__destruct析构方法

面向对象的程序设计思路是现代程序设计由面向过程演变面向对象的必然趋势,所以面向对象的而设计思路必然有它不同的时代意义,必然有着不同面向过程的不同历史使命,而php 5以后成功添加面向对象的设计思路其实是必然的过程。面向对象的设计主要思路就是将程序和数据封装在一个叫对象的基本单位之中来提高重用性,灵活性和可扩展性。他同面向过程和函数式编程的设计思路一样是编程语言的一种范式,是一种规范编程程序的设计方法。只是各自承担着不同的规范职责而已。

对象是基本单位,对象的封装需要类来实现,这才能将对象一个个区别开来。对象和类的共同存在的,对象没有类就像一个家庭没有人一样没有意义,而类没有对象也就像一个孩子没有家一样无法存活。

OOP(Object-Oriented Programming, 面向对象的编程)技术为编程人员敞开了一扇大门,使其编程的代码更简洁、更易于维护,并且具有更强的可重用性。 OOP达到了软件工程的三个目标:重用性、灵活性、扩展性 OOP面向对象编程的特点:封装、继承、多态。

如何抽象一个类

1.类的声明

简单格式:

[修饰符] class 类名{ //使用class关键字加空格后加上类名

[成员属性] //也叫成员变量

[成员方法] //也叫成员函数

}

完整格式:

[修饰符] class 类名 [extends 父类] [implements 接口1[,接口2…]]{

[成员属性] //也叫成员变量

[成员方法] //也叫成员函数

}

2.成员属性

格式:修饰符 $变量名[=默认值];   //如:public $name=”zhangsan”;

注意:成员属性不可以是带运算符的表达式、变量、方法或函数调用。

public $var3 = 1+2;  //错误格式

public $var4 = self::myStaticMethod( );  //错误格式

public $var5 = $myVar;  //错误格式

正确定义方式:

public $var6 = 100;       //普通数值(4个标量:整数、浮点数、布尔、字串)

public $var6 = myConstant;  //常量

public $var7 = self::classConstant; //静态属性

public $var8 = array(true, false);   //数组

3.成员方法

成员方法格式:

[修饰符] function 方法名(参数..){

[方法体]

[return 返回值]

}

通过类实例化对象

1.实例化对象

当定义好类后,我们使用new关键字来生成一个对象。

$对象名称 = new 类名称();

$对象名称 = new 类名称([参数列表]);

2.对象中成员的访问

语法:

$引用名 = new 类名(构造参数);

$引用名->成员属性=赋值; //对象属性赋值

echo $引用名->成员属性; //输出对象的属性

$引用名->成员方法(参数);//调用对象的方法

3.特殊对象引用 $this

在类内部引用成员,要用 $this 代表类本身。

构造方法 __construct

大多数类都有一种称为构造函数的特殊方法。当创建一个对象时,它将自动调用构造函数,也就是使用new 这个关键字来实例化对象的时候自动调用构造方法。

构造函数的声明与其它操作的声明一样,只是其名称必须是__construct( )。这是PHP5 中的变化,以前的版本中,构造函数的名称必须与类名相同,这种在PHP5 中仍然可以用,但现在以经很少有人用了,这样做的好处是可以使构造函数独立于类名,当类名发生改变时不需要改相应的构造函数名称了。为了向下兼容,如果一个类中没有名为__construct( )的方法,PHP 将搜索一个php4 中的写法,与类名相同名的构造方法。

构造方法语法格式:

[修饰符] function __construct([参数]){

程序体

}

在一个类中只能声明一个构造方法,而是只有在每次创建对象的时候都会去调用一次构造方法,不能主动的调用这个方法,所以通常用它执行一些有用的初始化任务。比如对成属性在创建对象的时候赋初值。

析构方法 __destruct

与构造函数相对的就是析构函数。析构函数是PHP5 新添加的内容,在PHP4 中没有析构函数。析构函数允许在销毁一个类之前执行的一些操作或完成一些功能,比如说关闭文件,释放结果集等,析构函数会在到某个对象的所有引用都被删除或者当对象被显式销毁时执行,也就是对象在内存中被销毁前调用析构函数。与构造函数的名称类似,一个类的析构函数名称必须是__destruct( )。析构函数不能带有任何参数。

析构方法方法格式

[修饰符] function __destruct([参数]){

程序体

}

以下是示例

<?php 

class person{
	public $name;
	public $sex;
	public $age;
	public function __construct($name,$sex,$age){
		$this->name = $name;
		$this->sex = $sex;
		$this->age = $age;
	}
	
	public function say(){
		echo 'I am '.$this->name.','.$this->sex.','.$this->age.'<br>';
	}
	public function __destruct(){
		echo 'goodbye '.$this->name.'<br>';
	}
}

$p1 = new person('Zhang san','boy','16');
$p2 = new person('Wu min','girl','14');

echo $p1->say();
echo $p2->say();

?>