67677新澳门手机版 > 67677新澳门手机版 > 深入PHP面向对象、模式与实践
深入PHP面向对象、模式与实践
2020-03-14 20:20

1 语法

第4章 高级特性

67677新澳门手机版,第1章  PHP:设计与管理

深入PHP : 面向对象、模式与实践 (第2版)

1.1 基础语法

clone

需要操作原对象,但又不想影响原对象.

$K_back = clone $K;

基本数据类型和数组都为真复制,即为真副本,当属性为对象时,为假复制,改变副本仍会影响原对象.解决方案:

//在原对象中添加
function __clone(){
    $this->对象 = clone $this->对象
}

__clone在clone前自动触发,可以执行一些在备份前的属性操作.

&传递引用

方法引用传递,改变源对象

function set_K(& $K){...}

function & get_K(){...}

static延迟静态绑定

应用场景:Dog类和Person类都需要一个返回实例化的方法,Dog类和Person类都继承于Animal抽象类.

abstract class Animal{
    public static function create(){
        //实例化调用类
        return new static();
    }
}

class Person extends Animal{...}

//返回Person实例化类
Person::create();

拦截器

  1. __get($property),访问未定义的属性时调用.
  2. __set($property,$value),给未定义的属性赋值时被调用.
  3. __isset($property),对未定义属性调用isset()方法时调用.
  4. __unset($property),对未定义属性调用unset()方法时调用.
  5. __call($method,$arg_array),调用未定义方法时调用.__call很有用,但要慎用,因为太灵活.应用场景:有一个专门打印Person类信息的Person_Writer类,如果通过Person类调用Person_Writer类.

    //Person委托Person_Writer类处理打印事务.
    class Person {
        private $writer;
        ...
    
        function __call($method_name,$args){
            if(methood_exists($this->wirter,$method_name)){
                return $this->writer->$method_name($this);
            }
        }
    
        //高级__call写法,当委托方法参数不确定时使用.
        function __call($method_name,$args){
            //当然这里这样写法意义不大,但是call一般都是用call_user_func_array调用
            $args = $this ;
            if(methood_exists($this->wirter,$method_name)){
                return call_user_func_array(
                    array($this->writer,$method_name),$args);
                )
            }
        }
    
    }
    

回调函数

应用场景: 3个类,Product类,Product_Sale类,Product_Totalizer类,要实现:当卖出Product总共价格超过指定金额时,输出警告.

//Product
class Product {
    public $name;
    public $price;
}

//Product_Sale
class Product_Sale {
    private $callbacks;

    //记录回调函数
    function register_callback ($callback) {
        if(! is_callback($callback)){
            thow new Exception('callback not callable');
        }
        $this->callbacks[] = $callback;
    }

    //执行回调函数
    function sale ($product){
        print "{$product->name} : 处理中 n";
        foreach($this->callbacks as $callback){
            call_user_func($callback , $product);
        }
    }
}

//Produce_Totalizer
class Produce_Totalizer {
    static function warn_amount ($amt) {
        $count = 0;
        return function ($produce) use ($amt , &count) {
            $count += $produce->price;
            print " count : {count}n"
            if($count>$amt){
                print "quot;超过指定金额{$amt}啦~";
            }
        };
    }
}

//模拟场景
$product_sale = new Produce_Sale();
//指定报警金额为8块
$product_sale = register_callback(Produce_Totalizer::warn_amount(8)); 

//卖商品
$product_sale->sale(new Product("Durex",6));
$product_sale->sale(new Produce("Jissbon",5));

//输出结果
Durex : 处理中
    count :6 

Jissbon : 处理中 
    count: 11

超过指定金额8块啦~

get_class()instanceof

get_class(类)用于判断是否精准等于类名;

instanceof 可以判断是否其本身或继承于某父类.

类中的方法和类中的属性

get_class_methods('类名'):获取类中所有方法.

get_class_vars('类名'):获取类中所有public参数;

反射API

本章内容提要:

本章主要介绍了本书有哪些内容。

67677新澳门手机版 1
基本信息

2 模式

  • 静态属性和方法:通过类而不是对象来访问数据和功能
  • 抽象类和接口:设计和实现分离
  • 错误处理:异常
  • Final类和方法:限制继承
  • 拦截器方法:自动委托
  • 析构方法:对象销毁前的清理工作
  • 克隆对象:创建对象的副本
  • 把对象解析成字符串:创建摘要型方法
  • 回调:用匿名函数为组件添加功能

第2章  PHP与对象

作者: (美)Matt Zandstra   
译者: 陈浩;吴孙滨;胡丹
丛书名: 图灵程序设计丛书
出版社:人民邮电出版社
ISBN:9787115225788
上架时间:2010-4-13
出版日期:2010 年5月
开本:16开
其他详细信息查看:

2.1 组合

问题:课堂类被演讲类和研讨会类继承着.但是演讲类和研讨类都要实现一次性计费和上N次课计费的方法.和输出计算的方式.

解决方案1: 在课堂类中添加计算一次性付费的方法,上N次课的计费方法和输出计算方式的方法.

解决方案2: 运用组合,将处理计费和输出计算方式单独封装为一个计费策略类.

67677新澳门手机版 2

abstract class Cost_Strategy {
    protected $duration;
    abstract function cost ();
    abstract function charge_type();

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

class Timed_Const_Strategy extends Cost_Stratedy {
    function cost () {
        //上一次课给5块钱- -.
        return $this->duration * 5;
    }

    function charge_type(){
        return "多次课结算";
    }
}

class Fixed_Const_Strategy extends Cost_Stratedy {
    function cost (){
        return 30 ;
    }

    function charge_type(){
        return "一次性课结算";
    }
}

abstract class Leason {

    private $cost_strategy;

    public __construct(Const_Strategy $cost_strategy){
        $this->cost_strategy = $cost_strategy;
    }

    function __call($method_name,$args){
        $args = $cost_strategy ;
        if(methood_exists($this->cost_strategy,$method_name)){
            return call_user_func_array(
                array($this->writer,$method_name),$args);
            )
        }
    }
}

//运用
$leasons[] = new Seminar(new Timed_Const_Strategy(4));
$leasons[] = new Lecture(new Fixed_Const_Strategy(null));

foreach ($leasons as $leason){
    print "leason charge : {$leason->const()}";
    print "charge_type : {$leason->charge_type()}"
}

leason charge 20. charge_type : 多次课结算;
leason charge 30. charge_type : 一次课结算;

组合既委托.同级委托.

继承既父子关系.

4.1  静态属性和方法

本章总结了PHP面向对象特性的发展过程,逐步介绍对象的概念。

内容简介

3 生成对象

静态属性和方法的声明:使用 static 关键字。

PHP/FI:支持变量、关联数组和函数。没有对象。

本书全面深入地剖析了面向对象的PHP编程与设计。首先介绍了PHP的OO特性,包括类声明、对象实例化、继承、方法与属性封装以及静态方法与属性、抽象类、接口、异常处理、对象克隆等高级主题。然后介绍了设计模式,阐述了模式的概念,展示了如何在PHP中实现几个关键的模式,用专门的章节介绍了企业模式和数据库模式。本书最后一部分围绕PHP应用程序开发,详细介绍了一批极为实用的辅助开发工具,讨论了具有普遍意义的最佳开发实践。
本书适合每位PHP程序员进阶参考,帮助他们掌握PHP面向对象设计和开发的精髓,跻身高端PHP程序员之列。

3.1 单例模式

确保系统中只有唯一一个用例.例如系统配置文件.

重点

1: 构造方法私有.

2: 类本身包含自己的实例化属性.

67677新澳门手机版 3

class Preferences {
    private static $instance;
    private function __construct(){ ... }

    public static function get_instance(){
        if(empty(self::$instance)){
            self::$instance = new Preferences();
        }
        return self::$instance;
    }
    ...
}

//使用
$preferences = Preferences::get_instance();

静态方法只能访问静态属性,不能访问普通属性。普通属性是属于对象的。

PHP3:加入对类的支持,但不能访问父类中被覆盖的方法。

 

3.2 工厂模式

通过一个父类,生产处多个不同功能的子类.

特点:产品方(新浪微博)和需求方(显示新浪微博)一一对应.

问题:印象笔记中,来源可能为新浪微博,或者开发者头条,在印象笔记显示的时候,两者的页眉和页尾是不一样的.

67677新澳门手机版 4

静态属性和方法的访问:使用 :: 来连接类名和静态元素。

PHP4:可以在子类中覆盖和访问父类的方法。对象在PHP脚本的传递依然会创建副本,但可以强制按引用传递(对象前面加&)。

目录

3.3 抽象模式

RLGL!!!.印象笔记不只要显示新浪微博内容!!!还要显示我的新浪账号,还要该微博啊!!卧槽~憋着急,吻我.

工厂模式主要用于生产一一对应的产品方和需求方,而抽象模式要做的是一个需求方(印象笔记_显示新浪微博),要多个工厂(把需求方抽象为多个需求方),例如提供新浪内容的工厂,提供新浪账号的工厂.提供微博内容的评论的工厂等.

67677新澳门手机版 5

代码:

abstract class Show_Evernote {
    abstract function get_header_text();
    abstract function get_context();
    abstract function get_footer_text();
    abstract function get_user();
    abstract function get_comment();

}

class 显示新浪微博 extends Show_Evernote{
    function get_header_text(){...};
    function get_context(){new 新浪微博_内容;}
    function get_footer_text(){...};
    function get_user(){new 新浪微博_账号 ;}
    function get_comment(){new 新浪微博_评论;}
}

//使用
印象笔记控件类->内容 = 显示新浪微博->get_context;
印象笔记控件类->账号 = 显示新浪微博->get_context;
...

一个类使用 parent 关键字来访问父类。在当前类(不是子类)访问静态元素,使用 self 关键字。在类外部,使用类名访问静态元素。

PHP5:明确支持对象和面向对象程序设计。默认按引用的方式传递对象。拥有更多扩展和增强对PHP对象的支持,比如命名空间、私有和保护类型的方法及属性、异常等。

第一部分 介绍
第1章 PHP:设计与管理 2
1.1 问题 2
1.2 PHP和其他语言 3
1.3 关于本书 5
1.3.1 对象 5
1.3.2 模式 5
1.3.3 实践 6
1.3.4 本书第2版中的新内容 7
1.4 小结 7
第二部分 对象
第2章 PHP与对象 10
2.1 PHP对象的偶然成功 10
2.1.1 最初:PHP/FI 10
2.1.2 语法糖:PHP 3 10
2.1.3 一场静悄悄的革命:PHP 4 11
2.1.4 拥抱改变:PHP 5 12
2.2 走向未来:PHP 6 12
2.3 拥护和疑虑:关于对象的争辩 13
2.4 小结 13

3.4 平行模式

当使用工厂/抽象模式必须要制定具体的创建者(需求方).

平行模式和抽象模式的模型图一致,但代码实现不一样.

抽象模式中父类均为抽象类,而平行模式中,所以类都为普通类,方便父类的实例化.

在这里列出显示印象笔记类的实现代码

class Show_Evernote{
    private $内容;
    private $账号;
    private $评论;

    function __construct(内容,账号,评论){
        $this->内容 = 内容;
        $this->账号 = 账号;
        $this->评论 = 评论;
    }

    function get_内容(){
        return clone $this->内容);
    }

    function get_账号(){
        return clone $this->账号);
    }

    function get_评论(){
        return clone $this->评论;
    }
}

//使用
$factory = new Show_Evernote( 
    new 新浪微博内容(),
    new 新浪微博账号(),
    new 新浪微博评论()
);

印象笔记控件类->显示印象笔记 = $factory;

其实大家可以发现,原型模式只不过只在最顶层类中包装了一下各组件子类而已,然而这样可以轻松的组合他们,例如实现一个显示新浪微博内容,但要显示开发者头条账号的需求?

只有在使用 parent 关键字调用方法的时候,才能对一个非静态方法进行静态形式的调用。

第3章  对象基础

.第3章 对象基础 14
3.1 类和对象 14
3.1.1 编写第一个类 14
3.1.2 第一个对象(或两个) 15
3.2 设置类中的属性 15
3.3 使用方法 18
3.4 参数和类型 20
3.4.1 基本类型 20
3.4.2 获得提示:对象类型 23
3.5 继承 24
3.5.1 继承问题 24
3.5.2 使用继承 28
3.5.3 public、private、protected:管理类的访问 32
3.6 小结 35
第4章 高级特性 36
4.1 静态方法和属性 36
4.2 常量属性 39
4.3 抽象类 39
4.4 接口 41
4.5 错误处理 43
4.6 Final类和方法 48
4.7 使用拦截器 49
4.8 析构方法 53
4.9 使用__clone()复制对象 54
4.10 定义对象的字符串值 56
4.11 小结 57
第5章 对象工具 58
5.1 PHP和包 58
5.1.1 PHP和命名空间 60
5.1.2 包含路径 62
5.1.3 自动加载 63
5.2 类函数和对象函数 64
5.2.1 查找类 64
5.2.2 了解对象或类 65
5.2.3 了解类中的方法 66
5.2.4 了解类属性 67
5.2.5 了解继承 67
5.2.6 方法调用 68
5.3 反射API 69
5.3.1 入门 69
5.3.2 开始行动 69
5.3.3 检查类 71
5.3.4 检查方法 72
5.3.5 检查方法参数 74
5.3.6 使用反射API 75
5.4 小结 78
第6章 对象与设计 79
6.1 代码设计的定义 79
6.2 面向对象设计和过程式编程 80
6.2.1 职责 83
6.2.2 内聚 83
6.2.3 耦合 83
6.2.4 正交 84
6.3 选择类 84
6.4 多态 85
6.5 封装 86
6.6 忘记细节 87
6.7 四个方向标 88
6.7.1 代码重复 88
6.7.2 类知道的太多 88
6.7.3 万能的类 88
6.7.4 条件语句 89
6.8 UML 89
6.8.1 类图 89
6.8.2 时序图 94
6.9 小结 95
第三部分 模式
第7章 什么是设计模式?为何使用它们 98
7.1 什么是设计模式 98
7.2 设计模式概览 100
7.2.1 命名 100
7.2.2 问题 100
7.2.3 解决方案 101
7.2.4 效果 101
7.3 《设计模式》格式 101
7.4 为什么使用设计模式 102
7.4.1 一个设计模式定义了一个问题 102
7.4.2 一个设计模式定义了一个解决方案 102
7.4.3 设计模式是语言无关的 102
7.4.4 模式定义了一组词汇 102
7.4.5 模式是经过测试的 103
7.4.6 模式是为协作而设计的 103
7.4.7 设计模式促进良好设计 103
7.5 PHP与设计模式 103
7.6 小结 104
第8章 模式原则 105
8.1 模式的启示 105
8.2 组合与继承 106
8.2.1 问题 106
8.2.2 使用组合 108
8.3 解耦 110
8.3.1 问题 110
8.3.2 降低耦合 111
8.4 针对接口编程,而不是针对实现编程 112
8.5 变化的概念 113
8.6 父子关系 113
8.7 模式 114
8.7.1 用于生成对象的模式 114
8.7.2 用于组织对象和类的模式 114
8.7.3 面向任务的模式 114
8.7.4 企业模式 114
8.7.5 数据库模式 114
8.8 小结 115
第9章 生成对象 116
9.1 生成对象的问题和解决方法 116
9.2 单例模式 119
9.2.1 问题 120
9.2.2 实现 120
9.2.3 结果 122
9.3 工厂方法模式 122
9.3.1 问题 122
9.3.2 实现 125
9.3.3 结果 126
9.4 抽象工厂模式 127
9.4.1 问题 127
9.4.2 实现 128
9.4.3 结果 129
9.4.4 原型模式 131
9.4.5 问题 132
9.4.6 实现 133
9.5 某些模式的骗术 134
9.6 小结 136
第10章 让面向对象编程更加灵活的模式 137
10.1 构造可灵活创建对象的类 137
10.2 组合模式 137
10.2.1 问题 138
10.2.2 实现 139
10.2.3 效果 143
10.2.4 组合模式小结 146
10.3 装饰模式 146
10.3.1 问题 146
10.3.2 实现 148
10.3.3 效果 151
10.4 外观模式 151
10.4.1 问题 152
10.4.2 实现 153
10.4.3 效果 153
10.5 小结 154
第11章 执行及描述任务 155
11.1 解释器模式 155
11.1.1 问题 155
11.1.2 实现 156
11.1.3 解释器的问题 162
11.2 策略模式 163
11.2.1 问题 163
11.2.2 实现 164
11.3 观察者模式 167
11.4 访问者模式 173
11.4.1 问题 174
11.4.2 实现 175
11.4.3 访问者模式的问题 178
11.5 命令模式 179
11.5.1 问题 179
11.5.2 实现 179
11.6 小结 183
第12章 企业模式 184
12.1 架构概述 184
12.1.1 模式 184
12.1.2 应用程序和层 185
12.2 企业架构之外的基础模式 187
12.2.1 注册表 187
12.2.2 实现 188
12.3 表现层 196
12.3.1 前端控制器 196
12.3.2 应用控制器 205
12.3.3 页面控制器 214
12.3.4 模板视图和视图助手 218
12.4 业务逻辑层 220
12.4.1 事务脚本 221
12.4.2 领域模型 225
12.5 小结 227
第13章 数据库模式 228
13.1 数据层 228
13.2 数据映射器 228
13.2.1 问题 229
13.2.2 实现 229
13.2.3 效果 239
13.3 标识映射 239
13.3.1 问题 240
13.3.2 实现 240
13.3.3 效果 242
13.4 工作单元 243
13.4.1 问题 243
13.4.2 实现 243
13.4.3 效果 246
13.4.4 延迟加载 247
13.4.5 问题 247
13.4.6 实现 247
13.4.7 效果 249
13.5 领域对象工厂 249
13.5.1 问题 249
13.5.2 实现 249
13.5.3 效果 250
13.6 标识对象 252
13.6.1 问题 252
13.6.2 实现 252
13.6.3 效果 256
13.7 选择工厂和更新工厂模式 257
13.7.1 问题 257
13.7.2 实现 257
13.7.3 效果 259
13.8 数据映射器中剩下些什么 260
13.9 小结 262
第四部分 实践
第14章 良好和糟糕的实践 264
14.1 超越代码 264
14.2 借一个轮子 264
14.3 合作愉快 266
14.4 为你的代码插上双翼 267
14.5 文档 267
14.6 测试 268
14.7 小结 269
第15章 PEAR 270
15.1 什么是PEAR 270
15.2 安装PEAR包 271
15.3 使用PEAR包 273
15.4 创建自己的PEAR包 278
15.4.1 package.xml 278
15.4.2 package.xml的组成元素 278
15.4.3 contents元素 279
15.4.4 依赖 282
15.4.5 使用phprelease进行灵活的自定义安装 283
15.4.6 发布包 284
15.4.7 创建自己的PEAR频道 284
15.5 小结 288
第16章 用phpDocumentor生成文档 289
16.1 为什么要使用文档 289
16.2 安装 290
16.3 生成文档 290
16.4 DocBlock注释 292
16.5 类的文档 293
16.6 文件的文档 294
16.7 属性的文档 295
16.8 方法的文档 296
16.9 在文档中创建链接 297
16.10 小结 300
第17章 使用CVS进行版本控制 301
17.1 为什么要使用版本控制 301
17.2 获得CVS 302
17.3 配置CVS代码库 303
17.3.1 创建代码库 303
17.3.2 配置客户端 304
17.3.3 在多台机器上运行CVS 304
17.4 开始项目 305
17.5 更新和提交 307
17.6 增加和删除文件及目录 309
17.6.1 添加文件 309
17.6.2 删除文件 310
17.6.3 添加目录 310
17.6.4 添加二进制文件 311
17.6.5 删除目录 311
17.7 标记和导出项目 312
17.7.1 标记项目 313
17.7.2 通过标签获取项目代码 313
17.7.3 导出项目 314
17.8 创建项目分支 314
17.9 小结 317
第18章 使用PHPUnit进行测试 318
18.1 功能测试与单元测试 318
18.2 手工测试 319
18.3 引入PHPUnit 321
18.3.1 创建测试用例 321
18.3.2 断言方法 322
18.3.3 测试异常 323
18.3.4 运行测试套件 324
18.3.5 约束 326
18.3.6 模拟与桩 328
18.3.7 失败是成功之母 331
18.4 警告 333
18.5 小结 335
第19章 用Phing实现项目的自动
构建 336
19.1 什么是Phing 336
19.2 获取和安装Phing 337
19.3 编写build文档 337
19.3.1 目标 339
19.3.2 属性 340
19.3.3 类型 345
19.3.4 任务 348
19.4 小结 352
第五部分 结论
第20章 对象、模式与实践 354
20.1 对象 354
20.1.1 选择 355
20.1.2 封装和委托 355
20.1.3 解耦 355
20.1.4 复用性 356
20.1.5 美学 356
20.2 模式 356
20.2.1 模式给我们带来了什么 357
20.2.2 模式和设计原则 357
20.3 实践 359
20.3.1 测试 359
20.3.2 文档 359
20.3.3 版本控制 360
20.3.4 自动构建 360
20.3.5 我们还遗漏了什么 360
20.4 小结 361
第六部分 附录
附录A 参考文献 364
附录B 简单的解析器 366

4 使用对象

静态元素的特性:

本章主要介绍PHP的核心面向对象特性。

4.1 组合模式

组合模式,可以理解为单一对象管理组合对象(聚合组件),最终组合体下的各个组合部件最好类型一致.不然特殊性越多,需要判断就越多.

假设捶背男,洗脚男,洗发男,用来服务一个人(妹子).

假设妹子的几个部位可用的服务男均为无限个.

67677新澳门手机版 6

//创建一个妹子
$妹子 = new 人();

//添加洗脚男、捶背男
$妹子->add_man(new 洗脚男);
$妹子->add_man(new 捶背男);

//循环所有男的给予舒服的方法.
$妹子->计算舒服程度();

这是一个很理想的组合模式,在现实情况,我们使用组合模式,可能不得不创建多种类型的洗脚男,需要添加许多判断条件.

  • 在任何地方都可用(假设你可以访问该类)
  • 类的每个实例都可以访问类中定义的静态元素
  • 不需要对象就能访问静态元素

3.1  类和对象

4.2 装饰模式

装饰模式,首先洗脚男,洗发男,捶背男都是人,但是如果,一个男的又捶背,又洗发,这怎么玩?.add_man两次?这不科学吧,来给这些男的装饰一下吧~

67677新澳门手机版 7

abstract class 人{
    ...
    abstract function get_well();
}   

class 男 extends 人 {
    //无论你是神马男,服务你,你就能获得10点舒服度.
    private $well = 10;
    function get_well(){
        return $this->well();
    }
}

abstract class 装饰男类型 extends 人 {
    protected $人;
    function __construct(人 $人){
        $this->人 = $人;
    } 
}

class 捶背装饰 extends 类型男装饰{
    function get_well(){
        return $this->人->get_well()+30;
    }
}

class 洗发装饰 extends 类型男装饰{
    function get_well(){
        return $this->人->get_well()+20;
    }
}

class 洗褪装饰 extends 类型男装饰{
    //老子不喜欢别人碰我的毛裤.
    function get_well(){
        return $this->人->get_well()-20;
    }
}

//创建捶背,能给予的舒服指数 - -嘻嘻.
$人 = new 捶背装饰(new 男);
$人->get_well(); // 10+30 = 40

//来来来,全能选手,捶背、洗发、洗腿一起来
$人 = new 洗脚装饰(new 洗发装饰(new 捶背装饰(new 男()))); //10+30+20-20 = 40,注意顺序,由里到外执行.

装饰模式,既(组合+继承),基类方法一定要尽量少,不然子类可能有它不该有的方法.直接类继承,她只可能是一种形态,而她的多种形态可能一并拥有的时候,应该运用组合.

继承即单一多态,组合既多种多态.

这个例子中,你可以添加女,然后把装饰男类型改为装饰通用类型,但每个get_well()都要多一个判断是男还是女(如果给予的舒服程度不一样).

这只是确保不可能出现在,之外的第三种人,如果基类为动物,给予服务的可能是鸡,鹅,鸭,那么装饰类型应该运用工厂模式,动物形态和装饰形态一一对应.方便拓展.

除了服务类型,服务男的样子也很重要,这就多了一种装饰,现在有装饰男类型相貌男类型,这种情况怎么破,其实类似.

67677新澳门手机版 8

//如何获取捶背的帅哥麦?,
$人 =new 男类型(new 捶背(new 帅哥麦(new 男())));

书中介绍了一个静态方法,该方法接受原始数据,然后返回对象,就像“工厂”一样。

本节目标,理解类和对象的关系。

4.3 外观模式

即给外部系统提供清晰接口

例如当Model层写得很混乱,但是里面的方法还能用,那我们的Controller层应该列举一些清晰的访问方法来供View层访问.外观模式,强调的是清晰的访问接口.

4.2  常量属性

3.1.1  编写第一个类

5 执行任务

常量属性使用 const 关键字来声明。常量属性不以美元符号开头,只能用大写字母来命名。

类是生成对象的代码模板。

5.1 策略模式

给类添加功能.对象要显式的调用它.

继续刚才的洗脚男和人的故事吧…你丫的爽完了要给钱吧?支付宝?微信?现金?

这个付款方式有多种,实现方法不应该放在类中,而是应该委托给别的类

abstract class 人 {

    protectd $支付方式;

    function set_支付方式(){...}

    function 付款(金额){
        return $支付方式->付款($金额);
    }
}

abstract class 付款{
    abstract function 付款($金额);
}

class 支付宝付款 extends 付款{

    function 付款($金额){
        return 外接支付宝付款流程($金额);
    }
}
...

//使用
$男 =new 男();

///爽爽爽
...

//结账
$支付宝支付账单 = new 支付宝付款($金额);
$人 = new 男();
$人->set_支付方式(new 支付宝付款());
$人->付款();

常量属性只包含基本数据类型的值。只能通过类而不能通过类的实例访问常量属性。引用常量属性时不需要用美元符号作为前导符。

使用 class 关键字和类名来声明类。类名是任意数字和字母的组合,不能以数字开头。和一个类关联的代码必须用大括号括起来。

5.2 观察者模式

当被观察者发生变化,观察者需要被通知.

当数据发生变化,页面需要被通知.

使用步骤:

  1. 观察者加载到被观察者中.
  2. 被观察者通知观察者.

67677新澳门手机版 9

例如登陆类(被观察)状态改变,要出发邮件系统和日志系统(观察者)

interface 被观察者{
    function attach(观察者);
    function detatch(观察者);
    function notify();
}

class Login implements 被观察者{
    private $观察者;

    function __construct(){
        $this->观察者 = array();
    }

    function attach($观察者){
        $this->观察者 = $观察者; 
    }

    function detach($观察者){
        //删除某个观察者的操作;
    }

    function notify(){
        foreach ($this->观察者 as $单个观察者){
            $单个观察者->update($this);
        }
    }       
}

interface 观察者{
    function update(被观察者);
}

abstract class Login_观察者 implements 观察者{
    private $login;
    function __construct (Login $login){
        $this->login = $login;
        $login->attach($this);
    }

    function update(观察者 $观察者){
        if ($观察者 ===$this->login){
            $this->do_update($观察者);
        }
    }
    abstract function do_update(Login $login);
}

class 邮件观察者 extends 登陆观察者 {
    function do_update(Login $login){
        //判断条件 发送邮件
    }
}

class 日志观察者 extends 登陆观察者 {
    function do_update(Login $login){
        //判断条件 记录到日志;
    }
}

//使用
$login = new Login();
new 邮件观察者 ($login);
new 日志观察者 ($login);

PHP有内置的SPL实现上述的观察者模式.

当需要在类的所有实例中都能访问某个属性,并且属性值无需改变时,应该使用常量。

class ShopProduct {
    // 类体
}

5.3 访问者模式

问题: 在一个军队中,有很多军队,军队下面可能包含军队/步兵/弓箭手,这时我们要显示一个军队的战斗力/需要粮食的各级分配?(遍历对象并设置显示方法).怎么办?.解决办法是军队还是保存自己的基本信息,设置一个访问者,访问者包含总战斗力方法和总粮食的方法.

67677新澳门手机版 10

访问者

abstract class 军队访问者{
    abstract function 访问(单元);

    function 访问军队($军队){
         $this->访问($军队);
    }
    function 访问弓箭手($弓箭手){
        $this->访问($弓箭手);
    }

    //这里重复定义了大量代码,其实可以用call来替代
    function __call($method_name,$args){
        if(strrpos($method_name, "访问")){
            return call_user_func_array(
                array($this,"访问"),$args
            );
        }
    }
}

class 军队战斗力访问者 extends 军队访问者{
    private $text="";

    function 访问($单元){
        $ret = "";
        $pad = 4*$单元->getDpth(); //设置显示深一级前面多4个空格.
        $ret .= sprintf( "%{$pad}s","");
        $ret .= get_class($单元). ": ";
        $ret .= "战斗力: " .$单元->bombardStrenth()."n";
        $this->text .=$ret;
    }

    function get_text(){
        return $this->text;
    }
}

被访问者

abstract class 单元{
    function 接受($军队访问者){
        $method = "访问_".get_class($this);
        $军队访问者->$method($this);
    }

    private $depth;
    protected function set_depath($depth){
        $this->depth=$depth;
    }

    function get_depth(){
        return $this->depth;
    }
    ...
}

abstract class 综合单元 extends 单元{
    function 接受($军队访问者){
        parent::接受($军队访问者)
        foreach($this->单元集合 as $this_unit){
            $this->unit->接受($军队访问者);
        }
    }
}

class 军队 extends 综合单元{
    function bombardStrenth(){
        $ret =0;
        foreach($this-units() as $unit){
            $ret += $unit->bombardStrenth();
        }
        return $ret
    }
}

class 弓箭手 extends 单元{
    function bombardStrenth(){
        return 4;
    }
}

调用

$main_army = new Army();
$main_army->add_unit(new 步兵());
$main_army->add_unit(new 弓箭手());

$军队战斗力访问者_实例 =new 军队战斗力访问者();
$main_army->接受(均分战斗力访问者);
print $军队战斗力访问者->get_text();

输出

军队: 战斗力: 50
    步兵: 攻击力 :48
    弓箭手: 攻击力: 4

4.3  抽象类

3.1.2  第一个对象

5.4 命令模式

例子为Web页面的login和feed_back,假如都需要使用ajax提交,那么问题来了,将表单封装好提交上去,得到了返回结果.如何根据返回结果跳转不同的页面?.

有些同学就说了,login和feed_back各自写一个方法憋,提交的时候调用各自的方法.

然后再来个logout命令..增加..删除..命令怎么办..

命令模式比较适合命令执行例如登陆,反馈等简单只需要判断是否成功的任务

67677新澳门手机版 11

命令:

abstract class Command{
    abstract function execute(Conmmand_Context $context);
}

class Login_Command extends Command{
    function execute(CommandContext $context){
        $managr =Register::getAccessManager();
        $user = $context->get("username");
        $pass = $context->get('pass');
        $user_obj = $manager->login($user,$pass);
        if(is_null($user_obj)){
            $context->setError($manager->getError());
            return false;
        }
        $context->addParam("user",$user_obj);
        return true;
    }
}

部署命令的调用者

class Command_Facotry{
    public function get_command($action){
        $class = UCFirst(strtolower($action))."_Command";
        $cmd = new $class();
        return $cmd;
    }

}

客户端

class Controller{
    private $context;
    function __construct(){
        //Command_Context主要用来存储request和params
        $this->context =new Command_Context();
    }
    function process(){
        $cmd Command_Factory::get_commad($this->context->get('action'));
        if(!$cmd-execute($this->context)){
            //错误处理
        }else{
            //成功 分发视图
        }
    }
}

使用

$controller =new Controller();
$context = $controller->get_context();
$context->add_param('action','login');
$context->add_param('username','404_k');
$context->add_param('pass','123456');
$controller->process();

用 abstract 关键字定义一个抽象类。可以创建抽象类的属性和方法。抽象类不能被实例化。

对象是根据类中定义的模板所构造的数据,是类的实例。使用 new 操作符来生成类对象。