Java中的设计模式详解：创建型、结构型、行为型模式

Java中的设计模式是一种被广泛应用的编程思想，它可以帮助开发者提高代码的可读性、可维护性、可扩展性等方面的优点。在本篇文章中，我们将详细讲解Java中的设计模式，包括创建型、结构型、行为型模式，并附带代码案例，适合编程小白学习。

一、创建型模式

创建型模式主要用于创建对象的过程，包括单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式。其中，单例模式是最简单的创建型模式，它保证在一个JVM中只有一个实例化的对象。下面我们来看一个简单的单例模式的代码实现。

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

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

上面的代码中，我们通过私有化构造函数、私有化静态变量和公共静态方法实现了一个单例模式。当我们需要使用该类的对象时，只需要调用getInstance()方法即可。

1.1 工厂模式

工厂模式是一种常用的创建型模式，主要用于创建复杂对象。它包括简单工厂模式、工厂方法模式和抽象工厂模式。下面我们来看一个简单工厂模式的代码实现。

public interface Animal {
    void say();
}

public class Cat implements Animal {
    @Override
    public void say() {
        System.out.println("喵喵喵");
    }
}

public class Dog implements Animal {
    @Override
    public void say() {
        System.out.println("汪汪汪");
    }
}

public class AnimalFactory {
    public static Animal create(String type) {
        if ("cat".equals(type)) {
            return new Cat();
        } else if ("dog".equals(type)) {
            return new Dog();
        } else {
            return null;
        }
    }
}

上面的代码中，我们定义了一个Animal接口，然后实现了Cat和Dog两个类，并通过工厂类AnimalFactory来创建对象。当我们需要使用某个对象时，只需要调用AnimalFactory.create(type)方法即可。

1.2 抽象工厂模式

抽象工厂模式是一种更为复杂的创建型模式，它可以创建一系列相关的对象。下面我们来看一个简单的抽象工厂模式的代码实现。

public interface Shape {
    void draw();
}

public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("画一个圆形");
    }
}

public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("画一个矩形");
    }
}

public interface Color {
    void fill();
}

public class Red implements Color {
    @Override
    public void fill() {
        System.out.println("填充红色");
    }
}

public class Green implements Color {
    @Override
    public void fill() {
        System.out.println("填充绿色");
    }
}

public abstract class AbstractFactory {
    public abstract Shape getShape(String shape);

    public abstract Color getColor(String color);
}

public class ShapeFactory extends AbstractFactory {
    @Override
    public Shape getShape(String shape) {
        if ("circle".equals(shape)) {
            return new Circle();
        } else if ("rectangle".equals(shape)) {
            return new Rectangle();
        } else {
            return null;
        }
    }

    @Override
    public Color getColor(String color) {
        return null;
    }
}

public class ColorFactory extends AbstractFactory {
    @Override
    public Shape getShape(String shape) {
        return null;
    }

    @Override
    public Color getColor(String color) {
        if ("red".equals(color)) {
            return new Red();
        } else if ("green".equals(color)) {
            return new Green();
        } else {
            return null;
        }
    }
}

上面的代码中，我们定义了Shape、Color两个接口，然后实现了Circle、Rectangle、Red、Green四个类，并通过抽象工厂类AbstractFactory来创建对象。当我们需要使用某个对象时，只需要调用对应的AbstractFactory子类的getShape()或getColor()方法即可。

二、结构型模式

结构型模式主要用于组合不同对象形成更大的结构，包括适配器模式、桥接模式、组合模式、装饰器模式、外观模式、享元模式、代理模式。下面我们来看一个装饰器模式的代码实现。

public interface Shape {
    void draw();
}

public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("画一个圆形");
    }
}

public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("画一个矩形");
    }
}

public abstract class ShapeDecorator implements Shape {
    protected Shape shape;

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

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

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

    @Override
    public void draw() {
        shape.draw();
        setRedBorder(shape);
    }

    private void setRedBorder(Shape shape){
        System.out.println("边框颜色: 红色");
    }
}

上面的代码中，我们定义了Shape接口，然后实现了Circle、Rectangle两个类，并通过装饰器类ShapeDecorator来增加其它功能。当我们需要画一个带有红色边框的圆形时，只需要调用RedShapeDecorator(new Circle()).draw()方法即可。

三、行为型模式

行为型模式主要用于对象之间的通信和协作，包括责任链模式、命令模式、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、模板方法模式、访问者模式。下面我们来看一个观察者模式的代码实现。

public interface Observer {
    void update(String message);
}

public class ConcreteObserver implements Observer {
    private String name;

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

    @Override
    public void update(String message) {
        System.out.println(name + "收到消息：" + message);
    }
}

public interface Subject {
    void registerObserver(Observer observer);

    void removeObserver(Observer observer);

    void notifyObservers(String message);
}

public class ConcreteSubject implements Subject {
    private List observerList = new ArrayList<>();

    @Override
    public void registerObserver(Observer observer) {
        observerList.add(observer);
    }

    @Override
    public void removeObserver(Observer observer) {
        observerList.remove(observer);
    }

    @Override
    public void notifyObservers(String message) {
        for (Observer observer : observerList) {
            observer.update(message);
        }
    }
}

上面的代码中，我们定义了Observer、Subject两个接口，然后实现了ConcreteObserver、ConcreteSubject两个类，并通过观察者模式实现了对象之间的通信和协作。当我们需要订阅某个Subject的消息时，只需要实现Observer接口并通过Subject.registerObserver()方法进行注册即可。

以上就是Java中的设计模式详解，包括创建型、结构型、行为型模式，并附带了代码案例。希望能够帮助到编程小白们更好、更快地掌握设计模式的概念和实现方式。

本文为翻滚的胖子原创文章,转载无需和我联系,但请注明来自猿教程iskeys.com

• 上一篇： Java中的函数式编程详解：函数式接口、Lambda表达式、Stream API
• 下一篇： Java中的算法详解：排序算法、搜索算法、字符串算法