java学习笔记-设计模式7(适配器模式)

意图

  将一个类的接口转换成另外一个客户希望的接口。Adapter 模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

  主要分为三类:类的适配器模式、对象的适配器模式、接口的适配器模式。

1. 类的适配器模式

  有一个Source类,拥有一个方法,待适配,目标接口时Targetable,通过Adapter类,将Source的功能扩展到Targetable里.

public class Source {
	public void method1(){
		System.out.println("this is original method!");
	}
}
public interface Targetable {
	//和原类方法相同
	public void method1();
	//新的
	public void method2();
}
public class Adapter extends Source implements Targetable{

	@Override
	public void method2() {
		System.out.println("this is targetable method!");
	}
}

2. 对象的适配器模式

  基本思路和类的适配器模式相同,只是将Adapter类作修改,这次不继承Source类,而是持有Source类的实例,以达到解决兼容性的问题。

public class Wrapper implements Targetable{

	private Source source;

	public Wrapper(Source source){
		super();
		this.source = source;
	}

	@Override
	public void method1() {
		source.method1();
	}

	@Override
	public void method2() {
		System.out.println("this is the targetable method!");
	}

}

3. 接口的适配器模式

  当不希望实现一个接口中所有的方法时,可以创建一个抽象类Wrapper,实现所有方法,我们写别的类的时候,继承抽象类即可。

public abstract class Wrapper2 implements Targetable{

	@Override
	public void method1() { }

	@Override
	public void method2() {	}

}
public class SourceSub extends Wrapper2{

	@Override
	public void method1() {
		System.out.println("this is first method!");
	}
}

  转自:http://blog.csdn.net/zhangerqing/article/details/8239539

时间: 2024-09-30 00:45:36

java学习笔记-设计模式7(适配器模式)的相关文章

Java学习笔记——设计模式之一简单工厂

蜀道之难.难于上青天,侧身西望长咨嗟 --蜀道难 设计模式第一篇,简单工厂. 定义Operation类 1 package cn.no1.simplefactory; 2 3 public abstract class Operation { 4 5 private double numA; 6 private double numB; 7 8 public double getNumA() { 9 return numA; 10 } 11 12 13 public void setNumA(d

JAVA学习笔记-----设计模式之工厂模式

1.设计模式---------->工厂模式: Sender.java package me.ele.mytest; public interface Sender {    public void send(); } 2.MailSend package me.ele.mytest; public class MailSend implements Sender {     @Override     public  void send()     {         System.out.pr

Java学习笔记——设计模式之十.观察者模式

 观察者模式(Observer),定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个主题对象.这个主题对象在状态发生变化时,会通知所有观察者对象,使他们能够自动更新自己. Subject类: 1 package cn.happy.design_pattern._10publishsubscribe; 2 3 import java.util.ArrayList; 4 import java.util.List; 5 6 public class Subject { 7 8 private

Java学习笔记——设计模式之九.建造者模式

 建造者模式(Builder),将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示. Product类: 1 package cn.happy.design_pattern._09builder; 2 3 import java.util.ArrayList; 4 import java.util.List; 5 6 public class Product { 7 8 List<String> parts = new ArrayList<>(); 9 10

Java学习笔记——设计模式之五.工厂方法

水边一只青蛙在笑 --石头和水 工厂方法模式(Factory Method),定义了一个用于创建对象的接口,让实现类决定实例化哪一个类.工厂方法使一个类的实例化延迟到其子类. 这里在简单和工厂的基础上写工厂: 先定义一个接口 1 package cn.no5.factorymethod; 2 3 import cn.no1.simplefactory.Operation; 4 5 public interface IFactory { 6 7 Operation CreateOperation(

Java学习笔记——设计模式之六.原型模式(浅克隆和深克隆)

That there's some good in this world, Mr. Frodo. And it's worth fighting for. 原型模式(prototype),用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象. 至于Object.clone()这里就不赘述了.文档看起来可能有些难懂,直接上代码反而更容易理解: 浅克隆: 1 package cn.happy.design_pattern._06prototype.shallowclone; 2 3 pub

java学习笔记-设计模式16(观察者模式)

意图 定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时, 所有依赖于它的对象都得到通知并被自动更新. public interface Observer { public void update(); } public class Observer1 implements Observer { @Override public void update() { System.out.println("observer1 has received!"); } } public

java学习笔记-设计模式20(备忘录模式)

意图 在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态.这样以后就可将该对象恢复到保存的状态. public class Original { private String value; public String getValue() { return value; } public void setValue(String value) { this.value = value; } public Original(String value) { this.valu

java学习笔记-设计模式18(职责链模式)

意图 使多个对象都有机会处理请求,从而避免请求的发送者和接收者之间的耦合关系.将这些对象连成一条链,并沿着这条链传递该请求,直到有一个对象处理它为止. public interface Handler { public void operator(); } public abstract class AbstractHandler { private Handler handler; public Handler getHandler() { return handler; } public v