PHP面向对象精要总结

黑格尔有句名言:存在即合理。以此为论据的话,静态类的使用必然有其合理性。不过物极必反,一旦代码过于依赖静态类,其劣化的结局则不可避免。这就好比罂粟作为一种草本植物,有其在药理上的价值,但如果肆无忌惮的大量使用,它就变成了毒品。

本文实例汇总了PHP面向对象程序设计的精要。分享给大家供大家参考。具体分析如下:

什么是静态类

1 使用extends实现继承以及重载、魔术方法的含义

所谓静态类指的是无需实例化成对象,直接通过静态方式调用的类。代码如下: 复制代码 代码如下:

class B extends A
声明的时候B里可以没有A里的方法
调用的时候:

class Math
{
    public static function ceil($value)
    {
        return ceil($value);
    }

$b=new B();
$b->A里的方法();
$b->A里的属性=1;
$b->B里的方法();
$b->B里的方法();

    public static function floor($value)
    {
        return floor($value);
    }
}

如果$a=new A();
可以
$a->A里的方法();
$a->A里的属性=1;
不可以
$a->B里的方法();
$a->B里的方法();
 
重载:B继承A ,B里实现和A同名的方法属性。
PHP中的”重载”与其它绝大多数面向对象语言不同。传统的”重载”是用于提供多个同名的
类方法,但各方法的参数类型和个数不同。
 
魔术方法:PHP把所有以__(两个下划线)开头的类方法当成魔术方法。所以你定义自己的类方法时,不要以
__为前缀。
 
2 继承用private和protected访问修饰符可见性

?>

属性方法private不可以被继承
属性方法protected类外部不可见,可以被继承
属性方法public 所定义的类成员可以在任何地方被访问

此时类所扮演的角色更像是命名空间,这或许是很多人喜欢使用静态类最直接的原因。

3 php中双冒号::的应用

静态类的问题

php类代码中常看到”::”的操作符,这个是作用域限定操作符,是用一个双冒号”::”表示,它用来置顶类中不同作用域的级别。左边是作用域右边是访问作用域的成员。
在php中定义的作用域有self和parent两种(在php6中提供了static作用域)。
 
范围解析操作符(也可称作 Paamayim
Nekudotayim)或者更简单地说是一对冒号,可以用于访问静态成员、方法和常量,还可以用于子类覆盖父类中的成员和方法。
复制代码 代码如下:class MyClass {
    const CONST_VALUE = ‘A constant value’;
}

本质上讲,静态类是面向过程的,因为通常它只是机械的把原本面向过程的代码集合到一起,虽然结果是以类的方式存在,但此时的类更像是一件皇帝的新衣,所以可以说静态类实际上是披着面向对象的壳儿,干着面向过程的事儿。

echo MyClass::CONST_VALUE;
class OtherClass extends MyClass
{
    public static $my_static = ‘static var’;

面向对象的设计原则之一:针对接口编程,而不是针对实现编程。这有什么不同?打个比方来说:抛开价格因素,你喜欢独立显卡的电脑还是集成显卡的电脑?我想绝大多数人会选择独立显卡。独立显卡可以看做是针对接口编程,而集成显卡就就可以看做是针对实现编程。如此说来针对实现编程的弊端就跃然纸上了:它丧失了变化的可能性。

    public static function doubleColon() {
        echo parent::CONST_VALUE . “n”;
        echo self::$my_static . “n”;
    }
}

下面杜撰一个文章管理系统的例子来具体说明一下:
复制代码 代码如下:

OtherClass::doubleColon();
//子类覆盖父类
class MyClass
{
    protected function myFunc() {
        echo “MyClass::myFunc()n”;
    }
}

class Article
{
    public function save()
    {
        ArticleDAO::save();
    }
}

class OtherClass extends MyClass
{
    // 覆盖父类中的方法
    public function myFunc()
    {
        // 但仍然可以调用已被覆盖的方法
        parent::myFunc();
        echo “OtherClass::myFunc()n”;
    }
}

?>

$class = new OtherClass();
$class->myFunc();

Article实现必要的领域逻辑,然后把数据持久化交给ArticleDAO去做,而ArticleDAO是一个静态类,就好像焊在主板上的集成显卡一样难以改变,假设我们为了测试代码可能需要Mock掉ArticleDAO的实现,但因为调用时使用的是静态类的名字,等同于已经绑定了具体的实现方式,Mock几乎不可能,当然,实际上有一些方法可以实现:
复制代码 代码如下:

4 php中this和self以及parent的作用

class Article
{
    private static $dao = ‘ArticleDAO’;

this:就是指向当前对象实例的指针,不指向任何其他对象或类。
self:表示当前类的作用域,与this不同的是它不表示类的某个特定实例,在类之外的代码中不能使用self,而且它不能识别自己在继承中层次的位置。也就是说,当在扩展类中使用self时,它调用的不是父类的方法,而是扩展类的重载的方法。self是指向类本身,也就是self是不指向任何已经实例化的对象,一般self使用来指向类中的静态变量。
复制代码 代码如下:private static
$firstCount = 0;
private $lastCount;

    public static funciton setDao($dao)
    {
        self::$dao = $dao;
    }

//构造函数
function __construct()
{
     $this->lastCount = ++self:$firstCount;
//使用self来调用静态变量,使用self调用必须使用::(域运算符号)
}
parent:表示当前类父类的作用域,其余的跟self特性一样。parent是指向父类的指针,一般我们使用parent来调用父类的构造函数。
复制代码 代码如下://继承类的构造函数
function __construct( $personSex, $personAge )
{
         parent::__construct( “test” );
//使用parent调用了父类的构造函数
         $this->personSex = $personSex;
          $this->personAge = $personAge;
}

    public static function save()
    {
        $dao = self::$dao;

5 构造函数与析构函数

        $dao::save();
    }
}

具有构造函数的类会在每次创建对象时先调用此方法,所以非常适合在使用对象之前做一些初始化工作。
function __construct() {}
如果子类中定义了构造函数则不会暗中调用其父类的构造函数。要执行父类的构造函数,需要在子类的构造函数中调用
parent::__construct()。
PHP 5 引入了析构函数的概念,这类似于其它面向对象的语言,如
C++。析构函数会在到某个对象的所有引用都被删除或者当对象被显式销毁时执行。
function __destruct() {}
 
6 final 关键字

?>

PHP 5 新增了一个 final
关键字。如果父类中的方法被声明为final,则子类无法覆盖该方法;
如果一个类被声明为final,则不能被继承。
 
7 继承和构造函数

有了变量的介入,可以在运行时设定具体使用哪个静态类:
复制代码 代码如下:

父类 子类 结果
有构造函数 无构造函数 父构造
有构造函数 有构造函数 子构造

Article::setDao(‘MockArticleDAO’);

 
8 接口

Article::save();

可以通过interface来定义一个接口,就像定义一个标准的类一样。
注意:
1)但其中定义所有的方法都是空的;
2)接口中定义的所有方法都必须是public,这是接口的特性;
3)实现多个接口时,接口中的方法不能有重名;
4)接口也可以继承,通过使用extends操作符;
5)接口中也可以定义常量。接口常量和类常量的使用完全相同。
它们都是定值,不能被子类或子接口修改。
复制代码 代码如下://
声明一个’iTemplate’接口
interface iTemplate
{
    public function setVariable($name, $var);
    public function getHtml($template);
}
// 实现接口
// 下面的写法是正确的
class Template implements iTemplate
{
    private $vars = array();
 
    public function setVariable($name, $var)
    {
        $this->vars[$name] = $var;
    }
 
    public function getHtml($template)
    {
        foreach($this->vars as $name => $value) {
            $template = str_replace(‘{‘ . $name . ‘}’, $value,
$template);
        }
 
        return $template;
    }
}

?>

9 属性

虽然这样的实现方式看似解决了Mock的问题,但是首先它修改的原有的代码,违反了开闭原则,其次它引入了静态变量,而静态变量是共享的状态,有可能会干扰其它代码的执行,所以并不是一个完美的解决方案。

类的变量成员叫做“属性”,属性声明是由关键字public或者protected或者private开头,然后跟一个变量来组成。
属性中的变量可以初始化,但是初始化的值必须是常数,这里的常数是指php脚本在编译阶段时就为常数,而不是在编译阶段之后在运行阶段运算出的常数。
在PHP5 中,预定义了两个函数“__get()”和“__set()”来获
取和赋值其属性,以及检查属性的“__isset()”和删除属性的方法“__unset()”。
简单的说一个是取值,一个是赋值。,“__set()”和“__get()”这两个方法,这两个方法不是默认存在的,而是我们手工添加到类里面去的,像构造方法(__construct())一样,
类里面添加了才会存在,可以按下面的方式来添加这两个方法,当然也可以按个人的风格来添加://__get()方法用来获取私有属性

补充说明,利用动态语言的特性,其实可以简单的通过require一个不同的类定义文件来实现Mock,但这样做同样有弊端,设想我们在脚本里需要多次变换实现方式,但实际上我们只有一次require的机会,否则就会出现重复定义的错误。

复制代码 代码如下: class Person{  
//下面是人的成员属性   
private $name; //人的名字  
private $sex; //人的性别  
private $age; //人的年龄  
//__get()方法用来获取私有属性   
private function __get($property_name){  
if(isset($this->$property_name)){  
return($this->$property_name);}else {  
return(NULL);  
}  
}  
}  
//__set()方法用来设置私有属性   
private function __set($property_name, $value){  
$this->$property_name = $value;  
}  
//__isset()方法   
private function __isset($nm){  
echo “isset()函数测定私有成员时,自动调用
“;  
return isset($this->$nm);  
}  
//__unset()方法   
private function __unset($nm){  
echo “当在类外部使用unset()函数来删除私有成员时自动调用的
“;  
unset($this->$nm);  
}  
}  
$p1=new Person();  
$p1->name=”this is a person name”;  
//在使用isset()函数测定私有成员时,自动调用__isset()方法帮我们完成,返回结果为true  
echo var_dump(isset($p1->name)).”
“;  
echo $p1->name.”
“;  
//在使用unset()函数删除私有成员时,自动调用__unset()方法帮我们完成,删除name私有属性  
unset($p1->name);  
//已经被删除了, 所这行不会有输出   
echo $p1->name;  
?>

对象的价值

复制代码 代码如下: class Person{
//下面是人的成员属性
private $name;
//人的名字
private $sex;
//人的性别
private $age;
//人的年龄
//__get()方法用来获取私有属性
private function __get($property_name){
if(isset($this->$property_name)){
return($this->$property_name);
}else{
return(NULL);
}
}
}
//__set()方法用来设置私有属性
private function __set($property_name, $value){
$this->$property_name = $value;
}
//__isset()方法
private function __isset($nm){
echo “isset()函数测定私有成员时,自动调用
“;
return isset($this->$nm);
}
//__unset()方法
private function __unset($nm){
echo “当在类外部使用unset()函数来删除私有成员时自动调用的
“;
unset($this->$nm);
}
}
$p1=new Person();
$p1->name=”this is a person name”;
//在使用isset()函数测定私有成员时,自动调用__isset()方法帮我们完成,返回结果为true
echo var_dump(isset($p1->name)).”
“;
echo $p1->name.”
“;
//在使用unset()函数删除私有成员时,自动调用__unset()方法帮我们完成,删除name私有属性
unset($p1->name);
//已经被删除了, 所这行不会有输出
echo $p1->name;
?>

如果放弃静态类,转而使用对象,应该如何实现文章管理系统的例子?代码如下: 复制代码 代码如下:

10 克隆

class Article
{
    private $dao;

对象复制可以通过clone关键字来完成(如果对象中存在__clone()方法,会先被调用)。对象中的
__clone()方法不能直接调用。
当对象被复制后,PHP5会对对象的所有属性执行一个“浅复制”(shallow
copy)。所有的属性中的引用
仍然不变,指向原来的变量。如果定义了__clone()方法,则新创建的对象(复制生成的对象)中的__clone()方法会被调用,
可用于修改属性的值(如果有必要的话)。

    public function __construct($dao = null)
    {
        if ($dao === null) {
            $dao = new ArticleDAO();
        }

希望本文所述对大家的php面向对象程序设计有所帮助。

        $this->setDao($dao);
    }

    public function setDao($dao)
    {
        $this->dao = $dao;
    }

    public function save()
    {
        $this->dao->save();
    }
}

?>

实际上,这里用到了人们常说的依赖注入技术,通过构造器或者Setter注入依赖的对象:
复制代码 代码如下:

$article = new Article(new MockArticleDAO());

$article->save();

?>

对象有自己的状态,不会发生共享状态干扰其它代码的执行的情况。

当然,静态类有好的一面,比如说很适合实现一些无状态的工具类,但多数时候,我的主观倾向很明确,多用对象,少用静态类,避免系统过早的固化。顺便说一句,希望别有人告诉我静态类比对象快之类的说教,谢谢。

发表评论

电子邮件地址不会被公开。 必填项已用*标注