设计模式之适配器模式 adapter 适配器模式分类概念角色详解 类适配器 对象适配器 接口适配器 双向适配器

package adapter;
/**客户角色 Client 港版插头
* @author noteless
*
*/
public class ClientHongKongSocket {
/**接受港版插座面板作为参数
* 港版插头,插入到港版插座面板
* @param targetHongkongPanel
*/
public void plugIn(TargetHongkongPanelInterface targetHongkongPanel) {
targetHongkongPanel.offerHongKongElectricity();
}
/*
* 测试主程序,港版插头 插入到适配器上
* 适配器插入到大陆面板上
*/
public static void main(String ...args) {
//港版插头
ClientHongKongSocket socket = new ClientHongKongSocket();
//大陆面板
AdapteeChinaMainlandPanel adapteeChinaMainlandPanel = new AdapteeChinaMainlandPanel();
//适配器
Adapter adapter = new Adapter(adapteeChinaMainlandPanel);
//港版插头 插到 适配器上
socket.plugIn(adapter);
}
}

package interfaceadapter;
public class Test {
public static void main(String[] args) {
Interfaces class1 = new ImplementClass1();
Interfaces class2 = new ImplementClass2();
class1.method1();
class1.method2();
class1.method3();
class1.method4();
class1.method5();
System.out.println("------");
class2.method1();
class2.method2();
class2.method3();
class2.method4();
class2.method5();
}
}

package doubleadapter;
public interface TargetInterface {
void targetRequest();
}



package doubleadapter;
public class TargetImplClass implements TargetInterface{
@Override
public void targetRequest() {
System.out.println("targetRequest ... ");
}
}

package doubleadapter;
public class Adapter implements TargetInterface,AdapteeInterface {
private TargetInterface target;
private AdapteeInterface adaptee;
Adapter(TargetInterface target){
this.target = target;
}

Adapter(AdapteeInterface adaptee){
this.adaptee = adaptee;
}
@Override
public void adapteeRequest() {
target.targetRequest();
}
@Override
public void targetRequest() {
adaptee.adapteeRequest();
}
}

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
package org.apache.commons.collections.iterators;
import java.util.Collection;
import java.util.Enumeration;
import java.util.Iterator;

public class EnumerationIterator implements Iterator {
private Collection collection;
private Enumeration enumeration;
private Object last;

public EnumerationIterator() {
this((Enumeration)null, (Collection)null);
}
public EnumerationIterator(Enumeration enumeration) {
this(enumeration, (Collection)null);
}

public EnumerationIterator(Enumeration enumeration, Collection collection) {
this.enumeration = enumeration;
this.collection = collection;
this.last = null;
}

public boolean hasNext() {
return this.enumeration.hasMoreElements();
}

public Object next() {
this.last = this.enumeration.nextElement();
return this.last;
}

public void remove() {
if (this.collection != null) {
if (this.last != null) {
this.collection.remove(this.last);
} else {
throw new IllegalStateException("next() must have been called for remove() to function");
}

} else {
throw new UnsupportedOperationException("No Collection associated with this Iterator");
}
}

public Enumeration getEnumeration() {
return this.enumeration;
}

public void setEnumeration(Enumeration enumeration) {
this.enumeration = enumeration;
}
}