设计模式之适配器模式、外观模式浅析

外观模式强调统一和简化接口，而适配器模式强调转换接口

/**
*
* 适配器模式
*     将一种接口转换为用户所期望的另一种接口
*
* 对象适配器--使用组合拥有被适配者接口，使用实现实现目的接口
* 类适配器--使用继承拥有被适配者与目的类
*
* 目的接口：用户所期望的接口
* 被适配器接口：待转换的接口
* 适配器：实现目的接口，同时使用组合包含被适配器接口，将被适配器接口转换为目的接口
* 适配器让原本接口不兼容的类可以合作无间
*
* 实例
*   火鸡与鸭子
*     鸭子会叫，也会飞
*     火鸡只会咯咯叫 飞的很近
*     将火鸡转换为鸭子
*
* @author Administrator
*
*/

package com.undergrowth.adapter;

/**
*
* 适配器模式
*     将一种接口转换为用户所期望的另一种接口
*
* 对象适配器--使用组合拥有被适配者接口，使用实现实现目的接口
* 类适配器--使用继承拥有被适配者与目的类
*
* 目的接口：用户所期望的接口
* 被适配器接口：待转换的接口
* 适配器：实现目的接口，同时使用组合包含被适配器接口，将被适配器接口转换为目的接口
* 适配器让原本接口不兼容的类可以合作无间
*
* 实例
*   火鸡与鸭子
*     鸭子会叫，也会飞
*     火鸡只会咯咯叫 飞的很近
*     将火鸡转换为鸭子
*
* @author Administrator
*
*/
public interface Duck {

public void quack();
public void fly();

}

package com.undergrowth.adapter;

/**
* 绿头鸭
* @author Administrator
*
*/
public class MallardDuck implements Duck {

@Override
public void quack() {
// TODO Auto-generated method stub
System.out.println("quack");
}

@Override
public void fly() {
// TODO Auto-generated method stub
System.out.println("i can fly");
}

}

package com.undergrowth.adapter;

/**
* 火鸡
* @author Administrator
*
*/
public interface Turkey {
public void gobble();
public void fly();
}

package com.undergrowth.adapter;

public class WildTurkey implements Turkey {

@Override
public void gobble() {
// TODO Auto-generated method stub
System.out.println("gobble");
}

@Override
public void fly() {
// TODO Auto-generated method stub
System.out.println("i can fly,but slower");
}

}

package com.undergrowth.adapter;

/**
* 火鸡适配器 将火鸡转换为鸭子
*
* @author Administrator
*
*/
public class TurkeyAdapter implements Duck {

Turkey turkey;

public TurkeyAdapter(Turkey turkey) {
this.turkey = turkey;
}

@Override
public void quack() {
// TODO Auto-generated method stub
turkey.gobble();
}

@Override
public void fly() {
// TODO Auto-generated method stub
turkey.fly();
}

}

package com.undergrowth.adapter.test;

import static org.junit.Assert.*;

import org.junit.Test;

import com.undergrowth.adapter.Duck;
import com.undergrowth.adapter.Turkey;
import com.undergrowth.adapter.TurkeyAdapter;
import com.undergrowth.adapter.WildTurkey;

public class TurkeyAdapterTest {

@Test
public void test() {
Turkey turkey=new WildTurkey();
//将火鸡转为鸭子
Duck duck=new TurkeyAdapter(turkey);
duck.quack();
duck.fly();
}

}

gobble
i can fly,but slower

package com.undergrowth.adapter;

import java.util.Enumeration;

public class  NumEnum implements Enumeration{

int length;
int count;
String[] data=null;
public NumEnum(String[] data){
this.data=data;
count=0;
length=data.length;
}

@Override
public boolean hasMoreElements() {
// TODO Auto-generated method stub
return (count<length);
}

@Override
public Object nextElement() {
// TODO Auto-generated method stub
return data[count++];
}

}

package com.undergrowth.adapter;

/**
* 将Enumeration转换为Iterator
*/
import java.util.Enumeration;
import java.util.Iterator;

public class EnumeIteratorAdapter implements Iterator {

Enumeration enumeration;

public EnumeIteratorAdapter(Enumeration enumeration){
this.enumeration=enumeration;
}

@Override
public boolean hasNext() {
// TODO Auto-generated method stub
return enumeration.hasMoreElements();
}

@Override
public Object next() {
// TODO Auto-generated method stub
return enumeration.nextElement();
}

@Override
public void remove() {
// TODO Auto-generated method stub
throw new UnsupportedOperationException();
}

}

package com.undergrowth.adapter.test;

import static org.junit.Assert.*;

import java.util.Enumeration;
import java.util.Iterator;

import org.junit.Test;

import com.undergrowth.adapter.EnumeIteratorAdapter;
import com.undergrowth.adapter.NumEnum;
import com.undergrowth.decorate.Price;

public class EnumeIteratorAdapterTest {

@Test
public void test() {
String[] data={"百度","谷歌","IBM","Oracle","Microsoft","HP","Lenovo","Tecent"};
Enumeration enumeration=new NumEnum(data);
Iterator iterator=new EnumeIteratorAdapter(enumeration);
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}

}

百度
谷歌
IBM
Oracle
Microsoft
HP
Lenovo
Tecent

/**
* 设计原则：
*   最少知识原则：只和你的密友交谈
* 为了只和你的密友交谈，对象中方法应该只出现在一下四种情况调用
*   1、对象本身中
*   2、对象作为其他对象的任何组件
*   3、对象作为方法参数进行传递
*   4、此方法所创建的实例化对象中
*   1、3、4的意味着不要在调用其他方法返回的对象上调用其方法
*
*
* 外观模式
*   提供了一个统一的接口，用来访问子系统的一群接口
*   定义了一个高层接口，让子系统更容易使用
* 外观模式只是提供了一个子系统的访问接口，并不影响子系统的单独使用
* 外观强调统一和简化接口，而适配器强调转换接口
*
* 示例
*   家庭影院
*
* @author Administrator
*
*/

package com.undergrowth.facade;

/**
* 设计原则：
*   最少知识原则：只和你的密友交谈
* 为了只和你的密友交谈，对象中方法应该只出现在一下四种情况调用
*   1、对象本身中
*   2、对象作为其他对象的任何组件
*   3、对象作为方法参数进行传递
*   4、此方法所创建的实例化对象中
*   1、3、4的意味着不要在调用其他方法返回的对象上调用其方法
*
*
* 外观模式
*   提供了一个统一的接口，用来访问子系统的一群接口
*   定义了一个高层接口，让子系统更容易使用
* 外观模式只是提供了一个子系统的访问接口，并不影响子系统的单独使用
* 外观强调统一和简化接口，而适配器强调转换接口
*
* 示例
*   家庭影院
*
* @author Administrator
*
*/
public class HomeTheatre {

Amplifier amp;
Projector pro;
Screen scr;
Curtain cur;
public HomeTheatre(Amplifier amp,Projector pro,Screen scr,Curtain cur){
this.amp=amp;
this.pro=pro;
this.cur=cur;
this.scr=scr;
}

public void watchMovie(){
cur.close();
scr.down();
pro.open();
amp.openAmp();
amp.setPlayer(0);
amp.setVolume(10);
}
public void closeMovie(){
amp.closeAmp();
pro.close();
scr.up();
cur.open();
}

}

package com.undergrowth.facade;

/**
* 功放
* @author Administrator
*
*/
public class Amplifier {

public void openAmp(){
System.out.println("打开功放");
}

public void closeAmp(){
System.out.println("关闭功放");
}

public void setVolume(int volume){
System.out.println("设置音量为"+5);
}

public void setPlayer(int num){
switch (num) {
case 1:
System.out.println("设置CD播放");
break;
default:
System.out.println("设置DVD播放");
break;
}

}
}

package com.undergrowth.facade;

/**
* 投影仪
* @author Administrator
*
*/
public class Projector {

public void open()
{
System.out.println("打开投影仪");
}
public void close(){
System.out.println("关闭投影仪");
}
}

package com.undergrowth.facade;

/**
* 将投影的屏幕放下
* @author Administrator
*
*/
public class Screen {

public void down(){
System.out.println("放下投影屏幕");
}
public void up(){
System.out.println("收起投影屏幕");
}

}

package com.undergrowth.facade;

/**
* 窗帘
* @author Administrator
*
*/
public class Curtain {

public void close(){
System.out.println("关上窗帘");
}
public void open(){
System.out.println("打开窗帘");
}
}

package com.undergrowth.facade;

import static org.junit.Assert.*;

import org.junit.Test;

public class HomeTheatreTest {

@Test
public void test() {
Amplifier amp=new Amplifier();
Projector pro=new Projector();
Screen scr=new Screen();
Curtain cur=new Curtain();
HomeTheatre homeTheatre=new HomeTheatre(amp, pro, scr, cur);
homeTheatre.watchMovie();
System.out.println("=================我是分割线==================");
homeTheatre.closeMovie();
}

}

关上窗帘
放下投影屏幕
打开投影仪
打开功放
设置DVD播放
设置音量为5
=================我是分割线==================
关闭功放
关闭投影仪
收起投影屏幕
打开窗帘