适配模式
在下图中可以看出,Adaptee类并没有sampleOperation2()方法,而客户端则期待这个方法。为使客户端能够使用Adaptee类,提供一个中间环节,即类Adapter,把Adaptee的API与Target类的API衔接起来。Adapter与Adaptee是继承关系。
interface Target{
// Adaptee有这个方法
void sampleOperation1();
// Adaptee没有这个方法
void sampleOperation2();
}
class Adaptee{
public void sampleOperation1(){}
}
class Adapter extends Adaptee implements Target{
public void sampleOperation2(){}
}
这好比ADSL,用户想通过电话线上网,但是电话线不能直接接到电脑上,但用户就是想通过电话线上网,所以引入了调制解调器,调制解调器就是做适配器的作用。
组合模式
组合模式就比较简单了,以树型结构组成的层次关系,忽略组合对象与单个对象的不同,用户将统一地使用组合结构中的所有对象。
以文件和文件夹为例
abstract class Compoent{}
class File extends Compoent{
private String fileName;
}
class FileFolder extends Compoent{
private List<Compoment> files;
private String fileFolderName;
public void scan(){
for(component f:files){
if(f instanceof File){
System.out.println("File "+((File) f).filename);
}else if(f instanceof Folder){
Folder e = (Folder)f ;
System.out.println("Folder "+e.foldername);
e.scan();
}
}
}
}
桥接模式
它的主要特点是把抽象(Abstraction)与行为实现(Implementation)分离开来,从而可以保持各部分的独立性以及应对他们的功能扩展。
1.Client 调用端
这是Bridge模式的调用者。
2.抽象类(Abstraction)
抽象类接口(接口这货抽象类)维护队行为实现(implementation)的引用。它的角色就是桥接类。
3.Refined Abstraction
这是Abstraction的子类。
4.Implementor
行为实现类接口(Abstraction接口定义了基于Implementor接口的更高层次的操作)
5.ConcreteImplementor
Implementor的子类
interface Implementor{
// 定义其实现类必须实现的接口
public void operation();
}
public class ConcreateImplementorA implements Implementor{
public void operation(){}
}
public class ConcreateImplementorB implements Implementor{
public void operation(){}
}
// 桥接类
public abstract class Abstract{
private Implementor implementor;
public void setTmplementor(Implementor implementor){
this.implementor = implementor;
}
public void getTmplementor(){
return this.implementor;
}
protected viod operation(){
this.implementor.operation();
}
}
public class RefinedAbstraction extends Abstract{
protected void operation(){
super.getImplementor.operation();
}
}
装饰者模式
装饰模式指的是在不必改变原类文件和使用继承的情况下,动态地扩展一个对象的功能。它是通过创建一个包装对象,也就是装饰来包裹真实的对象。
interface Source{ void method();}
public class Decorator implements Source{
// 这是真实的对象
private Source source ;
public void decotate1(){
System.out.println("decorate");
}
// 这是包装类提供的包装方法
@Override
public void method() {
decotate1();
source.method();
}
}
代理模式
装饰模式应该为所装饰的对象增强功能;代理模式对代理的对象施加控制,并不提供对象本身的增强功能。
客户端通过代理类访问,代理类实现具体的实现细节,客户只需要使用代理类即可实现操作。
interface BuyHouse{ void buyHosue();}
class BuyHouseImpl implements BuyHouse{
@Override
public void buyHosue() {
}
}
class Proxy implements BuyHouse{
private BuyHouse buyHosue;
public void setBuyHouse(final BuyHouse buyHouse){
this.buyHouse = buyHouse;
}
@Override
public void buyHosue() {
System.out.println("买房前准备");
buyHosue.buyHosue();
System.out.println("买房前准备");
}
}
外观模式
用一个大外部接口统一操作各个子对象
public interface Shape {
void draw();
}
public class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("Rectangle::draw()");
}
}
public class Square implements Shape {
@Override
public void draw() {
System.out.println("Square::draw()");
}
}
public class Circle implements Shape {
@Override
public void draw() {
System.out.println("Circle::draw()");
}
}
public class ShapeMaker {
private Shape circle;
private Shape rectangle;
private Shape square;
public ShapeMaker() {
circle = new Circle();
rectangle = new Rectangle();
square = new Square();
}
public void drawCircle(){
circle.draw();
}
public void drawRectangle(){
rectangle.draw();
}
public void drawSquare(){
square.draw();
}
}
public class FacadePatternDemo {
public static void main(String[] args) {
ShapeMaker shapeMaker = new ShapeMaker();
shapeMaker.drawCircle();
shapeMaker.drawRectangle();
shapeMaker.drawSquare();
}
}
享元模式
使用共享对象的方法,用来尽可能减少内存使用量以及分享资讯。通常使用工厂类辅助,例子中使用一个HashMap类进行辅助判断,数据池中是否已经有了目标实例,如果有,则直接返回,不需要多次创建重复实例。
abstract class flywei{ }
public class Flyweight extends flywei{
Object obj ;
public Flyweight(Object obj){
this.obj = obj;
}
}
class FlyweightFactory{
private HashMap<Object,Flyweight> data;
public FlyweightFactory(){ data = new HashMap<>();}
public Flyweight getFlyweight(Object object){
if ( data.containsKey(object)){
return data.get(object);
}else {
Flyweight flyweight = new Flyweight(object);
data.put(object,flyweight);
return flyweight;
}
}
}