深入PHP面向对象，模式与实践 第4章：高级特性

最新推荐文章于 2019-04-26 20:24:23 发布
最新推荐文章于 2019-04-26 20:24:23 发布
阅读量344 收藏 1
点赞数
分类专栏： php

深入PHP面向对象，模式与实践 第4章：高级特性

首先，这个博客不是教学的，而是我自己用来回顾的，其中可能直接放实例代码的比较多，你能看懂其中的重点，那么就说明你掌握了这个知识点，但是如果你没有看懂，那么这里也不会有对应的解释，自己百度去。

4.1 静态方法与属性

class IndexClass{
    static public $num=0;
    static public function addNum(){
        self::$num++;
        print self::$num."\n";
    }
}

IndexClass::addNum();
IndexClass::addNum();

输出结果：

1
2

注意点：

  1. static的值不是不可修改的，那是常量，静态方法只是说明他属于类，而不是类实例化后的对象。
  2. static的值在整个类的生命周期中都是公用的，在第一次运行IndexClass::addNum();，到第二次，它的值一直有效，而不是从0开始。
  3. 在静态方法中调用静态值时，采用的是self，而且是::，这里与self对应的是parent，而与::对应的则是->，一个是因为IndexClass没有超类，第二个则是因为静态属性属于类，不属于对象，所以使用::，所以外部调用静态方法时，也是使用::。
  4. 静态属性或者方法与可见性(public private protected)不是一个量级的概念，所以他们也可以设置可见性。

4.2 常量

class IndexClass{
    const KEY="password";
    const PWD_LENGTH=10;
    static public function getContent(){
        print self::KEY."\n";
        print self::PWD_LENGTH;
    }
}

print IndexClass::KEY."\n";
print IndexClass::PWD_LENGTH."\n";
IndexClass::getContent();

输出结果：

password
10
password
10

注意点：

  1. 常量一般命名方式就是全大写字母。
  2. 常量虽然是变量，但是不需要使用$符号。
  3. 内部或者外部获取常量的方式与获取静态属性的方式类似。
  4. 常量不可以修改。
  5. 常量只能包含基本的数据类型。

4.3 抽象类

<?php
// 定义一个基础的类：商品类
class ShopProduct{
    public $price;
    public function __construct($price=0)
    {
        $this->price=$price;
    }
}
// 定义一个抽象类，其中有抽象方法：write，打印商品价格
abstract class ShopProductWriter{
    protected $discount;
    // 定义抽象函数
    abstract public function write();
    public function setDiscount($discount){
        $this->discount=$discount;
    }
    public function getDiscount(){
        return $this->discount;
    }
    // 这里再定义一个静态方法
    static public function test(){
        return true;
    }
}
// 设置一个类，用来打印Cd类商品的信息
class CdProductorWriter extends ShopProductWriter{
    protected $shopProductInstance;
    public function __construct(ShopProduct $shopProduct)
    {
        $this->shopProductInstance=$shopProduct;
    }

    public function write()
    {
        parent::setDiscount(10);
        print $this->shopProductInstance->price-parent::getDiscount()."\n";
    }
}
// 再设置一个类，用来打印书的信息
class BookProductWriter extends ShopProductWriter{
    protected $shopProductInstance;
    public function __construct(ShopProduct $shopProduct)
    {
        $this->shopProductInstance=$shopProduct;
    }
    public function write()
    {
        parent::setDiscount(50);
        print $this->shopProductInstance->price-parent::getDiscount()."\n";
    }
}
// 实例化商品类时，需要传入对应的价格
$book=new ShopProduct(100);
$cd=new ShopProduct(200);
// 实例化打印类时，需要传入对应打印的商品的对象
$cdProductWriter=new CdProductorWriter($cd);
// 因为打印类都继承自抽象类：ShopProductWriter，所以可以保证其的：write方法一定存在
$cdProductWriter->write();
$bookProductWriter=new BookProductWriter($book);
$bookProductWriter->write();
// 尝试调用从抽象类中继承下来的静态方法
print CdProductorWriter::test()?"可以调用抽象类中的静态方法与属性":"不可以调用抽象类中的静态方法与属性";

输出结果：

190
50
可以调用抽象类中的静态方法与属性

注意点：

  1. 抽象类可以定义除了抽象方法之外的值，也可以在其中设置对应的属性和方法。
  2. 抽象类只能被用来继承，不能被用来实例。
  3. 所谓抽象类比起一般的类只有以下特殊点：
    1. 在申明前加上了abstract。
    2. 在其中一般至少定义一个abstract函数，而函数的可见性则是随意的，但是继承该抽象类的子类实现该抽线函数时，可见性不能比抽象类低，比如抽象类定义的是protected，那么字类就不能是private。
    3. 抽象方法中定义多少参数，覆写时就要传入多少参数，只能一致，不能多也不能少。如果设置了默认值，可以修改默认值。编译器只看数量，不看具体的值

4.4 接口

<?php
// 定义接口
interface Chargeable{
    // 只能定义函数名，而且函数的可见性只能为public
    // 或者可以忽略 public，因为如果直接写 function getPrice() 则该方法默认为public
    public function getPrice();
    public function getPriceInfo();
    // 也可以定义静态函数
    static public function showDiscount();
    // 可以定义常量
    const NUM=10;
    // 并且在实现类中可以调用该常量
    static public function getNUM();
}
// 接口就不叫 继承 了，而叫做 实现，PHP只能继承一个类，但是可以实现多个接口
class ShopProduct implements Chargeable{
    protected $price;
    public function __construct($price){
        $this->price=$price;
    }
    public function getPrice(){
        return $this->price;
    }
    public function getPriceInfo(){
        print "Price:".$this->price." $\n";
    }
    // 必须实现所有函数，而且可见性都必须是 public
    static public function showDiscount(){
        print "There is no discount\n";
    }
    // 获取该常量
    static public function getNUM(){
        // 注意这里不要跟继承混起来！！！parent::NUM，这里不是继承，而是实现，所以这么写是错误的
        return self::NUM;
    }
}

$cd=new ShopProduct(100);
print $cd->getPrice()."\n";
$cd->getPriceInfo();
ShopProduct::showDiscount();
ShopProduct::showDiscount();

输出结果

100
Price:100
There is no discount
10

注意点：

  1. 接口中只能定义函数，不能定义参数，静态的非静态的都不行，可以定义常量，在实现的类中可以调用。
  2. 实现该接口时，就必须实现该接口中所有方法，静态的非静态的都要，而且不能修改其可见性，简单来说就是要覆写接口中所有方法。
  3. 接口中只能定义可见性为public的函数。
  4. 实现多个接口时，两个接口间用,(逗号)隔开。
  5. 关于函数中参数的设定与抽象类是一致的。

4.5 延迟静态绑定：static关键字

<?php

abstract class ParentClass{
    public static function create(){
        return new static();
    }
}

class User extends ParentClass{
}

class Animal extends ParentClass{
    
}

print_r(User::create());
print_r(Animal::create());

这里有一遍博客讲的不错的：static 延迟静态绑定。

这里的重点就在于ParentClass中的一段代码：

return new static();

与之对应的一种写法是：

return new self();

self与static有什么区别呢？self返回的是ParentClass，而static返回的则是继承了ParentClass的类，简单来说就是在父类中调用了子类。

4.6 错误处理

<?php
// 根据自己需要定义两个特殊的错误处理类
class FileNameEmpty extends Exception{
    const CODE=1001;
    const MESSAGE="文件名不能为空";
    public function __construct($message = "", $code = 0, Throwable $previous = null){
        parent::__construct(self::MESSAGE,self::CODE, $previous);
    }
}

class FilePathWrong extends Exception{
    const CODE=1002;
    const MESSAGE="文件路径错误";
    public function __construct($message = "", $code = 0, Throwable $previous = null)
    {
        parent::__construct(self::MESSAGE,self::CODE, $previous);
    }
}
// 在这个类中根据情况抛出异常
class GetFile{
    public function getFilePath($fileName){
        if($fileName==""){
            throw new FileNameEmpty();
        }
        $fileContent=$this->getFileContentInfo($fileName);
        if($fileContent==""){
            throw new FilePathWrong();
        }
        return $fileContent;
    }
    public function getFileContentInfo($fileName){
        return ($fileName=="root")?"":"Hello World !";
    }
}
// 上一个类中抛出异常，在这个类中进行获取
class FileManager extends GetFile{
    public function getFileContent($fileName=''){
        try{
            $fileContent=$this->getFilePath($fileName);
            return $fileContent;
        }
        // 下面就是根据抛出的异常，制定对应的错误处理方式
        catch (FileNameEmpty $e){
            print $e->getMessage()."\n";
        }
        catch (FilePathWrong $e){
            print $e->getMessage()."\n";
        }
        catch (Exception $e){
            print $e->getMessage()."\n";
        }
    }
}

$fileManager=new FileManager();
$fileManager->getFileContent();
$fileManager->getFileContent("root");
print $fileManager->getFileContent("right filePath");

输出：

文件名不能为空
文件路径错误
Hello World !

注意点：

  1. 可以根据自己需要继承异常类(Exception)，再来根据对应的异常制定对应的处理方式
  2. 抛出异常后，下面的代码将不再执行
  3. 首先对应的函数中有抛出异常的代码throw new Exception，在外部才可以使用try catch获取异常
  4. 异常类可以抓住多个，但是上个获取后(catch)，就不会去获取下一个，所以一定要把catch(Exception $e)放到最后
  5. 实例化异常类后，需要传入两个参数message，code，这两个只是为了在获取异常时可以获取对应的异常的提示信息，而与Exception本身无关。

4.7 Final 类和方法

// 定义一个类为 final 类
final class EndClass{
    
}
class OutPutClass{
    // 定义一个方法为 final 方法
    final public function getDiscount(){
        return 10;
    }
}

注意点：

  1. final类不能被继承，除此之外，与一般的类使用方法一致，可以被实例化，可以设置静态，非静态的函数与属性。
  2. final方法不能被覆写。

4.8 使用拦截器

<?php

class PersonWriter{
    // 5
    public function writeName(Person $person){
        print $person->getName()."\n";
    }
    public function writeAge(Person $person){
        print $person->getAge()."\n";
    }
}

class Person{
    private $writer;
    // 2
    public function __construct(PersonWriter $writer)
    {
        $this->writer=$writer;
    }
    // 4
    public function __call($name, $arguments)
    {
        if(method_exists($this->writer,$name)){
            return $this->writer->$name($this);
        }
    }
    // 6
    public function getName(){
        return "Name";
    }
    public function getAge(){
        return "Age";
    }
}
// 1
$person=new Person(new PersonWriter());
// 3
$person->writeName();

输出

Name

注意点：

  1. 仔细看上面的类的调用，其中的调用很复杂，我在其中把调用顺序用数字标出来了
  2. 重点的一段代码就是：return $this->writer->$name($this);，这里就像是在用运行时，用字符串临时组成代码的运行程序一样。

4.9 析构方法

class Example{
    public function __construct(){
        print "该类被实例化\n";
    }
    public function __destruct(){
        print "该类占用的资源将被释放\n"
    }
}

4.10 使用__clone()复制对象

这里有一些别的笔记，我需要先记一下：

<?php
class Example{
    public $num=10;
    public function addNum(){
        $this->num++;
        return $this->num;
    }
}

$firstNum=new Example();
$secondNum=$firstNum;
print $firstNum->addNum()."\n";
print $secondNum->addNum()."\n";

输出

11
12

注意点：

  • PHP 4以及之前的版本：$second是一个新的对象。
  • PHP 5以及之后的版本：$first，$second是针对同一个对象的两个调用。
  • 所以$secondNum运行addNum时，是从11开始的，而不是10，因为$firstNum已经运行过一次了。

这里再记录一个注意点：== 判断两个值是否相等，===判断两个值是否相等，且是否都是对象，但是无法判断这两个值是两个相同的对象，还是针对一个对象的两次引用。

所以在PHP 5之后，要想复制一个对象，可以使用clone函数

<?php
class Example{
    public $num=10;
    public function addNum(){
        $this->num++;
        return $this->num;
    }
    public function __clone()
    {
        $this->num=10;
    }
}

$firstNum=new Example();
print $firstNum->addNum()."\n";
$secondNum=clone $firstNum;
print $secondNum->addNum()."\n";

注意点：

  1. __clone函数只有在对象被clone函数执行时才会运行，像一般的$person2=$person;这样的方式是不会处罚该函数的。
  2. clone函数运行时，会把对象复制出一个新的给变量，但是如果其中存在的某个属性是对一个对象的调用，则不会创建对应对象的副本，而只是单纯的引用。
<?php

class CountNum{
    private $num=0;
    public function addNum(){
        $this->num++;
    }
    public function getNum(){
        return $this->num;
    }
}

class Example{
    public $num=10;
    public $countNum;
    public function __construct(CountNum $countNum)
    {
        $this->countNum=$countNum;
    }
    public function __clone()
    {
        $this->countNum=new CountNum();
    }
    public function addCountNum(){
        $this->countNum->addNum();
    }
    public function getCountNum(){
        return $this->countNum->getNum();
    }
}

$firstNum=new Example(new CountNum());
$secondNum=clone $firstNum;
$firstNum->addCountNum();
print $secondNum->getCountNum();

输出

0

注意点:

  1. 这里的重点就一个$this->countNum=new CountNum();，如果没有这段代码，则直接输出1，因为运行$secondNum=clone $firstNum;时，$firstNum中的属性public $countNum;与$secondNum中是针对同一个CountNum的引用，所以$firstNum的对其的操作会直接影响到$secondNum上去。但是在__clone中将$secondNum的$countNum指向了一个新对象，所以两者就无关了。

4.11 定义对象的字符串值

<?php

class OutPutString{
    public function __toString()
    {
        return "print/echo 该类时，该方法的返回字符串将被调用";
    }
}

$outputString=new OutPutString();
print $outputString;

输出

print/echo 该类时，该方法的返回字符串将被调用

4.12 回调，匿名函数和闭包

在介绍知识点之前，先看几个函数：

  • call_user_func
<?php

$functions=function ($param){
    print "调用匿名函数，并传入参数：{$param}\n";
};

call_user_func($functions,10);

在这里再介绍一个调用对象中类的方式

<?php

class HandleNum{
    public function outputNum($num){
        print "The Num is {$num}\n";
    }
    // 注意，这里不能写成 public function addNum(&$num) 这样，只能传入值，不能传入引用
    public function addNum($num){
        $num++;
    }
}

$num=10;
// 一个对象实例作为第一个参数，需要调用的方法作为第二个参数传入，可以以这样的方式调用对象中的方法来处理数组
call_user_func(array(new HandleNum(),"outputNum"),$num);
call_user_func(array(new HandleNum(),"addNum"),$num);
print $num;
  • array_walk
<?php

$array=range(0,10);
$unChangeArray=$array;
// 注意这里调用第一个参数时，采用的是 &$value，传入的不是参数的值，而是参数本身，所以在函数中对参数作出修改后，也能直接修改原始数组的值
$functions=function (&$value,$key){
    $value++;
};

array_walk($array,$functions);
print "未修改数据前\n";
print_r($unChangeArray);
print "调用函数修改过数据后\n";
print_r($array);

输出结果

在这里插入图片描述

注意点：

  1. 这里创建了一个匿名函数$functions=function，并将其保存在变量$functions中。

返回一个匿名函数

<?php

$anotherFunction=function ($outsideParam){
    return function ($anotherFunctionParams) use ($outsideParam){
        print "输出父作用域中传入的函数:{$outsideParam}\n";
        print "传入该匿名函数中传入的函数:{$anotherFunctionParams}\n";
    };
};

$newFunction=$anotherFunction("创建函数时传入的参数");
$newFunction("创建的函数被调用时传入的参数");

这里就是想说明两点：

  1. PHP运行时，感觉可以将接下来要执行的代码用字符串拼接起来一样。
  2. 所谓的函数，也可以作为一个变量来存储，来返回。
  3. 在返回函数时，要将父作用域中的参数不是作为参数传入返回的函数中的方法就是使用use。
trouble-i-am-in
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深入PHP面向对象、模式与实践_第3版_高清PDF(附完整源码)
10-23
深入PHP面向对象、模式与实践_第3版_高清PDF(附完整源码)，高清PDF，书上所有代码均有附带在压缩包内
深入PHP：面向对象、模式与实践（第三版）高清PDF和完整源码下载.rar
01-11
买了这本书，感觉很不错，但是没办法天天带着这本书，就搞了电子版本的，原先是没有目录的，看起来很不方便，又找了一个有目录的，结合代码，方便大家
深入 PHP 面向对象、模式与实践
HugeStaff
03-21 842
深入php面向对象、模式与实践 1 语法 1.1 基础语法 clone 需要操作原对象,但又不想影响原对象. 1 $K_back = clone $K; 基本数据类型和数组都为真复制,即为真副本,当属性为对象时,为假复制,改变副本仍会影响原对象.解决方案: 1 2 3 4
读《深入php面向对象、模式与实践》有感（一）
weixin_30325793的博客
02-28 117
什么样的代码需要改进？书中给出了四个标准（我个人比较认可这四个标准，实际开发中也的确时常遇到）： 一、代码重复 用书中的原话讲：“如果你在写代码的时候，总是感觉似曾相识，很可能你的代码已经重复了”。 代码重复的坏处在于，当你某一段代码需要修改，而与该段代码重复的代码往往也要修改，即你要为同一个问题修改多出相同的代码，而有时你可能会漏掉某处忘记修改。。。。。当发现有代码重复时你应当检查...
20.对象的高级特性
weixin_34387468的博客
03-30 81
对象比较，当同一个类的两个实例的所有属性都相等时，可以使用比较运算符==进行判断，当需要判断两个变量是否为同一个对象的引用时，可以使用全等运算符===进行判断。 class Car { } $a = new Car(); $b = new Car(); if ($a == $b) echo '=='; //true if ($a === $b) echo '==='; //fals...
深入PHP：面向对象、模式与实践（第三版）高清PDF和完整源码_(0601).rar
06-02
《深入PHP：面向对象、模式与实践》是PHP开发领域的一本经典著作，特别是第三版，它详尽地探讨了PHP的面向对象编程、设计模式以及最佳实践。这本书旨在帮助PHP开发者提升技能，掌握更高级的技术，从而在项目中实现更...
深入PHP面向对象、模式与实践 (第2版)》 part2
12-11
本书全面深入地剖析了面向对象的php编程与设计。首先介绍了php的oo特性，包括类声明、对象实例化、继承、方法与属性封装以及静态方法与属性、抽象类、接口、异常...《深入PHP面向对象、模式与实践 (第2版)》.part2.rar
深入PHP面向对象、模式与实践 (第2版) part1
12-11
本书全面深入地剖析了面向对象的php编程与设计。首先介绍了php的oo特性，包括类声明、对象实例化、继承、方法与属性封装以及静态方法与属性、抽象类、接口、异常...《深入PHP面向对象、模式与实践 (第2版)》.part2.rar
深入PHP：面向对象、模式与实践（第三版）高清PDF和完整源码.rar.rar
06-06
《深入PHP：面向对象、模式与实践》是PHP开发者必读的经典著作，尤其在第三版中，作者深入探讨了PHP的面向对象编程、设计模式以及实际应用中的最佳实践。本书旨在提升读者对PHP的深入理解，使他们能够利用高级技术...
深入PHP：面向对象、模式与实践（第3版）完整版带书签.pdf
01-10
深入PHP：面向对象、模式与实践（第3版）完整版带书签.pdf 个人收集电子书，仅用学习使用，不可用于商业用途，如有版权问题，请联系删除！
深入PHP 面向对象 模式与实践第三版(完整版).pdf
04-10
深入PHP面向对象 模式与实践第三版号称是php中的圣经,
深入PHP 面向对象、模式与实践.rar
06-03
深入PHP 面向对象、模式与实践.rar
深入PHP：面向对象、模式与实践（第三版）高清PDF和完整源码.zip
06-03
深入PHP：面向对象、模式与实践（第三版）高清PDF和完整源码
深入PHP 面向对象，模式与实践总结
TROUBLE I AM IN
04-26 352
深入PHP 面向对象，模式与实践总结 辞职后的第一件事情就是把这本书啃完，断断续续也大致啃完一遍了，下面是我个人的一些感觉以及阅读本书的一些建议。 适合那些人读？ 刚入行或者1-2年的开发人员，其实都蛮适合读这本书的，因为这本书的确写的很好，很适合你作为巩固老知识，系统学习PHP面向对象知识的书籍。 而且你最好一章一章之间不要断开读太久，因为有些代码是复用的，所以你可能会突然不知所云这一段代码是哪...
深入PHP面向对象、模式与实践——生成对象（1）
程序员的修养
04-01 356
单例模式 生成对象的问题和解决方案 abstract class Employee { protected $name; public function __construct($name) { $this->name = $name; } abstract function fire(); }class Minion extends Employ
深入PHP面向对象，模式与实践 第10章 让面向对象编程更加灵活的模式
TROUBLE I AM IN
04-08 328
让面向对象编程更加灵活的模式 笔记 组合模式 使用场景 顾名思义，组合模式是适用于组合的，这里的组合不是只类之间功能的组合，而是类对象之间的组合，而且也不是完全不同的类，因为业务联系而组合在一起，而是继承自同一个父类的对象组合在一起。 示例1 <?php abstract class Unit{ abstract function bombardStrength(); } /** ...
PHP高级程序员面试第一季
07-01
二、PHP面向对象的特性 1. 访问修饰符：public、private、protected，控制类成员的访问权限。 2. 构造函数与析构函数：构造函数用于初始化新创建的对象，析构函数在对象销毁前执行。 3. 静态成员：静态变量和静态...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值