设计模式代表着更快开发健壮软件的有用方法，而且还提供了以友好的术语封装大型理念的方法。
- 工厂模式
工厂设计模式提供获取某个对象的新实例的一个接口，同时使调用代码避免确定实际实例化基类步骤，
很多高级模式都是依赖于工厂模式
工厂模式分为：简单工厂模式、工厂方法模式、抽象工厂模式。工厂模式是一种类，建立了一个工厂来根据所需来创建对象，这种方式在多态性编程中是很重要的，允许动态替换类，修改配置。例如：从数据库A变成从另外的数据源去获取，这时候，要修改起来就比较麻烦，要修改其他很多类的代码。这种设计显然是不够灵活的，换句话说，就是紧耦合的，系统中某个部分的函数或类严重依赖于系统的其他部分中的函数或类的行为和结构。（工厂模式，就是解决这样的一些情况的设计方法。）
简单工厂模式，通过静态方法创建对象。可以理解成，只负责生产同一等级结构中的任何一个产品，但是不能新增产品。
工厂方法模式，去掉了简单工厂模式中方法的静态属性，使其可以被子类集成，定义一个创建对象的接口，
让子类去决定实例化哪个类。可以理解成，用来生产同一等级结构中的固定产品，但是支持增加产品。
/**
* 基本工厂模式
* */
class User {
private $username;
public function __construct($username) {
$this->username = $username;
}
public function getUser() {
return $this->username;
}
}
class userFactory {
static public function createUser() {
return new User('Jack');
}
}
$user = userFactory::createUser();echo $user->getUser(); /*简单工厂模式
* */
interface userProperties {
function getUsername();
function getGender();
function getJob();
}
class User implements userProperties{
private $username;
private $gender;
private $job;
public function __construct($username, $gender, $job) {
$this->username = $username;
$this->gender = $gender;
$this->job = $job;
}
public function getUsername() {
return $this->username;
}
public function getGender() {
return $this->gender;
}
public function getJob() {
return $this->job;
}
}
class userFactory {
static public function createUser($properties = []) {
return new User($properties['username'], $properties['gender'], $properties['job']);
}
}
$employers = [
['username' => 'Jack', 'gender' => 'male', 'job' => 'coder'],
['username' => 'Marry', 'gender' => 'female', 'job' => 'designer'],
];
$user = userFactory::createUser($employers[0]);
echo $user->getUsername(); /* 工厂方法模式
**/
interface userProperties {
function getUsername();
function getGender();
function getJob();
}
interface createUser {
function create($properties);
}
class User implements userProperties{
private $username;
private $gender;
private $job;
public function __construct($username, $gender, $job) {
$this->username = $username;
$this->gender = $gender;
$this->job = $job;
}
public function getUsername() {
return $this->username;
}
public function getGender() {
return $this->gender;
}
public function getJob() {
return $this->job;
}
}
class userFactory {
private $user;
public function __construct($properties = []) {
$this->user = new User($properties['username'], $properties['gender'], $properties['job']);
}
public function getUser() {
return $this->user;
}
}
class FactoryMan implements createUser {
function create($properties) {
return new userFactory($properties);
}
}
class FactoryWoman implements createUser {
function create($properties) {
return new userFactory($properties);
}
}
class clientUser {
static public function getClient($properties) {
$fac = new FactoryMan;
$man = $fac->create($properties);
echo $man->getUser()->getUsername();
}
}
$employers = [
['username' => 'Jack', 'gender' => 'male', 'job' => 'coder'],
['username' => 'Marry', 'gender' => 'female', 'job' => 'designer'],
];
$user = clientUser::getClient($employers[0]);/**
* 抽象工厂模式
* */
interface userProperties {
function getUsername();
function getGender();
function getJob();
}
interface createUser { //将对象的创建抽象成一个接口
function createOpen($properties);//内向创建
function createIntro($properties);//外向创建
}
class User implements userProperties{
private $username;
private $gender;
private $job;
public function __construct($username, $gender, $job) {
$this->username = $username;
$this->gender = $gender;
$this->job = $job;
}
public function getUsername() {
return $this->username;
}
public function getGender() {
return $this->gender;
}
public function getJob() {
return $this->job;
}
}
class userFactory {
private $user;
public function __construct($properties = []) {
$this->user = new User($properties['username'], $properties['gender'], $properties['job']);
}
public function getUser() {
return $this->user;
}
}
class FactoryMan implements createUser {
function createOpen($properties) {
return new userFactory($properties);
}
function createIntro($properties) {
return new userFactory($properties);
}
}
class FactoryWoman implements createUser {
function createOpen($properties) {
return new userFactory($properties);
}
function createIntro($properties) {
return new userFactory($properties);
}
}
class clientUser {
static public function getClient($properties) {
$fac = new FactoryMan;
$man = $fac->createOpen($properties);
echo $man->getUser()->getUsername();
}
}
$employers = [
['username' => 'Jack', 'gender' => 'male', 'job' => 'coder'],
['username' => 'Marry', 'gender' => 'female', 'job' => 'designer'],
];
$user = clientUser::getClient($employers[0]);- 单例模式
这样有利于我们协调系统整体的行为。这种方式简化了在复杂环境下的配置管理。
优点：
1.在单例模式中，活动的单例只有一个实例，对单例类的所有实例化得到的都是相同的一个实例。这样就 防止其它对象对自己的实例化，确保所有的对象都访问一个实例
2.单例模式具有一定的伸缩性，类自己来控制实例化进程，类就在改变实例化进程上有相应的伸缩性。
3.提供了对唯一实例的受控访问。
4.由于在系统内存中只存在一个对象，因此可以 节约系统资源，当 需要频繁创建和销毁的对象时单例模式无疑可以提高系统的性能。
5.允许可变数目的实例。
6.避免对共享资源的多重占用。
缺点：
1.不适用于变化的对象，如果同一类型的对象总是要在不同的用例场景发生变化，单例就会引起数据的错误，不能保存彼此的状态。
2.由于单利模式中没有抽象层，因此单例类的扩展有很大的困难。
3.单例类的职责过重，在一定程度上违背了“单一职责原则”。
4.滥用单例将带来一些负面问题，如为了节省资源将数据库连接池对象设计为的单例类，可能会导致共享连接池对象的程序过多而出现连接池溢出；
如果实例化的对象长时间不被利用，系统会认为是垃圾而被回收，这将导致对象状态的丢失。
实现单例模式
一个类能返回对象一个引用(永远是同一个)和一个获得该实例的方法，当我们调用这个方法时，如果类持有的引用不为空就返回这个引用，如果类保持的引用为空就创建该类的实例并将实例的引用赋予该类保持的引用；同时我们 还将该类的构造函数定义为私有方法，这样其他处的代码就无法通过调用该类的构造函数来实例化该类的对象，只有通过该类提供的静态方法来得到该类的唯一实例。
观察者模式
观察者模式为您提供了避免组件之间紧密耦合的另一种方法。该模式非常简单：一个对象通过添加一个方法（该方法允许另一个对象，即观察者 注册自己）使本身变得可观察。
一个简单示例是系统中的用户列表。清单 4 中的代码显示一个用户列表，添加用户时，它将发送出一条消息。添加用户时，通过发送消息的日志观察者可以观察此列表。
interface IObserver{
function onChanged( $sender, $args );
}
interface IObservable{
function addObserver( $observer );
}
class UserList implements IObservable{
private $_observers = array();
public function addCustomer( $name ){
foreach( $this->_observers as $obs )
$obs->onChanged( $this, $name );
}
public function addObserver( $observer ){
$this->_observers []= $observer;
}
}
class UserListLogger implements IObserver{
public function onChanged( $sender, $args ){
echo( "'$args' added to user list\n" );
}
}
$ul = new UserList();
$ul->addObserver( new UserListLogger() );
$ul->addCustomer( "Jack" );- 策略模式
处理程序算法与其他算法之间的互换 ，策略模式提供了管理相关的算法族的办法。策略类的等级结构定义了一个算法或行为族。
恰当使用继承可以把公共的代码转移到父类里面，从而避免重复的代码。
实现方式：声明一个抽象的拥有一个算法方法的基类来实现，通过继承基类的具体类来实现
实现方式：声明一个抽象的拥有一个算法方法的基类来实现，通过继承基类的具体类来实现
//抽象策略接口
abstract class Strategy{
abstract function wayToSchool();
}
//具体策略角色
class BikeStrategy extends Strategy{
function wayToSchool(){
echo "骑自行车去上学";
}
}
class BusStrategy extends Strategy{
function wayToSchool(){
echo "乘公共汽车去上学";
}
}
class TaxiStrategy extends Strategy{
function wayToSchool(){
echo "骑出租车去上学";
}
}
//环境角色
class Context{
private $strategy;
//获取具体策略
function getStrategy($strategyName){
try{
$strategyReflection = new ReflectionClass($strategyName);
$this->strategy = $strategyReflection->newInstance();
}catch(ReflectionException $e){
$this->strategy = "";
}
}
function goToSchool(){
$this->strategy->wayToSchool();
// var_dump($this->strategy);
}
}
//测试
$context = new Context();
$context->getStrategy("BusStrategy");
$context->goToSchool();
3493
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
