Composite模式也叫组合模式,是构造型的设计模式之一.通过递归手段来构造树形的形象结构,并可以通过一个对象来访问整个对象树.
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<IFile> 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<IFile> 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<IFile> children;
public Folder(String name) {
this.name = name;
children = new ArrayList<IFile>();
}
public void display() {
System.out.println(name);
}
public List<IFile> 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<IFile> 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);
}
}
}
}
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();
}
}
Adapter模式也叫适配器模式，是构造型模式之一，通过Adapter模式可以改变已有类（或外部类）的接口形式。
适配器模式应用场景
在大规模的系统开发过程中，我们常常碰到诸如以下这些情况：我们需要实现某些功能，这些功能已有还不太成熟的一个或多个外部组件，如果我们自己重新开发这些功能会花费大量时间；所以很多情况下会选择先暂时使用外部组件，以后再考虑随时替换。但这样一来，会带来一个问题，随着对外部组件库的替换，可能需要对引用该外部组件的源代码进行大面积的修改，因此也极可能引入新的问题等等。如何最大限度的降低修改面呢？Adapter模式就是针对这种类似需求而提出来的。Adapter模式通过定义一个新的接口（对要实现的功能加以抽象），和一个实现该接口的Adapter（适配器）类来透明地调用外部组件。这样替换外部组件时，最多只要修改几个Adapter类就可以了，其他源代码都不会受到影响。
适配器模式的结构
1.通过继承实现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();
}
}