设计模式七大原则
编写软件过程中，程序员面临着来自 耦合性，内聚性以及可维护性，可扩展性，重用性，灵活性 等多方面的挑战，设计模式是为了让程序(软件)，具有更好
1) 代码重用性 (即：相同功能的代码，不用多次编写)
2) 可读性 (即：编程规范性, 便于其他程序员的阅读和理解)
3) 可扩展性 (即：当需要增加新的功能时，非常的方便，称为可维护)
4) 可靠性 (即：当我们增加新的功能后，对原来的功能没有影响)
设计模式原则，其实就是程序员在编程时，应当遵守的原则，也是各种设计模式的基础
1 单一职责原则
一个类只负责一项职责
通常情况下，应当遵守单一职责原则， 只有逻辑足够简单，才可以在方法级违反单一职责原则。
class Animal {
public void run(String dog) {
System.out.println(dog + "run...");
}
}
public class Demo {
public static void main(String[] args) {
Animal animal = new Animal();
animal.run("dog");
animal.run("bird");
}
}
解决上述问题，当一个类方法出现不满足需求时，可以用不同Anmial实例完成不同的run方法，虽然在类上保证单一原则但改动较大，好的处理可以通过基本的方法上保证单一原则
class Animal {
public void run(String dog) {
System.out.println(dog + "run...");
}
public void fly(String bird) {
System.out.println(bird + "fly...");
}
}
public class Demo {
public static void main(String[] args) {
Animal animal = new Animal();
animal.run("dog");
animal.fly("bird");
}
}
2 接口隔离原则
一个类对另一个类的依赖应该建立在最小的接口上
对于问题：
interface I {
public void Operator1();
public void Operator2();
public void Operator3();
public void Operator4();
public void Operator5();
}
class A {
public void depend1(I i){
i.Operator1();
}
public void depend2(I i){
i.Operator2();
}
public void depend3(I i){
i.Operator3();
}
}
class B implements I{
public void Operator1(){
System.out.println("类B实现接口I的方法1");
}
public void Operator2(){
System.out.println("类B实现接口I的方法2");
}
public void Operator3(){
System.out.println("类B实现接口I的方法3");
}
//对于类B来说，Operator4和Operator5不是必需的，但是由于接口A中有这两个方法，所以在实现过程中即使这两个方法的方法体为空，也要将这两个没有作用的方法进行实现。
public void Operator4(){}
public void Operator5(){}
}
class C {
public void depend1(I i){
i.Operator1();
}
public void depend2(I i){
i.Operator4();
}
public void depend3(I i){
i.Operator5();
}
}
class D implements I {
public void Operator1(){
System.out.println("类D实现接口I的方法1");
}
//对于类D来硕，Operator2和Operator3不是必需的，但是由于接口A中有这两个方法，所以实现过程中即使这两个方法的方法体为空，也要讲这两个没有作用的方法进行实现。
public void Operator2(){}
public void Operator3(){}
public void Operator4(){
System.out.println("类D实现接口I的方法4");
}
public void Operator5(){
System.out.println("类D实现接口I的方法5");
}
}
将接口拆分为独立的几个接口，类 A 和类 C 分别与他们需要的接口建立依赖关系。也就是采用接口隔离原则,
接口 I 中出现的方法，根据实际情况拆分为三个接口
3 依赖倒转
高层模块不应该依赖低层模块，两者都应该依赖其抽象
抽象不应该依赖细节
细节应该依赖抽象
模块间的依赖通过抽象发生，实现类之间不发生直接的依赖关系（面向接口编程）
问题：
class Driver{
public void drive(Benz benz){
benz.run();
}
}
class Benz {
public void run(){
System.out.println("奔驰汽车run....");
}
}
public class Demo {
public static void main(String[] args) {
Driver driver = new Driver();
driver.drive(new Benz());
}
}
驾驶员和汽车对象耦合，当某一天替换牌子时，需要新增类，同时驾驶员也要新增方法。
interface Car{
void run();
}
class Driver{
public void drive(Car car){
car.run();
}
}
class Benz implements Car {
public void run(){
System.out.println("奔驰汽车run....");
}
}
class Audi implements Car {
public void run(){
System.out.println("奥迪汽车run....");
}
}
public class Demo {
public static void main(String[] args) {
Driver driver = new Driver();
driver.drive(new Benz());
driver.drive(new Audi());
}
}
引入一个抽象的接口 Car, 让驾驶员只与接口类Car发生依赖，具体交由实现类。
4 里氏替换
问题：
继承包含这样一层含义：父类中凡是已经实现好的方法，实际上是在设定规范和契约，虽然它不强制要求所有的子类必须遵循这些契约，但是如果子类对这些已经实现的方法任意修改，就会对整个继承体系造成破坏
继承在给程序设计带来便利的同时，也带来了弊端。比如使用继承会给程序带来侵入性，程序的可移植性降低， 增加对象间的耦合性，如果一个类被其他的类所继承，则当这个类需要修改时，必须考虑到所有的子类，
并且父类修改后，所有涉及到子类的功能都有可能产生故障
class A {
public int func1(int a, int b) {
return a - b;
}
}
class B extends A {
//这里，重写了 A 类的方法, 可能是无意识
public int func1(int a, int b) {
return a + b;
}
public int func2(int a, int b) {
return func1(a, b) + 1;
}
}
public class Demo {
public static void main(String[] args) {
A a = new A();
int m = 10, n=5;
System.out.println("m-n=" + a.func1(m, n));
B b = new B();
//这里可能是不想调用子类方法，本来直接想用父类方法
System.out.println("m-n=" + b.func1(m, n));
}
}
改进： 原来的父类和子类都继承一个更通俗的基类，原有的继承关系去掉，采用依赖，聚合，组合等关系代替.
//把更加基础的方法和成员写到 Base 类
class Base {
}
class A extends Base{
public int func1(int a, int b) {
return a - b;
}
}
class B extends A {
//如果 B 需要使用 A 类的方法,使用组合关系
private A a = new A();
//这里，重写了 A 类的方法, 可能是无意识
public int func1(int a, int b) {
return a + b;
}
//我们仍然想使用 A 的方法
public int func3(int a, int b) {
return this.a.func1(a, b);
}
}
5 开闭原则
开闭原则（Open Closed Principle）是编程中最基础、最重要的设计原则
一个软件实体如类，模块和函数应该对扩展开放，对修改关闭。即：修改功能时对使用不用修改， 修改使用时，对功能提供不用修改。用抽象构建框架，用实现扩展细节。
当软件需要变化时，尽量通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码来实现变化。
编程中遵循其它原则，以及使用设计模式的目的就是遵循开闭原则
interface Car{
void run();
}
class Driver{
public void drive(Car car){
car.run();
}
}
class Benz implements Car {
public void run(){
System.out.println("奔驰汽车run....");
}
}
public class Demo {
public static void main(String[] args) {
Driver driver = new Driver();
driver.drive(new Benz());
}
}
如果要对Car类run方法增加功能， 最直接的方法就是在实现类上修改，但开闭原则建议尽量不要修改已有的代码，尽量通过扩展来实现改变。
interface Car{
void run();
}
class Driver{
public void drive(Car car){
car.run();
}
}
class Benz implements Car {
public void run(){
System.out.println("奔驰汽车run....");
}
}
class Benz2 extends Benz implements Car {
public void run(){
System.out.println("奔驰汽车run2....");
}
}
6 迪米特法则
一个对象应该对其他对象保持最少的了解
类与类关系越密切，耦合度越大
迪米特法则(Demeter Principle)又叫最少知道原则，即一个类对自己依赖的类知道的越少越好。也就是说，对于被依赖的类不管多么复杂，都尽量将逻辑封装在类的内部。对外除了提供的 public 方法，不对外泄露任何信息
迪米特法则还有个更简单的定义：只与直接的朋友通信
直接的朋友：每个对象都会与其他对象有耦合关系，只要两个对象之间有耦合关系，我们就说这两个对象之间是朋友关系。耦合的方式很多，依赖，关联，组合，聚合等。其中，我们称出现成员变量，方法参数，方法返回值中的类为直接的朋友，而出现在局部变量中的类不是直接的朋友。也就是说，陌生的类最好不要以局部变量的形式出现在类的内部。
class A{
B b;//全局变量 - 直接朋友
public B m1(){} //方法返回值 - 直接朋友
public void m2(B b){}//方法入参 - 直接朋友
public void m3(){
B b1 = new B();// 局部变量 非直接朋友
}
}
7 合成复用原则
某个类只是需要使用某个类方法时，建议使用合成或聚合，减少继承。
