学习设计模式之适配器模式01

[color=blue] [size=medium]适配器模式：把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口不匹配而无法在一起工作的两个类能够在一起工作.[/size][/color]
[b] 适配器模式类型：[/b]
[list]
[*]对象适配器模式(适配器容纳一个它包裹的类的实例)
[*]类适配器模式(适配器继承自已实现的类)
[/list]
[b]适配器模式主要内容：[/b]
[list]
[*]类适配器(在接口中定义了他期望的行为时，我们就可以应用适配器模式，提供一个实现该接口的类，并且扩展已有的类，通过创建子类来实现适配)
[*]对象适配器(通过组合除了满足“用户期待接口”还降低了代码间的不良耦合)
[*]缺省适配器模式(由一个抽象类实现的，并且在抽象类中要实现目标接口中所规定的所有方法，但很多方法的实现都是“平庸”的实现，也就是说，这些方法都是空方法。而具体的子类都要继承此抽象类。)
[/list]
[size=medium] [color=blue] 适配器适应情况：[/color][/size]
[list]
[*]接口中规定了所有要实现的方法
[*]但一个要继承此接口的具体类，只用到了其中的几个方法，而其它的方法都是没有用的
[/list]
[b]牵涉到java基础知识：抽象类[/b]
先看看抽象类 例如：在POS系统常常会出现采购订单和销售订单。这两种类型的订单可以抽象出订单或在考虑工人，老师，学生等共性时候可以抽象出人

 public abstract class Person
{
	private String name;
	private int age;

	public Person(String name, int age){
		this.name = name;
		this.age =age;
	}

	public abstract String getSay();

	public void say(){
		System.out.println(this.getSay());
	}
}

class Worker extends Person
{
	private float money;

	public Worker(String name, int age, float money){
		super(name,age);
		this.money = money;
	}

	public void getSay(){

	}
}

class Student extends Person
{
	private float score;

	public Student(String name, int age, float score){
		super(name, age);
		this.score = score;
	}
	public void getSay(){

	}
}


public static void Main(Strings[] args){
         Person p = new Worker("张三",25,5000);
	p.getSay();
	Person p = new Student("李四",18,85);
	p.getSay();
}

[color=blue][b]回顾抽象类的性质：[/b][/color]
[quote]
1.类和方法都要被关键字abstract去修饰
2.抽象的方法不用去实现而只要声明一下就可以了
3.抽象类不可以去实例化，也就是不能去new
4.一个类中如果含有抽象方法，那么这个类就必须被声明为抽象类，继承它的子类必须去覆写这个抽象方法才可以被实例化
[/quote]
下面开始实施一个简单的类适配器：

interface Eat
{
	public void eatBread();
	public void eatApplea();
	public void eatBanana();
}

abstract class PersonEat implements Eat
{
	public void eatBread(){

	}

	public void eatApplea(){

	}

	public void eatBanana(){

	}
}

class Person extends PersonEat
{
	 public void eatBread(){
		System.out.println("Eat Bread");
	 }
	 public void eatApple(){
	    System.out.println("Eat APple");
	 }
}

public static void main(String[] args){
	Person p = new Person();
	p.eatBread();
	p.eatApple();
}

[size=medium][color=blue]这种类适配器不适合在实际运用 因为它采用类似“多继承”的实现方式，带来了不良的高耦合，最好用对象适配器 因为它采用“对象组合”的方式，更符合松耦合[/color][/size]
下面看个简单的对象适配器实例

public interface Brower
{
	public void request();
}

public class IEBrowerAdaptee
{
	public void sprcificRequest(){};
}

public class BrowerAdapter implements Brower
{
	public BrowerAdapter(IEAdaptee adaptee){
		super();
		this.adaptee = adaptee;
	}

	public void request(){
		adaptee.specificRequest();
	}

	private IEAdaptee adaptee;
}