Java设计模式系列5-----组合模式,桥接模式,适配器模式

1.组合模式

Composite模式也叫组合模式,是构造型的设计模式之一.通过递归手段来构造树形的形象结构,并可以通过一个对象来访问整个对象树.

Component （树形结构的节点抽象）

• 为所有的对象定义统一的接口（公共属性，行为等的定义）
• 提供管理子节点对象的接口方法
• [可选]提供管理父节点对象的接口方法

Leaf （树形结构的叶节点）
Component的实现子类
Composite（树形结构的枝节点）
Component的实现子类

import java.util.List;

/*
 * 文件节点抽象(是文件和目录的父类)
 */
public interface IFile {
	
	//显示文件或者文件夹的名称
	public void display();
	
	//添加
	public boolean add(IFile file);
	
	//移除
	public boolean remove(IFile file);
	
	//获得子节点
	public List getChild();
}
import java.util.List;


public class File implements IFile {
	private String name;
	
	public File(String name) {
		this.name = name;
	}
	

	public void display() {
		System.out.println(name);
	}

	public List getChild() {
		return null;
	}


	public boolean add(IFile file) {
		return false;
	}

	public boolean remove(IFile file) {
		return false;
	}

}
import java.util.ArrayList;
import java.util.List;


public class Folder implements IFile{
	private String name;
	private List children;
	
	public Folder(String name) {
		this.name = name;
		children = new ArrayList();
	}
	

	public void display() {
		System.out.println(name);
	}

	public List getChild() {
		return children;
	}


	public boolean add(IFile file) {
		return children.add(file);
	}


	public boolean remove(IFile file) {
		return children.remove(file);
	}


}
import java.util.List;


public class MainClass {
	public static void main(String[] args) {
		//C盘
		Folder rootFolder = new Folder("C:");
		//beifeng目录
		Folder beifengFolder = new Folder("beifeng");
		//beifeng.txt文件
		File beifengFile = new File("beifeng.txt");
		
		rootFolder.add(beifengFolder);
		rootFolder.add(beifengFile);
		
		//ibeifeng目录
		Folder ibeifengFolder = new Folder("ibeifeng");
		File ibeifengFile = new File("ibeifeng.txt");
		beifengFolder.add(ibeifengFolder);
		beifengFolder.add(ibeifengFile);
		
		Folder iibeifengFolder = new Folder("iibeifeng");
		File iibeifengFile = new File("iibeifeng.txt");
		ibeifengFolder.add(iibeifengFolder);
		ibeifengFolder.add(iibeifengFile);
		
		displayTree(rootFolder,0);
		
	}
	
	public static void displayTree(IFile rootFolder, int deep) {
		for(int i = 0; i < deep; i++) {
			System.out.print("--");
		}
		//显示自身的名称
		rootFolder.display();
		//获得子树
		List children = rootFolder.getChild();
		//遍历子树
		for(IFile file : children) {
			if(file instanceof File) {
				for(int i = 0; i <= deep; i++) {
					System.out.print("--");
				}
				file.display();
			} else {
				displayTree(file,deep + 1);
			}
		}
	}
}

2.桥接模式

Bridge 模式又叫做桥接模式，是构造型的设计模式之一。Bridge模式基于类的最小设计原则，通过使用封装，聚合以及继承等行为来让不同的类承担不同的责任。它的主要特点是把抽（abstraction）与行为实现（implementation）分离开来，从而可以保持各部分的独立性以及应对它们的功能扩展。

桥接模式的角色和职责
Client: Bridge模式的使用者
Abstraction: 抽象类接口（接口或抽象类）, 维护对行为实现（Implementor）的引用
Refined Abstraction:Abstraction子类
Implementor:行为实现类接口 (Abstraction接口定义了基于Implementor接口的更高层次的操作)
ConcreteImplementor: Implementor子类

package com.ibeifeng.eg3;

public abstract class Car {
	private Engine engine;
	
	public Car(Engine engine) {
		this.engine = engine;
	}
	
	public Engine getEngine() {
		return engine;
	}

	public void setEngine(Engine engine) {
		this.engine = engine;
	}

	public abstract void installEngine();
}
package com.ibeifeng.eg3;

public class Bus extends Car{

	public Bus(Engine engine) {
		super(engine);
	}

	public void installEngine() {
		System.out.print("Bus：");
		this.getEngine().installEngine();
	}
}
package com.ibeifeng.eg3;

public class Jeep extends Car {

	public Jeep(Engine engine) {
		super(engine);
	}

	public void installEngine() {
		System.out.print("Jeep：");
		this.getEngine().installEngine();
	}

}
package com.ibeifeng.eg3;

public interface Engine {
	public void installEngine();
}
package com.ibeifeng.eg3;

public class Engine2000 implements Engine {

	public void installEngine() {
		System.out.println("安装2000cc发动机");
	}

}
package com.ibeifeng.eg3;

public class Engine2200 implements Engine{

	public void installEngine() {
		System.out.println("安装2200cc发动机");
	}

}
package com.ibeifeng.eg3;

public class MainClass {
	public static void main(String[] args) {
		
		Engine engine2000 = new Engine2000();
		Engine engine2200 = new Engine2200();
		
		Car car1 = new Bus(engine2000);
		car1.installEngine();
		
		Car car2 = new Bus(engine2200);
		car2.installEngine();
		
		Car jeep1 = new Jeep(engine2000);
		jeep1.installEngine();
		
		Car jeep2 = new Jeep(engine2200);
		jeep2.installEngine();
		
	}
}

3.适配器模式

Adapter模式也叫适配器模式，是构造型模式之一，通过Adapter模式可以改变已有类（或外部类）的接口形式。
适配器模式应用场景
在大规模的系统开发过程中，我们常常碰到诸如以下这些情况：我们需要实现某些功能，这些功能已有还不太成熟的一个或多个外部组件，如果我们自己重新开发这些功能会花费大量时间；所以很多情况下会选择先暂时使用外部组件，以后再考虑随时替换。但这样一来，会带来一个问题，随着对外部组件库的替换，可能需要对引用该外部组件的源代码进行大面积的修改，因此也极可能引入新的问题等等。如何最大限度的降低修改面呢？Adapter模式就是针对这种类似需求而提出来的。Adapter模式通过定义一个新的接口（对要实现的功能加以抽象），和一个实现该接口的Adapter（适配器）类来透明地调用外部组件。这样替换外部组件时，最多只要修改几个Adapter类就可以了，其他源代码都不会受到影响。
适配器模式的结构
1.通过继承实现Adapter

2.通过委让实现Adapter

public class Adapter extends Current{
	public void use18V() {
		System.out.println("使用适配器");
		this.use220V();
	}
}

public class Adapter2 {
	private Current current;
	
	public Adapter2(Current current) {
		this.current = current;
	}
	
	public void use18V() {
		System.out.println("使用适配器");
		this.current.use220V();
	}
}

public class Current {
	
	public void use220V() {
		System.out.println("使用220V电流");
	}
}

public class MainClass {
	public static void main(String[] args) {
//		Current current = new Current();
//		current.use220V();
		
//		Adapter adapter = new Adapter();
//		adapter.use18V();
		
		Adapter2 adapter = new Adapter2(new Current());
		adapter.use18V();
	}
}