里氏代換原則是由麻省理工學院（MIT）電腦科學實驗室的Liskov女士，在1987年的OOPSLA大會上發表的一篇文章《Data Abstraction and Hierarchy》裡面提出來的，主要闡述了有關繼承的一些原則，也就是什麼時候應該使用繼承，什麼時候不應該使用繼承，以及其中的蘊涵的原理。2002年，我們前面單一職責原則中提到的軟體工程大師Robert C. Martin，出版了一本《Agile Software Development Principles Patterns and Practices》，在文中他把里氏代換原則最終簡化為一句話：“Subtypes must be substitutable for their base types”。也就是，子類必須能夠替換成它們的基類。
我們把里氏代換原則解釋得更完整一些：在一個軟體系統中，子類應該可以替換任何基類能夠出現的地方，並且經過替換以後，程式碼還能正常工作。

定義一：
如果對每一個型別為 T1的物件 o1，都有型別為 T2 的物件o2，使得以 T1定義的所有程式 P 在所有的物件 o1 都代換成 o2 時，程式 P 的行為沒有發生變化，那麼型別 T2 是型別 T1 的子型別。
定義二：
所有引用基類的地方必須能透明地使用其子類的物件。

//
//  里氏替換原則.cpp
//  c++
//
//  Created by 劉龍玲 on 16/5/12.
//  Copyright © 2016年 liulongling. All rights reserved.
//

#include <iostream>
using namespace
 
 std;

//案例：鴕鳥非鳥
class Bird
{
public:
    bool fly() {
        //鳥類可以飛;
        return true;
    };
    int getVelocity()
    {
        return this->velocity;
    }
private:
      int velocity;
};

//鴕鳥
class Ostrich: public Bird
{
    bool fly() {
        //鴕鳥不可以飛;
        return false;
    };
    int getVelocity()
    {
        return
 
 0;
    }
};

int main()
{
    //計算鳥飛越黃河所需的時間。
    Bird* bird = new Ostrich;
    cout<<"h:"<<3000/bird->getVelocity()<<endl;
    return 0;
}

由於C++標準沒有把除0錯當成標準異常，和原生陣列訪問越界為什麼不是一異常一樣，主要還是為了“效率/效能”。C++之父在談C++語言設計的書(The Design and Evolution of C++)裡談到：

“low-level events, such as arithmetic overflows and divide by zero, are assumed to be handled by a dedicated lower-level mechanism rather than by exceptions. This enables C++ to match the behaviour of other languages when it comes to arithmetic. It also avoids the problems that occur on heavily pipelined architectures where events such as divide by zero are asynchronous.”

簡單翻譯一下： “底層的事件，比如計算上的溢位和除0錯，被認為應用有一個同樣底層的機制去處理它們，而不是異常。這讓C++在涉及到算術領域的效能，可以和其它語言競爭。再者，它也避免了當某些事件，比如除0錯是非同步的情況下（譯者注：比如在別一個執行緒裡發生）所可能造成的‘管道重重’的架構這一問題。”所以我換成用java程式碼實現這個案例

package com.lll.test;
//鳥
public class Bird {
    private int velocity;

    public int getVelocity() {
        return velocity;
    }

    public void setVelocity(int velocity) {
        this.velocity = velocity;
    }
}

package com.lll.test;
//鴕鳥
public class Ostrich extends Bird{

    public int getVelocity() {
        return 0;
    }
}

package com.lll.test;

public class main {

    public static void main(String[] args) {
        Bird bird = new Bird();
        bird.setVelocity(100);
        int h = flyTime(bird);
        System.out.println("飛行時間是:"+h);
    }

    public static int flyTime(Bird bird)
    {
        return 3000/bird.getVelocity();
    }
}

執行結果正確:
飛行時間是:30

package com.lll.test;

public class main {

    public static void main(String[] args) {
        Bird bird = new  Ostrich();
        bird.setVelocity(100);
        int h = flyTime(bird);
        System.out.println("飛行時間是:"+h);
    }

    public static int flyTime(Bird bird)
    {
        return 3000/bird.getVelocity();
    }
}

執行結果異常：
Exception in thread “main” java.lang.ArithmeticException: / by zero
at com.lll.test.main.flyTime(main.java:11)
at com.lll.test.main.main(main.java:7)

我們知道，面向物件的語言的三大特點是繼承，封裝，多型，里氏替換原則是依賴於繼承，多型這兩大特性。里氏替換原則的定義是，所有引用基類的地方必須能透明地使用其子類的物件。通俗來講是隻要父類能出現的地方子類就可以出現，而且替換為子類也不會產生任何錯誤和異常。而我們在使用flyTime方法時 ，當使用者flyTime方法裡的引數Bird被Ostrich替換掉後，結果出現了異常，那麼它明顯違背了里氏替換原則。