菜鸟的Java设计模式学习总结

单例模式

单例模式通过确保一个类只创建一个实例来优化资源使用。饿汉式和饥汉式仅在于实例化时机不同，但核心思想相同。

实现

public class SingleObject {
    private static SingleObject instance = new SingleObject();
    private SingleObject() {
    }
    public static SingleObject getInstance() {
        return instance;
    }
    public void showMessage() {
        System.out.println("hello world!");
    }
}

使用

通过调用Singleton.getInstance()获取唯一实例。

工厂模式

工厂模式通过引入抽象工厂，统一管理对象创建，避免直接暴露实现细节。

实现

public class ShapeFactory {
    public Shape getShape(String shapeType) {
        if (shapeType == null)
            return null;
        if (shapeType.equalsIgnoreCase("CIRCLE"))
            return new Circle();
        else if (shapeType.equalsIgnoreCase("RECTANGLE"))
            return new Rectangle();
        else if (shapeType.equalsIgnoreCase("SQUARE"))
            return new Square();
        return null;
    }
}

使用

// 获取不同形状的实例
Shape circle = shapeFactory.getShape("CIRCLE");
Shape rectangle = shapeFactory.getShape("RECTANGLE");

代理模式

代理模式允许在不修改目标对象代码的情况下增强功能，分为基于子类和接口动态代理。

基于子类动态代理

public class Producer {
    public void saleProduct(float money) {
        System.out.println("您好！这里是生产产家的销售...");
    }
    public void afterService(float money) {
        System.out.println("您好，这里是生产产家的售后...");
    }
}
class MyProxy {
    public Producer proxy() {
        Producer producer = new Producer();
        return (Producer) Enhancer.create(
            producer.getClass(),
            new MethodInterceptor() {
                public Object intercept(Object obj, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                    System.out.println("\t方法被拦截：" + method);
                    Object invoke = null;
                    if ("saleProduct".equals(method.getName())) {
                        invoke = method.invoke(producer, (float) args[0] * 0.8f);
                    }
                    return invoke;
                }
            }
        );
    }
}

基于接口动态代理

public interface IProducer {
    void saleProduct(float money);
    void afterService(float money);
}
class MyProxy implements InvocationHandler {
    private IProducer target;
    public MyProxy(IProducer target) {
        this.target = target;
    }
    public void invoke(IProducer target, Method method, Object[] args) throws Throwable {
        System.out.println("\t方法被拦截：" + method);
        Object invoke = null;
        if ("saleProduct".equals(method.getName())) {
            invoke = method.invoke(target, (float) args[0] * 0.8f);
        }
        return invoke;
    }
}
public class Test {
    public static void main(String[] args) {
        MemoryCard card = new MemoryCard();
        Computer computer = new ComputerImpl();
        Adapter02 adapter = new Adapter02(card);
        computer.getContent();
        computer.readContent();
    }
}

适配者模式

适配者模式通过桥接不兼容的接口，实现系统间互操作。

对象实例适配器

public class MemoryCard {
    public String content() {
        return "学习资料\n\t--日韩\n\t--欧美\n\t--国产\n\t--主播";
    }
}
public interface Computer {
    String getContent();
    void readContent();
}
public class Adapter01 implements Computer {
    private MemoryCard memoryCard = new MemoryCard();
    public String getContent() {
        System.out.println("内存卡内容读取中...");
        String content = memoryCard.content();
        System.out.println("内存卡内容读取完成...");
        return content;
    }
    public void readContent() {
        String content = getContent();
        System.out.println("电脑正在输出读取到的内存卡信息...");
        System.out.println("\n电脑读取到的内容：\n" + content);
    }
}

类适配器

public class Adapter02 extends MemoryCard implements Computer {
    public String getContent() {
        System.out.println("内存卡内容读取中...");
        String content = super.content();
        System.out.println("内存卡内容读取完成...");
        return content;
    }
    public void readContent() {
        String content = getContent();
        System.out.println("电脑正在输出读取到的内存卡信息...");
        System.out.println("\n电脑读取到的内容：\n" + content);
    }
}

建造者模式

建造者模式将对象的构建过程分解为独立的步骤，便于管理复杂对象的创建。

实现

public interface IBuilder {
    void buildGround();
    void buildGroundBeam();
    void buildFixture();
    void buildCement();
    void buildRoof();
    House getHouse();
}
public class DefaultBuilder implements IBuilder {
    protected House house = new House();
    public DefaultBuilder() {
        this.house = new House();
    }
    @Override
    public void buildGround() {
        house.setGround("打地基完成");
    }
    @Override
    public void buildGroundBeam() {
        house.setGroundBeam("地梁施工完成");
    }
    @Override
    public void buildFixture() {
        house.setFixture("钢筋施工完成");
    }
    @Override
    public void buildCement() {
        house.setCement("水泥施工完成");
    }
    @Override
    public void buildRoof() {
        house.setRoof("屋顶施工完成");
    }
    @Override
    public House getHouse() {
        return house;
    }
}
public class Director {
    public static House create(IBuilder builder) {
        builder.buildGround();
        builder.buildGroundBeam();
        builder.buildFixture();
        builder.buildCement();
        builder.buildRoof();
        return builder.getHouse();
    }
}

使用

House house = Director.create(new DefaultBuilder());

总结

这些设计模式在软件开发中发挥着重要作用，了解它们的特点和适用场景有助于有效地解决实际问题。通过不断学习和实践，可以更好地掌握这些模式并灵活运用以优化代码质量。

转载地址：http://xomwk.baihongyu.com/

你可能感兴趣的文章

vue3+Element-plus icon图标无法显示的问题(已解决)