本文所有代码为golang

S - 单一职责原则

Single Responsibility Principle，简称SRP。即指，一个类只做且只能做一件事。

例：现在需要从网络上获取一些 JSON 数据，然后解析它，并把结果保存在本地文件中。

思路：
第 1 个类应该只处理网络。我们给它提供一个 URL，然后接收 JSON 数据或者在出现问题时，收到一个错误信息。
第 2 个类应该只解析它接收到的 JSON 数据并以相应的格式返回结果。
第 3 个类应该以相应的格式接收 JSON 数据，并把它保存在本地文件中。

完整代码如下：

package main

import (
    "encoding/json"
    "io"
    "io/ioutil"
    "log"
    "net/http"
)

type response struct {
    Error err `json:"error"`
}

type err struct {
    Message string `json:"message"`
    Code    int    `json:"code"`
    Name    string `json:"name"`
}

const (
    link = "https://www.zhihu.com/api/v4/answer_later/count"
)

// 第一个类
func getResult(url string) (io.Reader, error) {
    res, err := http.Get(url)
    if err != nil {
        log.Fatal(err)
    }
    return res.Body, nil
}

// 第二个类
func parseJSON(result io.Reader) (response, error) {
    var resp response
    err := json.NewDecoder(result).Decode(&resp)
    if err != nil {
        return response{}, err
    }
    return resp, nil
}

// 第三个类
func storeToFile(resp response) {
    rs, err := json.Marshal(resp)
    if err != nil {
        log.Fatal(err)
    }
    err = ioutil.WriteFile("jsonFile.json", rs, 0644)
    if err != nil {
        log.Fatal(err)
    }
}

func main() {
    reader, err := getResult(link)
    if err != nil {
        log.Fatal(err)
    }
    resp, err := parseJSON(reader)
    if err != nil {
        log.Fatal(err)
    }
    storeToFile(resp)
}

O - 开闭原则

Open-Closed Principle，简称 OCP。类应该对扩展开放，对修改关闭

例子如下：

package main

import "fmt"

type A struct {
    year int
}

func (a A) Talk() string { return "a talk" }

func (a A) PrintTalk() { fmt.Printf("print talk %s", a.Talk()) }

func (a A) Greet() { fmt.Println("Hello GolangUK", a.year) }

type B struct {
    A
}

func (b B) Talk() string { return "b talk" }

func (b B) Greet() { fmt.Println("Welcome to GolangUK", b.year) }

func main() {
    var a A
    a.year = 2016
    var b B
    b.year = 2017
    a.Greet()     // Hello GolangUK 2016
    b.Greet()     // Welcome to GolangUK 2017
    b.A.Greet()   // Hello GolangUK 2017
    b.PrintTalk() // print talk a talk
}

L - 里氏替换原则

Liskov Substitution Principle，简称LSP。
如果对象 A 是对象 B 的子类，或者对象 A 实现了接口 B（本质上讲，A 就是 B 的一个实例），那么我们应该能够在不做任何特殊处理的情况下，像使用一个对象 B 或者 B 的一个实例那样使用对象 A。

I - 接口隔离原则

Interface Segregation Principle，简称 ISP。
即应该保持接口短小，在实现时选择实现多个小接口而不是庞大的单个接口。

D - 依赖倒置原则

Dependency Inversion Principle，简称 DIP。
高级模块不应该依赖具象的低级模块，它们都应该依赖相应模块的抽象层。