|
1.装饰模式（Decorator Pattern）
顾名思义，装饰模式就是给一个对象增加一些新的功能，而且是动态的，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例。 举例：穿上漂亮的衣服美美的化个妆谁还不是小仙女咋地。 接口：
public interface beBeautiful {
public void beautiful();
}
华服：
public class hotDresses implements beBeautiful {
@Override
public void beautiful() {
System.out.println('穿上漂亮的衣服');
}
}
美妆：
public class Cosmetic implements beBeautiful {
private beBeautiful beautiful;
public Cosmetic(beBeautiful beautiful) {
this.beautiful = beautiful;
}
@Override
public void beautiful() {
System.out.println('画一个美美的妆');
beautiful.beautiful();
System.out.println('谁还不是小仙女咋地');
}
}
秒变小仙女：
public class You {
public static void main(String[] args){
beBeautiful be=new hotDresses();
beBeautiful tt=new Cosmetic(be);
tt.beautiful();
}
}
结果： 装饰器模式的应用场景： 1、需要扩展一个类的功能。 2、动态的为一个对象增加功能，而且还能动态撤销。（继承不能做到这一点，继承的功能是静态的，不能动态增删）
2.迭代器模式（Iterator Pattern）
迭代器模式就是顺序访问聚集中的对象，一般来说，集合中非常常见，如果对集合类比较熟悉的话，理解本模式会十分轻松。这句话包含两层意思：一是需要遍历的对象，即聚集对象，二是迭代器对象，用于对聚集对象进行遍历访问。 举例：模拟一个集合类的过程。 迭代器接口：
public interface Iterator {
//前遍历
public Object previous();
//后遍历
public Object next();
//判断是否有下一个
public boolean hasNext();
//取第一个元素
public Object first();
}
集合接口：
public interface Collection {
public Iterator iterator();
//获取集合所有元素
public Object get(int i);
//获取集合大小
public int size();
}
迭代器实现类：
public class myIterator implements Iterator {
private Collection collection;
private int num=-1;
public myIterator(Collection collection) {
this.collection = collection;
}
@Override
public Object previous() {
if(num>0){
num--;
}
return collection.get(num);
}
@Override
public Object next() {
if(num<>1){
num++;
}
return collection.get(num);
}
@Override
public boolean hasNext() {
if(num<>1){
return true;
}else{
return false;
}
}
@Override
public Object first() {
num=0;
return collection.get(num);
}
}
集合实现类：
public class myColllection implements Collection {
public String string[]={'1','2','3','4','5'};
@Override
public Iterator iterator() {
return new myIterator(this);
}
@Override
public Object get(int i) {
return string[i];
}
@Override
public int size() {
return string.length;
}
}
测试：
public class Test {
public static void main(String[] args){
Collection c=new myColllection();
Iterator i=c.iterator();
while (i.hasNext()){
System.out.println(i.next());
}
}
}
结果：
Java.util.Iterable接口只有一个方法就是iterator(),也就是说通过这个方法可以遍历聚集类中的所有方法和属性，基本上所有高级的语言都有Iterator这个接口或者实现，Java已经把迭代器给我们准备了，我们再去写迭代器就有点儿多此一举，所以迭代器模式我们基本不用自己去实现，直接使用List或者Map就可以完整的解决问题。但是我们也必须清楚他的实现过程，这样我们就可以写出自己的集合类，甚至框架！
3.组合模式（Composite Pattern）
组合模式有时又叫部分-整体模式在处理类似树形结构的问题时比较方便。
public class TreeNode{
private String name;
private TreeNode parent;
private Vector children=new Vector();
public TreeNode(String name){
this.name=name;
}
public TreeNode getParent() {
return parent;
}
public void setParent(TreeNode parent) {
this.parent = parent;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//添加孩子节点
public void add(TreeNode node){
children.add(node);
}
//删除孩子节点
public void remove(TreeNode node){
children.remove(node);
}
//取得孩子节点
public Enumeration etChildren(){
return children.elements();
}
}
实现：
public class Tree {
TreeNode root=null;
public Tree(String name) {
root = new TreeNode(name);
}
public static void main(String[] args){
Tree tree=new Tree('A');
TreeNode nodeB=new TreeNode('B');
TreeNode nodeC=new TreeNode('C');
TreeNode nodeD=new TreeNode('D');
TreeNode nodeE=new TreeNode('E');
TreeNode nodeF=new TreeNode('#');
TreeNode nodeG=new TreeNode('#');
TreeNode nodeH=new TreeNode('#');
TreeNode nodeI=new TreeNode('#');
TreeNode nodeJ=new TreeNode('#');
TreeNode nodeK=new TreeNode('#');
nodeD.add(nodeF);
nodeD.add(nodeG);
nodeE.add(nodeH);
nodeE.add(nodeI);
nodeB.add(nodeD);
nodeB.add(nodeJ);
nodeC.add(nodeE);
nodeC.add(nodeK);
tree.root.add(nodeB);
tree.root.add(nodeC);
}
}
使用场景：将多个对象组合在一起进行操作，常用于表示树形结构中，例如二叉树等。 4.观察者模式（Observer Pattern）
当一个对象变化时，其它依赖该对象的对象都会收到通知，并且随着变化！对象之间是一种一对多的关系。 观察者接口：
public interface Observer {
public void update();
}
第一个观察者：
public class myObserver1 implements Observer{
@Override
public void update() {
System.out.println('myObserver1 has changed');
}
}
第二个观察者：
public class myObserver2 implements Observer {
@Override
public void update() {
System.out.println('myObserver2 has changed');
}
}
对象接口：
public interface Subject {
//增加观察者
public void add(Observer observer);
//删除观察者
public void delete(Observer observer);
//通知所有观察者
public void notifyObservers();
//自己的方法
public void operation();
}
需要监控的对象列表：
public abstract class AbstractSubject implements Subject {
private Vector vector = new Vector();
@Override
public void add(Observer observer) {
vector.add(observer);
}
@Override
public void delete(Observer observer) {
vector.remove(observer);
}
@Override
public void notifyObservers() {
Enumeration enumo = vector.elements();
while(enumo.hasMoreElements()){
enumo.nextElement().update();
}
}
}
主对象：
public class mySubject extends AbstractSubject {
@Override
public void operation() {
System.out.println('update self');
notifyObservers();
}
}
测试：
public class Test {
public static void main(String[] args){
Subject su=new mySubject();
su.add(new myObserver1());
su.add(new myObserver2());
su.operation();
}
}
结果： 
源码：
链接: https://pan.baidu.com/s/15nzQHIsCLJmdIUBdDQzd5Q 密码: 4qjs
|
