文章目录
5. 建造者模式(Builder)
目的
封装一个对象的构造过程,并允许按步骤构造。
引用:创建者模式又叫建造者模式,是将一个复杂的对象的构建与它的表示分离,使
得同样的构建过程可以创建不同的表示。创建者模式隐藏了复杂对象的创建过程,它把复杂对象的创建过程加以抽象,通过子类继承或者重载的方式,动态的创建具有复合属性的对象。
类图
![](https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/db5e376d-0b3e-490e-a43a-3231914b6668.png)
实现
产品类
public class Bike {
private IFrame frame;
private ISeat seat;
private ITire tire;
public IFrame getFrame() {
return frame;
}
public void setFrame(IFrame frame) {
this.frame = frame;
}
public ISeat getSeat() {
return seat;
}
public void setSeat(ISeat seat) {
this.seat = seat;
}
public ITire getTire() {
return tire;
}
public void setTire(ITire tire) {
this.tire = tire;
}
}
Builder 类:
// 抽象 builder 类
public abstract class Builder {
abstract void buildFrame();
abstract void buildSeat();
abstract void buildTire();
abstract Bike createBike();
}
ConcreteBuilder 类 :
// 具体 builder 类
public class MobikeBuilder extends Builder{
private Bike mBike = new Bike();
@Override
void buildFrame() {
mBike.setFrame(new AlloyFrame());
}
@Override
void buildSeat() {
mBike.setSeat(new DermisSeat());
}
@Override
void buildTire() {
mBike.setTire(new SolidTire());
}
@Override
Bike createBike() {
return mBike;
}
}
public class OfoBuilder extends Builder{
private Bike mBike = new Bike();
@Override
void buildFrame() {
mBike.setFrame(new CarbonFrame());
}
@Override
void buildSeat() {
mBike.setSeat(new RubberSeat());
}
@Override
void buildTire() {
mBike.setTire(new InflateTire());
}
@Override
Bike createBike() {
return mBike;
}
}
指挥者类:
public class Director {
private Builder mBuilder = null;
public Director(Builder builder) {
mBuilder = builder;
}
public Bike construct() {
mBuilder.buildFrame();
mBuilder.buildSeat();
mBuilder.buildTire();
return mBuilder.createBike();
}
}
客户端使用:
public class Click {
public static void main(String[] args) {
showBike(new OfoBuilder());
showBike(new MobikeBuilder());
}
private void showBike(Builder builder) {
Director director = new Director(builder);
Bike bike = director.construct();
bike.getFrame().frame();
bike.getSeat().seat();
bike.getTire().tire();
}
}
应用场景
- 需要生成的对象具有复杂的内部结构
- 需要生成的对象内部属性本身相互依赖
- 与不可变对象配合使用
优点
- 建造者独立,易扩展
- 便于控制细节风险
6. 原型模式(Prototype)
当系统中需要大量创建相同或者相似的对象时,就可以通过“原型设计模式”来实现。原型模式是“创建型设计模式”中的一种。
原型模式的核心思想是,通过拷贝指定的“原型实例(对象)”,创建跟该对象一样的新对象。简单理解就是“克隆指定对象”。
这里提到的“原型实例(对象)”,就是被克隆的对象,它的作用就是指定要创建的对象种类。
目的
使用原型实例指定要创建对象的类型,通过复制这个原型来创建新对象。
类图
![](https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/b8922f8c-95e6-4187-be85-572a509afb71.png)
原型模式主要用于对象的复制,它的核心是就是类图中的原型类Prototype。Prototype类需要具备以下两个条件:
- 实现Cloneable接口。在java语言有一个Cloneable接口,它的作用只有一个,就是在运行时通知虚拟机可以安全地在实现了此接口的类上使用clone方法。在java虚拟机中,只有实现了这个接口的类才可以被拷贝,否则在运行时会抛出CloneNotSupportedException异常。
- 重写Object类中的clone方法。Java中,所有类的父类都是Object类,Object类中有一个clone方法,作用是返回对象的一个拷贝,但是其作用域protected类型的,一般的类无法调用,因此,Prototype类需要将clone方法的作用域修改为public类型。
实现
原型类
public abstract class Prototype implements Cloneable{
private String id;
public Prototype(String id) {
this.id = id;
}
public String getId() {
return this.id;
}
public Prototype clone() throws CloneNotSupportedException {
return (Prototype) super.clone();
}
}
具体实现类
public class CreateProtype extends Prototype{
public CreateProtype(String id) {
super(id);
}
}
客户端代码
public class JavaDemo {
public static void main(String[] args) throws CloneNotSupportedException {
Prototype p1 = new CreateProtype("1");
Prototype p2 = p1.clone();
System.out.println(p1 == p2);
}
}
原型模式的注意事项
- 使用原型模式复制对象不会调用类的构造方法。因为对象的复制是通过调用Object类的clone方法来完成的,它直接在内存中复制数据,因此不会调用到类的构造方法。不但构造方法中的代码不会执行,甚至连访问权限都对原型模式无效。而单例模式中,只要将构造方法的访问权限设置为private型,就可以实现单例。但是clone方法直接无视构造方法的权限,所以,单例模式与原型模式是冲突的,在使用时要特别注意。
- 深拷贝与浅拷贝。Object类的clone方法只会拷贝对象中的基本的数据类型(浅拷贝),对于数组、容器对象、引用对象等都不会拷贝,这就是浅拷贝。如果要实现深拷贝,必须将原型模式中的数组、容器对象、引用对象等另行拷贝。例如:
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
class scratch {
public static void main(String[] args) throws CloneNotSupportedException {
Prototype p1 = new CreateProtype("1");
Prototype p2 = p1.clone();
System.out.println(p1 == p2);
System.out.println(p1);
System.out.println(p2);
}
}
abstract class Prototype implements Cloneable{
private List<String> list;
private String id;
public Prototype(String id) {
this.id = id;
list = new ArrayList<>();
list.add(id);
}
public String getId() {
return this.id;
}
public List<String> getList() {
return this.list;
}
public Prototype clone() throws CloneNotSupportedException {
Prototype prototype = null;
try{
prototype = (Prototype)super.clone();
Collections.copy(prototype.list, this.list);
}catch(CloneNotSupportedException e){
e.printStackTrace();
}
return prototype;
}
}
class CreateProtype extends Prototype{
public CreateProtype(String id) {
super(id);
}
public String toString(){
return this.getId().hashCode()+"++"+this.getList().hashCode();
}
}
应用场景
当代码不应该依赖于需要复制的对象的具体类时
优点
- 可以不耦和具体类的情况下克隆对象
- 避免重复的初始化代码
- 更方便的构建复杂对象
7. 享元模式(Flyweight)
目的
利用共享的方式来支持大量细粒度的对象,这些对象一部分内部状态是相同的。
类图
- Flyweight:享元对象
- IntrinsicState:内部状态,享元对象共享内部状态
- ExtrinsicState:外部状态,每个享元对象的外部状态不同
![](https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/5f5c22d5-9c0e-49e1-b5b0-6cc7032724d4.png)
实现
public interface Flyweight {
void doOperation(String extrinsicState);
}
public class ConcreteFlyweight implements Flyweight {
private String intrinsicState;
public ConcreteFlyweight(String intrinsicState) {
this.intrinsicState = intrinsicState;
}
@Override
public void doOperation(String extrinsicState) {
System.out.println("Object address: " + System.identityHashCode(this));
System.out.println("IntrinsicState: " + intrinsicState);
System.out.println("ExtrinsicState: " + extrinsicState);
}
}
public class FlyweightFactory {
private HashMap<String, Flyweight> flyweights = new HashMap<>();
Flyweight getFlyweight(String intrinsicState) {
if (!flyweights.containsKey(intrinsicState)) {
Flyweight flyweight = new ConcreteFlyweight(intrinsicState);
flyweights.put(intrinsicState, flyweight);
}
return flyweights.get(intrinsicState);
}
}
public class Client {
public static void main(String[] args) {
FlyweightFactory factory = new FlyweightFactory();
Flyweight flyweight1 = factory.getFlyweight("aa");
Flyweight flyweight2 = factory.getFlyweight("aa");
flyweight1.doOperation("x");
flyweight2.doOperation("y");
}
}
Object address: 1163157884
IntrinsicState: aa
ExtrinsicState: x
Object address: 1163157884
IntrinsicState: aa
ExtrinsicState: y
对象只创建了一次。
优点
如果系统有大量类似的对象,可以节省大量的内存及CPU资源