开闭准则
依赖倒置准则
繁多职责准则
接口隔离准则
迪米特法令
里氏替换准则
合成复用准则

代码开发遵循设计准则，使代码构造有条理且易于扩大和保护。并不需要僵硬地依照软件设计准则去实现，而是依据不同的场景，选取比拟适合的设计准则。

开闭准则

含意：一个软件实体，如类、模块和函数要对扩大凋谢，对批改敞开。在一个根底类上要减少性能时，不要去批改类中的代码，而是新增类继承根底类，在新增类中减少性能。

示例：

一般计算器反对加减乘除

public class GeneralCalculator {    public int add(int x, int y){        return x + y;    }    public int sub(int x, int y){        return x - y;    }    public int mul(int x, int y){        return x * y;    }    public int div(int x, int y){        return x / y;    }}

迷信计算器反对幂运算和一般运算

public class ScientificCalculator extends GeneralCalculator {    public int power(int x, int y){        if (x == 0){            return 0;        }        if (y == 0){            return 1;        }        int sum = 1;        for (int i = 0; i < y; i++) {            sum = mul(sum, x);        }        return sum;    }}

类图：

依赖倒置准则

含意：形象不应该依赖于细节，细节该当依赖于形象。就是针对接口编程，在任何应用对象的中央都是用形象类型，比方返回类型、成员变量和办法参数等。

示例：

人吃水果，能够吃苹果香蕉等

public interface IFruits {    String getName();}public class Apple implements IFruits {    public String getName() {        return "苹果";    }}public class Banana implements IFruits {    public String getName() {        return "香蕉";    }}public class Person {    public void eat(IFruits fruits){        System.out.println("我正在吃" + fruits.getName());    }}public class TestMain {    public static void main(String[] args) {        Person person = new Person();        IFruits apple = new Apple();        person.eat(apple);    }}

类图：

繁多职责准则

含意：一个类、办法或接口只实现一个性能。比方办法的命名都是见名知意，一个办法内容不要蕴含多种解决逻辑。

示例：电商下单流程有创立订单、扣减库存、领取。这是三个模块各自独自用一个类示意一个服务，每个服务都有本人独立的性能，不把这三个性能放到同一个类中。

public class OrderService {    public void createOrder(){        System.out.println("创立订单");    }}public class StockService {    public void subStock(){        System.out.println("扣减库存");    }}public class PayService {    public void pay(){        System.out.println("领取胜利");    }}public class TestMain {    public static void main(String[] args) {        new OrderService().createOrder();        new StockService().subStock();        new PayService().pay();    }}

类图：

接口隔离准则

含意：建设多个专门的接口，不要建设抽象的接口。多个办法不应该在一个接口中，应该建设多个接口，搁置一种类型的办法。

示例：有飞机、汽车、轮船三种交通工具

接口不能定义成这样，不然每一个实现类都要实现这三个接口，导致代码的冗余

public interface IVehicle {    /**     * 飞     */    void fly();    /**     * 行驶     */    void run();    /**     * 航行     */    void sail();}

正确示例如下

public interface IFlyVehicle {    /**     * 飞     */    void fly();}public interface IRunVehicle {    /**     * 行驶     */    void run();}public interface ISailVehicle {    /**     * 航行     */    void sail();}public class Plane implements IFlyVehicle {    public void fly() {        System.out.println("飞机航行");    }}public class Car implements IRunVehicle {    public void run() {        System.out.println("汽车行驶");    }}public class Ship implements ISailVehicle {    public void sail() {        System.out.println("轮船行驶");    }}

类图：

迪米特法令

含意：迪米特法令又叫起码晓得准则。类与类之间的利用尽量放弃间接利用，一个类中尽量少导入别的类。

示例：司机开车送老板去机场

谬误示例：老板类中没必要引入汽车这个类，司机引入这个类即可

public class Car {    public void run(){        System.out.println("汽车行驶中");    }}public class Driver {    public void driveCar(Car car){        car.run();    }}public class Boss {    public void goAirport(Driver driver){        Car car = new Car();        driver.driveCar(car);    }}public class TestMain {    public static void main(String[] args) {        Boss boss = new Boss();        Driver driver = new Driver();        boss.goAirport(driver);    }}

类图：

正确示例：

public class Car {    public void run(){        System.out.println("汽车行驶中");    }}public class Driver {    public void driveCar(){        Car car = new Car();        car.run();    }}public class Boss {    public void goAirport(Driver driver){        driver.driveCar();    }}public class TestMain {    public static void main(String[] args) {        Boss boss = new Boss();        Driver driver = new Driver();        boss.goAirport(driver);    }}

类图：

里氏替换准则

含意：一个软件实体如果实用一个父类，那么也肯定要能实用于其子类，援用父类的中央，能替换成实用其子类，保障程序逻辑不变。

子类能够实现父类的形象办法，也能够减少本人的性能，但不要笼罩非形象办法；

示例：这边要和依赖倒置准则辨别，依赖倒置准则重视的是模块依赖形象接口；里氏替换准则重视的是子类与父类的关系。

司机能够开车，奥托飞驰都能够，飞驰多一个车载冰箱性能

public interface ICar {    void run();}public class Alto implements ICar {    public void run() {        System.out.println("行驶");    }}public class BenzCar implements ICar {    public void run() {        System.out.println("行驶");    }    private void codeStorage(){        System.out.println("具备冰箱冷藏性能");    }}public class TestMain {    public static void main(String[] args) {        Alto alto = new Alto();        BenzCar benzCar = new BenzCar();        Driver driver = new Driver();        driver.driveCar(alto);        driver.driveCar(benzCar);    }}

类图：

合成复用准则

含意：实现性能复用，采纳对象组合的形式。一个新类要应用另一个类的已有性能，能够去援用类，而不是去继承类。

示例：同繁多职责准则，一个服务要实现下单功能，则同时引入订单服务、库存服务、领取服务，而不是去继承服务

类图：同繁多职责准则