第三周作业
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 加入
还未添加个人简介
评论