一、常见关键字和魔术方法
1、final：
使用final 标识的类不能被继承
在类中使用final 表示成员的方法，在子类中不能被覆盖
注意：不能用final 标识成员属性
例1：
<?php
final class Person{
public $name;
}
class Stu extends Person{
}
运行之后：Fatal error: Class Stu may not inherit from final class (Person)
例2：
<?php
class Person{
final function say(){
}
}
class Stu extends Person{
function say(){
}
}
运行之后：Fatal error: Cannot override final method Person::say()
2、static：
(1)使用static 关键字可以将类中的成员表识为静态的，可以修饰成员属性和成员方法，但不能修饰类
(2)调用静态成员属性
a、在类的外部调用可以用 类名::静态属性名
b、在类的内部调用可以用 类名::静态属性名 还可以 用 self::静态属性名
(3)调用静态成员发法
a、类的外部调用可以用 类名::静态方法名
b、在类的内部调用可以用 类名::静态方法名 还可以 用 self::静态方法名
c、对于静态方法，我们可以使用对象的形式调用 对象->静态方法名()
(4)静态的东西只会被初始化一次。执行效率很高！
如果在类的内部 构造方法是私有的
/1.创建私有并且是静态的成员属性,为它赋予初始值null
//2.将构造方法私有化(目的：不能在类的外部通过new来实例化)
//3.编写静态公有方法，在该方法中判断静态段中是否已经有了该对象，如果有，直接返回该对象，如果没有创建该对象
例1：
<?php
static $a=100;
echo $a; //输出200
static $a=200;
echo $a; //输出200
例2：
<?php
static $a=array();
$a[‘a‘]=‘a‘;
$a[‘b‘]=‘b‘;
static $a=array(c,d);
echo "<pre />";
print_r($a);
//输出：Array(
[0] => c
[1] => d
[a] => a
[b] => b)
例:3：
<?php
class Person{
static $count;
function __construct(){
self::$count++;
}
static function getCount(){
return self::$count;
}
}
Person::$count=0;
$person1=new Person();
$person2=new Person();
$person3=new Person();
$person4=new Person();
echo Person::getCount(); //输出 4
echo $person3 -> getCount(); //输出 4
3、const：将类中的成员属性定义为常量。
(1)声明
a、使用关键字 const 声明一个常量，
b、常量不能带$符号
c、常量不能用访问控制修饰符修饰
d、常量声明立刻要被赋予初始值
(2)使用
a、在类的内部使用
类名：：常量名
self：：常量名
b、在类的外部使用
类名：：常量名
例：
<?php
class Myclass{
const CONSTANT = "CONSTANT value";
function showCounstant(){
echo self::CONSTANT."<br />";
}
}
echo MyClass::CONSTANT."<br />"; //输出 CONSTANT value
$class = new MyClass();
$class -> showCounstant(); //输出 CONSTANT value
4、instanceof：使用这个关键字可以确定一个对象是类的实例，类的子类，还是实现了某个特定接口，并进行相应的操作。
5、clone：克隆对象
通过clone关键字克隆出来的副本。两个对象完全独立，但他们中的成员及成员属性值完全一样，如果需要对克隆后的副本对象重新赋值，可以使用 __clone()魔法方法，该方法中自动包含$this 和 $that 两个对象引用，$this 是副本对象的引用，$that 是原本对象的引用。
例：
<?php
class Person{
private $name;
private $sex;
private $age;
function __construct($name,$sex,$age){
$this -> name = $name;
$this -> sex = $sex;
$this -> age = $age;
}
//声明此方法则在对象克隆时自动调用，用来为新的对象重新赋值
function say(){
echo "我的名字是：$this->name 我的性别是：$this->sex 我的年龄是：$this->age <br /> ";
}
function __clone(){
//1.等号左边的$this指代克隆（新的）的对象
//2.等号右边的$this指代被克隆（原来的）的对象
$this -> name = "我是{$this->name}的副本"; //为副本对象中的name 重新赋值
$this -> age = "10"; //为副本对象中的age 重新赋值
}
}
$person1 = new Person("张三","男",20);
$person2 = clone $person1; //使用clone克隆对象，并自动调用__clone() 方法
$person1 -> say(); //调用原对象的说话方法，打印原对象中的全部属性值
$person2 -> say(); //调用副本对象的说话方法，打印副本对象中的全部属性值
输出结果：
我的名字是：张三 我的性别是：男 我的年龄是：20
我的名字是：我是张三的副本 我的性别是：男 我的年龄是：10
6、__toString：快速获取对象的字符串表示的最便捷的方式，它是在直接输出对象时自动调用的方法。
调用时机：当在类的外部想直接输出对象的时候会被自动调用
参数？？？没有
方法体中主要是返回一个字符串（其他数据类型不可以）
例：
<?php
class TestClass{
private $foo; //在类中声明一个成员的方法
function __construct($foo){
$this -> foo = $foo;
}
public function __toString(){ //在类中定义一个 __toString()方法
return $this -> foo; //返回一个成员属性 $foo 的值
}
}
$obj = new TestClass("Hello"); /
echo $obj; //直接输出对象引用，则会自动调用__toString()方法
// 输出 Hello
7、__call：当调用对象中不存在的方法时，会自动调用该方法，且程序也可以继续往下执行
有另个参数：第一个参数是调用不存在的方法时，接收这个方法名称字符串，而参数列表则以数组的形式传递到__call()方法的第二个参数中。
例：
<?php
class TestClass{
function printHello(){
echo "Hello<br />";
}
/**
*声明魔术方法 __call(),用来处理对象中不存在的方法
*$functionNam 访问不存在的成员的方法名称字符串
*$args 访问不存在的成员方法中传递的参数数组
* */
function __call($functionName,$args){
echo "你所调用的函数：".$functionName."(参数："; //输出调用不存在的方法名
print_r($args); //输出不存在的方法时的参数列表
echo ")不存在！<br />\n"; //输出附加的一些提示信息
}
}
$person = new TestClass();
$person -> myFun("one",2,"three");
$person -> otherFun(8,9);
$person -> printHello();
输出结果：
你所调用的函数：myFun(参数：Array ( [0] => one [1] => 2 [2] => three ) )不存在！
你所调用的函数：otherFun(参数：Array ( [0] => 8 [1] => 9 ) )不存在！
Hello
8、自动加载类（__autoload()全局函数）
调用时机：在本脚本中实例化一个类的时候会被自动调用
参数 1个，要被实例化的类名
在方法体中，我们可以使用require的方式获取该类所在的文件
例：在同一目录下
文件1：shop.class.php
<?php
class shop{
public $name;
}
文件2：user.class.php
<?php
class shop{
public $name;
}
文件3：main.php
<?php
function __autoload($name){
include (strtolower($name).".class.php"); //在方法中使用include 包含类所在的文件
}
$peron = new user(); //user 方法不存在时，自动调用__autoload()函数，将类名“user”作为参数载入 自动 “include user.class.php”
$person2 = new shop(); //shop 方法不存在时，自动调用__autoload()函数，将类名“shop”作为参数载入 自动 “include shop.class.php”
9、对象串行化
例：
<?php
class Person{
private $name;
private $sex;
private $age;
function __construct($name,$sex,$age){
$this->name = $name;
$this->sex = $sex;
$this->age = $age;
}
function say(){
echo "我的名字是：$this->name 我的性别是：$this->sex 我的年龄是：$this->age ";
}
}
$person = new Person("张三","男",29);
$person_string = serialize($person); //串行化
file_put_contents("file.txt",$person_string);
//被串行化的结果 O:6:"Person":3:{s:12:" Person name";s:6:"张三";s:11:" Person sex";s:3:"男";s:11:" Person age";i:29;}
$person_string = file_get_contents("file.txt");
$person = unserialize($person_string); //反串行化
$person -> say();
//调用say() 方法解析之后结果： 我的名字是：张三 我的性别是：男 我的年龄是：29
10、单态设计模式
例：
<?php
define ("HOST","localhost");
define ("USER","root");
define ("PASS","123321");
define ("DBNAME","xiaogou");
class DB{
static public $count;
static public $i;
static function getDb(){
if(!(bool)(self::$count)){
self::$count = new DB(); //如果本类中的count为空，说明还没有被实例化过
}
return self::$count; //返回本类的对象
}
private function __construct(){
mysql_connect(HOST,USER,PASS);
mysql_select_db(DBNAME);
self ::$i++;
}
function select($tbname){
$sql = "select * from $tbname";
$result = mysql_query($sql);
while($rows=mysql_fetch_assoc($result)){
$row[]=$rows;
}return $row;
}
}
$db=DB::getDb(); //通过静态的方法去获取静态方法getDb()去获取DB类的对象
$arr = $db->select("liuyan"); //访问对象中的成员
echo "<pre />";
var_dump($arr);