java设计模式简述

阳光穿透心脏的1/2处 2022-05-28 10:47 246阅读 0赞

# 重要的几个设计模式的概述 #

##     ##

# 构造器模式 #

类A中保存静态内部类builder，该内部类中保存A的字段，方法设置A的字段值并返回Build对象，最后的build方法返回A的对象，方法内将之前设置的字段值复制给返回的那个A的对象。新建对象的时候使用链式调用。

public class Pet \{  
  
public static class Builder \{  
private String petName;  
private String ownerName;  
private String address;  
private String telephone;  
  
public Builder withPetName(final String petName)\{  
this.petName = petName;  
return this;  
\}  
public Builder withOwnerName(final String ownerName)\{  
this.ownerName = ownerName;  
return this;  
\}  
public Builder withAddress(final String address)\{  
this.address = address;  
return this;  
\}  
public Builder withTelephone(final String telephone)\{  
this.telephone = telephone;  
return this;  
\}  
  
public Pet build()\{  
return new Pet(  
petName,  
ownerName,  
address,  
telephone  
);  
\}  
\}  
private final String petName;  
private final String ownerName;  
private final String address;  
private final String telephone;  
private Pet(final String petName,  
final String ownerName,  
final String address,  
final String telephone  
)\{  
this.petName = petName;  
this.ownerName = ownerName;  
this.address = address;  
this.telephone = telephone;  
\}  
\}

那么用构造器模式构建对象的时候，就可以这样：

/\*\*  
 \* 链式构造  
 \* @param args  
 \*/  
public static void main(String\[\] args) \{  
final Pet.Builder builder = new Pet.Builder();  
final Pet pet = builder  
.withPetName("动物名")  
.withOwnerName("主人名字")  
.withAddress("地址")  
.withTelephone("电话号")  
.build();

# 策略模式 #

可以轻松替换某个算法的具体实现细节，而不需要完全重写代码，甚至可以在运行时替换实现。通常和依赖注入联合使用。

比较抽象，那么这么说，一组类似的操作可以共同抽象出一个行为，使用接口进行定义，随后可以有一系列可以按需要来实现这个接口的类，每个类定义了不同的实现。使用的时候方法形式参数可以传入这个接口类型，也就是可以接受任何实现了这个接口的类，真正使用时使用的就是具体实现类的实现代码。

public interface Strategy {
       
       public int doOperation(int num1, int num2);
    }

定义一个接口 用来对两个整数进行操作

public class OperationAdd implements Strategy{
       
       @Override
       public int doOperation(int num1, int num2) {
       
          return num1 + num2;
       }
    }

这个类显然是要实现两数相加的具体实现，实现了Strategy接口，重写了操作的具体方法

public class OperationSubstract implements Strategy{
       
       @Override
       public int doOperation(int num1, int num2) {
       
          return num1 - num2;
       }
    }

同理 实现减法

public class OperationMultiply implements Strategy{
       
       @Override
       public int doOperation(int num1, int num2) {
       
          return num1 * num2;
       }
    }

实现乘法

public class Context {
       
       private Strategy strategy;
    
       public Context(Strategy strategy){
       
          this.strategy = strategy;
       }
    
       public int executeStrategy(int num1, int num2){
       
          return strategy.doOperation(num1, num2);
       }
    }

客户端类只可以见到context类，他不管怎么实现的具体算法

public class StrategyPatternDemo {
       
       public static void main(String[] args) {
       
          Context context = new Context(new OperationAdd());  //只与Context通信，传入具体的实现      
          System.out.println("10 + 5 = " + context.executeStrategy(10, 5));//调用执行即可
    
          context = new Context(new OperationSubstract());     //只需传入实现类   
          System.out.println("10 - 5 = " + context.executeStrategy(10, 5));
    
          context = new Context(new OperationMultiply());        
          System.out.println("10 * 5 = " + context.executeStrategy(10, 5));
       }
    }

类图如下：

![70][]

使用策略模式，可以将使用何种实现推迟到运行之前，任何想要增添的算法只需要实现接口即可，拓展性强。

# 模板模式 #

在模板模式（Template Pattern）中，一个抽象类公开定义了执行它的方法的方式/模板。它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。这种类型的设计模式属于行为型模式。

## 介绍 ##

**意图：**定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

**主要解决：**一些方法通用，却在每一个子类都重新写了这一方法。

**何时使用：**有一些通用的方法。

**如何解决：**将这些通用算法抽象出来。

**关键代码：**在抽象类实现，其他步骤在子类实现。

**应用实例：** 1、在造房子的时候，地基、走线、水管都一样，只有在建筑的后期才有加壁橱加栅栏等差异。 2、西游记里面菩萨定好的 81 难，这就是一个顶层的逻辑骨架。 3、spring 中对 Hibernate 的支持，将一些已经定好的方法封装起来，比如开启事务、获取 Session、关闭 Session 等，程序员不重复写那些已经规范好的代码，直接丢一个实体就可以保存。

**优点：** 1、封装不变部分，扩展可变部分。 2、提取公共代码，便于维护。 3、行为由父类控制，子类实现。

**缺点：**每一个不同的实现都需要一个子类来实现，导致类的个数增加，使得系统更加庞大。

**使用场景：** 1、有多个子类共有的方法，且逻辑相同。 2、重要的、复杂的方法，可以考虑作为模板方法。

**注意事项：**为防止恶意操作，一般模板方法都加上 final 关键词。

我的理解：模板类定好框架实现部分抽象部分，抽象的部分由实现类或子类重写自身特定实现。

创建一个抽象类，它的模板方法被设置为 final。

*Game.java*

public abstract class Game {
       
       abstract void initialize();
       abstract void startPlay();
       abstract void endPlay();
    
       //模板
       public final void play(){
       
    
          //初始化游戏
          initialize();
    
          //开始游戏
          startPlay();
    
          //结束游戏
          endPlay();
       }
    }

创建扩展了上述类的实体类。

*Cricket.java*

public class Cricket extends Game {
       
    
       @Override
       void endPlay() {
       
          System.out.println("Cricket Game Finished!");
       }
    
       @Override
       void initialize() {
       
          System.out.println("Cricket Game Initialized! Start playing.");
       }
    
       @Override
       void startPlay() {
       
          System.out.println("Cricket Game Started. Enjoy the game!");
       }
    }

*Football.java*

public class Football extends Game {
       
    
       @Override
       void endPlay() {
       
          System.out.println("Football Game Finished!");
       }
    
       @Override
       void initialize() {
       
          System.out.println("Football Game Initialized! Start playing.");
       }
    
       @Override
       void startPlay() {
       
          System.out.println("Football Game Started. Enjoy the game!");
       }
    }

使用 *Game* 的模板方法 play() 来演示游戏的定义方式。

*TemplatePatternDemo.java*

public class TemplatePatternDemo {
       
       public static void main(String[] args) {
       
    
          Game game = new Cricket();
          game.play();
          System.out.println();
          game = new Football();
          game.play();        
       }
    }

统一用父类引用

注：final：

# 1.final用于修饰变量 #

final变量只能赋值一次，赋值的方式有三种：

1）声明变量时直接赋值；

2）非静态成员变量在\{\}块中赋值，静态成员变量在static\{\}块中赋值；

3）非静态成员变量在构造方法中赋值。

三种赋值方式的顺序是1）、2）、3），若有一种方式先行赋值了，则后面的方式就不能再赋值，否则就会编译错误。

2.final修饰类

final类不能被继承，因此不会有子类。final类中的方法不论是否有final修改，都是final的。

# 3.final修饰方法 #

final方法不能被override。若父类中的方法为final的，则子类不能override该方法，但可以调用该方法（父类的final方法）。