PHP的加载方式
手动加载
加载指定具体的某一个文件
主要加载的关键词 : include require require_once
示例 : require ‘Test.php‘;
自动加载
__autoload
格式 : void __autoload ( string $class )
只可定义一次加载未定义的类。此函数将会在 PHP 7.2.0 中弃用。
遇到未包含的类，会触发 __autoload 进行加载，如果所有加载规则中没有此类，则 Fatal error。
示例 :
function __autoload($classname){
require $classname.‘.php‘;
}
$test = new Test();
echo $test->index();
spl_autoload_register
格式 :
function spl_autoload_register ($autoload_function = null, $throw = true, $prepend = false) {}
将函数注册到SPL __autoload函数队列中。如果该队列中的函数尚未激活，则激活它们。
如果在你的程序中已经实现了__autoload()函数，它必须显式注册到__autoload()队列中。
示例 :
function loadRes($classname)
{
require $classname.‘.php‘;
}
spl_autoload_register(‘loadRes‘);
$load = new Load();
echo ‘<br/>‘;
echo $load->load();
设计模式
什么是设计模式
设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结。
使用设计模式是为了重用代码、让代码更容易被他人理解、保证代码可靠性。
设计模式的分类
创建型模式（Creational Patterns）
该设计模式提供了一种在创建对象的同时隐藏创建逻辑的方式，而不是使用 new 运算符直接实例化对象。程序在判断针对某个给定实例需要创建哪些对象。
创建型模式的分类
工厂模式（Factory Pattern）
抽象工厂模式（Abstract Factory Pattern）
单例模式（Singleton Pattern）
建造者模式（Builder Pattern）
原型模式（Prototype Pattern）
结构型模式（Structural Patterns）
该设计模式关注类和对象的组合，继承的概念被用来组合接口和定义组合对象。
结构型模式的分类
适配器模式（Adapter Pattern）
桥接模式（Bridge Pattern）
过滤器模式（Filter、Criteria Pattern）
组合模式（Composite Pattern）
装饰器模式（Decorator Pattern）
外观模式（Facade Pattern）
享元模式（Flyweight Pattern）
代理模式（Proxy Pattern）
行为型模式（Behavioral Patterns）
该设计模式特别关注对象之间的通信。
行为型模式的分类
责任链模式（Chain of Responsibility Pattern）
命令模式（Command Pattern）
解释器模式（Interpreter Pattern）
迭代器模式（Iterator Pattern）
中介者模式（Mediator Pattern）
备忘录模式（Memento Pattern）
观察者模式（Observer Pattern）
状态模式（State Pattern）
空对象模式（Null Object Pattern）
J2EE 模式
该设计模式特别关注表示层
J2EE 模式分类
MVC 模式（MVC Pattern）
业务代表模式（Business Delegate Pattern）
组合实体模式（Composite Entity Pattern）
数据访问对象模式（Data Access Object Pattern）
前端控制器模式（Front Controller Pattern）
拦截过滤器模式（Intercepting Filter Pattern）
服务定位器模式（Service Locator Pattern）
传输对象模式（Transfer Object Pattern）
各种分类的工厂模式的代码案例
简单工厂模式的案例
简单工厂模式又称为静态模式，是因为简单工厂模式是通过一个静态方法来创建对象
代码 :
/**
* Interface People
* 创建一个人的接口类 并定义一个方法 注意:接口中的方法只定义,不实现
*/
interface People
{
public function say();
}
/**
* Class Man
* 创建一个男人类 来实现 人的接口类 中 所定义的方法
*/
class Man implements People{
public function say()
{
echo ‘这是男人的方法<br/>‘;
}
}
/**
* Class Woman
* 创建一个女人类 来实现 人的接口类 中 所定义的方法
*/
class Woman implements People
{
public function say()
{
echo ‘这是女人的方法‘;
}
}
/**
* Class SimpleFactory
* 通过简单工厂模式生产对应的男人与女人的对象
*/
class SimpleFactory
{
public static function createMan()
{
return new Man();
}
public static function createWoman()
{
return new Woman();
}
}
//--------------[实现]-------------
$man = SimpleFactory::createMan();
$man->say();
$woman = SimpleFactory::createWoman();
$woman->say();
//--------------[实现]-------------
工厂模式
定义一个用于创建对象的接口，让子类决定哪个类实例化。 他可以解决简单工厂模式中的封闭开放原则问题。
代码 :
//工厂方法模式
/**
* Interface People
*
*/
interface People{
public function say();
}
class Man implements People{
public function say()
{
echo ‘I am Male <br/>‘;
}
}
class Woman implements People{
public function say()
{
echo ‘I am female‘;
}
}
/**
* Interface CreatePeople
* 创建对象接口
*/
interface CreatePeople{
public function create();
}
/**
* Class ManFactory
* 实现男人创建对象工厂接口
*/
class ManFactory implements CreatePeople{
public function create()
{
return new Man();
}
}
/**
* Class WomanFactory
* 实现女人创建对象工厂接口
*/
class WomanFactory implements CreatePeople{
public function create()
{
return new Woman();
}
}
/**
* Class Client
* 客户端
*/
class Client{
public function testF()
{
$manFactory = new ManFactory();
$man = $manFactory->create();
$man->say();
$womanFactory = new WomanFactory();
$woman = $womanFactory->create();
$woman->say();
}
}
//--------[测试]--------
$client = new Client();
$client->testF();
//--------[测试]--------
抽象工厂模式
提供一个创建一系列(多个)相关或相互依赖对象的接口。而工厂方法是一个
代码 :
//抽象工厂模式 与方法工厂模式 区别在于 方法只有一个（实现工厂），抽象有多个（实现工厂）
/**
* Interface people
* 人类
*/
interface people
{
public function say();
}
/**
* Class OneMan
* 第一个男人类
*/
class OneMan implements people
{
public function say()
{
echo ‘我是第一个帅哥<br>‘;
}
}
/**
* Class TwoMan
* 第二个男人类
*/
class TwoMan implements people
{
public function say()
{
echo ‘我 是第二个老实人<br>‘;
}
}
/**
* Class OneWoman
* 第一个类型的女人类
*/
class OneWoman implements people
{
public function say()
{
echo ‘我是高冷美女<br>‘;
}
}
/**
* Class TwoWoman
* 第二个女人类
*/
class TwoWoman implements people
{
public function say()
{
echo ‘我是小清新女人<br>‘;
}
}
interface createPeoples
{
#创建第一个类型
public function createOne();
#创建第二个类型
public function createTwo();
}
#创建男人的对象
class FactoryMan implements createPeoples
{
public function createOne()
{
return new OneMan();
}
public function createTwo()
{
return new TwoMan();
}
}
/**
* Class FactoryWoman
* 创建女人类的
*/
class FactoryWoman implements createPeoples
{
public function createOne()
{
return new OneWoman();
}
public function createTwo()
{
return new TwoWoman();
}
}
class Client
{
public function test()
{
$factory = new FactorYMan();
$man = $factory->createOne();
$man->say();
$factory = new FactoryWoman();
$man = $factory->createOne();
$man->say();
}
}
$test = new Client();
$test->test();
简单工厂模式、工厂模式和抽象工厂模式的区别
简单工厂模式(静态方法工厂模式) ： 用来生产同一等级结构中的任意产品。（不能增加新的产品）
工厂模式 ：用来生产同一等级结构中的固定产品。（支持增加任意产品）
抽象工厂 ：用来生产不同产品种类的全部产品。（不能增加新的产品，支持增加产品种类）
单利模式的代码案例
单例模式，属于创建型模式，它提供了一种创建对象的最佳方式
这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。
创建的方法
它们必须拥有一个构造函数，并且必须被标记为private
它们拥有一个保存类的实例的静态成员变量
它们拥有一个访问这个实例的公共的静态方法
代码案例 :
/**
* 单例模式 只能产生一个对象
* 单利模式特点：三私一公
* 1、私有构造函数：防止实例化
* 2、私有克隆方法：防止克隆
* 3、私有静态属性：保存对象
* 4、共有有化静态方法： 获取对象
*/
class Singleton
{
private static $obj;//私有化静态属性
/**
* Singleton constructor.
* 私有构造函数
*/
private function __construct()
{
}
/**
* 私有克隆方法
*/
private function __clone()
{
// TODO: Implement __clone() method.
}
/**
*
*/
public static function getInstance()
{
if (!is_object(self::$obj))
{
self::$obj = new self();
}
return self::$obj;
}
}
// 实例化
/*$obj1 = new Singleton();
var_dump($obj1);*/
$obj2 = Singleton::getInstance();
var_dump($obj2);
#克隆一下
/*$obj3 = clone $obj2;
var_dump($obj3);*/
$obj3 = Singleton::getInstance();
var_dump($obj3);
class test
{
}
$test = new test();
var_dump($test);
$test1 = new test();
var_dump($test1);
$test2 = new test();
var_dump($test2);
$test3 = new test();
var_dump($test3);
适配器模式的代码案例
将某个对象的接口适配为另一个对象所期望的接口。它结合了两个独立接口的功能。
代码 :
//适配器模式 规定的接口被适配的对象实现
/**
* Interface Db
*创建数据库链接查询的接口
*/
interface Db{
/**
* 数据库的链接
* @param $host
* @param $username
* @param $password
* @param $database
* @return mixed
*/
public function connect($host,$username,$password,$database);
/**
* sql查询
* @param $sql
* @return mixed
*/
public function query($sql);
/**
* 数据库关闭
* @return mixed
*/
public function close();
}
/**
* Class MySql
* MySQL实现数据库接口类中的方法
*/
class MySql implements Db{
protected $connect;
public function connect($host, $username, $password, $database)
{
$connect = mysqli_connect($host,$username,$password,$database);
$this->connect = $connect;
}
public function query($sql)
{
return mysqli_query($this->connect,$sql);
}
public function close()
{
mysqli_close($this->connect);
}
}
/**
* Class Client
* 客户端
*/
class DbClient
{
public function dao()
{
$host = ‘127.0.0.1‘;
$username = ‘www.blogs.test‘;
$password = ‘123456‘;
$database = ‘www.blogs.test‘;
$sql = ‘select * from login‘;
$mysql = new MySql();
$mysql->connect($host,$username,$password,$database);
$res = $mysql->query($sql);
while ($rows = mysqli_fetch_array($res)){
var_dump($rows);
}
$mysql->close();
}
}
$demo = new DbClient();
echo $demo->dao();
MVC模式的代码案例
将某个对象的接口适配为另一个对象所期望的接口。
它结合了两个独MVC 模式代表 Model-View-Controller（模型-视图-控制器） 模式。
这种模式用于应用程序的分层开发。
Model（模型）
模型代表一个存取数据的对象。它也可以带有逻辑，在数据变化时更新控制器。
View（视图）
视图代表模型包含的数据的可视化。
Controller（控制器）
控制器作用于模型和视图上。它控制数据流向模型对象，并在数据变化时更新视图。它使视图与模型分离开。