Java中的模式类-猿码集

1. 什么是模式类

在Java中，设计模式是开发人员从过去的问题和解决方案的实践中总结出来的通用设计构造。模式类相当于一种编程模式，用于解决一类问题。

模式在Java编程中是非常常见的，它可以帮助我们快速地解决一些复杂的问题，并且具有可复用性和可拓展性。

在Java中，常见的模式类包括单例模式、工厂模式、观察者模式等。

2. 单例模式

2.1 什么是单例模式

单例模式是一种保证在一个进程中只存在一个对象实例的设计模式。在实际应用中，单例模式经常频繁使用，经典的单例模式实现方式是饿汉式和懒汉式。

2.2 饿汉式实现

饿汉式实现方式是在类加载时就创建对象实例。代码如下：


public class Singleton {
    private static Singleton instance = new Singleton();
    private Singleton() {}
    public static Singleton getInstance() {
        return instance;
    }
}

这种方式简单，线程安全，但是当类被加载时，就会创建实例，会占用内存资源。

2.3 懒汉式实现

懒汉式实现方式是在调用方法时才会创建对象实例。代码如下：


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

这种方式节省了内存资源，但是线程不安全，需要在方法上加锁保证线程安全。

3. 工厂模式

3.1 什么是工厂模式

工厂模式是一种创建模式，其目的是为了提供一个通用的接口，来创建不同的对象。工厂模式将对象创建的过程封装在一个工厂类中，而不是直接在客户端中创建对象。

3.2 工厂模式的实现

下面是工厂模式的一个简单实现：


public interface Shape {
    void draw();
}
public class Rect implements Shape {
    public void draw() {
        System.out.println("Rect draw");
    }
}
public class Circle implements Shape {
    public void draw() {
        System.out.println("Circle draw");
    }
}
public class ShapeFactory {
    public static Shape create(String type) {
        if (type.equalsIgnoreCase("rect")) {
            return new Rect();
        } else if (type.equalsIgnoreCase("circle")) {
            return new Circle();
        }
        return null;
    }
}

上面的代码定义了一个Shape接口，其中包含了一个方法draw，定义了一个Rect和一个Circle类，这两个类实现了Shape接口，并且分别实现了draw方法。最后，定义了一个ShapeFactory类，其中包含了一个静态方法create，这个方法可以根据传入的参数(type)，动态地创建Rect或者Circle对象。

4. 观察者模式

4.1 什么是观察者模式

观察者模式是一种行为模式，其中一个对象(Subject)的状态更改会导致其他对象(Observer)的状态更改。观察者模式中，Subject对象通常包含了一个自己的状态(status)，Observer对象通常是被注册到Subject对象中的，每当Subject对象的状态发生更改的时候，所有注册到它上面的Observer对象都会被通知，并且进行相应的操作。

4.2 观察者模式的实现

下面是观察者模式的一个简单实现：


public interface Observer {
    void update(String status);
}
public class ConcreteObserver implements Observer {
    public void update(String status) {
        System.out.println("ConcreteObserver update status = " + status);
    }
}
public interface Subject {
    void attachObserver(Observer observer);
    void detachObserver(Observer observer);
    void notifyObservers();
}
public class ConcreteSubject implements Subject {
    private List observers = new ArrayList<>();
    private String status;
    public void attachObserver(Observer observer) {
        observers.add(observer);
    }
    public void detachObserver(Observer observer) {
        observers.remove(observer);
    }
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(status);
        }
    }
    public void setStatus(String status) {
        this.status = status;
        notifyObservers();
    }
}

上面的代码定义了一个Observer接口，其中包含了一个方法update，定义了一个ConcreteObserver类，这个类实现了Observer接口，并且具体实现了update方法。定义了一个Subject接口，其中包含了attachObserver、detachObserver、notifyObservers三个方法，定义了一个ConcreteSubject类，这个类实现了Subject接口，并且具体实现了三个方法，这个类还包含了一个状态属性(status)，在setStatus方法中进行状态的设置，并且调用notifyObservers方法通知所有观察者状态已经更改。

5. 总结

Java中的模式类是一种常见的编程模式，它可以帮助我们快速地解决一些复杂的问题。本文讲述了单例模式、工厂模式和观察者模式三种常见的模式实现方式，通过这三种模式的实现方式，可以帮助我们更好地理解如何在自己的程序中使用模式类来解决一些问题。

Java中的模式类