Java设计模式

胡萝卜i

已于 2022-11-21 19:51:22 修改

阅读量115

点赞数

分类专栏： java 文章标签：设计模式 java

于 2021-07-17 14:51:08 首次发布

本文链接：https://blog.csdn.net/weixin_48336487/article/details/118855726

版权

java 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

一、什么是设计模式？

设计模式（Design Pattern）是前辈们对代码开发经验的总结，是解决特定问题的一系列套路。它不是语法规定，而是一套用来提高代码可复用性、可维护性、可读性、稳健性以及安全性的解决方案。

1995 年，GoF（Gang of Four，四人组/四人帮）合作出版了《设计模式：可复用面向对象软件的基础》一书，共收录了 23 种设计模式，从此树立了软件设计模式领域的里程碑，人称「GoF设计模式」。

GoF 23

一种思维，一种态度，一种进步

创建型模式：
单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式。
结构型模式：
适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。
行为型模式：
模板方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式、访问者模式。

二、学习设计模式的意义

这 23 种设计模式的本质是面向对象设计原则的实际运用，是对类的封装性、继承性和多态性，以及类的关联关系和组合关系的充分理解。

正确使用设计模式具有以下有点：

可以提高程序员的思维能力，编程能力和设计能力。
使程序设计更加标准化、代码编制更加工程化，使软件开发效率大大提高，从而缩短软件的开发周期。
使设计的代码可重用性高、可读性强、可靠性高、灵活性好、可维护性强。

三、OOP七大原则

开闭原则：对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码；
里氏替换原则：子类可以扩展父类的功能,但不能改变父类原有的功能
依赖倒置原则：要面向接口编程，不要面向实现编程；
单一职责原则：一个类只负责一项职责；
接口隔离原则：要为各个类建立自己需要的专用接口；
迪米特法则：一个类对于其他类知道的越少越好，一个对象应当对其他对象尽可能少的了解,只和朋友通信，不和陌生人说话；
合成复用原则：尽量使用对象组合,其次再考虑使用继承关系来实现；

四、单例模式

1.饿汉式单例

package com.wcf.single;

/**
 * @Data:2021/7/17 23:52
 * @Author:胡萝卜
 */
//饿汉式单例
public class Hungry {
    private Hungry(){}
    private final static Hungry HUNGRY=new Hungry();
    public static Hungry getInstance(){
        return HUNGRY;
    }
}

2.懒汉式单例

package com.wcf.single;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;

/**
 * @Data:2021/7/17 23:54
 * @Author:胡萝卜
 */
//懒汉式单例
    //道高一尺魔高一丈
public class LazyMan {
    private static boolean huluobo=false;
    private LazyMan(){
        synchronized (LazyMan.class){
            if (huluobo==false){
                huluobo=true;
            }else {
                throw new RuntimeException("不要试图使用反射破坏异常");
            }

        }
    }
    private volatile static LazyMan lazyMan;
    //双重检测锁模式的 懒汉式单例  DCL懒汉式
    public static LazyMan getInstance(){
        if (lazyMan==null){
            synchronized (LazyMan.class){
                if (lazyMan==null){
                    lazyMan=new LazyMan();//不是一个原子性操作
                    /*
                    1.分配内存空间
                    2.执行构造方法，初始化对象
                    3.把这个对象指向这个空间
                     */
                }
            }
        }

        return lazyMan;
    }
    public static void main(String[] args) throws Exception{
     //反射
       /* LazyMan instance = LazyMan.getInstance();*/
        Field huluobo = LazyMan.class.getDeclaredField("huluobo");
        huluobo.setAccessible(true);
        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        LazyMan instance = declaredConstructor.newInstance();
        huluobo.set(instance,false);
        LazyMan instance2= declaredConstructor.newInstance();
        System.out.println(instance);
        System.out.println(instance2);
    }
}

3.静态内部类

package com.wcf.single;

/**
 * @Data:2021/7/18 0:06
 * @Author:胡萝卜
 */
//静态内部类
public class Holder {
    private Holder(){}
    public static Holder getInstance(){
        return InnerClass.HOLDER;
    }
    public static class InnerClass{
        private static final Holder HOLDER=new Holder();
    }
}

4.枚举

package com.wcf.single;

import java.lang.reflect.Constructor;

//enum是一个什么？本身也是一个类
public enum EnumSingle {
    INSTANCE;
    public EnumSingle getInstance(){
        return INSTANCE;
    }
}
class Test{
    public static void main(String[] args) throws Exception {
        EnumSingle instance = EnumSingle.INSTANCE;
        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class);
        declaredConstructor.setAccessible(true);
        EnumSingle instance2 = declaredConstructor.newInstance();
        System.out.println(instance);
        System.out.println(instance2);
    }
}

五、工厂模式

1.简单工厂模式

package com.wcf.factory.simple;

/**
 * @Data:2021/7/18 1:14
 * @Author:胡萝卜
 */
//简单工厂模式
public class CarFactory {
    //方法一
    public static Car getCar(String car){
        if (car.equals("五菱")){
            return new WuLing();
        }else if (car.equals("特斯拉")){
            return new Tesla();
        }else {
            return null;
        }
    }
    //方法二
    public static Car getWuling(){
        return new WuLing();
    }
    public static Car getTesla(){
        return new Tesla();
    }
}

package com.wcf.factory.simple;

/**
 * @Data:2021/7/18 1:07
 * @Author:胡萝卜
 */
public interface Car {
    void name();
}

package com.wcf.factory.simple;

/**
 * @Data:2021/7/18 1:07
 * @Author:胡萝卜
 */
public class Tesla implements Car{
    @Override
    public void name() {
        System.out.println("特斯拉");
    }
}

package com.wcf.factory.simple;

/**
 * @Data:2021/7/18 1:07
 * @Author:胡萝卜
 */
public class WuLing implements Car{
    @Override
    public void name() {
        System.out.println("五菱宏光");
    }
}

package com.wcf.factory.simple;

/**
 * @Data:2021/7/18 1:08
 * @Author:胡萝卜
 */
public class Consumer {
    public static void main(String[] args) {
       /* Car car=new WuLing();
        Car car1=new Tesla();*/
        //使用工厂创建
        Car car = CarFactory.getCar("五菱");
        Car car1 = CarFactory.getCar("特斯拉");
        car.name();
        car1.name();
    }
}

2.工厂方法模式

package com.wcf.factory.method;
//工厂方法模式
public interface CarFactory {
    Car getCar();
}

package com.wcf.factory.method;

/**
 * @Data:2021/7/18 1:07
 * @Author:胡萝卜
 */
public interface Car {
    void name();
}

package com.wcf.factory.method;

/**
 * @Data:2021/7/18 1:30
 * @Author:胡萝卜
 */
public class MoBai implements Car{

    @Override
    public void name() {
        System.out.println("摩拜单车");
    }
}

package com.wcf.factory.method;

/**
 * @Data:2021/7/18 1:26
 * @Author:胡萝卜
 */
public class MoBaiFactory implements CarFactory{
    @Override
    public Car getCar() {
        return new MoBai();
    }
}

package com.wcf.factory.method;

/**
 * @Data:2021/7/18 1:07
 * @Author:胡萝卜
 */
public class Tesla implements Car {
    @Override
    public void name() {
        System.out.println("特斯拉");
    }
}

package com.wcf.factory.method;

/**
 * @Data:2021/7/18 1:26
 * @Author:胡萝卜
 */
public class TeslaFactory implements CarFactory{
    @Override
    public Car getCar() {
        return new Tesla();
    }
}

package com.wcf.factory.method;

/**
 * @Data:2021/7/18 1:07
 * @Author:胡萝卜
 */
public class WuLing implements Car {
    @Override
    public void name() {
        System.out.println("五菱宏光");
    }
}

package com.wcf.factory.method;

/**
 * @Data:2021/7/18 1:26
 * @Author:胡萝卜
 */
public class WuLingFactory implements CarFactory{
    @Override
    public Car getCar() {
        return new WuLing();
    }
}

package com.wcf.factory.method;

import com.wcf.factory.simple.CarFactory;

/**
 * @Data:2021/7/18 1:08
 * @Author:胡萝卜
 */
public class Consumer {
    public static void main(String[] args) {
        Car car = new WuLingFactory().getCar();
        Car car1 = new TeslaFactory().getCar();
        Car car2 = new MoBaiFactory().getCar();
        car.name();
        car1.name();
        car2.name();
    }
}

3.抽象工厂模式

package com.wcf.factory.abstract1;

/**
 * @Data:2021/7/18 14:29
 * @Author:胡萝卜
 */
//抽象产品工厂
public interface IProductFactory {
    //生产手机
    IphoneProduct IPHONE_PRODUCT();
    //生产路由器
    IRouterProduct I_ROUTER_PRODUCT();
}

package com.wcf.factory.abstract1;

/**
 * @Data:2021/7/18 14:34
 * @Author:胡萝卜
 */
public class Client {
    public static void main(String[] args) {
        System.out.println("--------------------小米系列产品-----------------------");
        //小米工厂
        XiaoMiFactory xiaoMiFactory = new XiaoMiFactory();
        IphoneProduct iphoneProduct = xiaoMiFactory.IPHONE_PRODUCT();
        iphoneProduct.callup();
        iphoneProduct.sendSMS();

        IRouterProduct iRouterProduct = xiaoMiFactory.I_ROUTER_PRODUCT();
        iRouterProduct.openwifi();
        System.out.println("--------------------华为系列产品-----------------------");
        //华为工厂
        HuaWeiFactory huaWeiFactory = new HuaWeiFactory();
        IphoneProduct iphoneProduct1 = huaWeiFactory.IPHONE_PRODUCT();
        iphoneProduct1.callup();

        IRouterProduct iRouterProduct1 = huaWeiFactory.I_ROUTER_PRODUCT();
        iRouterProduct1.openwifi();
        iRouterProduct1.openwifi();
    }
}

package com.wcf.factory.abstract1;

/**
 * @Data:2021/7/18 14:31
 * @Author:胡萝卜
 */
public class HuaWeiFactory implements IProductFactory{
    @Override
    public IphoneProduct IPHONE_PRODUCT() {
        return new HuaWeiPhone();
    }

    @Override
    public IRouterProduct I_ROUTER_PRODUCT() {
        return new HuaWeiRouter();
    }
}

package com.wcf.factory.abstract1;

/**
 * @Data:2021/7/18 14:22
 * @Author:胡萝卜
 */
//华为手机
public class HuaWeiPhone implements IphoneProduct{

    @Override
    public void start() {
        System.out.println("开启华为手机");
    }

    @Override
    public void shutdown() {
        System.out.println("关闭华为手机");
    }

    @Override
    public void callup() {
        System.out.println("华为打电话");
    }

    @Override
    public void sendSMS() {
        System.out.println("华为发短信");
    }
}

package com.wcf.factory.abstract1;

/**
 * @Data:2021/7/18 14:25
 * @Author:胡萝卜
 */
//小米路由器
public class HuaWeiRouter implements IRouterProduct{
    @Override
    public void start() {
        System.out.println("启动华为路由器");
    }

    @Override
    public void shutdown() {
        System.out.println("关闭华为路由器");
    }

    @Override
    public void openwifi() {
        System.out.println("打开华为wifi");
    }

    @Override
    public void setting() {
        System.out.println("打开华为设置");
    }
}

package com.wcf.factory.abstract1;

/**
 * @Data:2021/7/18 14:19
 * @Author:胡萝卜
 */
//手机产品接口
public interface IphoneProduct {
    void start();
    void shutdown();
    void callup();
    void sendSMS();
}

package com.wcf.factory.abstract1;
//路由器产品接口
public interface IRouterProduct {
    void start();
    void shutdown();
    void openwifi();
    void setting();
}

package com.wcf.factory.abstract1;

/**
 * @Data:2021/7/18 14:31
 * @Author:胡萝卜
 */
public class XiaoMiFactory implements IProductFactory{
    @Override
    public IphoneProduct IPHONE_PRODUCT() {
        return new XiaoMiPhone();
    }

    @Override
    public IRouterProduct I_ROUTER_PRODUCT() {
        return new XiaoMiRouter();
    }
}

package com.wcf.factory.abstract1;

/**
 * @Data:2021/7/18 14:22
 * @Author:胡萝卜
 */
//小米手机
public class XiaoMiPhone implements IphoneProduct{

    @Override
    public void start() {
        System.out.println("开启小米手机");
    }

    @Override
    public void shutdown() {
        System.out.println("关闭小米手机");
    }

    @Override
    public void callup() {
        System.out.println("小米打电话");
    }

    @Override
    public void sendSMS() {
        System.out.println("小米发短信");
    }
}

package com.wcf.factory.abstract1;

/**
 * @Data:2021/7/18 14:25
 * @Author:胡萝卜
 */
//小米路由器
public class XiaoMiRouter implements IRouterProduct{
    @Override
    public void start() {
        System.out.println("启动小米路由器");
    }

    @Override
    public void shutdown() {
        System.out.println("关闭小米路由器");
    }

    @Override
    public void openwifi() {
        System.out.println("打开小米wifi");
    }

    @Override
    public void setting() {
        System.out.println("打开小米设置");
    }
}

六、建造者模式

1.案例一

package com.wcf.builder.demo01;

/**
 * @Data:2021/7/18 15:07
 * @Author:胡萝卜
 */
//抽象的建造者：方法
public abstract class Builder {
    abstract void buildA();//地基
    abstract void buildB();//钢筋工程
    abstract void buildC();//铺电线
    abstract void buildD();//粉刷
    //完工：得到产品
    abstract Product getProduct();
}

package com.wcf.builder.demo01;

/**
 * @Data:2021/7/18 15:19
 * @Author:胡萝卜
 */
//指挥：核心负责指挥构建一个工程，工程如何构建，由它决定
public class Director {
    //指挥工人按照顺序建房子
    public Product build(Builder builder){
        builder.buildA();
        builder.buildB();
        builder.buildC();
        builder.buildD();
       return builder.getProduct();
    }
}

package com.wcf.builder.demo01;

/**
 * @Data:2021/7/18 15:10
 * @Author:胡萝卜
 */
//产品:房子
public class Product {
    private String buildA;
    private String buildB;
    private String buildC;
    private String buildD;

    public String getBuildA() {
        return buildA;
    }

    public void setBuildA(String buildA) {
        this.buildA = buildA;
    }

    public String getBuildB() {
        return buildB;
    }

    public void setBuildB(String buildB) {
        this.buildB = buildB;
    }

    public String getBuildC() {
        return buildC;
    }

    public void setBuildC(String buildC) {
        this.buildC = buildC;
    }

    public String getBuildD() {
        return buildD;
    }

    public void setBuildD(String buildD) {
        this.buildD = buildD;
    }

    @Override
    public String toString() {
        return "Product{" +
                "buildA='" + buildA + '\'' +
                ", buildB='" + buildB + '\'' +
                ", buildC='" + buildC + '\'' +
                ", buildD='" + buildD + '\'' +
                '}';
    }
}

package com.wcf.builder.demo01;

/**
 * @Data:2021/7/18 15:15
 * @Author:胡萝卜
 */
//具体的建造者
public class Worker extends Builder{
    private Product product;

    public Worker() {
        product = new Product();
    }

    @Override
    void buildA() {
        product.setBuildA("地基");
        System.out.println("地基");
    }

    @Override
    void buildB() {
        product.setBuildB("钢筋工程");
        System.out.println("钢筋工程");
    }

    @Override
    void buildC() {
        product.setBuildC("铺电线");
        System.out.println("铺电线");
    }

    @Override
    void buildD() {
        product.setBuildD("粉刷");
        System.out.println("粉刷");
    }

    @Override
    Product getProduct() {
        return product;
    }
}

package com.wcf.builder.demo01;

/**
 * @Data:2021/7/18 15:21
 * @Author:胡萝卜
 */
public class Test {
    public static void main(String[] args) {
        //包工头
        Director director=new Director();
        //指挥具体的工人完成产品
        Product build = director.build(new Worker());
        System.out.println(build.toString());
    }
}

2.案例二

package com.wcf.builder.demo02;

/**
 * @Data:2021/7/18 15:26
 * @Author:胡萝卜
 */
//建造者
public abstract class Builder {
    abstract Builder builderA(String msg);//汉堡
    abstract Builder builderB(String msg);//可乐
    abstract Builder builderC(String msg);//薯条
    abstract Builder builderD(String msg);//甜点

    abstract Product getProduct();
}

package com.wcf.builder.demo02;

/**
 * @Data:2021/7/18 15:27
 * @Author:胡萝卜
 */
//产品：套餐
public class Product {
    private String BuildA="汉堡";
    private String BuildB="可乐";
    private String BuildC="薯条";
    private String BuildD="甜点";

    public String getBuildA() {
        return BuildA;
    }

    public void setBuildA(String buildA) {
        BuildA = buildA;
    }

    public String getBuildB() {
        return BuildB;
    }

    public void setBuildB(String buildB) {
        BuildB = buildB;
    }

    public String getBuildC() {
        return BuildC;
    }

    public void setBuildC(String buildC) {
        BuildC = buildC;
    }

    public String getBuildD() {
        return BuildD;
    }

    public void setBuildD(String buildD) {
        BuildD = buildD;
    }

    @Override
    public String toString() {
        return "Product{" +
                "BuildA='" + BuildA + '\'' +
                ", BuildB='" + BuildB + '\'' +
                ", BuildC='" + BuildC + '\'' +
                ", BuildD='" + BuildD + '\'' +
                '}';
    }
}

package com.wcf.builder.demo02;

/**
 * @Data:2021/7/18 15:29
 * @Author:胡萝卜
 */
//具体的建造者
public class Worker extends Builder{
    private  Product product;

    public Worker() {
        product=new Product();
    }

    @Override
    Builder builderA(String msg) {
        product.setBuildA(msg);
        return this;
    }

    @Override
    Builder builderB(String msg) {
        product.setBuildB(msg);
        return this;
    }

    @Override
    Builder builderC(String msg) {
        product.setBuildC(msg);
        return this;
    }

    @Override
    Builder builderD(String msg) {
        product.setBuildD(msg);
        return this;
    }

    @Override
    Product getProduct() {
        return product;
    }
}

package com.wcf.builder.demo02;

/**
 * @Data:2021/7/18 15:32
 * @Author:胡萝卜
 */
public class Test {
    public static void main(String[] args) {
        //服务员
        Worker worker=new Worker();
        //链式编程:在原来的基础上，可以自由 组合了如果不组合，也有默认的套餐
        Product product = worker.builderA("全家桶").getProduct();
        System.out.println(product.toString());
    }
}

七、原型模式

package com.wcf.prototype.demo02;

import java.util.Date;

/**
 * @Data:2021/7/18 15:52
 * @Author:胡萝卜
 */
/*
实现一个接口Cloneable
重写一个方法clone()
 */
public class Video implements Cloneable{
    private String name;
    private Date createTime;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Object obj = super.clone();
        //实现深克隆~
        Video v = (Video) obj;
        v.createTime = (Date) this.createTime.clone();//将对象的属性也进行克隆
        return obj;
    }

    public Video() {
    }

    public Video(String name, Date createTime) {
        this.name = name;
        this.createTime = createTime;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

    @Override
    public String toString() {
        return "Video{" +
                "name='" + name + '\'' +
                ", createTime=" + createTime +
                '}';
    }
}

package com.wcf.prototype.demo02;

import java.util.Date;

/**
 * @Data:2021/7/18 15:55
 * @Author:胡萝卜
 */
/*
客户端：克隆
 */
public class BiLiBiLi {
    public static void main(String[] args) throws CloneNotSupportedException {
        //原型对象 v1
        Date date=new Date();
        Video v1 = new Video("萝卜说java",date);
        Video v2 = (Video) v1.clone();
        System.out.println("v1=>"+v1);
        System.out.println("v2=>"+v2);
        System.out.println("=========================================");
        date.setTime(2131231);
        System.out.println("v1=>"+v1);
        System.out.println("v2=>"+v2);
       /* //v1 克隆 v2
        System.out.println("v2=>hashCode:"+v2.hashCode());
        v2.setName("Clone: 萝卜说java");
        System.out.println(v2);*/
    }
}

八、适配器模式

package com.wcf.adapter;

/**
 * @Data:2021/7/18 17:11
 * @Author:胡萝卜
 */
//要被适配的类 :网线
public class Adaptee {
    public void request(){
        System.out.println("连接网线上网");
    }
}

package com.wcf.adapter;

/**
 * @Data:2021/7/18 17:16
 * @Author:胡萝卜
 */
/*
1.集成（类适配器，单继承）
2.组合（对象适配器：常用）
 */
//真正的适配器 需要连接USB，连接网线
public class Adapter extends Adaptee implements NetToUsb{

    @Override
    public void handleRequest() {
        super.request();//可以 上网了
    }
}

package com.wcf.adapter;

/**
 * @Data:2021/7/18 17:16
 * @Author:胡萝卜
 */
/*
1.集成（类适配器，单继承）
2.组合（对象适配器：常用）
 */
//真正的适配器 需要连接USB，连接网线
public class Adapter2  implements NetToUsb{
    private Adaptee adaptee;

    public Adapter2(Adaptee adaptee) {
        this.adaptee = adaptee;
    }

    @Override
    public void handleRequest() {
       adaptee.request();//可以 上网了
    }
}

package com.wcf.adapter;

/**
 * @Data:2021/7/18 17:12
 * @Author:胡萝卜
 */
//客户端类:想上网，插不上网线
public class Computer {
    //我们的电脑需要连接上转接器才可以上网
    public void net(NetToUsb adapter){
        //上网的具体实现，找一个转接头
        adapter.handleRequest();

    }

    public static void main(String[] args) {
        //电脑 适配器 网线
        Computer computer = new Computer();//电脑
        Adaptee adaptee = new Adaptee();//网线
        Adapter2 adapter = new Adapter2(adaptee);//转接器
        computer.net(adapter);
    }
}

package com.wcf.adapter;
//接口转换器的抽象实现
public interface NetToUsb {
    //作用:处理请求 网线=》usb
    public void  handleRequest();
}

九、桥接模式

package com.wcf.bridge;
//品牌
public interface Brand {
    void info();
}

package com.wcf.bridge;

/**
 * @Data:2021/7/18 21:18
 * @Author:胡萝卜
 */
//苹果品牌
public class Apple implements Brand{

    @Override
    public void info() {
        System.out.println("苹果");
    }
}

package com.wcf.bridge;

/**
 * @Data:2021/7/18 21:18
 * @Author:胡萝卜
 */
//联想品牌
public class Lenovo implements Brand{

    @Override
    public void info() {
        System.out.println("联想");
    }
}

package com.wcf.bridge;

/**
 * @Data:2021/7/18 21:20
 * @Author:胡萝卜
 */
//抽象的电脑类
public abstract class Computer {
    //组合，品牌
    protected Brand brand;

    public Computer(Brand brand) {
        this.brand = brand;
    }
    public void info(){
        brand.info();//自带品牌

    }
}
class Desktop extends Computer{

    public Desktop(Brand brand) {
        super(brand);
    }

    @Override
    public void info() {
        super.info();
        System.out.println("台式机");
    }
}
class Laptop extends Computer{

    public Laptop(Brand brand) {
        super(brand);
    }

    @Override
    public void info() {
        super.info();
        System.out.println("笔记本");
    }
}

package com.wcf.bridge;

/**
 * @Data:2021/7/18 21:25
 * @Author:胡萝卜
 */
public class Test {
    public static void main(String[] args) {
        //苹果笔记本
        Computer computer=new Laptop(new Apple());
        computer.info();
        //联想台式机
        Computer computer1=new Desktop(new Lenovo());
        computer1.info();
    }
}

十、代理模式

1.静态代理

package com.wcf.proxy.demo01;

/**
 * @Data:2021/7/18 23:45
 * @Author:胡萝卜
 */
//房东
public class Host implements Rent {

    @Override
    public void rent() {
        System.out.println("房东要出租房子!");
    }
}

package com.wcf.proxy.demo01;
//租房
public interface Rent {
    public void rent();
}

package com.wcf.proxy.demo01;

import com.wcf.proxy.demo02.Host;
import com.wcf.proxy.demo02.Rent;

/**
 * @Data:2021/7/18 23:46
 * @Author:胡萝卜
 */
public class Proxy implements Rent {
    private Host host;

    public Proxy() {
    }

    public Proxy(Host host) {
        this.host = host;
    }

    @Override
    public void rent() {
        seeHouse();
        host.rent();
        hetong();
        fare();
    }
    //看房
    public void seeHouse(){
        System.out.println("中介带你看房");
    }
    //签合同
    public void hetong(){
        System.out.println("签租赁合同");
    }
    //收中介费
    public void fare(){
        System.out.println("收中介费");
    }
}

package com.wcf.proxy.demo01;

import com.wcf.proxy.demo02.Host;

/**
 * @Data:2021/7/18 23:46
 * @Author:胡萝卜
 */
public class Client {
    public static void main(String[] args) {
        //房东要出租房子
        Host host = new Host();
        //代理，中介帮房东出租房子，代理角色一般会有一些附属操作
        Proxy proxy = new Proxy(host);
        //你不用面对房东，直接找中介租房即可!
        proxy.rent();
    }
}

2.动态代理

package com.wcf.proxy.demo02;
//租房
public interface Rent {
    public void rent();
}

package com.wcf.proxy.demo02;

/**
 * @Data:2021/7/18 23:45
 * @Author:胡萝卜
 */
//房东
public class Host implements Rent{

    @Override
    public void rent() {
        System.out.println("房东要出租房子!");
    }
}

package com.wcf.proxy.demo02;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * @Data:2021/7/19 0:02
 * @Author:胡萝卜
 */
//用这个类，自动生成代理类
public class ProxyInvocationHandler implements InvocationHandler {
    //被代理的接口
    private Rent rent;

    public void setRent(Rent rent) {
        this.rent = rent;
    }

    //生成代理对象
    public Object getProxy(){
       return Proxy.newProxyInstance(this.getClass().getClassLoader(),rent.getClass().getInterfaces(),this );
    }
    //处理代理实例，并返回结果
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //动态代理的本质，就是使用反射机制实现
        seeHouse();
        Object result = method.invoke(rent, args);
        fare();
        return result;
    }
    public void seeHouse(){
        System.out.println("中介带看房子");
    }
    public void fare(){
        System.out.println("收中介费");
    }
}

package com.wcf.proxy.demo02;

/**
 * @Data:2021/7/19 0:07
 * @Author:胡萝卜
 */
public class Client {
    public static void main(String[] args) {
        //真实角色
        Host host=new Host();
        //代理角色 现在没有
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        //通过调用 程序处理角色 来处理我们 要调用的接口对象
        pih.setRent(host);
        Rent proxy = (Rent) pih.getProxy();
        proxy.rent();
    }
}

胡萝卜i

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java设计模式

设计模式（Design Pattern）是前辈们对代码开发经验的总结，是解决特定问题的一系列套路。它不是语法规定，而是一套用来提高代码可复用性、可维护性、可读性、稳健性以及安全性的解决方案。1995 年，GoF（Gang of Four，四人组/四人帮）合作出版了《设计模式：可复用面向对象软件的基础》一书，共收录了 23 种设计模式，从此树立了软件设计模式领域的里程碑，人称「GoF设计模式」。GoF 23一种思维，一种态度，一种进步单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式。
复制链接

扫一扫