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

软件设计七大准则

开闭准则

定义：一个软件实体如类、模块和函数应该对扩大凋谢，对批改敞开。
用形象构建框架，用实现扩大细节。
长处：进步软件系统的可复用性及可维护性。

代码示例

接口：

public interface ICourse {
    Integer getId();
    String getName();
    Double getPrice();
}

基类：

public class JavaCourse implements ICourse{
    private Integer id;
    private String name;
    private Double price;

    public JavaCourse(Integer id, String name, Double price) {
        this.id = id;
        this.name = name;
        this.price = price;
    }

    @Override
    public Integer getId() {
        return this.id;
    }

    @Override
    public String getName() {
        return this.name;
    }

    @Override
    public Double getPrice() {
        return this.price;
    }

    @Override
    public String toString() {
        return "JavaCourse{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}

扩大类（子类）：

public class JavaDiscountCourse extends JavaCourse{
    public JavaDiscountCourse(Integer id, String name, Double price) {
        super(id, name, price);
    }

    public Double getOriginPrice(){
        return super.getPrice();
    }

    @Override
    public Double getPrice() {
        return super.getPrice()*0.8;
    }
    
}

测试：

public class OpenCloseTest {
    @Test
    public void openCloseTest(){
        ICourse iCourse = new JavaDiscountCourse(99, "Java从零到企业级开发", 348d);
        JavaDiscountCourse javaDiscountCourse = (JavaDiscountCourse) iCourse;
        System.out.println("课程ID: "+javaDiscountCourse.getId()+"  课程名称: "+javaDiscountCourse.getName()+
                "  价格: "+javaDiscountCourse.getPrice() + "  初始价格: "+javaDiscountCourse.getOriginPrice());
    }
}

准则剖析

利用场景：打折销售

需要：须要减少网站的网课打折性能。

实现：间接在“应用层”上扩大（继承）了基类，而不是间接对“底层”的接口或者基类进行批改。

起因：如果接口的办法较多，基类实现的逻辑比较复杂，对其进行间接批改会存在危险扩散，容易引起Bug。越低层次的模块（或越根底的模块）的批改，影响的范畴越大；相同越高层次的模块的批改，影响的范畴越小。

举例：如果Dao层中的一个模块被多个Service层模块应用，对Dao层的该模块进行批改会影响到多个Service层模块，甚至影响到Controller 层。

依赖倒置准则

定义：高层模块不应该依赖低层模块，二者都应该依赖其形象。
形象不应该依赖细节；细节应该依赖形象。
针对接口编程，不要针对实现编程。
长处：能够缩小类间的耦合性、进步零碎稳定性，进步代码可读性和可维护性，可升高批改程序所造成的危险。

代码示例

实体类：

public class Feyl {
    private ICourse icourse;

    public void setICourse(ICourse icourse) {
        this.icourse = icourse;
    }

    public void studyCourse(){
        icourse.studyCourse();
    }
}

接口：

public interface ICourse {
    void studyCourse();
}

实现类:

public class ArithmeticCourse implements ICourse{
    @Override
    public void studyCourse() {
        System.out.println("Feyl is learning Arithmetic course!");
    }
}

public class JavaCourse implements ICourse{
    @Override
    public void studyCourse() {
        System.out.println("Feyl is learning Java course!");
    }
}

public class FECourse implements ICourse{
    @Override
    public void studyCourse() {
        System.out.println("Feyl is learning FECourse!");
    }
}

测试类：

public class DependencyInversionTest {    
    @Test
    public void DependencyInversionTest(){
        Feyl feyl = new Feyl();
        feyl.setICourse(new ArithmeticCourse());
        feyl.studyCourse();
        feyl.setICourse(new JavaCourse());
        feyl.studyCourse();
        feyl.setICourse(new FECourse());
        feyl.studyCourse();
    }
}

准则剖析

利用场景：减少学习的课程

需要：减少实体类（人）学习的课程性能。

实现：通过ICourse接口将实体类（人）与具体学习的课程相分割。减少具体课程时，让减少的课程间接实现接口，此过程不须要对具体的实体类（人）进行批改。

繁多职责准则

定义：不要存在多于一个导致类变更的起因
一个类/接口/办法只负责一项职责
长处：升高类的复杂度、进步类的可读性、进步零碎的可维护性、升高变更引起的危险

代码示例

类的繁多职责：

public class ICourse {
}

public interface ICourseManager {
    void studyCourse();
    void refundCourse();
}

public interface ICourseContent {
    String courseName();
    byte[] courseVideo();
}

public class ICourseImpl implements ICourseManager,ICourseContent{
    @Override
    public String courseName() {
        return null;
    }

    @Override
    public byte[] courseVideo() {
        return new byte[0];
    }

    @Override
    public void studyCourse() {

    }

    @Override
    public void refundCourse() {

    }
}

办法的繁多职责：

public class Method {
    public void updateUserInfo(String username, String address){
        username = "Feyl";
        address = "HeNan";
    }

    public void updateUserInfo(String username, String... properties){
        username = "Feyl";
//        properties = ;
    }
    public void updateUsername(String username){
        username = "Feyl";
    }

    public void updateAddress(String address){
        address = "HeNan";
    }
}

接口隔离准则

定义：用多个专门的接口，而不应用繁多的总接口，客户端不应该依赖它不须要的接口
一个类对一个类的依赖应该建设在最小的接口上
建设繁多接口，不要建设宏大臃肿的接口
尽量细化接口，接口中的办法尽量少
留神适度准则，肯定要适度
长处：合乎咱们常说的高内聚低耦合的设计思维，从而使得类具备很好的可读性、可扩展性和可维护性。

代码示例

反例：

public interface IAnimalAction {
    void eat();
    void fly();
    void swim();
}

public class Bird implements IAnimalAction{
    @Override
    public void eat() {

    }

    @Override
    public void fly() {

    }

    @Override
    public void swim() {

    }
}

范例：

public interface IEatAnimalAction {
    void eat();
}

public interface IFlyAnimalAction {
    void fly();
}

public interface ISwimAnimalAction {
    void swim();
}

public class Dog implements ISwimAnimalAction,IEatAnimalAction{
    @Override
    public void eat() {

    }

    @Override
    public void swim() {

    }
}

迪米特准则

定义：一个对象应该对其余对象放弃起码的理解。又叫起码晓得准则
尽量升高类与类之间的耦合
长处：升高类之间的耦合
强调只和敌人交换,不和陌生人谈话
敌人：呈现在成员变量、办法的输出、输入参数中的类称为成员敌人类，而呈现在办法体外部的类不属于敌人类。

代码示例

反例：

public class Course {}

public class TeamLeader {
    public void checkNumberOfCourse(List<Course> courses){
        System.out.println("在线课程的数量："+courses.size());
    }
}

public class Boss {
    void commandCheckNumber(TeamLeader teamLeader) {
        List<Course> list = new ArrayList<Course>();
        for (int i = 0; i < 20; i++) {
            list.add(new Course());
        }
        teamLeader.checkNumberOfCourse(list);
    }
}

测试类：

public class DemeterTest {
    @Test
    public void demeterTest() {
        new Boss().commandCheckNumber(new TeamLeader());
    }
}

范例：

public class TeamLeader {
    public void checkNumberOfCourse(){
        List<Course> courses = new ArrayList<Course>();
        for (int i = 0; i < 20; i++) {
            courses.add(new Course());
        }
        System.out.println("在线课程的数量："+courses.size());
    }
}

public class Boss {
    public void commandCheckNumber(TeamLeader teamLeader) {
        teamLeader.checkNumberOfCourse();
    }
}

里氏替换准则

定义：如果对每一个类型为T1的对象o1，都有类型为T2的对象o2，使得以T1定义的所有程序P在所有的对象o1都替换成o2时，程序P的行为没有发生变化，那么类型T2是类型T1的子类型。

定义扩大：一个软件实体如果实用一个父类的话，那肯定实用于其子类，所有援用父类的中央必须能通明地应用其子类的对象，子类对象可能替换父类对象，而程序逻辑不变。

引申意义：子类能够扩大父类的性能，但不能扭转父类原有的性能。

含意1：子类能够实现父类的形象办法，但不能笼罩父类的非形象办法。

含意2：子类中能够减少本人特有的办法。

含意3：当子类的办法重载父类的办法时，办法的前置条件（即办法的输出/入参）要比父类办法的输出参数更宽松。

含意4：当子类的办法实现父类的办法时（重写/重载或实现形象办法），办法的后置条件（即办法的输入/返回值）要比父类更严格或相等。

长处1：束缚继承泛滥，开闭准则的一种体现。

长处2：增强程序的健壮性，同时变更时也能够做到十分好的兼容性，进步程序的维护性、扩展性。升高需要变更时引入的危险。

对开闭准则代码批改使其符和里氏替换准则：

// ICourse接口、JavaCourse类放弃不变

public class JavaDiscountCourse extends JavaCourse{
    public JavaDiscountCourse(Integer id, String name, Double price) {
        super(id, name, price);
    }

    public Double getDiscountPrice(){
        return super.getPrice()*0.8;
    }
}

测试类：

public class OpenCloseTest {
    @Test
    public void openCloseTest(){
        ICourse iCourse = new JavaDiscountCourse(99, "Java从零到企业级开发", 348d);
        JavaDiscountCourse javaDiscountCourse = (JavaDiscountCourse) iCourse;
        System.out.println("课程ID: "+javaDiscountCourse.getId()+"  课程名称: "+javaDiscountCourse.getName()+
                "  价格: "+javaDiscountCourse.getDiscountPrice() + "  初始价格: "+javaDiscountCourse.getPrice());
    }
}

代码示例

反例：

public class Rectangle {
    private long length;

    public long getLength() {
        return length;
    }

    public void setLength(long length) {
        this.length = length;
    }

    public long getWidth() {
        return width;
    }

    public void setWidth(long width) {
        this.width = width;
    }

    private long width;
}

public class Square extends Rectangle{
    private long sideLength;

    public long getSideLength() {
        return sideLength;
    }

    public void setSideLength(long sideLength) {
        this.sideLength = sideLength;
    }

    @Override
    public long getLength() {
        return getSideLength();
    }

    @Override
    public void setLength(long length) {
        setSideLength(length);
    }

    @Override
    public long getWidth() {
        return getSideLength();
    }

    @Override
    public void setWidth(long width) {
        setSideLength(width);
    }
}

测试类：

public class Test {
    public static void resize(Rectangle rectangle){
        while(rectangle.getWidth() <= rectangle.getLength()){
            rectangle.setWidth(rectangle.getWidth()+1);
            System.out.println("Width: " + rectangle.getWidth()+"\t Length: "+rectangle.getLength());
        }
        System.out.println("resize办法完结: Width: "+rectangle.getWidth()+"\tLength: "+rectangle.getLength());
    }

    public static void main(String[] args) {
        /*Rectangle rectangle = new Rectangle();
        rectangle.setWidth(10);
        rectangle.setLength(20);
        resize(rectangle);*/
        Square square = new Square();
        square.setLength(10);
        resize(square);
    }
}

范例：

public interface Quadrangle {
    long getWidth();
    long getLength();
}

public class Rectangle implements Quadrangle{
    private long width;
    private long length;

    @Override
    public long getWidth() {
        return 0;
    }

    @Override
    public long getLength() {
        return 0;
    }

    public void setWidth(long width) {
        this.width = width;
    }

    public void setLength(long length) {
        this.length = length;
    }
}

public class Square implements Quadrangle{
    private long sideLength;

    @Override
    public long getWidth() {
        return sideLength;
    }

    @Override
    public long getLength() {
        return sideLength;
    }

    public long getSideLength() {
        return sideLength;
    }

    public void setSideLength(long sideLength) {
        this.sideLength = sideLength;
    }
}

Test测试类中的
//        square.setLength(10);
//        resize(square);
会抛异样。
若将 resize(Rectangle rectangle) 改为 resize(Quadrangle quadrangle)，办法中的set办法也不能满足要求。
由此看来，反例中的继承关系违反了里氏替换准则。

办法重载（入参）：

public class Base {
    public void method(HashMap map){
        System.out.println("父类的HashMap办法被执行。");
    }
}

public class Child extends Base {
/*    @Override
    public void method(HashMap map) {
        System.out.println("子类的HashMap入参办法被调用了!");
    }*/

    public void method(Map map){
        System.out.println("子类的Map入参办法被调用了!");
    }
}

办法重载（返回值）：

public abstract class Base {
    public abstract Map method();
}

public class Child extends Base{
    @Override
    public HashMap method() {
        HashMap<String,String> hashMap = new HashMap<>();
        System.out.println("子类的HashMap被调用!");
        hashMap.put("msg","子类的HashMap被调用!");
        return hashMap;
    }
}

合成(组合)/聚合复用准则

定义：尽量应用对象组合/聚合，而不是继承关系达到软件复用的目标
聚合has-A和组合contains-A
长处：能够使零碎更加灵便,升高类与类之间的耦合度，一个类的变动对其余类造成的影响绝对较少
何时应用合成/聚合、继承
聚合has-A、组合contains-A 继承is-A

代码示例

public abstract class DBConnection {
    /*public String getConnection(){
        return "Mysql数据库连贯";
    }*/
    public abstract String getDBConnection();
}

public class MySQLConnection extends DBConnection{
    @Override
    public String getDBConnection() {
        return "MySQL数据库连贯";
    }
}

public class PostgreSQLConnection extends DBConnection{
    @Override
    public String getDBConnection() {
        return "PostgreSQL数据库连贯";
    }
}

public class ProductDao{
    private DBConnection dbConnection;

    public void setDbConnection(DBConnection dbConnection) {
        this.dbConnection = dbConnection;
    }

    public void addProduct(){
        String conn = dbConnection.getDBConnection();
        System.out.println("应用"+conn+"减少产品");
    }
}

测试代码：

public class CompositionAggregationTest {
    @Test
    public void compositionAggregationTest(){
        ProductDao productDao = new ProductDao();
//        productDao.setDbConnection(new MySQLConnection());
        productDao.setDbConnection(new PostgreSQLConnection());
        productDao.addProduct();
    }
}

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

软件设计七大准则

开闭准则

代码示例

准则剖析

依赖倒置准则

代码示例

准则剖析

繁多职责准则

代码示例

接口隔离准则

代码示例

迪米特准则

代码示例

里氏替换准则

代码示例

合成(组合)/聚合复用准则

代码示例

评论

发表回复取消回复

更多文章

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

深入解析：基于Delta的线性数据结构模型，打造高效富文本编辑器

轻松管理社交媒体：使用Automa插件实现一键拉黑功能

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

软件设计七大准则

开闭准则

代码示例

准则剖析

依赖倒置准则

代码示例

准则剖析

繁多职责准则

代码示例

接口隔离准则

代码示例

迪米特准则

代码示例

里氏替换准则

代码示例

合成(组合)/聚合复用准则

代码示例

评论

发表回复 取消回复

更多文章

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

深入解析：基于Delta的线性数据结构模型，打造高效富文本编辑器

轻松管理社交媒体：使用Automa插件实现一键拉黑功能

发表回复取消回复