适配器模式---姚明打篮球实例

适配器模式，属于结构型模式，其主要作用是将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

适用情况：

以下情况使用适配器模式
• 你想使用一个已经存在的类，而它的接口不符合你的需求。
• 你想创建一个可以复用的类，该类可以与其他不相关的类或不可预见的类（即那些接口可能不一定兼容的类）协同工作。
• （仅适用于对象Adapter）你想使用一些已经存在的子类，但是不可能对每一个都进行子类化以匹配它们的接口。对象适配器可以适配它的父类接口。
 

大话设计模式上的定义：将一个类的接口转换为客户希望的另一个接口，Adapter模式使得原本接口不兼容而不能在一起工作的类可以一起工作。

有类适配器和对象适配器两种，但是由于java C#不允许多继承，在此只介绍对象适配器。

Target类：这是客户所期待的接口。目标可以是具体或者是抽象额类，也可以是接口

Adaptee类：定义一个已经存在的接口（也可以是一个类我认为i），这个接口需要适配。这个类形似于Target类，但是有所不同

Adaper类： 这是一个适配器类Adapter,一般此适配器类需要继承Target类，通过内部包装一个Adaptee对象，把源接口转换成目标接口

这是对象适配器的抽象实现

    package com.visionsky.DesignPattern; 
     
    interface Target { 
        void Request(); 
    } 
     
    class Adaptee { 
        void SpecificRequst() { 
            System.out.println("Adaptee's SpecificRequst"); 
        } 
    } 
     
    class Adapter  implements Target  
    { 
     
        private Adaptee adaptee; 
        public Adapter() 
        { 
            this.adaptee=new Adaptee(); 
        } 
         
        @Override 
        public void Request() { 
             System.out.println("Adapter's Request"); 
             adaptee.SpecificRequst(); 
        } 
     
    } 
     
    public class AdapterDemo { 
     
        /** 
         * @param args 
         */ 
        public static void main(String[] args) { 
            // TODO Auto-generated method stub 
            Target t=new Adapter(); 
            t.Request(); 
        } 
     
    } 

姚明打球实例：姚明是队员之一，但是队员们的抽象类是说英语的，姚明不懂得。所以需要一个Adaper类来改变接口使得姚明可以听懂

/*
 * 这是Target类
 * 这是客户所期待的接口。目标可以是具体或者是抽象额类，也可以是接口
 */
public abstract class Player {
	protected String name;

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

	public abstract void Attack();

	public abstract void Defense();
}


public class Center extends Player{
	public Center(String name){
		super(name);
	}

	@Override
	public void Attack() {
		System.out.println("中锋进攻！");
	}

	@Override
	public void Defense() {
		System.out.println("中锋防守！");
	}
}

/*
 * Adaptee类
 * 不能使用Target目标类（接口）当中的方法（外籍听不懂英文）
 * 于是只能通过一个Adapter（翻译者）来实现Target的方法
 * 此时这个类外籍中锋类是透明的
 */
public class ForeignCenter {
	protected String name;
	/*public ForeignCenter(String name){
		this.name = name;
	}*/
	public void 进攻(){
		System.out.println("外籍中锋进攻！");
	}
	public void 防守(){
		System.out.println("外籍中锋防守！");
	}
}

public class ForwardFirst extends Player{
	public ForwardFirst(String name){
		super(name);
	}

	@Override
	public void Attack() {
		System.out.println("1号后卫进攻！");
	}

	@Override
	public void Defense() {
		System.out.println("1号后卫防守！");
	}
}


public class GuardFirst extends Player{

	public GuardFirst(String name){
		super(name);
	}

	@Override
	public void Attack() {
		System.out.println("1号前锋进攻！");
	}

	@Override
	public void Defense() {
		System.out.println("1号前锋防守！");
	}
	
}

/*
 * 这是一个适配器类Adapter,一般此适配器类需要继承Target类
 * 为了让我们的外籍中锋（Adaptee对象 ）能够使用Target的方法
 * 通过内部包装一个Adaptee对象，把源接口转换成目标接口
 */
public class Translator extends Player{
    private ForeignCenter wjzf  = new ForeignCenter();
	public Translator(String name) {
		super(name);
		wjzf.name = name;
	}
	@Override
	public void Attack() {
		wjzf.进攻();
	}
	@Override
	public void Defense() {
		wjzf.防守();
	}
}

public class MainTest {
	public static void main(String args[]) {
		Player b = new ForwardFirst("巴蒂尔");
		b.Attack();

		Player m = new GuardFirst("麦克格雷迪");
		m.Attack();

		// 翻译者告诉姚明，你既要进攻，又要防守
		Player ym = new Translator("姚明");
		ym.Attack();
		ym.Defense();
	}
}