代理模式适配器模式装饰模式实例

最新推荐文章于 2024-12-07 09:00:00 发布

原创最新推荐文章于 2024-12-07 09:00:00 发布 · 340 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#设计模式

Java 专栏收录该内容

13 篇文章

订阅专栏

本文深入讲解了三种常用的设计模式：代理模式、适配器模式和装饰模式。通过具体实例介绍了每种模式的应用场景、实现方式及其核心优势。适合希望提高软件设计能力的开发者阅读。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

代理模式

// Calculate.java
public interface Calculate {
    int add(int a, int b);
}


// Calculator.java
public class Calculator implements Calculate {
    public int add(int a, int b) {
        return a + b;
    }
}


// CalculatorProxy.java - 代理
public class CalculatorProxy implements Calculate {
    private Calculator calculator;

    public CalculatorProxy(Calculator calculator) {
        this.calculator = calculator;
    }

    public int add(int a, int b) {
        System.out.println("calculate " + a + " + " + b);
        return calculator.add(a, b);
    }
}


// ProxyTest.java
public class ProxyTest {
    public static void main(String[] args) {
        Calculator calculator = new Calculator();
        CalculatorProxy calculatorProxy = new CalculatorProxy(calculator);
        int sum = calculatorProxy.add(4, 6);
        System.out.println(sum);
    }
}

// 输出结果：
// calculate 4 + 6
// 10

适配器模式

// RedFirer.java
public interface RedFirer {
    void burn();
}


// Kyo.java
public class Kyo implements RedFirer {
    public void burn() {
        System.out.println("燃烧吧，我的赤焰！");
    }
}


// GreenFirer.java
public interface GreenFirer {
    void burn();
}


// Ash.java
public class Ash implements GreenFirer {
    public void burn() {
        System.out.println("燃烧吧，我的翠焰！");
    }
}


// FakeKyo.java - 适配器
public class FakeKyo implements RedFirer {
    private GreenFirer greenFirer;

    public FakeKyo(GreenFirer greenFirer) {
        this.greenFirer = greenFirer;
    }

    public void burn() {
        greenFirer.burn();
    }
}


// AdapterTest.java
public class AdapterTest {
    public static void main(String[] args) {
        GreenFirer ash = new Ash();
        RedFirer fakeKyo = new FakeKyo(ash);
        fakeKyo.burn();
    }
}

// 输出结果：
// 燃烧吧，我的翠焰！

装饰模式

// Learn.java
public interface Learn {
    void learnBasic();
    void writeDemo();
    void conclude();
    void learnSth();
}


// NormalLearn.java
public class NormalLearn implements Learn {
    public void learnBasic() {
        System.out.println("学习基础知识....");
    }

    public void writeDemo() {
        System.out.println("编写测试....");
    }

    public void conclude() {
        System.out.println("总结....");
    }

    public void learnSth() {
        learnBasic();
        writeDemo();
        conclude();
    }
}


// AbstractLearn.java - 装饰器
public abstract class AbstractLearn implements Learn {
    private final Learn learn;

    public AbstractLearn(Learn learn) {
        this.learn = learn;
    }

    public void learnBasic() {
        learn.learnBasic();
    }

    public void writeDemo() {
        learn.writeDemo();
    }

    public void conclude() {
        learn.conclude();
    }

    public void learnSth() {
        learnBasic();
        writeDemo();
        conclude();
    }
}


// LazyDecorator.java
public class LazyDecorator extends AbstractLearn {
    public LazyDecorator(Learn learn) {
        super(learn);
    }

    public void copyDemo() {
        System.out.println("抄袭别人的测试....");
    }

    public void writeDemo() {
        super.writeDemo();
        copyDemo();
    }
}


// QuickDecorator.java
public class QuickDecorator extends AbstractLearn {
    public QuickDecorator(Learn learn) {
        super(learn);
    }

    public void speedUp() {
        System.out.println("加快打字速度....");
    }

    public void conclude() {
        super.conclude();
        speedUp();
    }
}


// DecoratorTest.java
public class DecoratorTest {
    public static void main(String[] args) {
        Learn learn = new NormalLearn();
        learn = new LazyDecorator(learn);
        learn = new QuickDecorator(learn);
        learn.learnSth();
    }
}

// 输出结果：
// 学习基础知识....
// 编写测试....
// 抄袭别人的测试....
// 总结....
// 加快打字速度....