Posted on | Post modified: | In
Words count in article: 576 | Reading time ≈ 2

里氏替换原则

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

第二种定义：所有引用基类的地方必须能透明地使用其子类的对象。只要有父类出现的地方，都可以用子类来替代，而且不会出现任何错误和异常。但是反过来则不行，有子类出现的地方，不能用其父类替代。

  • java类的继承的优点：
    子类拥有父类的所有方法和属性，从而可以减少创建类的工作量。
    提高了代码的重用性。
    提高了代码的扩展性，子类不但拥有了父类的所有功能，还可以添加自己的功能。
  • 缺点：
    继承是侵入性的。只要继承，就必须拥有父类的所有属性和方法。
    降低了代码的灵活性。因为继承时，父类会对子类有一种约束。
    增强了耦合性。当需要对父类的代码进行修改时，必须考虑到对子类产生的影响。有时修改了一点点代码都有可能需要对打断程序进行重构。
    里氏替换原则可以解决这个问题

里氏替换原则对继承进行了规则上的约束，这种约束主要体现在四个方面：

  • 子类必须实现父类的抽象方法，但不得重写（覆盖）父类的非抽象（已实现）方法。
  • 子类中可以增加自己特有的方法。
  • 当子类覆盖或实现父类的方法时，方法的前置条件（即方法的形参）要比父类方法的输入参数更宽松。
  • 当子类的方法实现父类的抽象方法时，方法的后置条件（即方法的返回值）要比父类更严格。

优点：

  • 约束继承泛滥，开闭原则的体现
  • 加强程序的健壮性，同时变更也可以做到非常好的兼容性，提高程序的维护性，扩展性，降低需求变更时的风险

Posted on | Post modified: | In
Words count in article: 101 | Reading time ≈ 1

合成复用原则

定义：尽量使用对象组合/聚合而不是继承关系达到软件复用的目的
优点：可以使系统更加灵活，降低类与类之间的耦合度，一个类的变化对其他类影响较小

例子：数据库连接添加，连接类进行抽象，不同数据库之间是同等级的实现类

Posted on | Post modified: | In
Words count in article: 1,987 | Reading time ≈ 8

简单工厂模式

简单工厂模式不能说是一个设计模式，说它是一种编程习惯可能更恰当些。因为它至少不是Gof23种设计模式之一。但它在实际的编程中经常被用到，而且思想也非常简单

模式定义

简单工厂模式(Simple Factory Pattern)：又称为静态工厂方法(Static Factory Method)模式，它属于类创建型模式。在简单工厂模式中，可以根据参数的不同返回不同类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。

模式结构

简单工厂模式包含如下角色：
Factory：工厂角色
Product：抽象产品角色
ConcreteProduct：具体产品角色

角色 职责
工厂角色 是简单工厂模式的核心，它负责实现创建所有具体产品类的实例。工厂类可以被外界直接调用，创建所需的产品对象。
抽象产品角色（Product） 是所有具体产品角色的父类，它负责描述所有实例所共有的公共接口。
具体产品角色（Concrete Product） 继承自抽象产品角色，一般为多个，是简单工厂模式的创建目标。工厂类返回的都是该角色的某一具体产品。
Read more »

Posted on | Post modified: | In
Words count in article: 602 | Reading time ≈ 3

工厂方法模式

定义与类型

定义：工厂方法模式定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。属于创建型

适用场景

  • 创建对象需要大量的代码
  • 客户端不需要知道产品类型如何创建的细节
  • 一个类通过其子类来指定创建哪个对象

    优点

  • 用户只需要关心产品所对应的工程无需关心细节
  • 加入新产品符合开闭原则，提高可扩展性

    缺点

  • 类的个数增多，增加了系统的复杂性
  • 增加了系统的抽象性和可理解性
Read more »

Posted on | Post modified: | In
Words count in article: 988 | Reading time ≈ 5

抽象工厂模式

定义：抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

产品族与产品等级结构

比如，餐馆新推出的套餐，炸鸡加可乐为一个组合的套餐 这个套餐 就是一个产品族。炸鸡、可乐分别是这个套餐中不同的产品等级。

适用场景

  • 客户端不依赖产品类如何实现创建的细节
  • 强调一系列相关产品对象（同一产品族）一起使用创建对象需要大量的代码
  • 提供一个产品类的库，所有的产品均以相同的接口出现，从而使客户端不依赖具体的实现

优点

  • 具体产品在代码层隔离，无需关心实现的细节
  • 将一个系列的产品族统一到一起创建

缺点

  • 规定了所有可能被创建产品的集合，产品族中扩展新的产品较为困难，需要修改抽象工程的接口
  • 增加了系统的抽象性和理解难度

场景例子

现在视频与手记组成一个课程，课程又分为java和Python两种课程，以后可能会添加更多课程

添加产品族较为容易，但是添加产品等级较为困难，这个例子中 如果再把源代码作为课程的一部分的话就需要修改大量的接口

UML图

#####代码
Article 产品抽象类

1
2
3
4
5
6
7
8
9
10
package com.anthony.design.pattern.creational.abstractfactory;

/**
 * @ Description:
 * @ Date: Created in 18:12 2018-11-26
 * @ Author: Anthony_Duan
 */
public abstract class Article {
    public abstract void produce();
}

Video产品抽象类

1
2
3
4
5
6
7
8
9
10
package com.anthony.design.pattern.creational.abstractfactory;

/**
 * @ Description:
 * @ Date: Created in 18:12 2018-11-26
 * @ Author: Anthony_Duan
 */
public abstract class Video {
    public abstract void produce();
}

JavaVideo JavaArticle PythonVideo PythonArticle 产品具体类

1
2
3
4
5
6
7
8
9
10
11
12
13
package com.anthony.design.pattern.creational.abstractfactory;

/**
 * @ Description:
 * @ Date: Created in 18:14 2018-11-26
 * @ Author: Anthony_Duan
 */
public class JavaArticle extends Article {
    @Override
    public void produce() {
        System.out.println("编写Java课程手记");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
package com.anthony.design.pattern.creational.abstractfactory;

/**
 * @ Description:
 * @ Date: Created in 18:16 2018-11-26
 * @ Author: Anthony_Duan
 */
public class JavaVideo extends Video {
    @Override
    public void produce() {
        System.out.println("录制Java视频");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
package com.anthony.design.pattern.creational.abstractfactory;

/**
 * @ Description:
 * @ Date: Created in 18:15 2018-11-26
 * @ Author: Anthony_Duan
 */
public class PythonArticle extends Article {
    @Override
    public void produce() {
        System.out.println("编写Python课程手记");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
package com.anthony.design.pattern.creational.abstractfactory;

/**
 * @ Description:
 * @ Date: Created in 18:17 2018-11-26
 * @ Author: Anthony_Duan
 */
public class PythonVideo extends Video {
    @Override
    public void produce() {
        System.out.println("录制Python视频");
    }
}

抽象工厂类

1
2
3
4
5
6
7
8
9
10
11
12
package com.anthony.design.pattern.creational.abstractfactory;

/**
 * @ Description:
 * @ Date: Created in 18:18 2018-11-26
 * @ Author: Anthony_Duan
 */
public interface CourseFactory {
    Video getVideo();

    Article getArticle();
}

java 与Python 两个产品族的工厂类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package com.anthony.design.pattern.creational.abstractfactory;

/**
 * @ Description:
 * @ Date: Created in 18:19 2018-11-26
 * @ Author: Anthony_Duan
 */
public class JavaCourseFactory implements CourseFactory {
    public Video getVideo() {
        return new JavaVideo();
    }

    public Article getArticle() {
        return new JavaArticle();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package com.anthony.design.pattern.creational.abstractfactory;

/**
 * @ Description:
 * @ Date: Created in 18:23 2018-11-26
 * @ Author: Anthony_Duan
 */
public class PythonCourseFactory implements CourseFactory {
    public Video getVideo() {
        return new PythonVideo();
    }

    public Article getArticle() {
        return new PythonArticle();
    }
}

test类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package com.anthony.design.pattern.creational.abstractfactory;


/**
 * @ Description: 抽象工厂模式
 * @ Date: Created in 18:23 2018-11-26
 * @ Author: Anthony_Duan
 */
public class test {
    public static void main(String[] args) {
        CourseFactory courseFactory = new JavaCourseFactory();
        Video video = courseFactory.getVideo();
        Article article = courseFactory.getArticle();
        video.produce();
        article.produce();

    }
}

Posted on | Post modified: | In
Words count in article: 1,455 | Reading time ≈ 7

建造者模式

建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

一个 Builder 类会一步一步构造最终的对象。该 Builder 类是独立于其他对象的。

简介

意图：将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。

主要解决：主要解决在软件系统中，有时候面临着”一个复杂对象”的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。

何时使用：一些基本部件不会变，而其组合经常变化的时候。

如何解决：将变与不变分离开。

关键代码：建造者：创建和提供实例，导演：管理建造出来的实例的依赖关系。

应用实例： 1、去肯德基，汉堡、可乐、薯条、炸鸡翅等是不变的，而其组合是经常变化的，生成出所谓的”套餐”。 2、JAVA 中的 StringBuilder。

优点

  • 建造者独立，易扩展。
  • 便于控制细节风险。

缺点

  • 产品必须有共同点，范围有限制。
  • 如内部变化复杂，会有很多的建造类。

使用场景

  • 需要生成的对象具有复杂的内部结构。
  • 需要生成的对象内部属性本身相互依赖。

注意事项：与工厂模式的区别是：建造者模式更加关注与零件装配的顺序。

Read more »