摘要：開放封閉原則是面向對象設計的核心所在，遵循這個原則可以避免許多不可避免的麻煩。而且能極大的增加軟件的可擴展性可維護性和可復用性。依賴倒轉原則定義高層模塊不應該依賴低層模塊。

定義：原件實體（類、模塊、函數等等）應該可以擴展，但是不可修改

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, "^");// 此操作為乘方，拋出異常:非法操作符
    }
}

    結果顯而易見，最開始我們要做四則運算，后來又想加入乘方運算，由于程序最初的時候并沒有考慮到乘方的運算，此時就得更改源代碼；舉一反三，三角函數的運算怎么辦？再次違反開放-封閉原則改變源代碼？所以，在需求變化時，一個類（單元，最好具有原子性，也有可能是方法）的功能要盡可能的唯一，只做一件事。
    開放-封閉原則是面向對象設計的核心所在，遵循這個原則可以避免許多不可避免的麻煩。而且能極大的增加軟件的可擴展性、可維護性和可復用性。

定義：就一個類而言，應該僅有一個引起它變化的原因

還是四則運算,在這里我們把它做一個重構

/**
 * 抽象工廠
 */
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接口就可以了，是不是很方便(#^.^#)，保證了開放-封閉原則的基礎上，單一職能。

定義：
a.高層模塊不應該依賴低層模塊。兩個都應該依賴抽象。
b.抽象不應該依賴細節，細節應該依賴抽象。

說白了，要盡量針對抽象（abstract）類編程，或者針對接口（interface）編程（第二段代碼），不要針對實現編程（第一段代碼）。
再舉個栗子：就拿U盤的插口為例吧。U盤作為讀寫信息的一個媒介，需要連入到PC機上，如果全世界不統一為一個USB接口的話，那么只做U盤的廠商要針對聯想做一種，Mac做一種，戴爾做一種……想想都很可怕，所以才會出現USB接口規范這個抽象的概念，大家針對這個規范制作U盤就可以了。

定義：子類型必須能夠替換掉他們的父類型

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();
}

可能我這里舉的栗子不太恰當，但也反映出我想表達的意思了；就是說子類所重寫的方法完全不是父類所需要的方法了，這對客戶端來說是不可思議的。

定義：如果兩個類不必彼此直接通信，那么這兩個雷就不應當發生直接的相互作用。如果其中一個類需要調用另一個類的某一個方法的話，可以通過第三者轉發這個調用。

根本思想就是強調了類之間的松耦合
舉個栗子：你公司的維修部管維修電子設備，其中一個專人A負責修PC機；你電腦壞了，需要修理，打電話給A，A恰好不在，需要等到A回來才能修電腦，但是你又急用電腦，造成了公司資源的浪費（專人A相當于維修部的一個實例，也就是對象）。
換個角度考慮，公司所有人都可以維修PC機，你直接給維修部打電話，要他們派人過來維修你的電腦（這時候，只是維修部需要關心派誰去維修電腦，你就不需要關心是誰來了）。不針對具體，只針對抽象.

定義：一個接口擁有的行為應該盡可能的少

舉個栗子：一般手機只需要滿足打電話發短信就OK了，不需要其它額外的行為；由此可以衍生出新的接口，智能手機繼承手機，添加新行為：玩王者榮耀，老年機玩不了王者榮耀，只有現在的智能機才能玩王者榮耀，如果把playKingOfGlory方法作為Phone接口中的方法就顯得不太合適了。

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

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