PHP：面向对象学习笔记，重点模拟Mixin（掺入）

背景

相对于Python、Node和Ruby来说PHP算是一门容易学习和使用的语言，因为这个特点也使其成为WEB开发领域的佼佼者，本文记录一下我对PHP面向对象部分的学习笔记。

先来一个复杂的例子：Mixin（掺入）

Ruby和Python可以用非常漂亮的语法支持掺入，PHP能实现吗？让我们试试吧。

参考其他语言的掺入示例可以查看这篇文章：设计原则：请重新审视“多重继承”，找机会拥抱一下“掺入（Mixin）”。

PHP5.4提供的有Traits机制可以方便的模拟掺入，下面的示例是采用5.3版本的机制模拟出来的。

期望的最终效果

class Playable
{
public function play($that)
{
echo "一起玩吧，".$that->name;
}
}

class Base extends _Object
{
public $name = "段光伟<br/>";
}

class Child extends Base {}

Base::implement(new Playable());

$base = new Base();
$child = new Child();

$base->play();
$child->play();

是不是特别像C#的扩展方法。

实现代码

class _Object
{
private static $mixins = array();

public static function implement($target)
{
$class = get_called_class();

if (!isset(self::$mixins[$class]))
{
self::$mixins[$class] = array();
}

foreach (get_class_methods($target) as $method)
{
self::$mixins[$class][$method] = $target;
}
}

public function class_name()
{
return self::get_class($this);
}

public function __call($method, $params)
{
$params = array_merge(array($this), $params);
$class  = $class = get_called_class();

$mixin = $this->find_mixin($class, $method);

call_user_func_array($mixin, $params);
}

private function find_mixin($class, $method)
{
while ($class != NULL)
{
if (isset(self::$mixins[$class][$method]))
{
$target = self::$mixins[$class][$method];

return array($target, $method);
}

$class = get_parent_class($class);
}

throw new MethodException("方法 $method 不存在");
}
}

看不明白不要紧，继续看下文，回头再看这个。

面向对象

很多信息在注释中可以看到，在文中不会再重复一遍。

基本的类型声明

代码

<?php

header("content-type: text/html; charset=utf-8");

// 类型不能有修饰符。
// 成员以应用访问修饰符号，一共有三种访问修饰符：public、protected和private。
class TestClass {
// 属性默认访问级别是private。
private $private_property = "私共成员<br/>";

// var形式的默认访问级别是public。
var $public_property = "公共成员<br/>";

// 方法默认访问级别是public。
public function public_method() {
echo $this->private_property;
}
}

$test = new TestClass();

echo $test->public_property;
$test->public_method();

?>

运行结果

// 公共成员
// 私共成员

继承：实现继承和接口继承

代码

<?php

header("content-type: text/html; charset=utf-8");

/*
* 使用interface关键字可以声明接口，接口以及接口的成员不能有任何修饰符。
*/
interface Playable {
function play();
}

/*
* 使用abstract关键字可以声明抽象类和方法。
*/
abstract class Base {
private    $header = "";
private    $rooter = "";

public function __construct($header, $rooter) {
$this->header = $header;
$this->rooter = $rooter;
}

public function write() {
$this->writeHeader();
$this->writeContent();
$this->writeRooter();
}

private function writeHeader() {
echo $this->header."<br/>";
}

private function writeRooter() {
echo $this->rooter."<br/>";
}

protected abstract function writeContent();
}

/*
* 使用final关键字可以禁止类型或方法被重写。
* 使用parent::在重写的方法里调用父类型的方法。
*/
final class Child extends Base implements Playable {
private    $content = "";

public function __construct($header, $rooter, $content) {
parent::__construct($header, $rooter);

$this->content = $content;
}

protected function writeContent() {
echo $this->content."<br/>";
}

public function play() {
echo "游戏中。。。<br/>";
}

public function __destruct() {
echo "析构中<br/>";
}
}

$child = new Child("头", "尾", "内容");
$child->write("段光伟");
$child->play();

?>

运行结果

头
内容
尾
游戏中。。。
析构中

静态成员

代码

<?php

header("content-type: text/html; charset=utf-8");

class StaticBaseClass {
public static $StaticProperty = "父类静态属性<br/>";
const MAX = "父类常量<br/>";

public static function staticMethod() {
/* 在内部可以使用类名或self关键字，但是self访问的其定义时的类型，而不是运行时的类型,
* 这在子类和父类里有同名的静态成员和常量时会出现问题，为了避免这个问题可以使用static
* 关键字。
*/

echo get_called_class()." self::\$StaticProperty ".self::$StaticProperty;
echo get_called_class()." StaticBaseClass::\$StaticProperty ".StaticBaseClass::$StaticProperty;
echo get_called_class()." static::\$StaticProperty ".static::$StaticProperty;

echo get_called_class()." self::MAX ".self::MAX;
echo get_called_class()." StaticBaseClass::MAX ".StaticBaseClass::MAX;
echo get_called_class()." static::MAX ".static::MAX;
}
}

class StaticChildClass extends StaticBaseClass {
public static $StaticProperty = "子类静态属性<br/>";
const MAX = "子类常量<br/>";
}

// 在外部必须使用类名访问。
StaticBaseClass::StaticMethod();
echo StaticBaseClass::$StaticProperty;
echo StaticBaseClass::MAX;

// 在子类中可以调用父类的静态成员和常量。
StaticChildClass::StaticMethod();
echo StaticChildClass::$StaticProperty;
echo StaticChildClass::MAX;

?>

运行结果

StaticBaseClass self::$StaticProperty 父类静态属性
StaticBaseClass StaticBaseClass::$StaticProperty 父类静态属性
StaticBaseClass static::$StaticProperty 父类静态属性
StaticBaseClass self::MAX 父类常量
StaticBaseClass StaticBaseClass::MAX 父类常量
StaticBaseClass static::MAX 父类常量
父类静态属性
父类常量
StaticChildClass self::$StaticProperty 父类静态属性
StaticChildClass StaticBaseClass::$StaticProperty 父类静态属性
StaticChildClass static::$StaticProperty 子类静态属性
StaticChildClass self::MAX 父类常量
StaticChildClass StaticBaseClass::MAX 父类常量
StaticChildClass static::MAX 子类常量
子类静态属性
子类常量

又是魔法方法

代码

<?php

header("content-type: text/html; charset=utf-8");

/*
* 什么叫魔法方法：被解释器在某些特殊情况下调用的实例方法。
*/
class WebDeveloper {
public $info = array();

// 当执行赋值时，而目标成员不存在会调用此方法。
public function __set($item, $value) {
$this->info[$item] = $value;
}

// 当执行取值时，而目标成员不存在会调用此方法。
public function __get($item) {
return $this->info[$item];
}

// 当执行isset方法时，而目标成员不存在会调用此方法。
public function __isset($item) {
return isset($this->info[$item]);
}

// 当执行unset方法时，而目标成员不存在会调用此方法。
public function __unset($item) {
unset($this->info[$item]);
}

// 当执行方法调用时，而目标方法不存在会调用此方法。
public function __call($method_name, $args) {
echo $method_name, var_dump($args), "<br/>";
}
}

$developer = new WebDeveloper();
$developer->name = "段光伟";

echo "{$developer->name}<br/>";
echo (isset($developer->name) ? "TRUE" : "FALSE")."<br/>";
unset($developer->name);
echo (isset($developer->name) ? "TRUE" : "FALSE")."<br/>";

$developer->saySomething('hi!','how are you!');

?>

输出结果

段光伟
TRUE
FALSE
saySomethingarray(2) { [0]=> string(3) "hi!" [1]=> string(12) "how are you!" }

可调用对象（其实还是魔法方法）

代码

<?php
header("content-type: text/html; charset=utf-8");

class CallableClass
{
public function __invoke($x)
{
var_dump($x);
}
}

$obj = new CallableClass;

$obj(5);
call_user_func_array($obj, array(5));
var_dump(is_callable($obj));

?>

输入结果

int(5) int(5) bool(true)

Reflection（反射）

代码

<?php

header("content-type: text/html; charset=utf-8");

/*
* 使用interface关键字可以声明接口，接口以及接口的成员不能有任何修饰符。
*/
interface Playable {
function play();
}

/*
* 使用abstract关键字可以声明抽象类和方法。
*/
abstract class Base {
private    $header = "";
private    $rooter = "";

public static $StaticProperty = "父类静态属性<br/>";
const MAX = "父类常量<br/>";

public function __construct($header, $rooter) {
$this->header = $header;
$this->rooter = $rooter;
}

public function write() {
$this->writeHeader();
$this->writeContent();
$this->writeRooter();
}

private function writeHeader() {
echo $this->header."<br/>";
}

private function writeRooter() {
echo $this->rooter."<br/>";
}

protected abstract function writeContent();
}

/*
* 使用final关键字可以禁止类型或方法被重写。
* 使用parent::在重写的方法里调用父类型的方法。
*/
final class Child extends Base implements Playable {
public $content = "";
public static $StaticProperty = "子类静态属性<br/>";
const MAX = "子类常量<br/>";

public function __construct($header, $rooter, $content) {
parent::__construct($header, $rooter);

$this->content = $content;
}

protected function writeContent() {
echo $this->content."<br/>";
}

public function play() {
echo "游戏中。。。<br/>";
}

public function __destruct() {
echo "析构中";
}
}

$child = new Child("开始", "结束", "内容");

echo get_class($child).'<br/>';
print_r(get_class_methods(get_class($child)));
echo '<br/>';
print_r(get_class_vars(get_class($child)));
echo '<br/>';
echo $child->{"play"}();
?>

输出结果

Child
Array ( [0] => __construct [1] => play [2] => __destruct [3] => write )
Array ( [content] => [StaticProperty] => 子类静态属性
)
游戏中。。。
析构中

备注

PHP属于：静态类型、鸭子类型、弱类型、解释执行的语言 ，后面详细介绍这些概念及其对应的语言特色。