java设计模式例题
问题1：某软件公司要基于面向对象开发一套图表库，该图表库可以为应用系统提供多种不同外观的图表，例如柱状图(HistogramChart)、饼状图(PieChart)、折线图(LineChart)等。该软件公司图表库设计人员希望为应用系统开发人员提供一套灵活易用的图表库，通过设置不同的参数即可得到不同类型的图表，而且可以较为方便地对图表库进行扩展，以便能够在将来增加一些新类型的图表。请选用相应的设计模式设计该系统。
//采用简单工厂模式
package com.factory;
import com.Product.Chart;
import com.Product.Impl.HistogramChart;
import com.Product.Impl.LineChart;
import com.Product.Impl.PieChart;
//图表工厂类
public class ChartFactory {
//静态工厂方法
public static Chart getChart(String type){
Chart chart=null;
if(type.equalsIgnoreCase("HistogramChart")){
chart=new HistogramChart();
}else if (type.equalsIgnoreCase("PieChart")){
chart= new PieChart();
}else if(type.equalsIgnoreCase("LineChart")){
chart = new LineChart();
}
return chart;
}
}
package com.Product;
//抽象图表接口：抽象产品类
public interface Chart {
public void display();
}
package com.Product.Impl;
import com.Product.Chart;
//柱形图类
public class HistogramChart implements Chart {
public void display() {
System.out.println("显示柱形图!");
}
public HistogramChart() {
System.out.println("创建柱形图!");
}
}
package com.Product.Impl;
import com.Product.Chart;
//折线图类
public class LineChart implements Chart {
public void display() {
System.out.println("显示折线图!");
}
public LineChart() {
System.out.println("创建折线图!");
}
}
package com.Product.Impl;
import com.Product.Chart;
//饼状图类
public class PieChart implements Chart {
public void display() {
System.out.println("显示饼状图！");
}
public PieChart() {
System.out.println("创建饼状图！");
}
}
package com.wtf;
import com.Product.Chart;
import com.factory.ChartFactory;
public class Test {
public static void main(String[] args) {
//创建饼状图产品
Chart chart = ChartFactory.getChart("PieChart");
chart.display();
//创建折线图产品
chart=ChartFactory.getChart("LineChart");
chart.display();
}
}
问题2：某系统运行日志记录器(Logger)可以通过多种途径保存系统的运行日志，例如通过文件记录或数据库记录，用户可以通过修改配置文件灵活地更换日志记录方式。在设计各类日志记录器时，开发人员发现需要对日志记录器进行一些初始化工作，初始化参数的设置过程较为复杂，而且某些参数的设置有严格的先后次序，否则可能会发生记录失败。为了更好地封装记录器的初始化过程并保证多种记录器切换的灵活性，请选用相应的设计模式设计该系统。
//采用工厂方法模式
package com.wtfsorms.factory;
import com.wtfsorms.product.Logger;
//日志记录器工厂接口， 抽象工厂
public interface LoggerFactory {
public Logger createLog();
}
package com.wtfsorms.factory;
import com.wtfsorms.product.FileLogger;
import com.wtfsorms.product.Logger;
//文件日志记录器工厂类， 具体工厂
public class FileLoggerFactory implements LoggerFactory {
public Logger createLog() {
return new FileLogger();
}
}
package com.wtfsorms.factory;
import com.wtfsorms.product.DatebaseLogger;
import com.wtfsorms.product.Logger;
//数据库日志记录器工厂类， 具体工厂
public class DatabaseLoggerFactory implements LoggerFactory
{
public Logger createLog() {
return new DatebaseLogger();
}
}
package com.wtfsorms.product;
//日志记录器接口，抽象产品
public interface Logger {
public void writeLog();
}
package com.wtfsorms.product;
//文件日志记录器，具体产品
public class FileLogger implements Logger {
public void writeLog() {
System.out.println("文件日志记录");
}
}
package com.wtfsorms.product;
//数据库日志记录器， 具体产品
public class DatebaseLogger implements Logger {
public void writeLog() {
System.out.println("数据库日志");
}
}
package com.wtfstroms;
import com.wtfsorms.factory.FileLoggerFactory;
import com.wtfsorms.factory.LoggerFactory;
import com.wtfsorms.product.Logger;
public class Test {
public static void main(String[] args) {
//创建日志记录器
LoggerFactory logFactory=new FileLoggerFactory();
Logger log=logFactory.createLog();
log.writeLog();
System.out.println("**************");
}
}
问题3：某公司要开发一套界面皮肤库，可以对基于面向对象的桌面软件进行界面美化。用户在使用时可以通过菜单来选择皮肤，不同的皮肤将提供视觉效果不同的按钮、文本框、组合框等界面元素，例如春天(Spring)风格的皮肤将提供浅绿色的按钮、绿色边框的文本框和绿色边框的组合框，而夏天(Summer)风格的皮肤则提供浅蓝色的按钮、蓝色边框的文本框和蓝色边框的组合框。
图1 皮肤库系统结构示意图
该皮肤库需要具备良好的灵活性和可扩展性，用户可以自由选择不同的皮肤，开发人员可以在不修改既有代码的基础上增加新的皮肤。请选用相应的设计模式来设计该界面皮肤
//抽象工厂模式
//定义抽象工厂
package com.factory;
import com.product.button.Button;
import com.product.ComboBox.ComboBox;
import com.product.TextField.TextField;
public interface SkinFactory {
public Button createButton();
public TextField createTextField();
public ComboBox createComboBox();
}
//定义具体春天(Spring)风格的皮肤工厂
package com.factory.impl;
import com.factory.SkinFactory;
import com.product.button.Button;
import com.product.ComboBox.ComboBox;
import com.product.ComboBox.impl.SpringComboBox;
import com.product.TextField.TextField;
import com.product.TextField.impl.SpringTextField;
import com.product.button.impl.SpringButton;
public class SpringSkinFactory implements SkinFactory {
public Button createButton() {
return new SpringButton();
}
public TextField createTextField() {
return new SpringTextField();
}
public ComboBox createComboBox() {
return new SpringComboBox();
}
}
//定义具体产品，夏天(Summer)风格的皮肤工厂
package com.factory.impl;
import com.factory.SkinFactory;
import com.product.button.Button;
import com.product.ComboBox.ComboBox;
import com.product.ComboBox.impl.SummerComboBox;
import com.product.TextField.TextField;
import com.product.TextField.impl.SummerTextField;
import com.product.button.impl.SummerButton;
public class SummerSkinFactory implements SkinFactory {
public Button createButton() {
return new SummerButton();
}
public TextField createTextField() {
return new SummerTextField();
}
public ComboBox createComboBox() {
return new SummerComboBox();
}
}
//抽象产品按钮（button）
package com.product.button;
public interface Button {
public void display();
}
//具体产品，浅绿色的按钮
package com.product.button.impl;
import com.product.button.Button;
public class SpringButton implements Button {
public void display() {
System.out.println("浅绿色的按钮");
}
}
//具体产品，浅蓝色的按钮
package com.product.button.impl;
import com.product.button.Button;
public class SummerButton implements Button {
public void display() {
System.out.println("浅蓝色的按钮");
}
}
//抽象产品，组合框(ComboBox)
package com.product.ComboBox;
public interface ComboBox {
public void display();
}
//定义具体产品，绿色边框组合框
package com.product.ComboBox.impl;
import com.product.ComboBox.ComboBox;
public class SpringComboBox implements ComboBox {
public void display() {
System.out.println("绿色边框组合框");
}
}
//定义具体产品，蓝色边框组合框
package com.product.ComboBox.impl;
import com.product.ComboBox.ComboBox;
public class SummerComboBox implements ComboBox {
public void display() {
System.out.println("蓝色边框组合框");
}
}
//抽象产品，文本框（TextField ）
package com.product.TextField;
public interface TextField {
public void display();
}
//定义具体产品，绿色边框文本框
package com.product.TextField.impl;
import com.product.TextField.TextField;
public class SpringTextField implements TextField {
public void display() {
System.out.println("绿色边框文本框");
}
}
//定义具体产品，蓝色边框文本框
package com.product.TextField.impl;
import com.product.TextField.TextField;
public class SummerTextField implements TextField {
public void display() {
System.out.println("蓝色边框文本框");
}
}
//测试
package wtf;
import com.factory.SkinFactory;
import com.factory.impl.SpringSkinFactory;
import com.factory.impl.SummerSkinFactory;
import com.product.button.Button;
import com.product.ComboBox.ComboBox;
import com.product.TextField.TextField;
public class Test {
public static void main(String[] args) {
SkinFactory skinFactory;
Button button;
TextField textField;
ComboBox comboBox;
//春天(Spring)风格的皮肤
skinFactory=new SpringSkinFactory();
button=skinFactory.createButton();
textField=skinFactory.createTextField();
comboBox=skinFactory.createComboBox();
button.display();
textField.display();
comboBox.display();
System.out.println("*********************************");
//夏天(Summer)风格的皮肤
skinFactory=new SummerSkinFactory();
button=skinFactory.createButton();
textField=skinFactory.createTextField();
comboBox=skinFactory.createComboBox();
button.display();
textField.display();
comboBox.display();
}
}
问题4：网易游戏软件公司决定开发一款基于角色扮演的多人在线网络游戏，玩家可以在游戏中扮演虚拟世界中的一个特定角色，角色根据不同的游戏情节和统计数据（例如力量、魔法、技能等）具有不同的能力，角色也会随着不断升级而拥有更加强大的能力。
作为该游戏的一个重要组成部分，需要对游戏角色进行设计，而且随着该游戏的升级将不断增加新的角色。通过分析发现，游戏角色是一个复杂对象，它包含性别、面容等多个组成部分，不同类型的游戏角色，其性别、面容、服装、发型等外部特性都有所差异，例如“天使”拥有美丽的面容和披肩的长发，并身穿一袭白裙；而“恶魔”极其丑陋，留着光头并穿一件刺眼的黑衣。
无论是何种造型的游戏角色，它的创建步骤都大同小异，都需要逐步创建其组成部分，再将各组成部分装配成一个完整的游戏角色。请选用相应的设计模式来实现游戏角色的创建。
//生成器模式
package com.product;
//产品人物类
public class Actor {
private String Type;//脸色类型
private String sex;//性别
private String face;//脸型
private String costume;//服装
private String hairstyle;//发型
添加get.set方法
}
package com.build;
import com.product.Actor;
public abstract class ActorBuilder {
//抽象建造者
protected Actor actor=new Actor();
public abstract void buildType();
public abstract void buildSex();
public abstract void buildFace();
public abstract void buildCostume();
public abstract void buildHairstyle();
public Actor createActor(){
return actor;
}
}
package com.build.Impl;
import com.build.ActorBuilder;
//天使角色建造器:具体建造者
public class AngelBuilder extends ActorBuilder {
public void buildType() {actor.setType("天使"); }
public void buildSex() {actor.setSex("神"); }
public void buildFace() {actor.setFace("美丽"); }
public void buildCostume() { actor.setCostume("白裙"); }
public void buildHairstyle() {actor.setHairstyle("披肩的长发"); }
}
package com.build.Impl;
import com.build.ActorBuilder;
//魔鬼角色建造器:具体建造者
public class GhostBuilder extends ActorBuilder {
public void buildType() { actor.setType("魔鬼"); }
public void buildSex() { actor.setSex("妖"); }
public void buildFace() { actor.setFace("丑陋"); }
public void buildCostume() { actor.setCostume("刺眼的黑衣"); }
public void buildHairstyle() { actor.setHairstyle("光头"); }
}
package com.director;
import com.build.ActorBuilder;
import com.product.Actor;
//构建器
public class DirectorController {
public Actor construct(ActorBuilder actorBuilder){
actorBuilder.buildType();
actorBuilder.buildSex();
actorBuilder.buildFace();
actorBuilder.buildCostume();
actorBuilder.buildHairstyle();
return actorBuilder.createActor();
}
}
//测试类
package wtf;
import com.build.ActorBuilder;
import com.build.Impl.AngelBuilder;
import com.build.Impl.GhostBuilder;
import com.director.DirectorController;
import com.product.Actor;
public class Driver {
public static void main(String[] args) {
System.out.println(" 天使 ");
DirectorController directorController=new DirectorController();
ActorBuilder actorBuilder=new AngelBuilder();
Actor angle=directorController.construct(actorBuilder);
String type=angle.getType();
System.out.println(type+"的外观:\t");
System.out.println("性别:\t"+angle.getSex());
System.out.println("面容:\t"+angle.getFace());
System.out.println("服装:\t"+angle.getCostume());
System.out.println("发型:\t"+angle.getHairstyle());
System.out.println(" 恶魔 ");
ActorBuilder actorBuilder1=new GhostBuilder();
Actor ghost = directorController.construct(actorBuilder1);
String type2=ghost.getType();
System.out.println(type2+"的外观:\t");
System.out.println("性别:\t"+ghost.getSex());
System.out.println("面容:\t"+ghost.getFace());
System.out.println("服装:\t"+ghost.getCostume());
System.out.println("发型:\t"+ghost.getHairstyle());
}
}
问题5：中国软件公司承接了一个服务器负载均衡(Load Balance)软件的开发工作，该软件运行在一台负载均衡服务器上，可以将并发访问和数据流量分发到服务器集群中的多台设备上进行并发处理，提高了系统的整体处理能力，缩短了响应时间。由于集群中的服务器需要动态删减，且客户端请求需要统一分发，因此需要确保负载均衡器的唯一性，只能有一个负载均衡器来负责服务器的管理和请求的分发，否则将会带来服务器状态的不一致以及请求分配冲突等问题。如何确保负载均衡器的唯一性是该软件成功的关键，请选用相应的设计模式设计该服务器负载均衡器。
//单例模式
package com.wtf;
//服务器
public class CustomServer {
public String Name;
public int Size;
public String getName() {return Name;}
public void setName(String name) {Name = name;}
public int getSize() {return Size;}
public void setSize(int size) {Size = size; }
public CustomServer(String name) { Name = name; }
}
//服务器负载均衡(Load Balance)软件
package com.wtf;
import java.util.Random;
public class LoadBalancer
{
// 私有静态变量，存储唯一实例
private static LoadBalancer instance = null;
// 服务器集合
private ArrayList<CustomServer> serverList = null;
// 私有构造函数
private LoadBalancer()
{
serverList = new ArrayList<CustomServer>();
}
// 公共静态成员方法，返回唯一实例
public static LoadBalancer GetLoadBalancer() {
if (instance == null) {
instance = new LoadBalancer();
}
return instance;
}
// 添加一台Server
public void AddServer(CustomServer server)
{
serverList.add(server);
}
// 移除一台Server
public void RemoveServer(String serverName)
{
for(CustomServer server:serverList){
if (server.Name.equals(serverName))
{
serverList.remove(server);
break;
}
}
}
// 获得一台Server - 使用随机数获取
private Random rand = new Random();
public CustomServer GetServer()
{
int index=rand.nextInt(serverList.size());
return serverList.get(index);
}
}
//测试类
package wtf;
import com.wtf.CustomServer;
import com.wtf.LoadBalancer;
public class Test {
public static void main(String[] args)
{
LoadBalancer balancer, balancer2, balancer3;
balancer = LoadBalancer.GetLoadBalancer();
balancer2 = LoadBalancer.GetLoadBalancer();
balancer3 = LoadBalancer.GetLoadBalancer();
// 判断负载均衡器是否相同
if (balancer == balancer2 && balancer == balancer3 && balancer2 == balancer3)
{
System.out.println("服务器负载均衡器是唯一的！");
}
// 增加服务器
balancer.AddServer(new CustomServer("Server 1") );
balancer.AddServer(new CustomServer("Server 2"));
balancer.AddServer(new CustomServer("Server 3"));
balancer.AddServer(new CustomServer("Server 4"));
// 模拟客户端请求的分发
for (int i = 0; i < 10; i++)
{
CustomServer server = balancer.GetServer();
System.out.println("该请求已分配至 : " + server.Name);
}
}
}
问题6：某系统需要提供一个文件加密模块，加密流程包括三个操作，分别是读取源文件、加密、保存加密之后的文件。读取文件和保存文件使用流来实现，这三个操作相对独立，其业务代码封装在三个不同的类中。现在需要提供一个统一的加密外观类，用户可以直接使用该加密外观类完成对文件的读取、加密和保存三个操作，而不需要与每一个类进行交互，请选用相应的设计模式设计该加密模块，要求编程模拟实现。
//外观模式
//加密外观类
package ww.wtf;
public class EncryptFacade {
private FileReader reader;
private CipherMachine cipher;
private FileWriter writer;
public EncryptFacade() {
reader = new FileReader();
cipher = new CipherMachine();
writer = new FileWriter();
}
public void fileEncrypt(String fileNameSrc,String fileNameDes){
String plainStr = reader.read(fileNameSrc);
String encryptStr = cipher.encrypt(plainStr);
writer.write(encryptStr, fileNameDes);
}
}
//读取文件
package ww.wtf;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class FileReader {
public String read(String fileNameSrc) {
System.out.println("读取文件，获取明文");
StringBuffer sb = new StringBuffer();
try {
FileInputStream inFS = new FileInputStream(fileNameSrc);
int data;
while ((data=inFS.read())!=-1) {
sb = sb.append((char)data);
}
inFS.close();
} catch (FileNotFoundException e) {
// TODO: handle exception
System.out.println("文件不存在！");
}catch (IOException e) {
// TODO: handle exception
System.out.println("文件操作失败！");
}
return sb.toString();
}
}
//数据加密
package ww.wtf;
public class CipherMachine {
public String encrypt(String plainText) {
System.out.println("数据加密，将明文转换为密文。");
String s = "";
for (int i = 0; i < plainText.length(); i++) {
String c = String.valueOf(plainText.charAt(i) % 7);
s += c;
}
return s;
}
}
//保存文件
package ww.wtf;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileWriter {
public void write(String encryptStr,String fileNameDes) {
System.out.println("保存密文，写入文件");
try {
FileOutputStream outFS = new FileOutputStream(fileNameDes);
outFS.write(encryptStr.getBytes());
outFS.close();
} catch (FileNotFoundException e) {
// TODO: handle exception
System.out.println("文件不存在！");
}catch (IOException e) {
// TODO: handle exception
System.out.println("文件操作错误！");
}
}
}
//测试
package ww.wtf;
public class Client {
public static void main(String[] args) {
EncryptFacade ef = new EncryptFacade();
ef.fileEncrypt(System.getProperty("user.dir")+"D:\\a.txt",
System.getProperty("user.dir")+"test2.txt");
}
}
问题7：华为企业的SCM(Supply Chain Management，供应链管理)系统中包含一个采购审批子系统。该企业的采购审批是分级进行的，即根据采购金额的不同，由不同层次的主管人员来审批，主任可以审批5万元以下（不包括5万元）的采购单，副董事长可以审批5万元至10万元（不包括10万元）的采购单，董事长可以审批10万元至50万元（不包括50万元）的采购单，50万元及以上的采购单就需要开董事会讨论决定。如下图所示：
图2 采购单分级审批示意图
请选用相应的设计模式设计并实现该系统。
//职责链模式
package com;
//请求类
public class PurchaseRequest {
private double amount; //采购金额
private int number; //采购单编号
private String purpose; //采购目的
get，set方法加带参构造方法
}
package com;
//责任链对象抽象类
public abstract class Approver {
protected Approver successor; //定义后继对象
protected String name; //审批者姓名
public Approver(String name) {
this.name = name;
}
//设置后继者
public void setSuccessor(Approver successor) {
this.successor = successor;
}
//抽象请求处理方法
public abstract void processRequest(PurchaseRequest request);
}
package com.wtf.impl;
import com.Approver;
import com.PurchaseRequest;
//主任类：具体处理者,主任可以审批5万元以下（不包括5万元）的采购单
public class Director extends Approver {
public Director(String name) {
super(name);
}
//具体请求处理方法
public void processRequest(PurchaseRequest request) {
if (request.getAmount() < 50000) {
System.out.println("主任" + this.name + "审批采购单：" + request.getNumber() + "，金额：" + request.getAmount() + "元，采购目的：" + request.getPurpose() + "。"); //处理请求
}
else {
this.successor.processRequest(request); //转发请求
}
}
}
package com.wtf.impl;
import com.Approver;
import com.PurchaseRequest;
//副董事长类：具体处理者,副董事长可以审批5万元至10万元（不包括10万元）的采购单
public class VicePresident extends Approver{
public VicePresident(String name) {
super(name);
}
//具体请求处理方法
public void processRequest(PurchaseRequest request) {
if (request.getAmount() < 100000) {
System.out.println("副董事长" + this.name + "审批采购单：" + request.getNumber() + "，金额：" + request.getAmount() + "元，采购目的：" + request.getPurpose() + "。"); //处理请求
}
else {
this.successor.processRequest(request); //转发请求
}
}
}
package com.wtf.impl;
import com.Approver;
import com.PurchaseRequest;
//董事长类：具体处理者,董事长可以审批10万元至50万元（不包括50万元）的采购
public class President extends Approver {
public President(String name) {
super(name);
}
//具体请求处理方法
public void processRequest(PurchaseRequest request) {
if (request.getAmount() < 500000) {
System.out.println("董事长" + this.name + "审批采购单：" + request.getNumber() + "，金额：" + request.getAmount() + "元，采购目的：" + request.getPurpose() + "。"); //处理请求
}
else {
this.successor.processRequest(request); //转发请求
}
}
}
package com.wtf.impl;
import com.Approver;
import com.PurchaseRequest;
//董事会类：具体处理者,50万元及以上的采购单就需要开董事会讨论决定
public class Congress extends Approver {
public Congress(String name) {
super(name);
}
public void processRequest(PurchaseRequest request) {
System.out.println("召开董事会审批采购单：" + request.getNumber() + "，金额：" + request.getAmount() + "元，采购目的：" + request.getPurpose() + "。"); //处理请求
}
}
//测试
import com.Approver;
import com.PurchaseRequest;
import com.wtf.impl.Congress;
import com.wtf.impl.Director;
import com.wtf.impl.President;
import com.wtf.impl.VicePresident;
public class Test1 {
public static void main(String[] args) {
//创建采购单
PurchaseRequest p1 = new PurchaseRequest(20000, 10001, "java开发");
PurchaseRequest p2 = new PurchaseRequest(60000, 10002, "SSM实战");
PurchaseRequest p3 = new PurchaseRequest(300000, 10003, "oracle");
PurchaseRequest p4 = new PurchaseRequest(800000, 10004, "mysql");
//创建处理者
Approver zs = new Director("张三");//主任
Approver ls = new VicePresident("李四");//副董事长
Approver ww = new President("王五");//董事长
Approver ll = new Congress("李六");//董事会
//为处理者设置下一个处理者,形成职责链
zs.setSuccessor(ls);
ls.setSuccessor(ww);
ww.setSuccessor(ll);
//处理请求,都是从最前面的处理者开始
zs.processRequest(p1);
zs.processRequest(p2);
zs.processRequest(p3);
zs.processRequest(p4);
}
}
问题8：法国香水商品管理系统的商品名称存储一个字符串数组中，现在需要自定义一个双向迭代器OwnerItertator实现对该商品名称数组的双向(前向和后向)遍历，请选用相应的设计模式设计并实现该系统。要求绘制类图并写出实现过程。
//迭代器模式
//抽象迭代器，它定义了访问和遍历元素的接口
package com.wtf.iterator;
public interface AbstractIterator {
public void next();//指向下一个元素
public void previous();//指向上一个元素
public boolean isLast();//判断当前游标指向的位置是不是最后一个元素
public boolean isFirst();//判断当前游标指向的位置是不是第一个元素
public String getNextItem();//获取下一个元素值
public String getPreviousItem();//获取上一个元素值
}
//具体迭代器，它实现迭代器接口，并在对该聚合遍历时跟踪当前位置
package com.wtf.iterator.impl;
import com.wtf.iterator.AbstractIterator;
import com.wtf.product.AbstractProductList;
public class MyIterator implements AbstractIterator {
private String[] productsName;
private int index1;//用于正向遍历
private int index2;//用于反向遍历
//构造方法
public MyIterator(AbstractProductList list) {
productsName = list.getProductsName();
index1 = 0;
index2 = productsName.length - 1;
}
public void next() {
if(index1<productsName.length){
index1++;
}
}
public boolean isLast() {
return (index1 == productsName.length);
}
public void previous() {
if (index2>-1) {
index2--;
} else {
}
}
public boolean isFirst() {
return index2==-1;
}
public String getNextItem() {
return productsName[index1];
}
public String getPreviousItem() {
return productsName[index2];
}
}
//抽象商品集合：抽象聚合类
package com.wtf.product;
import com.wtf.iterator.AbstractIterator;
public abstract class AbstractProductList {
private String[] productsName;
//构造方法
public AbstractProductList(String[] productsName) {
this.productsName = productsName;
}
public String[] getProductsName(){
return this.productsName;
}
public abstract AbstractIterator getIterator();
}
//具体商品集合：具体聚合类
package com.wtf.product.impl;
import com.wtf.iterator.AbstractIterator;
import com.wtf.iterator.impl.MyIterator;
import com.wtf.product.AbstractProductList;
public class ProductList extends AbstractProductList {
//构造方法
public ProductList(String[] productsName) {
super(productsName);
}
public AbstractIterator getIterator() {
return new MyIterator(this);
}
}
//测试
package com;
import com.wtf.iterator.AbstractIterator;
import com.wtf.product.AbstractProductList;
import com.wtf.product.impl.ProductList;
public class Client{
public static void main(String[] args) {
//法国香水商品
String[] pNames = {"香奈儿Chanel","迪奥Dior","娇兰GUERLAIN","夏尔美shalimar"};
AbstractProductList list = new ProductList(pNames);
AbstractIterator iterator= list.getIterator();
while(!iterator.isLast()) {
System.out.println(iterator.getNextItem());
iterator.next();
}
System.out.println("----------------------------------------------------");
while (!iterator.isFirst()) {
System.out.println(iterator.getPreviousItem());
iterator.previous();
}
}
}
问题9：
问题10：
163
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
