1.类的继承

在PHP和Java语言里面没有多继承，只有单继承

// 定义一个“人”类做为父类
class Person
{
    // 下面是人的成员属性
    var $name;  //人的名子
    var $sex;   //人的性别
    var $age;   //人的年龄

    // 定义一个构造方法参数为属性姓名$name、性别$sex和年龄$age进行赋值
    function __construct($name, $sex, $age) 
    {
        $this->name = $name;
        $this->sex = $sex;
        $this->age = $age;
    }

    // 这个人可以说话的方法, 说出自己的属性
    function say() 
    {
        echo "我的名子叫：" . $this->name . " 性别：" . $this->sex . " 我的年龄是：" . $this->age;
    }
}
class Student extends Person
{
    var $school;    // 学生所在学校的属性

    // 这个学生学习的方法
    function study()
    {
        echo "我的名字叫：" . $this->name . " 我正在" . $this->school . "学习<br />";
    }
}

2.重载新的方法（parent::）

一种是使用父类的“类名::“来调用父类中被覆盖的方法；

class Student extends Person
{
    var $school;    // 学生所在学校的属性

    function __construct($name, $sex, $age, $school)
    {
        // 使用父类中的方法为原有的属性赋值
        parent::__construct($name, $sex, $age);
        $this->school = $school;
    }

    // 这个学生学习的方法
    function study()
    {
        echo "我的名子叫：" . $this->name . " 我正在" . $this->school . " 学习";
    }

    // 这个人可以说话的方法, 说出自己的属性
    function say()
    {
        parent::say();

        // 加上一点自己的功能
        echo "我的年龄是：" . $this->age . " 我在" . $this->school . "上学";
    }
}

3.访问类型（public，protected，private）

PHP5支持如下3种访问修饰符：
public (公有的、默认的)，protected (受保护的)和private (私有的)三种。
子类中方法的访问权限一定不能低于父类被覆盖方法的访问权限，也就是一定要高于或等于父类方法的访问权限。

4.final关键字的应用

使用final关键标记的类不能被继承；

<?php
final class Person
{
    function say(){}
}
class Student extends Person
{
    function say() {}
}
?>

使用final关键标记的方法不能被子类覆盖，是最终版本；

<?php
class Person
{
    final function say()    {}
}
class Student extends Person
{
    function say()  {}
}
?>

5.static和const关键字的使用（self::）

类的静态变量，非常类似全局变量，能够被所有类的实例共享，类的静态方法也是一样的，类似于全局函数。

<?
class Person
{
    // 下面是人的静态成员属性
    public static $myCountry = "中国";

    // var $name; //人的名子

    // 这是人的静态成员方法
    public static function say()
    {
        echo "我是中国人";
    }
}

// 输出静态属性
echo Person::$myCountry;

// 访问静态方法
Person::say();

// 重新给静态属性赋值
Person::$myCountry = "美国";
echo Person::$myCountry;
?>

使用对象访问不到静态成员的，
类里面的静态方法只能访问类的静态的属性，
静态的方法是不用对象调用的，而是使用类名来访问
self和$this相似，只不过self是代表这个静态方法所在的类

<?
class Person
{
    // 下面是人的静态成员属性
    public static $myCountry = "中国";

    // 这是人的静态成员方法， 通过self访问其它静态成员
    public static function say() 
    {
        echo "我是" . self::$myCountry;
    }
}
// 访问静态方法
Person::say();
?>

!!!用“const”修饰的成员属性的访问方式和“static”修饰的成员访问的方式差不多，也是使用“类名”，在方法里面使用“self”关键字。但是不用使用“$”符号，也不能使用对象来访问。

<?php
class MyClass
{
    // 定义一个常量constant
    const constant = 'constant value';

    function showConstant()
    {
        echo self::constant . " "; // 使用self访问，不要加“$”
    }
}

echo MyClass::constant . " "; // 使用类名来访问，也不加“$”

$class = new MyClass();
$class->showConstant();
// echo $class::constant; // 是不允许的
?>

6.__toString()方法

<?php
// Declare a simple class
class TestClass
{
    public $foo;

    public function __construct($foo) 
    {
        $this->foo = $foo;
    }

    // 定义一个__toString方法，返加一个成员属性$foo
    public function __toString() 
    {
        return $this->foo;
    }
}

$class = new TestClass('Hello');
// 直接输出对象
echo $class;
?>

7.克隆对象__clone()方法

在PHP4中我们使用“clone”这个关键字克隆对象；

<?
class Person
{
    // 下面是人的成员属性
    var $name;  // 人的名子
    var $sex;   // 人的性别
    var $age;   // 人的年龄

    // 定义一个构造方法参数为属性姓名$name、性别$sex和年龄$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>";
    }
}

$p1 = new Person("张三", "男", 20);

// 使用“clone”克隆新对象p2，和p1对象具有相同的属性和方法。
$p2=clone $p1;
$p2->say();
?>

如果想在克隆后改变原对象的内容，需要在__clone()中重写原本的属性和方法， “__clone()”方法可以没有参数，它自 动包含$this和$that两个指针，$this指向复本，而$that指向原本；

<?
class Person
{
    // 下面是人的成员属性
    var $name;  // 人的名子
    var $sex;   // 人的性别
    var $age;   // 人的年龄

    // 定义一个构造方法参数为属性姓名$name、性别$sex和年龄$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>";
    }

    // 对象克隆时自动调用的方法, 如果想在克隆后改变原对象的内容，需要在__clone()中重写原本的属性和方法
    function __clone()
    {
        // $this指的复本p2, 而$that是指向原本p1，这样就在本方法里，改变了复本的属性。
        $this->name = "我是假的 $that->name";
        $this->age = 30;
    }
}

$p1 = new Person("张三", "男", 20);
$p2 = clone $p1;
$p1->say();
$p2->say();
?>
我的名子叫：张三 性别：男 我的年龄是：20我的名子叫：我是假的张三 性别：男 我的年龄是：30

8.__call()处理调用错误

可不可以在程序调用对象内部 不存在的方法时，提示我们调用的方法及使用的参数不存在，但程序还可以继续执行，这个时候我们就要使用在调用不存在的方法时自动调用的方 法“__call()”

<?php
//这是一个测试的类，里面没有属性和方法
class Test
{
}
//产生一个Test类的对象
$test = new Test();
//调用对象里不存在的方法
$test->demo("one", "two", "three");
//程序不会执行到这里
echo "this is a test<br>";
?>

//Fatal error: Call to undefined method Test::demo()


<?php
//这是一个测试的类，里面没有属性和方法
class Test
{
    // 调用不存的方法时自动调用的方法，第一个参数为方法名，第二个参数是数组参数
    function __call($function_name, $args)
    {
        print "你所调用的函数：$function_name(参数：";
        print_r($args);
        echo ")不存在！<br>";
    }
}
// 产生一个Test类的对象
$test=new Test();
// 调用对象里不存在的方法
$test->demo("one", "two", "three");
// 程序不会退出可以执行到这里
echo "this is a test<br>";
?>

9.抽象方法和抽象类（abstract）

子类必须把父类中的抽象方法全部都实现，否则子类中还存在抽象方法，那么子类还是抽象类，还是不能实例化类

<?
abstract class Demo
{
    var $test;

    abstract function fun1();
    abstract function fun2();

    function fun3() 
    {
        ...
    }
}
$demo = new Demo(); // 抽象类不能产生实例对象，所以这样做是错的，实例化对象交给子类
class Test extends Demo
{
    function fun1() 
    {
        ...
    }
    function fun2() 
    {
        ...
    }
}

$test = new Test(); // 子类可以实例化对象，因为实现了父类中所有抽象方法
?>

10.PHP5接口技术(interface)

<?php
// 使用”extends”继承另外一个接口
interface Two extends One
{
    function fun3();
    function fun4();
}
?>
<?php
// 使用“implements”这个关键字去实现接口中的抽象方法 接口和类之间
class Three implements One
{
    function fun1() 
    {
        ...
    }
    function fun2() 
    {
        ...
    }
}

// 实现了全部方法，我们去可以使用子类去实例化对象了
$three = new Three();
?>

<?php
// 使用extends继承一个类，使用implements实现多个接口
class Four extends 类名一 implemtns 接口一, 接口二, ...
{
    // 所有接口中的方法都要实现才可以实例化对象
    ...
}
?>

11.多态的应用

<?php
// 定义了一个形状的接口，里面有两个抽象方法让子类去实现
interface Shape
{
    function area();
    function perimeter();
}

// 定义了一个矩形子类实现了形状接口中的周长和面积
class Rect implements Shape
{
    private $width;
    private $height;

    function __construct($width, $height)
    {
        $this->width = $width;
        $this->height = $height;
    }

    function area()
    {
        return "矩形的面积是：" . ($this->width * $this->height);
    }

    function perimeter()
    {
        return "矩形的周长是：" . (2 * ($this->width + $this->height));
    }
}

// 定义了一个圆形子类实现了形状接口中的周长和面积
class  Circular implements Shape
{
    private $radius;

    function __construct($radius)
    {
        $this->radius=$radius;
    }

    function area()
    {
        return "圆形的面积是：" . (3.14 * $this->radius * $this->radius);
    }

    function perimeter()
    {
        return "圆形的周长是：" . (2 * 3.14 * $this->radius);
    }
}

// 把子类矩形对象赋给形状的一个引用
$shape = new Rect(5, 10);
echo $shape->area() . "<br>";
echo $shape->perimeter() . "<br>";

// 把子类圆形对象赋给形状的一个引用
$shape = new Circular(10);
echo $shape->area() . "<br>";
echo $shape->perimeter() . "<br>";
?>

12.把对象串行化serialize()方法，__sleep()方法，__wakeup()方法

有时候需要把一个对象在网络上传输，为了方便传输，可以把整个对象转化为二进制串，等到达另一端时，再还原为原来的对象，这个过程称之为串行化(也叫序列化)

<?
class Person
{
    // 下面是人的成员属性
    var $name;  // 人的名子
    var $sex;   // 人的性别
    var $age;   // 人的年龄

    // 定义一个构造方法参数为属性姓名$name、性别$sex和年龄$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>";
    }
}

$p1 = new Person("张三", "男", 20);
$p1_string = serialize($p1);    // 把一个对象串行化，返一个字符串
echo $p1_string . "<br>";       // 串行化的字符串我们通常不去解析
$p2 = unserialize($p1_string);  // 把一个串行化的字符串反串行化形成对象$p2
$p2->say();
?>

在PHP5中有两个魔术方法__sleep()方法和__wakeup()方法，在对象串行化的时候，会调用一个__sleep()方法来完成一 些睡前的事情；而在重新醒来，即由二进制串重新组成一个对象的时候，则会自动调用PHP的另一个函数__wakeup()，做一些对象醒来就要做的动作。

<?
class Person
{
    // 下面是人的成员属性
    var $name;  // 人的名子
    var $sex;   // 人的性别
    var $age;   // 人的年龄

    // 定义一个构造方法参数为属性姓名$name、性别$sex和年龄$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>";
    }

    // 指定串行化时把返回的数组中$name和$age值串行化，忽略没在数组中的属性$sex
    function __sleep()
    {
        $arr = array("name", "age"); // 此时，属性$sex将被删除！！！
        return($arr);
    }

    // 重新生成对象时，并重新赋值$age为40
    function __wakeup()
    {
        $this->age = 40;
    }
}

$p1 = new Person("张三", "男", 20);

// 把一个对象串行化，返一个字符串，调用了__sleep()方法,忽略没在数组中的属性$sex
$p1_string = serialize($p1);
echo $p1_string . "<br>"; // 串行化的字符串我们通常不去解析

$p2 = unserialize($p1_string); // 反串行化形成对象$p2重新赋值$age为40
$p2->say();
?>
//output
O:6:"Person":2:{s:4:"name";s:4:"张三";s:3:"age";i:20;}
我的名子叫：张三 性别： 我的年龄是：40

13.自动加载类 __autoload()函数

在 PHP 5 中，可以定义一个 __autoload()函数，它会在试图使用尚未被定义的类时自动调 用，通过调用此函数，脚本引擎在 PHP 出错失败前有了最后一个机会加载所需的类， __autoload()函数接收的一个参数，就是你想加载的类的 类名

<?php
function __autoload($classname)
{
    require_once $classname . '.php';
}

//MyClass1类不存在时，自动调用__autoload()函数，传入参数”MyClass1”
$obj = new MyClass1();

//MyClass2类不存在时，自动调用__autoload()函数，传入参数”MyClass2”
$obj2 = new MyClass2();
?>

注意：__autoload() 是专门为 类的不存在 而设计的！！！很多框架利用这个函数，实现 类文件的自动加载 ！！！