1、建造者模式:
定义:将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示;
说明:一步一步构造一个由多个部分组成的复杂对象;
复杂对象示意图:
(就像车是由轮胎、方向盘、发动机等等部分组成的)
建造者模式结构图:
①Builder(抽象建造者):创建一个产品Product对象的各个部件指定抽象接口,在该接口中一般声明两类方法,一类方法是buildPartX(),它们用于创建复杂对象的各个部件;另一类方法是getResult(),它们用于返回复杂对象;它既可以是抽象类也可以是接口;
②ConcreteBuilder(具体建造者):实现了抽象建造者接口,实现各个部件的构造和装配方法,定义并明确它所创建的复杂对象,也可以提供一个方法返回创建好的复杂产品对象;
③Product(产品角色):产品角色是被构建的复杂对象,包含多个组成部件,具体建造者创建该产品的内部表示并定义他的装配过程;
④Director(指挥者):负责安排复杂对象的创建次序,指挥者与抽象建造者之间存在关联关系,可以在其Construct()建造方法中调用建造者对象的部件构造与装配方法,完成复杂对象的建造;客户端一般只需要与指挥者交互;
实例:
建造者模式可以用于描述KFC然后创建套餐:套餐是一个复杂对象,它一般包含主食(如汉堡、鸡肉卷等)和饮料(如果汁、可乐等)等组成部分,不同的套餐有不同的组成部分,而KFC的服务员可以根据顾客的要求,一步一步装配这些组成部分,构造一份完整的套餐,然后返回给顾客;
/**
* @ClassName Meal
* @Description 产品类(套餐类)
* @Author lzq
* @Date 2019/6/5 15:03
* @Version 1.0
**/
public class Meal {
private String food;
private String drink;
public void setFood(String food) {
this.food = food;
}
public void setDrink(String drink) {
this.drink = drink;
}
public String getFood() {
return food;
}
public String getDrink() {
return drink;
}
}
/**
* @ClassName MealBuilder
* @Description 抽象建造者类(套餐建造者类)
* @Author lzq
* @Date 2019/6/5 15:05
* @Version 1.0
**/
public abstract class MealBuilder {
protected Meal meal = new Meal();
public abstract void buildFood();
public abstract void buildDrink();
public Meal getMeal() {
return this.meal;
}
}
/**
* @ClassName SubMealBuilderA
* @Description 具体建造者(A套餐建造者类)
* @Author lzq
* @Date 2019/6/5 15:07
* @Version 1.0
**/
public class SubMealBuilderA extends MealBuilder{
@Override
public void buildFood() {
meal.setFood("一个鸡腿堡...");
}
@Override
public void buildDrink() {
meal.setDrink("一杯可乐...");
}
}
/**
* @ClassName SubMealBuilderB
* @Description 具体建造者(B套餐建造者类)
* @Author lzq
* @Date 2019/6/5 15:08
* @Version 1.0
**/
public class SubMealBuilderB extends MealBuilder{
@Override
public void buildFood() {
meal.setFood("一个鸡肉卷...");
}
@Override
public void buildDrink() {
meal.setDrink("一杯果汁...");
}
}
/**
* @ClassName KFCWaiter
* @Description 服务员类(指挥者)
* @Author lzq
* @Date 2019/6/5 15:10
* @Version 1.0
**/
public class KFCWaiter {
private MealBuilder mb;
public void setMealBuilder(MealBuilder mb) {
this.mb = mb;
}
public Meal construct() {
mb.buildFood();
mb.buildDrink();
return mb.getMeal();
}
}
/**
* @ClassName TestDemo
* @Description 测试类
* @Author lzq
* @Date 2019/6/5 15:12
* @Version 1.0
**/
public class TestDemo {
public static void main(String[] args) {
MealBuilder mb = new SubMealBuilderA();
KFCWaiter kfcWaiter = new KFCWaiter();
kfcWaiter.setMealBuilder(mb);
Meal meal = kfcWaiter.construct();
System.out.println("套餐组成:");
System.out.println(meal.getFood());
System.out.println(meal.getDrink());
}
}
运行结果:
2、装饰器模式:
定义:动态地给一个对象添加一些额外的职责,就扩展功能而言,它比生成子类方式更为灵活;
简单说明:不使用继承而通过关联关系来调用现有类中的方法,达到复用的目的,并使得对象的行为可以灵活变化;
模式结构图:
- Component(抽象构件):定义了对象的接口,可以给这些对象动态的增加职责(方法);
- ConcreteComponent(具体构件):定义了具体的构建对象,实现了在抽象构建中声明的方法,装饰器可以给它增加额外的职责;
- Decorator(抽象装饰类):抽象装饰类是抽象构件类的子类,用于 给具体构件增加职责,但是具体职责在其子类中实现;
- ConcreteDecorator(具体装饰类):具体装饰类是抽象装饰类的子类,复杂向构件添加新的职责;
比如:
变形金刚在变形之前是一辆汽车,它可以在陆地上移动。当它变成机器人之后除了能在陆地上移动之外,还可以说话;如果需要,他还可以变成飞机,还能飞翔;
代码如下:
/**
* @ClassName Transfrom
* @Description 抽象构件类(变形金刚)
* @Author lzq
* @Date 2019/5/29 23:42
* @Version 1.0
**/
public interface Transfrom {
public void move();
}
/**
* @ClassName Car
* @Description 具体构件类(汽车类)
* @Author lzq
* @Date 2019/5/29 23:43
* @Version 1.0
**/
public final class Car implements Transfrom{
public Car() {
System.out.println("变形金刚是一辆车");
}
@Override
public void move() {
System.out.println("在陆地上移动");
}
}
/**
* @ClassName Changer
* @Description 抽象装饰类(变化类)
* @Author lzq
* @Date 2019/5/29 23:45
* @Version 1.0
**/
public class Changer implements Transfrom{
private Transfrom transfrom;
public Changer(Transfrom transfrom) {
this.transfrom = transfrom;
}
@Override
public void move() {
transfrom.move();
}
}
/**
* @ClassName Robot
* @Description 具体装饰类(机器人类)
* @Author lzq
* @Date 2019/5/29 23:46
* @Version 1.0
**/
public class Robot extends Changer{
public Robot(Transfrom transfrom) {
super(transfrom);
System.out.println("变成机器人");
}
public void say() {
System.out.println("说话");
}
}
/**
* @ClassName Airplane
* @Description 具体装饰类(飞机类)
* @Author lzq
* @Date 2019/5/29 23:49
* @Version 1.0
**/
public class Airplane extends Changer{
public Airplane(Transfrom transfrom) {
super(transfrom);
System.out.println("变成飞机");
}
public void fly() {
System.out.println("在天空飞翔");
}
}
/**
* @ClassName Client
* @Description 测试类
* @Author lzq
* @Date 2019/5/29 23:50
* @Version 1.0
**/
public class Client {
public static void main(String[] args) {
Transfrom camaro;
camaro = new Car();
camaro.move();
System.out.println("---------------");
Robot robot = new Robot(camaro);
robot.move();
robot.say();
}
}
运行结果: