原创 代理模式的一个实例
问题描述：
往往人们购买车子不是去生产工厂里面去买，而是去汽车的代理商那儿去购买，这个代理商的作用跟代理模式中描述的作用是一样的。
类的设计思路如下：
1、接口ICarSeller：是类CarProxy与类CarProducer的抽象，提供方法sellCars（int cars）
2.类CarProxy：汽车代理商，当自己的库存足够的时候，自己直接与消费者交易；当自己的库存不足的时候，首先需要向汽车生产商购买足够的汽车，然后再将汽车卖给消费者，提供了sellCars与buyCars两个方法。实例变量numberOfCars记录代理商的库存量，并且拥有对汽车生产商的引用。
3.类CarProducer：汽车生产商，可以在适当的时候销售汽车给汽车代理商（为了简化实例，只允许汽车销售商主动向其购买），并且可以在自己的库存量较少时自己生产汽车。提供了produce与sellCars两个方法
4.接口Customer：模拟消费者，提供方法buyCars
5.类personalCustomer：个人消费者，实现接口Customer，实现方法buyCars
下面用java语言实现：
package proxy.car;
public interface ICarSeller {
public void sellCars(int numberOfCars);
}
package proxy.car;
public class CarProxy implements ICarSeller {
//当前该代理商还剩余的汽车数量
private int numberOfCars;
private ICarSeller carProducer;
public int getNumberOfCars() {
return numberOfCars;
}
public void setNumberOfCars(int numberOfCars) {
this.numberOfCars = numberOfCars;
}
public CarProxy(int numberOfCars,ICarSeller carProducer) {
super();
this.numberOfCars = numberOfCars;
this.carProducer = carProducer;
}
public void sellCars(int numberOfCars) {
// TODO Auto-generated method stub
if(this.getNumberOfCars() > numberOfCars){
System.out.println("本代理商这儿购货，直接卖给消费者 " +numberOfCars +" 辆车 " );
this.setNumberOfCars(this.getNumberOfCars() - numberOfCars);
System.out.println("交易完成");
}else{
System.out.println("晕，我这儿货不够了");
this.buyCar(numberOfCars + 50);
}
}
public void buyCar(int numberOfCars){
carProducer.sellCars(numberOfCars + 50);
this.setNumberOfCars(this.getNumberOfCars() + numberOfCars + 50);
}
}
package proxy.car;
public class CarProducer implements ICarSeller {
private int numberOfCars;
public CarProducer(int numberOfCars) {
super();
this.numberOfCars = numberOfCars;
}
public int getNumberOfCars() {
return numberOfCars;
}
public void setNumberOfCars(int numberOfCars) {
this.numberOfCars = numberOfCars;
}
public void produce(int cars){
this.setNumberOfCars(this.getNumberOfCars() + cars);
System.out.println("已经生产出" + cars + "辆车");
}
public void sellCars(int numberOfCars) {
// TODO Auto-generated method stub
if(this.getNumberOfCars() - 50 > numberOfCars){
System.out.println("生产商库存充足，卖给代理商" + numberOfCars + "辆车");
}else{
System.out.println("生产商库存不足，必须先生产出足够的车辆");
this.produce(numberOfCars);
}
System.out.println("卖给代理商共" + numberOfCars + "辆车");
this.setNumberOfCars(this.getNumberOfCars() - numberOfCars);
}
}
package proxy.car;
public interface Customer {
public void buyCar(int cars);
}
package proxy.car;
public class PersonalCustomer implements Customer {
private ICarSeller carSeller;
public PersonalCustomer(ICarSeller carSeller) {
super();
this.carSeller = carSeller;
}
public void buyCar(int cars) {
// TODO Auto-generated method stub
System.out.println("我要买" + cars +"辆车");
carSeller.sellCars(cars);
}
}
package proxy.car;
public class Test {
public static void main(String[] args) {
// TODO Auto-generated method stub
ICarSeller carProducer = new CarProducer(200);
ICarSeller carProxy = new CarProxy(30,carProducer);
Customer customer = new PersonalCustomer (carProxy);
for(int i = 1;i < 20;i++){
customer.buyCar(i);
}
}
}
程序输出结果如下：
我要买1辆车
本代理商这儿购货，直接卖给消费者 1 辆车
交易完成
我要买2辆车
本代理商这儿购货，直接卖给消费者 2 辆车
交易完成
我要买3辆车
本代理商这儿购货，直接卖给消费者 3 辆车
交易完成
我要买4辆车
本代理商这儿购货，直接卖给消费者 4 辆车
交易完成
我要买5辆车
本代理商这儿购货，直接卖给消费者 5 辆车
交易完成
我要买6辆车
本代理商这儿购货，直接卖给消费者 6 辆车
交易完成
我要买7辆车
本代理商这儿购货，直接卖给消费者 7 辆车
交易完成
我要买8辆车
晕，我这儿货不够了
生产商库存充足，卖给代理商108辆车
卖给代理商共108辆车
我要买9辆车
本代理商这儿购货，直接卖给消费者 9 辆车
交易完成
我要买10辆车
本代理商这儿购货，直接卖给消费者 10 辆车
交易完成
我要买11辆车
本代理商这儿购货，直接卖给消费者 11 辆车
交易完成
我要买12辆车
本代理商这儿购货，直接卖给消费者 12 辆车
交易完成
我要买13辆车
本代理商这儿购货，直接卖给消费者 13 辆车
交易完成
我要买14辆车
本代理商这儿购货，直接卖给消费者 14 辆车
交易完成
我要买15辆车
本代理商这儿购货，直接卖给消费者 15 辆车
交易完成
我要买16辆车
本代理商这儿购货，直接卖给消费者 16 辆车
交易完成
我要买17辆车
晕，我这儿货不够了
生产商库存不足，必须先生产出足够的车辆
已经生产出117辆车
卖给代理商共117辆车
我要买18辆车
本代理商这儿购货，直接卖给消费者 18 辆车
交易完成
我要买19辆车
本代理商这儿购货，直接卖给消费者 19 辆车
交易完成
