迪米特原则：迪米特原则(Law of Demeter,LoD)，也叫最少知识原则(Low knowledge Principle,LKP)：一个对象应该对其他对象有最少的了解。也可以解释为只和朋友类进行通信，所谓朋友类就是直接和一个类产生耦合关系的类，而这个朋友类就是实现两个类之间低耦合的关键！
单一职责原则(Single Responsibility Principle)–SRP：There should never be more than one reason for a class to change -- 应该有且仅有一个原因引起类的变更，也就是说一个类应该只负责一种特定的功能！好处：便于维护，稳定性高，简化代码逻辑，代码易于理解！例如下面的代码：
/***情景 1：动物用通过空气呼吸*****/
class Animal {
private $name;
public function __construct ($name) {
$this -> name = name;
}
public function breath () {
echo $this -> name . "呼吸空气！";
}
}
/***情景 2：有一天，突然发现鱼呼吸水的*****/
//扩展方式1：方法体层面，这个严重违反了单一责任原则，因为能够导致改代码的情况是所有动物都换了呼吸方式，这里只是部分水生动物的呼吸方式换了
class Animal {
private $name;
public function __construct ($name) {
$this -> name = name;
}
public function breath () {
if ($this -> name == "鱼") {
echo $this -> name . "呼吸水！";
} else {
echo $this -> name . "呼吸空气！";
}
}
}
//扩展方式2：方法层面，一定程度违反单一职责原则
class Animal {
private $name;
public function __construct ($name) {
$this -> name = name;
}
public function breath () {
$this -> name . "呼吸空气！";
}
public function breath () {
$this -> name . "呼吸水！";
}
}
//扩展方式3：类层面，符合单一职责原则
class luSheng {
private $name;
public function __construct ($name) {
$this -> name = name;
}
public function breath () {
$this -> name . "呼吸空气！";
}
}
class shuiSheng {
private $name;
public function __construct ($name) {
$this -> name = name;
}
public function breath () {
$this -> name . "呼吸水！";
}
}依赖倒置原则(Dependence Inversion Principle ,DIP)定义如下：High level modules should not depend upon low level modules,Both should depend upon abstractions.Abstractions should not depend upon details.Details should depend upon abstracts. -- 高层次模块不能依赖于低层次模块，高低层次模块都应该依赖于抽象们；抽象不应该以来与实现的细节，实现细节应该依赖于抽象！总体概括为高低层次模块+实现细节都应该依赖于抽象们！DIP是面向接口编程，基本上面向接口编程都是符合dip原则的！注：低层次模块是高层次模块的组成部分 -- 高层次模块属于一个大的逻辑，而低层次模块属于颗粒原子逻辑，大逻辑由颗粒原子逻辑组成！代码例子如下：
//依赖注入的三种方式：构造方法注入，setter注入，接口注入
/***情景1：小红看红楼梦，看了一会，想看个小说*****/
class XiaoHong{
private $book;
public function __construct (HongLouMeng $book) {
$this -> book = $book;
}
public function read () {
$this -> book -> read();
}
}
class HongLouMeng {
public function read () {
echo "我在看红楼梦，四大名著之一喔！";
}
}
class Novel {
public function read () {
echo "看会小说，斗破苍穹！";
}
}
//注：上面是一个强依赖，因为小红只能看《红楼梦》，不能看其他书！
//另外，XiaoHong(高层次模块)依赖于HongLouMeng(低层次模块)，因此违反了依赖倒置原则！
//功能：声明读物接口
interface Read {
public function read();
}
//功能：声明阅读者接口，接口依赖注入
interface Reader {
public function read (Read $book);
}
class XiaoHong implements Reader {
private $book;
public function read (Read $book) {
$book -> read();
}
}
class HongLouMeng implements Read {
public function read () {
echo "我在看红楼梦，四大名著之一喔！";
}
}
class Novel implements Read {
public function read () {
echo "看会小说，斗破苍穹！";
}
}
//上面的设计就可以读到小说以及所有实现了 Read 接口的书了，真正从抽象层面实现了依赖接口隔离原则：客户端只依赖于它需要的接口，多余的接口都不要，这样子的话就要求接口设计尽量细化！
/*****盗用别人的例子，因为实在太好了****/
/***情景1：星探要发掘美女啦，当代美女的标准是 脸漂亮、好身材、好脾气 ***/
interface IPretty {
public function IsGoodLooking ();
public function IsGoodBody ();
public function IsGoodTemper ();
}
abstract class Searcher {
public setStandardPretty (IPretty $girl);
public showStandardPretty ();
}
class PrettyGirl implements IPretty {
public $name;
public function __construct ($name) {
$this -> name = $name;
}
public function IsGoodLooking () {
echo $this -> name . "脸很漂亮！";
}
public function IsGoodBody () {
echo $this -> name . "身材火爆！";
}
public function IsGoodTemper () {
echo $this -> name . "脾气很好！";
}
}
class MySearcher extends Searcher {
private $girl;
public function setStandardPretty (IPretty $girl) {
$this -> girl = $girl;
}
public function showStandardPretty () {
echo $this -> name . "的个人情况如下：";
$this -> girl -> IsGoodLooking ();
$this -> girl -> IsGoodBody();
$this -> girl -> IsGoodTemper();
}
}
$girl = new PrettyGirl("玛丽");
$searcher = new MySearcher();
$searcher -> setStandardPretty ($girl);
$searcher -> showStandardPretty ();
/***情景2：出现了另外一种美女的标准：只需要好脾气就行了，怎么办呢，那个接口 IPretty 根本不能满足****/
interface IPretty1 {
public function IsGoodLooking ();
public function IsGoodBody ();
}
interface IPretty2 {
public function IsGoodTemper ();
}
interface IPretty extends IPretty1, IPretty2 {
}
abstract class Searcher {
public setStandardPretty (IPretty $girl);
public showStandardPretty ();
public setTemperPretty (IPretty2 $girl);
public showTemperPretty ();
}
class PrettyGirl implements IPretty {
public $name;
public function __construct ($name) {
$this -> name = $name;
}
public function IsGoodLooking () {
echo $this -> name . "脸很漂亮！";
}
public function IsGoodBody () {
echo $this -> name . "身材火爆！";
}
public function IsGoodTemper () {
echo $this -> name . "脾气很好！";
}
}
class TemperPrettyGirl implements IPretty2 {
public $name;
public function __construct ($name) {
$this -> name = $name;
}
public function IsGoodTemper () {
echo $this -> name . "脾气很好！";
}
}
class MySearcher extends Searcher {
private $girl;
private $temper;
public function setStandardPretty (IPretty $girl) {
$this -> girl = $girl;
}
public function setTemperPretty (IPretty2 $girl) {
$this -> temper = $girl;
}
public function showStandardPretty () {
echo $this -> name . "的个人情况如下：";
$this -> girl -> IsGoodLooking ();
$this -> girl -> IsGoodBody();
$this -> girl -> IsGoodTemper();
}
public function showTemperPretty () {
echo $this -> name . "的个人情况如下：";
$this -> girl -> IsGoodTemper();
}
}
$girl = new PrettyGirl("玛丽");
$goodTemper = new TemperPrettyGirl("苏玛丽");
$searcher = new MySearcher();
$searcher -> setStandardPretty ($girl);
$searcher -> showStandardPretty ();
$searcher -> setTemperPretty ($goodTemper);
$searcher -> showTemperPretty ();
//上面代码将接口细化了，所以可以灵活地组合，更加方便扩展开闭原则：Software entities like classes,modules and functions should be open for extension but closed for modifications -- 软件实体，例如类、模块和函数，应该通过扩展来适应变化，不要通过修改代码来适应变化。例如下面的代码：
/***情景1：一个书店卖一本书，正常售卖，封装好的代码如下*****/
interface IBook {
public function getName ();
public function getPrice ();
public function getAuthor ();
}
class NovelBook implements IBook {
protected $name;
protected $price;
protected $author;
public function __construct ($name, $price, $author) {
$this -> name = $name;
$this -> price = $price;
$this -> author = $author;
}
public function getName () {
return $this -> name;
}
public function getPrice () {
return $this -> price;
}
public function getAuthor () {
return $this -> author;
}
}
/***情景2：书店活动，该书需要打折，怎么办呢，有如下三种方式****/
//方式1：在接口 IBook 中添加 public function getOffPrice ();方法，这样子做就是在改代码，
//同时还需要修改NovelBook中的代码，如果还有其他书实现了这个接口的话也是需要修改它们当中的代码，所以方式1不可取！
//方式2：在 NovelBook 这个实现类中修改代码，修改 getPrice() 或者添加一个方法 getOffPrice ()，这样子是可行，但是
//并不是最优的方式
//方式3：继承 NovelBook ，产生一个子类，然后在覆盖掉那个 getPrice () 方法，通过扩展方式去实现，
//对现有底层代码没有影响，在高层次模块中进行代码修改！
class OffNovelBook extends NovelBook {
public function __construct ($name, $price, $author) {
parent::construct ($name, $price, $author);
}
public function getPrice () {
if ($this -> price > 40) {
return $this -> price * 0.9;
} else {
return $this -> price * 0.8;
}
}
}
//注：变化有逻辑变化和子模块变化两种：
//前者是一段逻辑的变化，但是结果的处理方式不变，这样子可以直接修改代码！
//后者是模块的变化，这样子可能会影响到很多相关联的模块，尤其是底层模块发生变化时！里氏替换原则：Functions that use pointers or references to base classes must be able to use objects of derived classes without knowing it. -- 将一段代码中的父类对象替换为该类的子类对象，代码仍然可以顺利正确地执行，这样子就叫做符合里氏替换原则。这在数学上类比集合的包含关系，e 属于集合 A，对于集合 B 包含集合 A，e 属于集合 B！通俗来说，子类继承了父类中的一切，父类能够做到的，子类也可以；相反，子类的个性化操作，父类没有办法做到！
里氏替换原则有4个规范：
1.子类必须完全实现父类的方法。如果子类不能完整地实现父类的方法，或者父类的一些方法在子类中已经发生畸变，
则建议断开继承关系，采用依赖，聚集，组合等关系代替继承。代码走起：
abstract class AbstractGun{
public abstract function shoot();
}
class Handgun extends AbstractGun{
public function shoot(){
echo "手枪射击...";
}
}
class Rifle extends AbstractGun{
public function shoot(){
echo "步枪射击...";
}
}
class Cachine extends AbstractGun{
public function shoot(){
echo "机枪射击...";
}
}
class Soldier{
private $gun;
//这里就是使用父类的地方，可以使用子类（具体实现类对象）
public function setGun(AbstractGun $gun){
$this -> gun = $gun;
}
public function killEnemy(){
echo "士兵开始射击...";
$this -> gun -> shoot();
}
}
$soldier = new Soldier();
//设置士兵手握手枪
$soldier -> setGun(new Handgun());
$soldier -> killEnemy();
//设置士兵手握步枪
$soldier -> setGun(new Rifle());
$soldier -> killEnemy();
//设置士兵手握机枪
$soldier -> setGun(new Cachine());
$soldier -> killEnemy();
2.子类可以有自己的个性
class Aug extends Rifle {
public function ZoomOut () {
echo "通过放大镜观察。。。";
}
public function shoot () {
echo "AUG射击。。。";
}
}
class Snipper {
public function killEnemy(AUG $aug){
$aug -> zoomOut();
$aug -> shoot();
}
}
$snipper = new Snipper();
$snipper -> killEnemy(new AUG());
输出：
通过放大镜观察。。。AUG射击。。。
$snipper = new Snipper();
$snipper -> killEnemy(new Rifle());
输出：
报错，报ZoomOut方法不存在。。。
3.覆盖或实现父类的方法时输入参数可以被放大(放大的意思是范围更加广泛，也就是祖先类；缩小就是更加精确分类到具体类)
需要用到 Java 来阐述，因为PHP中是不同的机制！
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
public class Father{
public Collection doSomething(HashMap map){
System.out.println("父类被执行");
return map.values();
}
}
public class Son extends Father{
//这里其实相当于重载了，所以并没有覆盖掉父类的doSomething方法
public Collection doSomething(Map map){
System.out.println("子类被执行");
return map.values();
}
}
public class Client{
public static void main(Strings[] args){
//父类存在的地方，子类应该可以存在
//Father father = new Father();
Son father = new Son();
//这两个都会输出 "父类被执行" 这句话，因为这是重载，如果需要输出 "子类被执行" 这句话，则需要完全覆盖掉
//父类中doSomething方法，参数类型一模一样才行！
HashMap map = new HashMap();
father.doSomething(map);
}
}
4.覆盖或实现父类的方法时输出结果可以被缩小
父类的一个方法的返回值是一个类型T，子类的相同方法的返回值为S，那么里氏替换原则就要求S必须小于等于T。
也就是返回值也可以是父子关系！