移动架构之原型模式

发表于 | 分类于 | |

用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象

使用场景

以为是复制一个一摸一样的对象出来，所以说会在这个复制出来的对象上进行操作，避免破坏原来那一个对象

理解实例

在原型模式中，很多时候是由于为了操作方便，例如在工厂模式中如果需要对传入的对象做判断，从而调用其方法的时候，这样的话就会使得工厂的代码异常难维护，为了是工厂模式更利于维护，在具体类里面就可以克隆一份数据用以工厂模式里面去操作，具体用代码说明，首先依旧需要一个接口，而这个接口又需要继承一个拷贝对象的接口，这里用一个订单拆分的例子说明

1
2
3
public interface Prototype {
	Prototype cloneOrder();
}

1
2
3
4
public interface IOrder extends Prototype {
	int getOderNumber();
	void setOderNumber(int number);
}

在其子类中实现，这里就写一个子类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public class PersonOrder implements IOrder{
	private int oderNumber;
	private String name;

	@Override
	public int getOderNumber() {
		return oderNumber;
	}

	@Override
	public void setOderNumber(int number) {
		oderNumber=number;
	}

	public String getOrderName() {
		return name;
	}

	public void setOrderName(String name) {
		this.name=name;
	}

	@Override
	public Prototype cloneOrder() {
		PersonOrder personOrder=new PersonOrder();
		personOrder.setOderNumber(oderNumber);
		personOrder.setOrderName(name);
		return personOrder;
	}
}

那么若果在工厂模式中要获取到其方法，还要做判断，那么就会产生过多的冗余代码，此时可以选择在实现类中clone一个对象

1
2
3
4
5
6
7
8
9
10
11
12
13
public class OrderDealFactory {
	public void dealOrder(IOrder order) {
		System.out.println("原订单地址：" + order.hashCode());
		int number = order.getOderNumber();
		while (number > 0) {
			IOrder iOrder = (IOrder) order.cloneOrder();
			iOrder.setOderNumber(number > 1000 ? 1000 : number);
			number -= 1000;
			System.out.println("订单---number：" + iOrder.getOderNumber() +
					"，地址：" + iOrder.hashCode());
		}
	}
}

如果这里实例化的对象不同，那么在操作的时候，就有可能需要转型，那么在转型前就需要使用instanceof做判断，这样就破坏了其封装性
调用测试

1
2
3
4
5
6
7
8
9
10
public class Test {

	public static void main(String[] args) {
		OrderDealFactory orderDealFactory = new OrderDealFactory();
		PersonOrder order = new PersonOrder();
		order.setOderNumber(3500);
		order.setOrderName("个人订单");
		orderDealFactory.dealOrder(order);
	}
}

打印出来的处理地址并不是源地址，保留了源地址数据的原貌

Donate comment here