举例说明Java中的多例设计模式

本文深入探讨了多例设计模式的实现方式,通过固定数量的对象实例来优化资源使用,展示了如何在Java中创建男性和女性的唯一实例,并通过具体代码示例解释了其工作原理。
/**
 * 多例设计模式:类的能够实例化对象的个数是提前固定好的
 * @author JIASHIXI
 *
 */
class Sex{
	private String value;
	public static final int MALE = 0;
	public static final int FAMALE = 1;
	private static final Sex MALE_INSTANCE = new Sex("男");
	private static final Sex FAMALE_INSTANCE = new Sex("女");
	private Sex(String value) {
		this.value = value;
	}
	public static Sex getInstance(int choose) {
		switch(choose) {
			case MALE:
				return MALE_INSTANCE;
			case FAMALE:
				return FAMALE_INSTANCE;
			default:
				return null;
		}
	}
	public String toString() {
		return this.value;
	}
}

public class Test {
	public static void main(String[] args) {
		Sex sex = Sex.getInstance(Sex.MALE);
		System.out.println(sex);
	}
}

单例模式的扩展及应用。 编写一个类LimitInstanceClass,该类最多可以实例化指定个数实例。实例的个数用配置文件InstanceLimit.cfg指定。例如,如果InstanceLimit.cfg的内容为2,则LimitInstanceClass最多可以同时存在2个对象。LimitInstanceClass的对象有一个整型成员变量id,保存对象的编号;有一个boolean型变量isBusy,如果该变量的值为true,表示该对象正在被使用,否则该对象空闲;如果存在空闲的对象,则调用LimitInstanceClass的getInstance()方法会返回一个空闲对象,同时将该对象的isBusy置为true;如果不存在空闲对象则返回null。LimitInstanceClass有一个release()方法,该方法将对象的isBusy置为false。LimitInstanceClass还有一个String类型的成员变量accessMessage,以及一个成员方法writeAccessMessage(String message),该方法将参数message追加到accessMessage。LimitInstanceClass的printAccessMessage()方法输出accessMessage的内容。 编写一个线程类AccessLimitInstanceClassThread,在其run()方法中获取一个LimitInstanceClass对象,调用获得的对象的writeAccessMessage(String message)将自己的线程名写入accessMessage,随机休眠0-5秒,再调用printAccessMessage(),最后调用release()方法。 编写一个UseLimitInstanceClass类,在其main方法中实例化10个AccessLimitInstanceClassThread线程对象,并启动各个线程。 设置InstanceLimit.cfg的内容为3,写出你的程序的运行结果。
### ### Java中常用的设计模式及其实际应用示例 设计模式是软件开发中的最佳实践,它们提供了经过验证的解决方案来解决常见的设计问题。Java 中广泛使用了多种设计模式,以提高代码的可重用性、可维护性和可扩展性。 #### 单例模式(Singleton Pattern) 单例模式确保一个类只有一个实例,并提供一个全局访问点。这种模式常用于需要频繁实例化然后销毁的对象,或者是创建代价很高的对象。 ```java public enum PersonSingleton { INSTANCE; private String name; public String getName() { return name; } } ``` 上述代码展示了如何通过枚举实现单例模式,这种方式不仅能避免多线程同步问题,还能防止反序列化导致重新生成新对象的情况[^4]。 #### 原型模式(Prototype Pattern) 原型模式是一种创建型设计模式,它允许一个对象再创建另外一个提供相同功能的对象,同时保证较高的性能。这通常通过克隆机制实现。 ```java public abstract class Prototype implements Cloneable { protected String id; public Prototype(String id) { this.id = id; } public String getId() { return id; } @Override public Object clone() throws CloneNotSupportedException { return super.clone(); } } public class ConcretePrototype extends Prototype { public ConcretePrototype(String id) { super(id); } } ``` 在这个例子中,`ConcretePrototype`继承自`Prototype`抽象类,并实现了`clone()`方法来复制自身[^4]。 #### 策略模式(Strategy Pattern) 策略模式定义了一系列算法,并将每一个算法封装起来,使它们可以互相替换。该模式让算法独立于使用它的客户而变化。 ```java public interface Strategy { int doOperation(int num1, int num2); } public class OperationAdd implements Strategy { @Override public int doOperation(int num1, int num2) { return num1 + num2; } } public class Context { private Strategy strategy; public Context(Strategy strategy){ this.strategy = strategy; } public int executeStrategy(int num1, int num2){ return strategy.doOperation(num1, num2); } } ``` 这段代码演示了一个简单的计算器应用,其中`Context`类使用不同的策略来进行加法运算[^5]。 #### 模板方法模式(Template Method Pattern) 模板方法模式在一个方法中定义了一个算法的骨架,而将一些步骤延迟到子类中。这样可以让子类在不改变算法结构的情况下重新定义某些特定步骤。 ```java public abstract class Game { abstract void initialize(); abstract void startPlay(); abstract void endPlay(); // Template method public final void play(){ // Initialize the game initialize(); // Start playing startPlay(); // End playing endPlay(); } } public class Cricket extends Game { @Override void initialize() { System.out.println("Cricket Game Initialized! Start playing."); } @Override void startPlay() { System.out.println("Cricket Game Started. Enjoy the game!"); } @Override void endPlay() { System.out.println("Cricket Game Finished!"); } } ``` 这里`Game`类中的`play()`是一个模板方法,它调用了几个抽象方法,这些方法的具体实现由子类如`Cricket`提供。 #### 观察者模式(Observer Pattern) 观察者模式是行为型模式的一种,当对象的状态发生改变时,所有依赖它的对象都会得到通知并自动更新。 ```java import java.util.ArrayList; import java.util.List; public class Subject { private List<Observer> observers = new ArrayList<>(); private int state; public void attach(Observer observer){ observers.add(observer); } public void detach(Observer observer){ observers.remove(observer); } public void notifyAllObservers(){ for (Observer observer : observers) { observer.update(); } } public int getState() { return state; } public void setState(int state) { this.state = state; notifyAllObservers(); } } public class BinaryObserver extends Observer { public BinaryObserver(Subject subject){ this.subject = subject; this.subject.attach(this); } @Override public void update() { System.out.println("Binary String: " + Integer.toBinaryString(subject.getState())); } } ``` 这个例子中,`Subject`类维护了一组`Observer`对象,并且在其状态发生变化时会通知所有的观察者[^5]。 #### 结论 以上提到的设计模式只是冰山一角,每种模式都有其适用场景和优点。理解并掌握这些设计模式可以帮助开发者编写出更加灵活、可维护和可靠的代码。在实际项目中选择合适的设计模式是非常重要的,同时也需要注意不要过度设计,以免增加不必要的复杂度。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Jackson Xi

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值