轻松掌握 Java 设计模式：开启代码质量新篇章

后端

2023-11-03 19:52:24

探索 Java 设计模式：开启代码质量新篇章

在当今瞬息万变的数字世界，软件开发不再仅仅是让代码运行。优秀的程序员追求的是代码的质量、性能和灵活性，以满足不断变化的业务需求。而 Java 设计模式 正是通往代码质量新高度的指南针。

何为 Java 设计模式？

Java 设计模式是一套经过验证、可重用的解决方案，旨在解决软件开发中常见的挑战。通过运用设计模式，你可以轻松驾驭代码的复杂性，提升代码的可维护性、可扩展性和灵活性。

掌握设计模式核心理念

在踏上 Java 设计模式之旅之前，先让我们掌握其核心理念：

单一职责原则： 让每个类只负责一项职责，提高代码的可读性和可维护性。
开放-封闭原则： 使类对扩展开放，对修改关闭，让代码更易于扩展和维护。
里氏替换原则： 子类可以替换父类，而不会破坏系统的行为，确保代码的可重用性和可靠性。
接口隔离原则： 将接口设计得独立且细粒度，让代码更具灵活性。
依赖倒置原则： 让高层模块不依赖于低层模块，而是依赖于抽象，提高代码的松耦合性和可测试性。
合成复用原则： 通过组合而不是继承来实现代码的复用，提高代码的灵活性。
迪米特法则： 一个类应该只与那些它真正需要耦合的其他类耦合，减少代码的复杂性和提高可维护性。

常见设计模式一览

Java 设计模式库浩如烟海，我们精选了最常见的 10 种模式，为你开启代码质量之旅：

工厂模式： 创建对象的工厂，让代码更具灵活性。

public interface Shape {
    void draw();
}

public class Square implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a square");
    }
}

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

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

建造者模式： 通过一步一步地构建复杂对象，让代码更易于理解和维护。

public class House {
    private int rooms;
    private int windows;
    private int doors;

    public static class Builder {
        private House house;

        public Builder() {
            house = new House();
        }

        public Builder setRooms(int rooms) {
            house.rooms = rooms;
            return this;
        }

        public Builder setWindows(int windows) {
            house.windows = windows;
            return this;
        }

        public Builder setDoors(int doors) {
            house.doors = doors;
            return this;
        }

        public House build() {
            return house;
        }
    }
}

单例模式： 确保一个类只有一个实例，让代码更具性能和安全性。

public class Singleton {
    private static Singleton instance;

    private Singleton() {
        // Private constructor to prevent instantiation
    }

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

原型模式： 通过复制一个现有的对象来创建新的对象，提高代码的效率。

public class Shape implements Cloneable {
    private String shapeType;

    public Shape(String shapeType) {
        this.shapeType = shapeType;
    }

    @Override
    public Object clone() {
        try {
            return super.clone();
        } catch (CloneNotSupportedException e) {
            return null;
        }
    }
}

public class Circle extends Shape {
    private double radius;

    public Circle(String shapeType, double radius) {
        super(shapeType);
        this.radius = radius;
    }

    @Override
    public Object clone() {
        return new Circle(shapeType, radius);
    }
}

装饰模式： 在不改变对象本身的情况下，动态地给对象添加新的功能，提高代码的灵活性。

public interface Shape {
    void draw();
}

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

public class ShapeDecorator implements Shape {
    protected Shape decoratedShape;

    public ShapeDecorator(Shape decoratedShape) {
        this.decoratedShape = decoratedShape;
    }

    @Override
    public void draw() {
        decoratedShape.draw();
    }
}

public class RedShapeDecorator extends ShapeDecorator {
    public RedShapeDecorator(Shape decoratedShape) {
        super(decoratedShape);
    }

    @Override
    public void draw() {
        decoratedShape.draw();
        System.out.println("Color: Red");
    }
}

代理模式： 为对象提供一个代理或替代，让代码更具安全性、灵活性或性能。

public interface Image {
    void display();
}

public class RealImage implements Image {
    private String filename;

    public RealImage(String filename) {
        this.filename = filename;
        loadImageFromDisk();
    }

    private void loadImageFromDisk() {
        // Code to load image from disk
    }

    @Override
    public void display() {
        System.out.println("Displaying image " + 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();
    }
}

适配器模式： 让两个不兼容的类能够一起工作，提高代码的兼容性和灵活性。

public interface Bird {
    void fly();
    void makeSound();
}

public class Sparrow implements Bird {
    @Override
    public void fly() {
        System.out.println("Sparrow is flying");
    }

    @Override
    public void makeSound() {
        System.out.println("Sparrow is chirping");
    }
}

public class ToyDuck {
    public void squeak() {
        System.out.println("Toy duck is squeaking");
    }
}

public class BirdAdapter implements Bird {
    private ToyDuck toyDuck;

    public BirdAdapter(ToyDuck toyDuck) {
        this.toyDuck = toyDuck;
    }

    @Override
    public void fly() {
        toyDuck.squeak();
        toyDuck.squeak();
    }

    @Override
    public void makeSound() {
        toyDuck.squeak();
    }
}

桥接模式： 将抽象和实现解耦，让代码更易于扩展和维护。

public interface Shape {
    void draw();
}

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

public class Square implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a square");
    }
}

public interface Color {
    void fill();
}

public class Red implements Color {
    @Override
    public void fill() {
        System.out.println("Filling with red color");
    }
}

public class Blue implements Color {
    @Override
    public void fill() {
        System.out.println("Filling with blue color");
    }
}

public class ShapeBridge {
    private Shape shape;
    private Color color;

    public ShapeBridge(Shape shape, Color color) {
        this.shape = shape;
        this.color = color;
    }

    public void draw() {
        shape.draw();
        color.fill();
    }
}

组合模式： 将对象组合成树形结构，让代码更具组织性和可扩展性。

public interface Shape {
    void draw();
}

public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a circle");

Kyle

探索Web开发资源和人工智能教程的代码社区

联系我

扫码关注微信公众号

轻松掌握 Java 设计模式：开启代码质量新篇章

Kyle

舍弃vo2dto，一键实现对象get、set，编程省时又省力

Java并发编程：在疯狂中，寻找秩序与同步

深入解析 Docker Compose 配置文件与常用命令

Python代码运行加速指南：三招助你提升效率

强势进击，揭秘RocketMQ性能优化大法！