UML类图

在类图中一共包含以下几种模型元素，分别是：类（Class）、接口（Interface）以及类之间的关系。
类：
image.png
接口：在UML中，接口使用一个带有名称的小圆圈来进行表示。
image.png
类之间的关系：在UML类图中，有以下几种关系: 泛化（Generalization）, 实现（Realization），关联（Association)，聚合（Aggregation），组合(Composition)，依赖(Dependency)。
泛化：是一种继承关系，表示一般与特殊的关系，它指定了子类如何特化父类的所有特征和行为。用带三角箭头的实线表示，箭头指向父类。
image.png

实现：是一种类与接口的关系，表示类是接口所有特征和行为的实现。用带三角箭头的虚线表示，箭头指向接口。
image.png
关联：是一种拥有的关系，它使一个类知道另一个类的属性和方法。关联可以是双向的，也可以是单向的。双向的关联可以有两个箭头或者没有箭头，单向的关联有一个箭头。
image.png
上图中，老师与学生是双向关联，老师有多名学生，学生也可能有多名老师。但学生与某课程间的关系为单向关联，一名学生可能要上多门课程，课程是个抽象的东西他不拥有学生。
下图为自身关联：
image.png

  1. class teacher{
  2.      private Student student;   
  3. }

聚合：是整体与部分的关系，且部分可以离开整体而单独存在。聚合关系是关联关系的一种，是强的关联关系；关联和聚合在语法上无法区分，必须考察具体的逻辑关系。用带空心菱形的实心线表示，菱形指向整体。
image.png
组合：是整体与部分的关系，但部分不能离开整体而单独存在。组合关系是关联关系的一种，是比聚合关系还要强的关系，它要求普通的聚合关系中代表整体的对象负责代表部分的对象的生命周期。用带实心菱形的实线表示，菱形指向整体。
image.png

  1. class Company{
  2.     private Department department;
  3.     public Company{
  4.         department=new Deparment();
  5.     }
  6. }

依赖：是一种使用的关系，即一个类的实现需要另一个类的协助，所以要尽量不使用双向的互相依赖。用带箭头的虚线表示，指向被使用者。
image.png

  1. class Man{
  2.     public work(Computer computer){
  4.     }
  5. }

各种关系的强弱顺序：泛化 = 实现 > 组合 > 聚合 > 关联 > 依赖
image.png

简单工厂模式

简单工厂模式定义为：简单工厂模式又称为静态工厂方法模型，它属于类创建型模式。在简单工厂模式中，可以根据参数的不同返回不同类的实例。简单工厂专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。
对于简单工厂模式，只需要输入对应的数据，工厂就实例化出合适的对象，通过多态、返回父类的方式实现解耦合、灵活调整和增加子类。
image.png
简单工厂模式基本角色：
1.Factory（工厂角色）：工厂角色即工厂类，它是简单工厂模式的核心，负责实现创建所有实例的内部逻辑；工厂类可以直接被外界直接调用，创建所需的产品对象；在工厂类中提供了静态的工厂方法factoryMethod（），它返回一个抽象产品类Product，所有的具体产品都是抽象产品的子类。

  1. public class OperationFactory {
  2.     public static Operation createOperate(String operate){
  3.         Operation oper =null;
  4.         switch (operate){
  5.             case "+":oper=new OperationAdd();
  6.             break;
  7.             case "-":oper=new OperationSub();
  8.             break;
  9.             case "*":oper=new OperationMul();
  10.             break;
  11.             case "/":oper=new OperationDiv();
  12.             break;
  13.         }
  14.         return oper;
  15.     }
  16. }

2.Product（抽象产品角色）：抽象产品角色是简单工厂模式所创建的所有对象的父类,负责描述所有实例所共有的公共接口，它的引入将提高系统的灵活性，使得在工厂类中只需定义一个工厂方法，因为所有创建的具体产品对象都是其子类对象。

  1. public class Operation {
  2.     private double numberA = 0;
  3.     private double numberB = 0;
  5.     public double getNumberA() {
  6.         return numberA;
  7.     }
  9.     public void setNumberA(double numberA) {
  10.         this.numberA = numberA;
  11.     }
  13.     public double getNumberB() {
  14.         return numberB;
  15.     }
  17.     public void setNumberB(double numberB) {
  18.         this.numberB = numberB;
  19.     }
  21.     public double GetResult() {
  22.         double result = 0;
  23.         return result;
  24.     }
  25. }

3.ConcreteProduct（具体产品类）：具体产品角色是简单工厂模式的创建目标，所有创建的对象都充当这个角色的某个具体类的实例。每一个具体产品角色都继承了抽象产品角色，需要实现定义在抽象产品中的抽象方法 。

  1. class OperationAdd extends Operation {
  2.     public double GetResult() {
  3.         double result = 0;
  4.         result = getNumberA() + getNumberB();
  5.         return result;
  6.     }
  7. }
  9. class OperationSub extends Operation {
  10.     public double GetResult() {
  11.         double result = 0;
  12.         result = getNumberA() - getNumberB();
  13.         return result;
  14.     }
  15. }
  17. class OperationMul extends Operation {
  18.     public double GetResult() {
  19.         double result = 0;
  20.         result = getNumberA() * getNumberB();
  21.         return result;
  22.     }
  23. }
  25. class OperationDiv extends Operation {
  26.     public double GetResult() {
  27.         double result = 0;
  28.         result = getNumberA() / getNumberB();
  29.         return result;
  30.     }
  31. }

策略模式

单一职责原则

就一个类而言，应该仅有一个引起它变化的原因。
如果一个类承担的职责过多，就等于把这些职责耦合在一起，一个职责的变化可能会削弱或者抑制这个类完成其他职责的能力。这种耦合会导致脆弱的设计，当变化发生时，设计会遭到意想不到的破坏。
软件设计真正要做的许多内容，就是发现职责并把那些职责相互分离（如果能想到多于一个的动机去改变一个类，那么这个类就具有多于一个的职责）。

开放-封闭原则

依赖倒转原则