首页 > 文章列表 > Java语言设计模式详解

Java语言设计模式详解

java语言 设计模式 详解
147 2023-06-10

Java作为一种经典的面向对象编程语言,具有强大的灵活性和可扩展性,在实际应用中广泛使用。而设计模式则是Java程序员必须掌握的一项重要技能,它可以帮助程序员解决复杂的编程问题,提高代码的可重用性和可维护性。本篇文章将详细介绍Java语言中常用的几种设计模式。

一、单例模式

在Java中,有些对象只需要实例化一次,这样可以避免内存浪费和程序性能损失。比如数据库连接池、日志类、线程池等对象。单例模式就是实现这种需求的一种模式。

单例模式的核心思想是保证一个类只有一个实例,并提供一个全局访问它的方法。在Java中,单例模式通常通过私有构造函数和静态方法实现。

示例代码:

public class Singleton {

    private static Singleton instance;  

    private Singleton() {}

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

这里的instance变量是一个私有静态变量,在getInstance()方法中被初始化。注意,这里的构造函数是私有的,保证了外部无法通过new关键字创建实例。而getInstance()方法负责控制对象的实例化次数,并提供一个全局可访问的静态方法,用于获取唯一的实例。由于线程安全性的考虑,这里使用了synchronized关键字来同步getInstance()方法。

二、工厂模式

工厂模式是一种创建型模式,它的主要目的是封装、隐藏对象的创建过程,从而降低系统的耦合性,并遵循开放-封闭原则(即对修改封闭,对扩展开放)。

在Java中,工厂模式通常有三种实现方式:简单工厂,工厂方法和抽象工厂。其中,简单工厂是最基本的实现方式,工厂方法和抽象工厂则是在简单工厂模式的基础上发展而来。

  1. 简单工厂模式

简单工厂模式是通过一个静态方法来创建对象的,并且通过传入不同的参数,返回不同类型的对象。这种模式适用于创建的对象类型比较少,且不需要频繁地添加新对象类型。

示例代码:

public class SimpleFactory {

    public static Product createProduct(String type) {
        Product product = null;
        if ("A".equalsIgnoreCase(type)) {
            product = new ConcreteProductA();
        } else if ("B".equalsIgnoreCase(type)) {
            product = new ConcreteProductB();
        }
        return product;
    }
}

public interface Product {}

public class ConcreteProductA implements Product {}

public class ConcreteProductB implements Product {}

这里的SimpleFactory类中,定义了一个静态方法createProduct(),用于创建不同类型的Product对象。根据传入的参数类型,返回不同的Product对象类型。而Product接口和ConcreteProductA/B类则用于定义和实现具体的对象类型。

  1. 工厂方法模式

工厂方法模式是简单工厂模式的升级版,它不再使用静态方法,而是将对象的生产过程交给子类来完成。在这种模式中,每一个子类都可以根据需要创建自己的对象实例。

示例代码:

public interface Factory {
    Product createProduct();
}

public class ConcreteFactoryA implements Factory {
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

public class ConcreteFactoryB implements Factory {
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

这里的工厂方法是一个接口,每个工厂类都必须实现这个接口,并提供自己的createProduct()方法。通过这个方法,工厂类可以创建不同的Product类。每一个具体的工厂类都可以根据需要创建自己的对象实例,而客户端则只需要和工厂接口通信,无需知道具体的对象类型。

  1. 抽象工厂模式

抽象工厂模式是工厂方法模式的一个扩展,它提供了一种创建一系列相关或相互依赖对象的接口,而无需指定具体的类。

示例代码:

public interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

public class ConcreteFactory1 implements AbstractFactory {
    public ProductA createProductA() {
        return new ConcreteProductA1();
    }
    public ProductB createProductB() {
        return new ConcreteProductB1();
    }
}

public class ConcreteFactory2 implements AbstractFactory {
    public ProductA createProductA() {
        return new ConcreteProductA2();
    }
    public ProductB createProductB() {
        return new ConcreteProductB2();
    }
}

这里的AbstractFactory是一个接口,包含了创建ProductA和ProductB的方法。每个具体工厂类都必须实现这个接口,并提供自己的createProductA()和createProductB()方法。客户端则只需要使用抽象工厂接口,即可创建不同系列的产品。

三、策略模式

策略模式是一种行为型模式,它定义了一系列算法,将每个算法都封装起来,并且可以互相替换。策略模式可以使得如何完成某个算法的决策和算法本身分离开来,从而遵循了开放-封闭原则。

示例代码:

public interface Strategy {
    int calculate(int a, int b);
}

public class ConcreteStrategyAdd implements Strategy {
    public int calculate(int a, int b) {
        return a + b;
    }
}

public class ConcreteStrategySub implements Strategy {
    public int calculate(int a, int b) {
        return a - b;
    }
}

public class Context {
    private Strategy strategy;

    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    public int executeStrategy(int a, int b) {
        return strategy.calculate(a, b);
    }
}

这里的Strategy是一个策略接口,其中包含了calculate()方法。每个具体策略类都必须实现这个接口,并提供自己的calculate()方法。Context类则是策略模式的上下文环境,它接收一个策略实例并执行它的算法。在这里,Context类将算法的实现与算法本身分离开来,从而使得算法的决策可以在运行时动态地改变。

四、观察者模式

观察者模式是一种行为型模式,它定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个主题对象。当主题对象发生改变时,所有依赖它的观察者都会得到通知并自动更新。

在Java中,观察者模式常常使用Java的内置类库实现,如Observable类和Observer接口。这两个类是Java中观察者模式的基础类和接口,大部分情况下,只需要继承或实现这两个类即可完成观察者模式的实现。

示例代码:

import java.util.Observable;
import java.util.Observer;

public class Sender extends Observable {

    public void sendMessage(String message) {
        setChanged();
        notifyObservers(message);
    }
}

public class Receiver implements Observer {

    public void update(Observable o, Object arg) {
        System.out.println("Received message: " + arg.toString());
    }
}

在这里,Sender类是主题对象,继承了Java内置的Observable类。而Receiver类是观察者对象,实现了Java内置的Observer接口。在Sender对象中,当有新消息发送时,通过setChanged()方法设置状态为已改变,并通过notifyObservers()方法通知所有观察者对象。而在Receiver对象中,它通过update()方法接收到主题对象的通知,并执行自己的更新操作。

五、总结

Java设计模式是Java程序员必须掌握的一项重要技能,它可以帮助程序员解决复杂的编程问题,提高代码的可重用性和可维护性。单例模式、工厂模式、策略模式和观察者模式是Java中常用的几种设计模式,它们都有着自己的特点和适用场景。在实际开发中,程序员应该根据具体的需求和场景来选择合适的设计模式,以达到最优的效果。