乐趣区

关于设计模式:软件设计七大原则

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


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

开闭准则

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

示例:

一般计算器反对加减乘除

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

类图:

合成复用准则

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

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

类图:同繁多职责准则

退出移动版