设计模式------1.六大原则

1.最重要的原则：开放-封闭原则

定义：原件实体（类、模块、函数等等）应该能够扩展，可是不可修改

public class Calculate {
    public void operate(int a, int b, String symbol) throws Exception {
        if (symbol.equals("+")) {
            System.out.println("结果为" + (a + b));
        } else if (symbol.equals("-")) {
            System.out.println("结果为" + (a - b));
        } else if (symbol.equals("*")) {
            System.out.println("结果为" + a * b);
        } else if (symbol.equals("/")) {
            System.out.println("结果为" + a / b);
        } else {
            throw new Exception("非法操做符！");
        }
    }
}
public class Test {
    public static void main(String[] args) throws Exception {
        Calculate c = new Calculate();
        c.operate(10, 5, "+");// 结果为15
        c.operate(10, 5, "-");// 结果为5
        c.operate(10, 5, "*");// 结果为50
        c.operate(10, 5, "/");// 结果为2
        c.operate(10, 5, "^");// 此操做为乘方，抛出异常:非法操做符
    }
}

结果显而易见，最开始咱们要作四则运算，后来又想加入乘方运算，因为程序最初的时候并无考虑到乘方的运算，此时就得更改源代码；触类旁通，三角函数的运算怎么办？再次违反开放-封闭原则改变源代码？因此，在需求变化时，一个类（单元，最好具备原子性，也有多是方法）的功能要尽量的惟一，只作一件事。
    开放-封闭原则是面向对象设计的核心所在，遵循这个原则能够避免许多不可避免的麻烦。并且能极大的增长软件的可扩展性、可维护性和可复用性。

2.单一职能原则

定义：就一个类而言，应该仅有一个引发它变化的缘由

仍是四则运算,在这里咱们把它作一个重构

/**
 * 抽象工厂
 */
interface IFactory {
    Integer result(int a,int b);
}

/**
 * 加法工厂
 */
class AddFactory implements IFactory {
    @Override
    public Integer result(int a,int b) {
        return a+b;
    }
}

/**
 * 减法工厂
 */
class SubFactory implements IFactory {
    @Override
    public Integer result(int a, int b) {
        return a-b;
    }
}

/**
 * 乘法工厂
 */
class MulFactory implements IFactory {
    @Override
    public Integer result(int a, int b) {
        return a*b;
    }
}

/**
 * 除法工厂
 */
class DivFactory implements IFactory {
    @Override
    public Integer result(int a, int b) {
        return a/b;
    }
}

/**
 * 测试再也不赘述，为了省事没有抛异常 :)
 */
public static void main(String[] args) throws Exception {
        IFactory factory = new AddFactory();
        Integer result = factory.result(10, 5);
        System.out.println(result);// 15
}

这样的话，若是再引发需求变更，（假设咱们就是两个数的运算），直接增长类实现IFactory接口就能够了，是否是很方便(#^.^#)，保证了开放-封闭原则的基础上，单一职能。

3.依赖倒转原则

定义：
a.高层模块不该该依赖低层模块。两个都应该依赖抽象。
b.抽象不该该依赖细节，细节应该依赖抽象。

说白了，要尽可能针对抽象（abstract）类编程，或者针对接口（interface）编程（第二段代码），不要针对实现编程（第一段代码）。
再举个栗子：就拿U盘的插口为例吧。U盘做为读写信息的一个媒介，须要连入到PC机上，若是全世界不统一为一个USB接口的话，那么只作U盘的厂商要针对联想作一种，Mac作一种，戴尔作一种……想一想都很可怕，因此才会出现USB接口规范这个抽象的概念，你们针对这个规范制做U盘就能够了。

4.里氏代换原则

定义：子类型必须可以替换掉他们的父类型

public class Father {
    public void doSome(){
        System.out.println("作数学运算");
    }
}

public class Son extends Father {
    public void method() {
        System.out.println("作语文运算");
    }
}

public static void main(String[] args) {
        Father test = new Son();
        test.doSome();
}

可能我这里举的栗子不太恰当，但也反映出我想表达的意思了；就是说子类所重写的方法彻底不是父类所须要的方法了，这对客户端来讲是难以想象的。

5.迪米特法则

定义：若是两个类没必要彼此直接通讯，那么这两个雷就不该当发生直接的相互做用。若是其中一个类须要调用另外一个类的某一个方法的话，能够经过第三者转发这个调用。

根本思想就是强调了类之间的松耦合
举个栗子：你公司的维修部管维修电子设备，其中一个专人A负责修PC机；你电脑坏了，须要修理，打电话给A，A刚好不在，须要等到A回来才能修电脑，可是你又急用电脑，形成了公司资源的浪费（专人A至关于维修部的一个实例，也就是对象）。
换个角度考虑，公司全部人均可以维修PC机，你直接给维修部打电话，要他们派人过来维修你的电脑（这时候，只是维修部须要关心派谁去维修电脑，你就不须要关心是谁来了）。不针对具体，只针对抽象.

6.接口隔离原则

定义：一个接口拥有的行为应该尽量的少

举个栗子：通常手机只须要知足打电话发短信就OK了，不须要其它额外的行为；由此能够衍生出新的接口，智能手机继承手机，添加新行为：玩王者荣耀，老年机玩不了王者荣耀，只有如今的智能机才能玩王者荣耀，若是把playKingOfGlory方法做为Phone接口中的方法就显得不太合适了。

public interface Phone {
    void call();
    void sendMessage();
}

public interface SmartPhone extends Phone{
    public void playKingOfGlory();
}