1、适配器模式

两个不兼容接口间的桥梁，使得那些原本由于接口不兼容不能一起工作的那些类可以一起工作。将一个接口转换成客户希望的另一个接口。属于结构型模式。

播放器和高级播放器接口

public interface MediaPlayer {    public void play(String audioType,String fileName);}

public interface AdvancedMediaPlayer {    public void playVlc(String fileName);    public void playMP4(String fileName);}

实现高级播放器

public class VlcPlayer implements AdvancedMediaPlayer {    @Override    public void playVlc(String fileName) {        System.out.println("Playing vlc file: "+fileName);    }    @Override    public void playMP4(String fileName) {        //System.out.println();    }}

public class Mp4Player implements AdvancedMediaPlayer {    @Override    public void playVlc(String fileName) {        //    }    @Override    public void playMP4(String fileName) {        System.out.println("Playing MP4 file: "+fileName);    }}

创建实现了播放器接口的适配器类

public class MediaAdapter implements MediaPlayer {    AdvancedMediaPlayer advancedMediaPlayer;    public MediaAdapter(String audioType) {        if (audioType.equalsIgnoreCase("vlc")){            advancedMediaPlayer = new VlcPlayer();        }else if (audioType.equalsIgnoreCase("mp4")){            advancedMediaPlayer = new Mp4Player();        }    }    @Override    public void play(String audioType, String fileName) {        if (audioType.equalsIgnoreCase("vld")){            advancedMediaPlayer.playVlc(fileName);        }else if (audioType.equalsIgnoreCase("mp4")){            advancedMediaPlayer.playMP4(fileName);        }    }}

实现类播放器接口的实体类

public class AudioPlayer implements MediaPlayer {    MediaAdapter mediaAdapter;    @Override    public void play(String audioType, String fileName) {        //播放mp3音乐文件的内置支持        if (audioType.equalsIgnoreCase("mp3")){            System.out.println("Playing mp3 file: "+fileName);        }        //MediaAdapter提供了播放其他文件格式的支持        else if (audioType.equalsIgnoreCase("vlc")||audioType.equalsIgnoreCase("mp4")){            mediaAdapter = new MediaAdapter(audioType);            mediaAdapter.play(audioType,fileName);        }else {            System.out.println("Invalid media ."+audioType+" format not supported");        }    }}

使用MediaPlayer

public class Main {    public static void main(String[] args) {        AudioPlayer audioPlayer  = new AudioPlayer();        audioPlayer.play("mp3","哈哈");        audioPlayer.play("mp4","冰雪大冒险");        audioPlayer.play("vlc","mind me.");    }}

2、桥接模式

用于把抽象化和实现化解耦，使得二者可以独立变化。

创建桥接实现接口

public interface DrawAPI {    public void drawCircle(int radius,int x,int y);}

实现桥接接口的实现类

public class RedCircle implements DrawAPI {    @Override    public void drawCircle(int radius, int x, int y) {        System.out.println("Drawing circle: [color:red ,radius: "+radius+" ,x: "+x+" ,y: "+y+" ]");    }}

public class GreenCircle implements DrawAPI{    @Override    public void drawCircle(int radius, int x, int y) {        System.out.println("Drawing circle: [color:green ,radius: "+radius+" ,x: "+x+" ,y: "+y+" ]");    }}

使用桥接接口创建抽象类Shape

public abstract class Shape {    DrawAPI drawAPI;    public Shape(DrawAPI drawAPI) {        this.drawAPI = drawAPI;    }    public abstract void draw();}

创建Shape的实现类

public class Circle extends Shape {    private int x,y,radius;    public Circle(DrawAPI drawAPI, int x, int y, int radius) {        super(drawAPI);        this.x = x;        this.y = y;        this.radius = radius;    }    @Override    public void draw() {        drawAPI.drawCircle(x,y,radius);    }}

使用Shape和DrawAPI画出不同颜色的圆

public class Main {    public static void main(String[] args) {        Shape redCircle = new Circle(new RedCircle(),100,100,10);        Shape greenCircle = new Circle(new GreenCircle(),100,100,10);        redCircle.draw();        greenCircle.draw();    }}

3、装饰模式

允许向一个现有的对象添加一个新的功能，同时又不改变其结构。

接口以及实现类

public interface Shape {    public void draw();}

public class Rectangle implements Shape {    @Override    public void draw() {        System.out.println("Shape: Rectangle");    }}

public class Circle implements Shape {    @Override    public void draw() {        System.out.println("Shape: Circle");    }}

创建实现了Shape接口的抽象装饰类

public abstract class ShapeDecorator implements Shape {    protected Shape shape;    public ShapeDecorator(Shape shape) {        this.shape = shape;    }    @Override    public void draw() {        shape.draw();    }}

扩展了ShapeDecorator的实体装饰类

public class RedShapeDecorator extends ShapeDecorator {    public RedShapeDecorator(Shape shape) {        super(shape);    }        @Override    public void draw(){        shape.draw();        setRedBorder(shape);    }    public void setRedBorder(Shape shape){        System.out.println("Border color : Red");    }}

使用RedShapeDecorator 来装饰Shape对象

public class Main {    public static void main(String[] args) {        Shape circle = new Circle();        Shape redCircle = new RedShapeDecorator(new Circle());        Shape redRectangle = new RedShapeDecorator(new Rectangle());        System.out.println("Circle with normal border.");        circle.draw();        System.out.println("Circle with red border.");        redCircle.draw();        System.out.println("Rectangle of red border");        redRectangle.draw();    }}

4、外观模式

隐藏系统的复杂性，并向客户端提供了一个可以访问系统的接口。这种属于结构型模式，为子系统中的一组接口提供了一个一只界面，外观模式提供了一个高层接口，使得这一子系统更加容易使用。

创建一个接口以及其实现类

public interface Shape {    void draw();}

public class Rectangle implements Shape {    @Override    public void draw() {        System.out.println("Rectangle::draw()");    }}

public class Circle implements Shape {    @Override    public void draw() {        System.out.println("Circle::draw()");    }}

public class Square implements Shape {    @Override    public void draw() {        System.out.println("Square::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 Main {    public static void main(String[] args) {        ShapeMaker shapeMaker = new ShapeMaker();        shapeMaker.drawCircle();        shapeMaker.drawRectangle();        shapeMaker.drawSquare();    }}

5、享元模式

主要用于减少创建对象的数量，以减少内存占用和提高性能。属于结构型模式。

运用共享技术有效的支持大量细粒度的对象。

创建接口以及实现类

public interface Shape {    void draw();}

public class Circle implements Shape {    private String color;    private int x;    private int y;    private int radius;    public Circle(String color) {        this.color = color;    }    public void setX(int x) {        this.x = x;    }    public void setY(int y) {        this.y = y;    }    public void setRadius(int radius) {        this.radius = radius;    }    @Override    public void draw() {        System.out.println("Circle::draw() [color: "+color+",x: "+x+",y: "+y+",radius:"+radius);    }}

创建一个工厂，生成给定信息的实体类的对象

public class ShapeFactory {    private static final HashMap
    
      circleMap = new HashMap
     
      ();    public static HashMap
      
        getCircleMap(String color) {        Circle circle = (Circle) circleMap.get(color);        if(circle == null){            circle = new Circle(color);            circleMap.put(color,circle);            System.out.println("Creating circle of color: "+color);        }        return circleMap;    }}
      
     
    

使用工厂通过传递颜色信息来获取实体类对象

public class Main {    private static final String[] colors =new String[]{            "Red","Green","Blue","White","Black"    };    public static void main(String[] args) {        for (int i = 0; i < 20; i++) {            Circle circle = (Circle) ShapeFactory.getCircle(getRandomColor());            circle.setX(getRandomX());            circle.setY(getRandomY());            circle.setRadius(100);            circle.draw();        }    }    public static String  getRandomColor(){        return colors[(int) (Math.random()*colors.length)];    }    public static int getRandomX(){        return (int) (Math.random()*100);    }    public static int getRandomY(){        return (int) (Math.random()*100);    }}

6、代理模式

在代理模式中，一个类代表另一个。属于结构型模式。

为其他对象提供一种代理以控制对这个对象的访问。

创建接口和实现接口的实体类

public interface Image {    void display();}

public class RealImage implements Image {    private String fileName;    public RealImage(String fileName) {        this.fileName = fileName;        loadFromDisk(fileName);    }    private void loadFromDisk(String fileName) {        System.out.println("Loading :"+fileName);    }    @Override    public void display() {        System.out.println("Displaying: "+fileName);    }}

public class ProxyImage implements Image {    private String fileName;    private RealImage realImage;    public ProxyImage(String fileName) {        this.fileName = fileName;    }    @Override    public void display() {        if (realImage == null){            realImage = new RealImage(fileName);        }        realImage.display();    }}

被请求时，使用ProxyImage来获取RealImage对象

public class Main {    public static void main(String[] args) {        Image image = new ProxyImage("s.jpg");        //图像从磁盘加载        image.display();        System.out.println("");        //图像将无法从磁盘加载        image.display();    }}