设计模式学习--------1.组合模式学习

重新开始写博客 之前的JAVA博客一直没更新，一直忙，连地址都忘了，现在下定决心重新拾起。一边学习android 一边温习java基础。现在明白忙只是借口，真正的原因是因为太懒了，肯定能挤出时间学习总结,至少每周末会写一到两篇学习总结,下定决心坚持下来,恩,为自己加油。

-------------------------------------------------------------------

Android中对组合模式的应用，可谓是泛滥成粥，随处可见，那就是View和View Group类的使用。在android UI设计，几乎所有的widget和布局类都依靠这两个类。

考虑一个应用：

商品类别树

服装  

男装: 衬衣 西服

女装：裙子 套装

不用组合模式实现：

将服装看成根节点，男装和女装是树枝节点，衬衣等是叶子节点。根节点和树枝节点都可以包括叶子节点，所以看成一个组合类。

叶子节点定义：

package com.light.com;

public class Leaf {
private String name = "";

public Leaf() {
}

public Leaf(String name) {
this.name = name;
}

@Override
public String toString() {
return name;
}
}

组合类定义：

package com.light.com;

import java.util.ArrayList;
import java.util.List;

public class Composite {
private List<Composite> composites = new ArrayList<Composite>();
private List<Leaf> leafs = new ArrayList<Leaf>();
private String name = "";

public Composite() {}

public Composite(String name) {
this.name = name;
}

//添加树枝
public void addComposite(Composite childComposite){
composites.add(childComposite);
}

//添加叶子
public void addLeaf(Leaf leaf){
leafs.add(leaf);
}

@Override
public String toString() {
StringBuffer sb = new StringBuffer("+");
sb.append(this.name+" ");
for(Composite c :composites){
sb.append(c.toString());
}
sb.append(" ");
for(Leaf l:leafs){
sb.append(l.toString()+" ");
}
return sb.toString();
}

}

客户端：

package com.light.com;

public class Client {
public static void main(String[] args) {
Composite root = new Composite("服装");
Composite male = new Composite("男装");
Composite female = new Composite("女装");
Leaf shirt = new Leaf("衬衣");
Leaf jack = new Leaf("夹克");
Leaf dress = new Leaf("裙子");
Leaf coat = new Leaf("套装");
root.addComposite(male);
root.addComposite(female);
male.addLeaf(shirt);
male.addLeaf(jack);
female.addLeaf(dress);
female.addLeaf(coat);
System.out.println(root);
}
}

输出结果：

+服装 

  +男装 -衬衣 -夹克 

  +女装 -裙子 -套装 

有何问题：

需要区别对待组合对象和叶子对象。当叶子节点和树枝节点增多时，程序变的复杂，扩展性不强

引入组合模式

解决方案：

定义一个抽象类。既可以代表叶子对象也可以代表组合对象。

抽象类：

package com.light.com;

public abstract class Component {

public abstract void doSomething();

public void addChild(Component component) {
// 缺省实现抛异常,叶子对象没有这个功能
throw new UnsupportedOperationException("不支持这个功能");
}

public void removeChild(Component component) {
// 缺省实现抛异常,叶子对象没有这个功能
throw new UnsupportedOperationException("不支持这个功能");
}

public Component getChildren(int index){
// 缺省实现抛异常,叶子对象没有这个功能
throw new UnsupportedOperationException("不支持这个功能");
}
}

组件类：

package com.light.com;

import java.util.ArrayList;
import java.util.List;

public class Composite extends Component {
private List<Component> components = null;
private String name;

public Composite() {
}

public Composite(String name) {
this.name = name;
}

@Override
public void doSomething() {
//打印自己的名字
System.out.println("+"+this.name);
if (components != null) {
System.out.print(" ");
for (Component c : components) {
//递归
c.doSomething();
System.out.print(" ");
}
System.out.println();
}
}

@Override
public void addChild(Component component) {
if (components == null) {
components = new ArrayList<Component>();
}
components.add(component);
}

@Override
public void removeChild(Component component) {
if (components != null) {
components.remove(component);
}
}

@Override
public Component getChildren(int index) {
if (components != null) {
if (index >= 0 && index < components.size()) {
components.get(index);
}
}
return null;
}

}

叶子类：

package com.light.com;

public class Leaf extends Component{
private String name = "";

public Leaf() {
}

public Leaf(String name) {
this.name = name;
}

@Override
public void doSomething() {
//打印自己的名字
System.out.print("-"+this.name);
}
}

客户端：

package com.light.com;

public class Client {
public static void main(String[] args) {
Component root = new Composite("服装");
Component male = new Composite("男装");
Component female = new Composite("女装");
Component shirt = new Leaf("衬衣");
Component jack = new Leaf("夹克");
Component dress = new Leaf("裙子");
Component coat = new Leaf("套装");
root.addChild(male);
root.addChild(female);
male.addChild(shirt);
male.addChild(jack);
female.addChild(dress);
female.addChild(coat);
root.doSomething();
}
}

输出结果：

+服装 

  +男装 -衬衣 -夹克 

  +女装 -裙子 -套装   

优点：

让客户端不再区分操作的是组合对象还是叶子对象，而是统一操作组件对象。增加了透明性

缺点：

客户端可能会调用叶子节点中的无用方法 抛出异常。牺牲了安全性。

考虑两个问题：

1.如果删除某个商品类别。如果这个类别没有子类别直接删除即可。但它若有子类别，一种是需要连带删除其子类另一种是将其子类别上移一层。

2.如果进行商品细化和整理，把原本A类别下得子类别移动到B类别下，需连带其子类一起移动。

问题解决方案：

在组合对象添加子组件对象时，为子组件对象设置父组件的引用，这样就可以在删除或移动时，将父组件的引用重新设置。把这些实现放到抽象类中

改进后的抽象类：

package com.light.com;

import java.util.List;

public abstract class Component {
//记录父组件对象
private Component parent;

public Component getParent() {
return parent;
}

public void setParent(Component parent) {
this.parent = parent;
}

public List<Component> getChildren(){
// 缺省实现抛异常,叶子对象没有这个功能
throw new UnsupportedOperationException("不支持这个功能");
}

public abstract void doSomething();

public void addChild(Component component) {
// 缺省实现抛异常,叶子对象没有这个功能
throw new UnsupportedOperationException("不支持这个功能");
}

public void removeChild(Component component) {
// 缺省实现抛异常,叶子对象没有这个功能
throw new UnsupportedOperationException("不支持这个功能");
}

public Component getChildren(int index){
// 缺省实现抛异常,叶子对象没有这个功能
throw new UnsupportedOperationException("不支持这个功能");
}
}

改进后的组件类：

package com.light.com;

import java.util.ArrayList;
import java.util.List;

public class Composite extends Component {
private List<Component> components = null;
private String name;

public Composite() {
}

public Composite(String name) {
this.name = name;
}

@Override
public List<Component> getChildren() {
return components;
}

@Override
public void doSomething() {
//打印自己的名字
System.out.println("+"+this.name);
if (components != null) {
System.out.print(" ");
for (Component c : components) {
//递归
c.doSomething();
}
System.out.println();
}
}

@Override
public void addChild(Component component) {
if (components == null) {
components = new ArrayList<Component>();
}
components.add(component);
//设置其为父类对象
component.setParent(this);
}

@Override
public void removeChild(Component component) {
if (components != null) {
//查找要删除组件的索引位置
int idx = components.indexOf(component);
//如果删除的为子组件类别
if(idx!=-1){
//将该子组件下的组件的父类别设置为其原来的父类别,刘备托孤给诸葛亮,诸葛亮设置成了刘禅的父类。
for(Component c:component.getChildren()){
c.setParent(this);
components.add(c);
}
}
//再将其删除,刘备挂了
components.remove(idx);
}
}

@Override
public Component getChildren(int index) {
if (components != null) {
if (index >= 0 && index < components.size()) {
components.get(index);
}
}
return null;
}

}

叶子类无变化。

客户端:

package com.light.com;

public class Client {
public static void main(String[] args) {
Component root = new Composite("服装");
Component male = new Composite("男装");
Component female = new Composite("女装");
Component shirt = new Leaf("衬衣");
Component jack = new Leaf("夹克");
Component dress = new Leaf("裙子");
Component coat = new Leaf("套装");
root.addChild(male);
root.addChild(female);
male.addChild(shirt);
male.addChild(jack);
female.addChild(dress);
female.addChild(coat);
root.doSomething();
root.removeChild(male);
root.doSomething();
}
}

输出结果：

+服装 

  +男装 -衬衣 -夹克 

  +女装 -裙子 -套装

+服装 

  +女装 -裙子 -套装 

  -衬衣 -夹克

---------------------------------------------------

android中组合模式的实现



牺牲了透明性 增加了安全性

View类的实现：

public class View{
//... ...
//省略了无关的方法
}

ViewGroup类的实现：

public abstract class ViewGroup extends View{
/**
* Adds a child view.
*/
public void addView(View child) {
//...
}

public void removeView(View view) {
//...
}

/**
* Returns the view at the specified position in the group.
*/
public View getChildAt(int index) {
try {
return mChildren[index];
} catch (IndexOutOfBoundsException ex) {
return null;
}
}

//other methods
}