什么是设计模式?
在软件开发过程中,经常出现的经典场景的典型解决方案,称为设计模式
如何学习设计模式?
典型场景 --> 典型问题 --> 典型解决办法
1.多态
-------------------------------------------------------------------------------------------------------------------------------------
用来消除逻辑语句.
多态(ploymorphism)是一个生物学上的概念,指同一特种的多种表现形态.
在面向对象中,指某种对象实例的不同表现形态.
abstract class Tiger {
public abstract function climb();
}
class XTiger extends Tiger {
public function climb() {
echo 'Drop' , '';
}
}
class MTiger extends Tiger {
public function climb() {
echo 'Up' , '';
}
}
class Cat {
public function climb() {
echo 'Fly';
}
}
class Client {
public static function call(Tiger $animal) { // 参数限定不严格,可以更加灵活, 可以传递一个父类类型,就可以有不同的子类形态
$animal->climb();
}
}
Client::call(new XTiger());
Client::call(new MTiger());
Client::call(new Cat());
?>
在23种设计模式中,可以有些模式可以自然消除的.
2.策略模式
-------------------------------------------------------------------------------------------------------------------------------------
在此模式中,算法是从复杂类提取的,因而可以方便地替换。例如,如果要更改搜索引擎中排列页的方法,则策略模式是一个不错的选择。思考一下搜索引擎的几个部分 —— 一部分遍历页面,一部分对每页排列,另一部分基于排列的结果排序。在复杂的示例中,这些部分都在同一个类中。通过使用策略模式,您可将排列部分放入另一个类中,以便更改页排列的方式,而不影响搜索引擎的其余代码。
//定义接口
interface IStrategy {
function filter($record);
}
//实现接口方式1
class FindAfterStrategy implements IStrategy {
private $_name;
public function __construct($name) {
$this->_name = $name;
}
public function filter($record) {
return strcmp ( $this->_name, $record ) <= 0;
}
}
//实现接口方式1
class RandomStrategy implements IStrategy {
public function filter($record) {
return rand ( 0, 1 ) >= 0.5;
}
}
//主类
class UserList {
private $_list = array ();
public function __construct($names) {
if ($names != null) {
foreach ( $names as $name ) {
$this->_list [] = $name;
}
}
}
public function add($name) {
$this->_list [] = $name;
}
public function find($filter) {
$recs = array ();
foreach ( $this->_list as $user ) {
if ($filter->filter ( $user ))
$recs [] = $user;
}
return $recs;
}
}
$ul = new UserList ( array (
"Andy",
"Jack",
"Lori",
"Megan"
) );
$f1 = $ul->find ( new FindAfterStrategy ( "J" ) );
print_r ( $f1 );
$f2 = $ul->find ( new RandomStrategy () );
3.命令链模式
------------------------------------------------------------------------------------------------------------------------------------
命令链 模式以松散耦合主题为基础,发送消息、命令和请求,或通过一组处理程序发送任意内容。每个处理程序都会自行判断自己能否处理请求。如果可以,该请求被处理,进程停止。您可以为系统添加或移除处理程序,而不影响其他处理程序。清单 5 显示了此模式的一个示例。
interface ICommand
{
function onCommand( $name, $args );
}
class CommandChain
{
private $_commands = array();
public function addCommand( $cmd )
{
$this->_commands []= $cmd;
}
public function runCommand( $name, $args )
{
foreach( $this->_commands as $cmd )
{
if ( $cmd->onCommand( $name, $args ) )
return;
}
}
}
class UserCommand implements ICommand
{
public function onCommand( $name, $args )
{
if ( $name != 'addUser' ) return false;
echo( "UserCommand handling 'addUser'\n" );
return true;
}
}
class MailCommand implements ICommand
{
public function onCommand( $name, $args )
{
if ( $name != 'mail' ) return false;
echo( "MailCommand handling 'mail'\n" );
return true;
}
}
$cc = new CommandChain();
$cc->addCommand( new UserCommand() );
$cc->addCommand( new MailCommand() );
$cc->runCommand( 'addUser', null );
$cc->runCommand( 'mail', null );
?>
此代码定义维护 ICommand 对象列表的 CommandChain 类。两个类都可以实现 ICommand 接口 —— 一个对邮件的请求作出响应,另一个对添加用户作出响应。
如果您运行包含某些测试代码的脚本,则会得到以下输出:
% php chain.php
UserCommand handling 'addUser'
MailCommand handling 'mail'
%
代码首先创建 CommandChain 对象,并为它添加两个命令对象的实例。然后运行两个命令以查看谁对这些命令作出了响应。如果命令的名称匹配 UserCommand 或 MailCommand,则代码失败,不发生任何操作。
为处理请求而创建可扩展的架构时,命令链模式很有价值,使用它可以解决许多问题。
4.工厂方法
-------------------------------------------------------------------------------------------------------------------------------------
进行扩展,避免对原有数据进行修改,只需要新增代码的子类,就可以完成。
对于修改是封闭的,对于扩展是开放的.
// 共同接口
// 数据库的接口
interface DB {
function conn();
}
// 创造数据库的接口
interface Factory {
function createDB();
}
// 服务端开发(不知道将会被谁调用)
class DbMysql implements DB {
public function conn() {
echo 'conn mysql
';
}
}
class DbSqlite implements DB {
public function conn() {
echo 'conn sqlite
';
}
}
class MySqlFactory implements Factory {
public function createDB() {
return new DbMysql();
}
}
class SqliteFactory implements Factory {
public function createDB() {
return new DbSqlite();
}
}
// ==== 服务器端添加oracle类
// 进行扩展,避免对原有数据进行修改
class orcale implements DB {
public function conn() {
echo 'conn orcal
';
}
}
class orcaleFactory implements Factory {
public function createDB() {
return new orcale();
}
}
// ------客户端开始调用.
$fact = new MysqlFactory();
$db = $fact->createDB();
$db->conn();
$fact = new SqliteFactory();
$db = $fact->createDB();
$db->conn();
5.单列模式
-------------------------------------------------------------------------------------------------------------------------------------
常见使用场景:
- 需要数据库类的时候
- 操作cookie类
- 上传图片类
DB.class.php
Upload.class.php
Cookie.class.php
// 这三个类都需要读取配置文件信息,而配置文件是共用的,因此配置读取类有一个对象就够了。
// (如何保证对象只有一个)
PHP对象什么时候全等
二个对象是一个的时候.
单例模式实现
- 封闭外部new操作
- 内部开公共接口,负责new操作,控制单一实例
- 禁止继承覆盖__construcotr
- 防止克隆
class Single {
protected static $ins = null;
public static function getIns() { // getIns的控制权在class内部,可以在getIns做手脚
if (self::$ins === null) {
self::$ins = new self();
}
return self::$ins; // 返回自身实例
}
final protected function __constructor() { // 方法前加 final,则方法不能被覆盖,类前加final,则类不能被继承。
}
// 封锁clone
final protected function __clone() {
}
}
$s1 = Single::getIns();
$s2 = clone $s1; // 克隆了,又产生了多个对象.
var_dump($s1, $s2);
var_dump($s1 === $s2); // true
6.观察者模式
-------------------------------------------------------------------------------------------------------------------------------------
一个对象变化,引起其它对象的反应。可以让其它几个对象观察变化的对象的反应.
一对多的关系.
优点:解耦。
观察者模式中的三者: Subject, Observer, Client;
// Subject
attach() // 记忆多个的对象
detach() // 告知记忆的对象,变化情况
notify() // 更新通知
// Observer
update() // 更新对象中执行的逻辑
// Client
// 调用添加观察者`attach()`
JavaScript实现观察者模式:
var select = document.querySelector('select');
var content = document.querySelector('.content');
var ad = document.querySelector('.ad');
// Subject
select.observer = {};
// 添加观察者
select.attach = function(key, obj) {
this.observer[key] = obj;
}
// 删除观察者
select.detach = function(key) {
delete this.observer[key];
}
// 更新通知
select.onchange = select.ontify = function() {
for (var key in this.observer) {
this.observer[key].update(this);
}
}
// Observer
// 观察者
content.update = function(observer) { // 参数是被观察者对象
alert('content');
if (observer.value) {
// 逻辑代码
}
}
ad.update = function(observer) { // 参数是被观察者对象
alert('ad');
if (observer.value) {
// 逻辑代码
}
}
// Client
// 监听
select.attach('content', content); // 只需要把独特的表示加入 对象key中
select.attach('ad', ad);
7.模版模式
-------------------------------------------------------------------------------------------------------------------------------------
模板模式准备一个抽象类,将部分逻辑以具体方法以及具体构造形式实现,然后声明一些抽象方法来迫使子类实现剩余的逻辑。不同的子类可以以不同的方式实现这些抽象方法,从而对剩余的逻辑有不同的实现。先制定一个顶级逻辑框架,而将逻辑的细节留给具体的子类去实现。
uml类图:
角色:
抽象模板角色(MakePhone):抽象模板类,定义了一个具体的算法流程和一些留给子类必须实现的抽象方法。
具体子类角色(XiaoMi):实现MakePhone中的抽象方法,子类可以有自己独特的实现形式,但是执行流程受MakePhone控制。
核心:
/**
* Created by PhpStorm->
* User extends Jang
* Date extends 2015/6/10
* Time extends 11 extends 06
*/
//抽象模板类
abstract class MakePhone
{
protected $name;
public function __construct($name)
{
$this->name=$name;
}
public function MakeFlow()
{
$this->MakeBattery();
$this->MakeCamera();
$this->MakeScreen();
echo $this->name."手机生产完毕!
";
}
public abstract function MakeScreen();
public abstract function MakeBattery();
public abstract function MakeCamera();
}
//小米手机
class XiaoMi extends MakePhone
{
public function __construct($name='小米')
{
parent::__construct($name);
}
public function MakeBattery()
{
echo "小米电池生产完毕!
";
}
public function MakeCamera()
{
echo "小米相机生产完毕!
";
}
public function MakeScreen()
{
echo "小米屏幕生产完毕!
";
}
}
//魅族手机
class FlyMe extends MakePhone
{
function __construct($name='魅族')
{
parent::__construct($name);
}
public function MakeBattery()
{
echo "魅族电池生产完毕!
";
}
public function MakeCamera()
{
echo "魅族相机生产完毕!
";
}
public function MakeScreen()
{
echo "魅族屏幕生产完毕!
";
}
}
客户端测试代码;
header("Content-Type:text/html;charset=utf-8");
//-------------------------模板模式---------------------
require_once "./Template/Template.php";
$miui=new XiaoMi();
$flyMe=new FlyMe();
$miui->MakeFlow();
$flyMe->MakeFlow();
适用场景及优势:
1、完成某一细节层次一致的一个过程或一系列步骤,但其个别步骤在更详细的层次上的实现可能不同时。我们通常考虑用模板模式来处理。
2、当不变的和可变的行为在方法的子类实现中混合在一起的时候,不变的行为就会在子类中重复出现,我们通过模板模式把这些行为搬移到单一的地方,这样就帮助子类摆脱重复的不变行为的纠缠。
3、模板模式通过把不变的行为搬移到超级抽象类,去除子类中的重复代码来体现它的优势。模板模式提供了一个很好的代码复用平台