java中的设计模式 - 七个结构型模式（完整代码实现）

目录

适配器模式

     电压代码实现：

桥接模式

 代码实现

组合模式

 代码实现：

装饰模式

 代码实现：

外观模式

      子系统调用代码实现：

享元模式

代码实现

代理模式

汽车代理代码实现：

• 适配器模式

适配器模式 (Adapter Pattern) ：将一个接口转换成客户希望的另一个接口，使接口不兼容的那些

类可以一起工作，其别名为包装器 (Wrapper) 。适配器模式既可以作为类结构型模式，也可以作为对

象结构型模式。

 类适配器，对象适配器，接口适配器

     电压代码实现：

package com.zz.db.mysql.config.study.adapter;

/**
 * 类说明
 *
 * @author Zeng zhiqiang
 * @version V1.0 创建时间: 2021/4/25 16:22
 * Copyright 2021 by WiteMedia
 */
public class Adapter implements Voltage {

    private HighVoltage highVoltage;

    public Adapter(HighVoltage highVoltage){
        this.highVoltage = highVoltage;
    }

    @Override
    public void charge() {
        highVoltage.charge();
        System.out.println("转化为5V");
    }
}


package com.zz.db.mysql.config.study.adapter;

/**
 * 类说明
 *
 * @author Zeng zhiqiang
 * @version V1.0 创建时间: 2021/4/25 16:31
 * Copyright 2021 by WiteMedia
 */
public class AdapterTest {

    public static void main(String[] args) {

        Phone phone = new Phone();
        //高电压
        HighVoltage highVoltage = new HighVoltage();
        //将高电压转换为低电压
        Adapter adapter = new Adapter(highVoltage);
        //在低电压上冲或变压器上充电
        phone.charging(adapter);
    }
}



package com.zz.db.mysql.config.study.adapter;

/**
 * 类说明
 *
 * @author Zeng zhiqiang
 * @version V1.0 创建时间: 2021/4/25 16:17
 * Copyright 2021 by WiteMedia
 */
public class HighVoltage implements Voltage {

    private  final int num = 220;
    @Override
    public void charge() {
        System.out.println("我的电压是" + num);
    }

}



package com.zz.db.mysql.config.study.adapter;

/**
 * 类说明
 *
 * @author Zeng zhiqiang
 * @version V1.0 创建时间: 2021/4/25 16:31
 * Copyright 2021 by WiteMedia
 */
public class Phone {


    public void charging(Voltage voltage){
        System.out.println("i am phone");
        voltage.charge();
    }
}


package com.zz.db.mysql.config.study.adapter;

//电压
public interface  Voltage {
    public void charge();
}

 

• 桥接模式

桥接模式是一种很实用的结构型设计模式，如果软件系统中某个类存在两个独立变化的维度，通过该

模式可以将这两个维度分离出来，使两者可以独立扩展，让系统更加符合 “ 单一职责原则 ” 。与多层继

承方案不同，它将两个独立变化的维度设计为两个独立的继承等级结构，并且在抽象层建立一个抽象

关联，该关联关系类似一条连接两个独立继承结构的桥，故名桥接模式。

 

桥接模式 (Bridge Pattern) ：将抽象部分与它的实现部分分离，使它们都可以独立地变化。它是一

种对象结构型模式，又称为柄体 (Handle and Body) 模式或接口 (Interface) 模式。

 

 代码实现

 Image 定义对象，ImageImpl定义对对象的操作

package com.yinjun.bridgepattern;

public class Client {
    public static void main(String args[]){
        Image image;
        Image image2;
        ImageImpl imp;
        image = (Image) XMLUtil.getBean("image");
        //相当于创建了一个子类对象
        image2 = new PNGImage();
        imp = (ImageImpl) XMLUtil.getBean("os");
        image.setImageImpl(imp);
        image.parseFile("我老婆小龙女");

        image2.setImageImpl(imp);
        image2.parseFile("我另一个老婆");
    }
}

<?xml version="1.0"  ?>
<config>
    <!--RefinedAbstraction-->
    <className>JPGImage</className>
    <!--ConcreteImplementor-->
    <className>WindowsImpl</className>
</config>




package com.yinjun.bridgepattern;

//抽象图像类：抽象类
abstract class Image {
    protected ImageImpl impl;
    public void setImageImpl(ImageImpl impl){
        this.impl = impl;
    }

    public abstract void parseFile(String fileName);
}



package com.yinjun.bridgepattern;

//抽象操作系统实现类：实现类接口
public interface ImageImpl {
    //显示像素矩阵m
    public void doPaint(Matrix m);
}



package com.yinjun.bridgepattern;
//JPG格式图像：扩充抽象类
public class JPGImage extends Image {
    @Override
    public void parseFile(String fileName) {
        //模拟解析JPG文件并获得一个像素矩阵对象m;
        Matrix m = new Matrix();
        impl.doPaint(m);
        System.out.println(fileName + "，格式为JPG。");
    }
}




package com.yinjun.bridgepattern;
//Linux操作系统实现类：具体实现类
public class LiunxImpl implements ImageImpl{
    public void doPaint(Matrix m){
        System.out.println("在Linux操作系统中显示图像");
    }
}



package com.yinjun.bridgepattern;

//像素矩阵类：辅助类，各种格式的文件最终都被转化为像素矩阵，不同的操作系统提供不同的方式显示像素矩阵
public class Matrix {

    public Matrix() {
        System.out.println("像素矩阵类：辅助类，各种格式的文件最终都被转化为像素矩阵，不同的操作系统提供不同的方式显示像素矩阵");
    }
}




package com.yinjun.bridgepattern;
//PNG格式图像：扩充抽象类
public class PNGImage extends Image {
    @Override
    public void parseFile(String fileName) {
        //模拟解析PNG文件并获得一个像素矩阵对象m;
        Matrix m = new Matrix();
        impl.doPaint(m);
        System.out.println(fileName + "，格式为PNG。");
    }
}



package com.yinjun.bridgepattern;

//Windows操作系统实现类：具体实现类
public class WindowsImpl implements ImageImpl{
    public void doPaint(Matrix m){
        //调用Windows系统的绘制函数绘制像素矩阵
        System.out.println("在Windows操作系统中显示图像");
    }
}



package com.yinjun.bridgepattern;



import org.w3c.dom.*;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import java.io.File;


public class XMLUtil {
    //该方法用于从XML配置文件中提取具体类类名，并返回一个实例对象
    //运用反射创建对象
    public static Object getBean(String args){
        DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();
        try {
            DocumentBuilder builder = dFactory.newDocumentBuilder();
            Document doc;
            doc = builder.parse(new File("src/com/yinjun/bridgepattern/config.xml"));
            NodeList nl=null;
            Node classNode=null;
            String cName=null;
            nl = doc.getElementsByTagName("className");
            if(args.equals("image")) {
                classNode=nl.item(0).getFirstChild();
            }else if(args.equals("os")) {
                classNode=nl.item(1).getFirstChild();
            }
            cName=classNode.getNodeValue();
            //com.yinjun.bridgepattern.JPGImage
            Class c=Class.forName("com.yinjun.bridgepattern." + cName);
            Object obj=c.newInstance();
            return obj;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

 

• 组合模式

组合模式 (Composite Pattern) ：组合多个对象形成树形结构以表示具有 “ 整体 — 部分 ” 关系的层次

结构。组合模式对单个对象（即叶子对象）和组合对象（即容器对象）的使用具有一致性，组合模式

又可以称为 “ 整体 — 部分 ”(Part-Whole) 模式，它是一种对象结构型模式。

 可以参考文件夹的结构模式

 代码实现：

 

package com.yinjun.compositepattern;
//抽象文件类：抽象构件
abstract class AbstractFile {
    public abstract void add(AbstractFile file);
    public abstract void move(AbstractFile file);
    public abstract AbstractFile getChild(int i);
    public abstract void killVirus();
}




package com.yinjun.compositepattern;

public class Client {
    public static void main(String args[]){
        //针对抽象构件编程
        //面向接口编程，不是面向实现编程
        AbstractFile file1,file2,folder1,folder2;

        folder1 = new Folder("我的文件夹");
        folder2 = new Folder("图像文件夹");


        file1 = new ImageFile("小龙女.jpg");
        file2 = new ImageFile("张无忌.gif");

        folder1.add(file1);
        folder2.add(file2);

        folder1.add(folder2);

        folder1.killVirus();
    }
}





package com.yinjun.compositepattern;

import java.util.ArrayList;

//文件夹类：容器构件
public class Folder extends AbstractFile{

    private String name;
    //定义集合fileList，用于存储AbstractFile类型的成员
    private ArrayList<AbstractFile> fileList = new ArrayList<>();

    public Folder(String name){
        this.name = name;
    }

    @Override
    public void add(AbstractFile file) {
        fileList.add(file);
    }

    @Override
    public void move(AbstractFile file) {
        fileList.remove(file);
    }

    @Override
    public AbstractFile getChild(int i) {
        return fileList.get(i);
    }

    @Override
    public void killVirus() {
        System.out.println("****对文件夹'" + name + "'进行杀毒");
        //递归调用成员构件的killVirus()方法
        fileList.forEach(f->f.killVirus());
    }
}



package com.yinjun.compositepattern;

//图像文件类：叶子构件
public class ImageFile extends AbstractFile {

    private String name;

    public ImageFile(String name){
        this.name = name;
    }


    @Override
    public void add(AbstractFile file) {
        System.out.println("对不起，不支持该方法！");
    }

    @Override
    public void move(AbstractFile file) {
        System.out.println("对不起，不支持该方法！");
    }

    @Override
    public AbstractFile getChild(int i) {
        System.out.println("对不起，不支持该方法！");
        return null;
    }

    @Override
    public void killVirus() {
        System.out.println("----对图像文件'" + name + "'进行杀毒");
    }
}

 

• 装饰模式

装饰模式 (Decorator Pattern) ：动态地给一个对象增加一些额外的职责，就增加对象功能来说，

装饰模式比生成子类实现更为灵活。装饰模式是一种对象结构型模式。

 

 代码实现：

 

package com.yinjun.decoratorpattern;

public class BlackBorderDecorator extends ComponentDecorator {

    public BlackBorderDecorator(Component component) {
        super(component);
    }

    public void setBlackBorderDecorator(){
        System.out.println("为构件增加黑色边框！");
    }

    @Override
    public void display() {
        this.setBlackBorderDecorator();
        super.display();
    }
}




package com.yinjun.decoratorpattern;

public class Client {

    public static void  main(String args[]){

        //使用抽象构件定义
        Component component,componentSB,componentSBB;
        //定义具体构件
        component = new Window();
        //定义装饰后的构件
         componentSB = new ScrollBarDecorator(component);
        componentSB.display();

//将装饰了一次之后的对象继续注入 到另一个装饰类中，进行第二次装饰
        componentSBB  = new BlackBorderDecorator(componentSB);
        componentSBB.display();


    }

}



package com.yinjun.decoratorpattern;
//抽象界面构件类：抽象构件类，为了突出与模式相关的核心代码，对原有控件代码进行了大量的简化
abstract class Component {
    public abstract void display();
}




package com.yinjun.decoratorpattern;
//构件装饰类：抽象装饰类
public class ComponentDecorator extends Component {
    //维持对抽象构件类型对象的引用
    private Component component;


    public ComponentDecorator(Component component){
        this.component = component;
    }

    @Override
    public void display() {
        component.display();
    }
}






package com.yinjun.decoratorpattern;
//滚动条装饰类：具体装饰类
public class ScrollBarDecorator extends ComponentDecorator {

    public ScrollBarDecorator(Component component) {
        super(component);
    }

    public void display(){
        this.setScrollbar();
        super.display();
    }

    public void setScrollbar(){
        System.out.println("为构件增加滚动条！");
    }
}






package com.yinjun.decoratorpattern;
//文本框类：具体构件类
public class TextBox extends Component {

    public void display(){
        System.out.println("显示文本框！");
    }
}






package com.yinjun.decoratorpattern;
//窗体类：具体构件类
public class Window extends Component {

    public void display(){
        System.out.println("显示窗体！");
    }
}

 

• 外观模式

外观模式是一种使用频率非常高的结构型设计模式，它通过引入一个外观角色来简化客户端与子系统

之间的交互，为复杂的子系统调用提供一个统一的入口，降低子系统与客户端的耦合度，且客户端调

用非常方便。

外观模式：为子系统中的一组接口提供一个统一的入口。外观模式定义了一个高层接口，这个接口使

得这一子系统更加容易使用

对不同对象的方法进行组合，对外提供一个接口即可 

      子系统调用代码实现：

 

package com.zz.db.mysql.config.study.shap;

/**
 * 类说明
 *
 * @author Zeng zhiqiang
 * @version V1.0 创建时间: 2021/4/26 14:47
 * Copyright 2021 by WiteMedia
 */
public class ClassOne {

    public void  domethod(){
        System.out.println("class one method run .....");
    }
}


package com.zz.db.mysql.config.study.shap;

/**
 * 类说明
 *
 * @author Zeng zhiqiang
 * @version V1.0 创建时间: 2021/4/26 14:49
 * Copyright 2021 by WiteMedia
 */
public class ClassThree {


    public void  domethod(){
        System.out.println("class three method run .....");
    }
}
  

package com.zz.db.mysql.config.study.shap;

/**
 * 类说明
 *
 * @author Zeng zhiqiang
 * @version V1.0 创建时间: 2021/4/26 14:48
 * Copyright 2021 by WiteMedia
 */
public class ClassTwo {


    public void  domethod(){
        System.out.println("class two method run .....");
    }
}



package com.zz.db.mysql.config.study.shap;

/**
 * 类说明
 *
 * @author Zeng zhiqiang
 * @version V1.0 创建时间: 2021/4/26 14:49
 * Copyright 2021 by WiteMedia
 */
public class Fade {


    private ClassOne one;

    private ClassTwo classTwo;

    private ClassThree classThree;


    public Fade(ClassOne one, ClassTwo classTwo, ClassThree classThree) {
        this.one = one;
        this.classTwo = classTwo;
        this.classThree = classThree;
    }


    public void runMehod1(){
        one.domethod();
        classThree.domethod();
    }



    public void runMehod2(){
        one.domethod();
        classTwo.domethod();
        classThree.domethod();
    }

}


package com.zz.db.mysql.config.study.shap;

/**
 * 类说明
 *
 * @author Zeng zhiqiang
 * @version V1.0 创建时间: 2021/4/26 14:53
 * Copyright 2021 by WiteMedia
 */
public class FadeTest {

    public static void main(String[] args) {
        Fade fade = new Fade(new ClassOne(),new ClassTwo(),new ClassThree());
        fade.runMehod1();
        fade.runMehod2();
    }
}

 

• 享元模式

当一个软件系统在运行时产生的对象数量太多，将导致运行代价过高，带来系统性能下降等问题。例

如在一个文本字符串中存在很多重复的字符，如果每一个字符都用一个单独的对象来表示，将会占用

较多的内存空间，那么我们如何去避免系统中出现大量相同或相似的对象，同时又不影响客户端程序

通过面向对象的方式对这些对象进行操作？享元模式正为解决这一类问题而诞生。享元模式通过共享

技术实现相同或相似对象的重用，在逻辑上每一个出现的字符都有一个对象与之对应，然而在物理上

它们却共享同一个享元对象，这个对象可以出现在一个字符串的不同地方，相同的字符对象都指向同

一个实例，在享元模式中，存储这些共享实例对象的地方称为享元池 (Flyweight Pool) 。我们可以

针对每一个不同的字符创建一个享元对象，将其放在享元池中，需要时再从享元池取出

 

 

享元模式 (Flyweight Pattern) ：运用共享技术有效地支持大量细粒度对象的复用。系统只使用少量的对象，而这些对象都很相

似，状态变化很小，可以实现对象的多次复用。由于享元模式要求能够共享的对象必须是细粒度对象，因此它又称为轻量级模式，它

是一种对象结构型模式

 

String 的内部实现，享元模式

 

 

 

 

 

代码实现

package com.yinjun.Flyweightpattern;
//黑色棋子类：具体享元类
public class BlackIgoChessman  extends IgoChessman{

    @Override
    public String getColor() {
        return "黑色";
    }
}



package com.yinjun.Flyweightpattern;

public class Client {
    public static void main(String args[]){

        IgoChessman black1,black2,white1,white2;

        IgoChessmanFactory factory;

        //获取享元工厂对象
        factory = IgoChessmanFactory.getInstance();


        //通过享元工厂获取三颗黑子
        black1 = factory.getIgoChessman("b");
        black2 = factory.getIgoChessman("b");

        System.out.println("判断两颗黑子是否相同：" + (black1==black2));

        white1 = factory.getIgoChessman("w");
        white2 = factory.getIgoChessman("w");

        System.out.println("判断两颗白子是否相同：" + (white1==white2));

        black1.display(new Coordinates(2,9));

        white1.display(new Coordinates(6,9));


    }
}





package com.yinjun.Flyweightpattern;

public class Coordinates {

    private int x;

    private int y;

    public Coordinates(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }

}



package com.yinjun.Flyweightpattern;
//围棋棋子类：抽象享元类
abstract class IgoChessman {

    public abstract String getColor();

    public void display(Coordinates coord){
        System.out.println("棋子颜色：" + this.getColor() + "，棋子位置：" + coord.getX() + "，" + coord.getY() );

    }
}






package com.yinjun.Flyweightpattern;

import java.util.Hashtable;
//围棋棋子工厂类：享元工厂类，使用单例模式进行设计
public class IgoChessmanFactory {

    private static IgoChessmanFactory instance = new IgoChessmanFactory();
    //使用Hashtable来存储享元对象，充当享元池
    private static Hashtable ht;

    private IgoChessmanFactory(){
        ht = new Hashtable();
        IgoChessman black,white;
        black = new BlackIgoChessman();
        ht.put("b",black);
        white = new WhiteIgoChessman();
        ht.put("w",white);
    }

    //返回享元工厂类的唯一实例
    public static IgoChessmanFactory getInstance() {
        return instance;
    }


    //通过key来获取存储在Hashtable中的享元对象
    public static IgoChessman getIgoChessman(String color){
        return (IgoChessman)ht.get(color);
    }
}







package com.yinjun.Flyweightpattern;

public class JDKStringClient {


    //JDK类库中的String类使用了享元模式，我们通过如下代码来加以说明：
    public static void main(String args[]){

        String str1 = "abcd";
        String str2 = "abcd";
        String str3 = "ab" + "cd";
        String str4 = "ab";
        str4 += "cd";


        System.out.println(str1 == str2);
        System.out.println(str1 == str3);
        System.out.println(str1 == str4);


        str2 += "e";
        System.out.println(str1 == str2);

//        true 统一个对象
//        true 先编译后存储，也是一个对象
//        false 初始值不一样，先创建对象，后改变
//        false 复制了一个原有的对象，进行改变，对象不一致

        //关于Java String类这种在修改享元对象时，先将原有对象复制一份，
        // 然后在新对象上再实施修改操作的机制称为“Copy On Write”，
        // 大家可以自行查询相关资料来进一步了解和学习“Copy On Write”机制，在此不作详细说明。

    }
}






package com.yinjun.Flyweightpattern;
//白色棋子类：具体享元类
public class WhiteIgoChessman  extends IgoChessman{
    @Override
    public String getColor() {
        return  "白色";
    }
}

 

 

• 代理模式

代理模式是常用的结构型设计模式之一，当无法直接访问某个对象或访问某个对象存在困难时可以通

过一个代理对象来间接访问，为了保证客户端使用的透明性，所访问的真实对象与代理对象需要实现

相同的接口。根据代理模式的使用目的不同，代理模式又可以分为多种类型，例如保护代理、远程代

理、虚拟代理、缓冲代理等，它们应用于不同的场合，满足用户的不同需求。

代理模式：给某一个对象提供一个代理或占位符，并由代理对象来控制对原对象的访问。

 

汽车代理代码实现：

静态代理：

 

package com.zz.db.mysql.config.study.staticproxy;

/**
 * 类说明
 *
 * @author Zeng zhiqiang
 * @version V1.0 创建时间: 2021/4/26 15:18
 * Copyright 2021 by WiteMedia
 */
public class CarProxy implements ICar {

    private ICarImpl iCar;

    public CarProxy(ICarImpl iCar){
        this.iCar  = iCar;
    }

    @Override
    public void makeCar() {
        iCar.makeCar();
    }
}


package com.zz.db.mysql.config.study.staticproxy;

/**
 * 类说明
 *
 * @author Zeng zhiqiang
 * @version V1.0 创建时间: 2021/4/26 15:19
 * Copyright 2021 by WiteMedia
 */
public class CarTest {
    public static void main(String[] args) {
        CarProxy carProxy = new CarProxy(new ICarImpl());
        carProxy.makeCar();
    }
}


package com.zz.db.mysql.config.study.staticproxy;

/**
 * 类说明
 *
 * @author Zeng zhiqiang
 * @version V1.0 创建时间: 2021/4/26 15:17
 * Copyright 2021 by WiteMedia
 */
public interface ICar {

    void makeCar();
}



package com.zz.db.mysql.config.study.staticproxy;

/**
 * 类说明
 *
 * @author Zeng zhiqiang
 * @version V1.0 创建时间: 2021/4/26 15:18
 * Copyright 2021 by WiteMedia
 */
public class ICarImpl implements ICar {
    @Override
    public void makeCar() {
        System.out.println("i make a car");
    }
}

动态代理：

链接地址：

https://blog.csdn.net/zzqtty/article/details/115947908?spm=1001.2014.3001.5501

 

 

最后

以上就是傲娇巨人为你收集整理的java中的设计模式 - 七个结构型模式（完整代码实现）的全部内容，希望文章能够帮你解决java中的设计模式 - 七个结构型模式（完整代码实现）所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。