第三周作业

发布于: 21 小时前

1、请在草稿纸上手写一个单例模式的实现代码,拍照提交作业。

2、请用组合设计模式编写程序,打印输出图 1 的窗口,窗口组件的树结构如图 2 所示,打印输出示例参考图 3。

运行结果:

package cn.dp.composite;

public class Client {

public static void main(String[] args) {

//定义所有的组合对象

Component winFormRoot = new Composite("WinForm(WINDOW窗口)");

Component textbox = new Composite("文本框");

Component frame = new Composite("FRAME1");

Component lable = new Composite("密码");

//定义所有的叶子对象

Component pictureLeaf = new Leaf("LOGO图片");

Component loginButtonLeaf = new Leaf("登录");

Component regButtonLeaf = new Leaf("注册");

Component lableLeaf = new Leaf("用户名");

Component passwordboxLeaf = new Leaf("密码框");

Component checkboxLeaf = new Leaf("复选框");

Component textboxLeaf = new Leaf("记住用户名");

Component linklableLeaf = new Leaf("忘记密码");

//按照树的结构来组合组合对象和叶子对象

winFormRoot.addChild(pictureLeaf);

winFormRoot.addChild(loginButtonLeaf);

winFormRoot.addChild(regButtonLeaf);

winFormRoot.addChild(frame);

frame.addChild(lableLeaf);

frame.addChild(textbox);

frame.addChild(lable);

frame.addChild(passwordboxLeaf);

textbox.addChild(checkboxLeaf);

textbox.addChild(textboxLeaf);

lable.addChild(linklableLeaf);

//调用根对象的输出功能来输出整棵树

winFormRoot.printStruct("");

}

}

package cn.dp.composite;

import java.util.List;

/**

* 抽象的组件对象

*/

public abstract class Component {

/**

* 记录父组件对象

*/

private Component parent = null;

/**

* 获取一个组件的父组件对象

* @return 一个组件的父组件对象

*/

public Component getParent() {

return parent;

}

/**

* 设置一个组件的父组件对象

* @param parent 一个组件的父组件对象

*/

public void setParent(Component parent) {

this.parent = parent;

}

/**

* 返回某个组件的子组件对象

* @return 某个组件的子组件对象

*/

public List<Component> getChildren() {

throw new UnsupportedOperationException("对象不支持这个功能");

}

/-------------------以下是原有的定义----------------------/

/**

* 输出组件自身的名称

*/

public abstract void printStruct(String preStr);

/**

* 向组合对象中加入组件对象

* @param child 被加入组合对象中的组件对象

*/

public void addChild(Component child) {

// 缺省的实现,抛出例外,因为叶子对象没有这个功能,或者子组件没有实现这个功能

throw new UnsupportedOperationException("对象不支持这个功能");

}

/**

* 从组合对象中移出某个组件对象

* @param child 被移出的组件对象

*/

public void removeChild(Component child) {

// 缺省的实现,抛出例外,因为叶子对象没有这个功能,或者子组件没有实现这个功能

throw new UnsupportedOperationException("对象不支持这个功能");

}

/**

* 返回某个索引对应的组件对象

* @param index 需要获取的组件对象的索引,索引从0开始

* @return 索引对应的组件对象

*/

public Component getChildren(int index) {

throw new UnsupportedOperationException("对象不支持这个功能");

}

}

package cn.dp.composite;

import java.util.*;

/**

* 组合对象,可以包含其它组合对象或者叶子对象

*/

public class Composite extends Component{

public void addChild(Component child) {

//延迟初始化

if (childComponents == null) {

childComponents = new ArrayList<Component>();

}

childComponents.add(child);

//添加对父组件的引用

child.setParent(this);

}

public void removeChild(Component child) {

if (childComponents != null) {

//查找到要删除的组件在集合中的索引位置

int idx = childComponents.indexOf(child);

if (idx != -1) {

//先把被删除的商品类别对象的父商品类别,设置成为被删除的商品类别的子类别的父商品类别

for(Component c : child.getChildren()){

//删除的组件对象是本实例的一个子组件对象

c.setParent(this);

//把被删除的商品类别对象的子组件对象添加到当前实例中

childComponents.add(c);

}

//真的删除

childComponents.remove(idx);

}

}

}

public List<Component> getChildren() {

return childComponents;

}

/-------------------以下是原有的实现,没有变化----------------------/

/**

* 用来存储组合对象中包含的子组件对象

*/

private List<Component> childComponents = null;

/**

* 组合对象的名字

*/

private String name = "";

/**

* 构造方法,传入组合对象的名字

* @param name 组合对象的名字

*/

public Composite(String name){

this.name = name;

}

/**

* 输出组合对象自身的结构

* @param preStr 前缀,主要是按照层级拼接的空格,实现向后缩进

*/

public void printStruct(String preStr){

//先把自己输出去

System.out.println(preStr+"+"+this.name);

//如果还包含有子组件,那么就输出这些子组件对象

if(this.childComponents!=null){

//然后添加一个空格,表示向后缩进一个空格

preStr+=" ";

//输出当前对象的子对象了

for(Component c : childComponents){

//递归输出每个子对象

c.printStruct(preStr);

}

}

}

}

package cn.dp.composite;

/**

* 叶子对象

*/

public class Leaf extends Component{

/**

* 叶子对象的名字

*/

private String name = "";

/**

* 构造方法,传入叶子对象的名字

* @param name 叶子对象的名字

*/

public Leaf(String name){

this.name = name;

}

/**

* 输出叶子对象的结构,叶子对象没有子对象,也就是输出叶子对象的名字

* @param preStr 前缀,主要是按照层级拼接的空格,实现向后缩进

*/

public void printStruct(String preStr){

System.out.println(preStr+"-"+name);

}

}

用户头像

赵龙

关注

还未添加个人签名 2017.12.10 加入

还未添加个人简介

评论

发布
暂无评论
第三周作业