Java设计模式

最新推荐文章于 2024-09-17 18:28:18 发布

做自己想变成的那个人

最新推荐文章于 2024-09-17 18:28:18 发布

阅读量120

点赞数

分类专栏：设计模式文章标签：设计模式 java

本文链接：https://blog.csdn.net/kuaimeidong/article/details/103882652

版权

设计模式专栏收录该内容

0 篇文章 0 订阅

订阅专栏

Java设计模式：简单工厂模式、工厂方法模式、抽象工厂模式、代理模式、单例模式
（持续更新中……）

0.简单工厂模式

举例：生产电脑，分为hp电脑和lenovo电脑

简单工厂模式分为三种：

01.普通

	//创建两个电脑的共同接口
	public interface Computer{
		public void create();
	}
	//创建两个实现类
	public class HpComputer implements Computer{
		@Override
		public void create(){
			System.out.println("this is HpComputer");
		}
	}
	public class LenovoComputer implements Computer{
		@Override
		public void create(){
			System.out.println("this is LenovoComputer");
		}
	}
	//创建工厂类
	public class ComputerFactory{
		public Computer produce(String type){
			if("Hp".equals(type)){
				return new HpComputer();
			}else if("Lenovo".equals(type)){
				return new LenovoComputer();
			}else{
				System.out.println("请输入正确的类型！");
				return null;
			}
		}
	}
	//测试
	public class FactoryTest{
		public static void main(String[] args){
			ComputerFactory factory = new ComputerFactory();
			Computer computer = factory.produce("Hp");
			computer.create();
		}
	}
	//输出：this is HpComputer

02.多个方法

对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象而多个工厂方法模式是提供多个工厂方法，分别创建对象。

	//修改ComputerFactory
	public class ComputerFactory{
		public Computer produceHp(){
			return new HpComputer();
		}
		public Computer produceLenovo(){
			return new LenovoComputer();
		}
	}
	//测试
	public class FactoryTest{
		public static void main(String[] args){
			ComputerFactory factory = new ComputerFactory();
			Computer computer = factory.produceHp();
			computer.create();
		} 
	}
	//输出： this is HpComputer

03.多个静态方法

将上面的多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可。

	//修改ComputerFactory
	public class ComputerFactory{
		public static Computer produceHp(){
			return new HpComputer();
		}
		public static Computer produceLenovo(){
			return new LenovoComputer();
		}
	}
	//测试
	public class FactoryTest{
		public static void main(String[] args){
			Computer computer = ComputerFactory.produceHp();
			computer.create();
		} 
	}
	//输出： this is HpComputer

总体来说，工厂模式适合：凡是出现了大量的产品需要创建，并且具有共同的接口时，可以通过简单工厂模式进行创建。

在以上的三种模式中，第一种如果传入的字符串有误，不能正确创建对象，第三种相对于第二种，不需要实例化工厂类，所以，大多数情况下，我们会选用第三种——静态工厂方法模式。

1.工厂方法模式

简单工厂模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，因此，就用到工厂方法模式。一旦需要增加新的功能，直接增加新的接口实现类和新的工厂类就可以了，不需要修改之前的代码。

	//创建两个电脑的共同接口
	public interface Computer{
		public void create();
	}
	//创建两个实现类
	public class HpComputer implements Computer{
		@Override
		public void create(){
			System.out.println("this is HpComputer");
		}
	}
	public class LenovoComputer implements Computer{
		@Override
		public void create(){
			System.out.println("this is LenovoComputer");
		}
	}
	//创建两个工厂类
	public class HpComputerFactory implements Provider{
		@Override
		public Computer produce(){
			return new HpComputer();
		}
	}
	public class LenovoComputerFactory implements Provider{
		@Override
		public Computer produce(){
			return new LenovoComputer();
		}
	}
	//再提供一个工厂接口
	public interface Provider{
		public Computer produce();
	}
	//测试类
	public class Test{
		public static void main(String[] args){
			Provider provider = new HpComputerFactory();
			Computer computer = provider.produce();
			computer.create();
		}
	}
	//输出： this is HpComputer

其实这个模式的好处就是，如果你现在想增加一个功能：创建华硕电脑，则只需做一个实现类，实现Computer接口，同时做一个工厂类，实现Provider接口，就OK了，无需去改动现成的代码。这样做，拓展性较好！

2.抽象工厂模式

我们一直都是生产联想和惠普的电脑，但是电脑也有多个产品线：台式机、笔记本和平板等等，联想和惠普都在生产这些不同产品线上的电脑，使用工厂方法模式已经满足不了需求，因此我们需要使用抽象工厂模式来解决这一问题。

抽象产品

	//定义抽象产品类
	public abstract class DesktopComputer {
	  public abstract void start();
	}
	public abstract class NotebookComputer {
	   public abstract void start();
	}

两个抽象产品类分别为DesktopComputer和NotebookComputer ，用来定义两个产品线：台式机和笔记本。它们都定义了start方法，用来启动电脑。

具体产品

具体产品为联想和惠普旗下的台式机和笔记本，如下所示。

	public class LenovoDesktopComputer extends DesktopComputer {
		@Override
		public void start() {
			System.out.println("联想台式电脑启动");
		}
	}

	public class HpDesktopComputer extends DesktopComputer {
		@Override
		public void start() {
			System.out.println("惠普台式电脑启动");
		}
	}

	public class LenovoNotebookComputer extends NotebookComputer {
		@Override
		public void start() {
			System.out.println("联想笔记本电脑启动");
		}
	}
	public class HpNotebookComputer extends NotebookComputer {
		@Override
		public void start() {
			System.out.println("惠普笔记本电脑启动");
		}
	}

抽象工厂

接着创建生产电脑的抽象工厂，如下所示，

	public abstract class ComputerFactory {
		public abstract DesktopComputer createDesktopComputer();
		public abstract NotebookComputer createNotebookComputer();
	}

定义了两个方法，分别用来生产台式电脑和笔记本电脑

具体工厂

定义联想和惠普工厂：

   public class LenovoFactory extends ComputerFactory {
		@Override
		public DesktopComputer createDesktopComputer() {
			return new LenovoDesktopComputer();
		}
		@Override
		public NotebookComputer createNotebookComputer() {
			return new LenovoNotebookComputer();
		}
	}

	public class HpFactory extends ComputerFactory {
		@Override
		public DesktopComputer createDesktopComputer() {
			return new HpDesktopComputer();
		}

		@Override
		public NotebookComputer createNotebookComputer() {
			return new HpNotebookComputer();
		}
	}

联想工厂和惠普工厂用来生产台式机和笔记本这两个不同产品线的电脑。

客户端调用

	public class Client {
			public static void main(String[]args) {
				ComputerFactory lenocoFactory=new LenovoFactory();
				lenocoFactory.createDesktopComputer().start();
				lenocoFactory.createNotebookComputer().start();
				ComputerFactory hpFactory=new HpFactory();
				hpFactory.createDesktopComputer().start();
				hpFactory.createNotebookComputer().start();
			}
	}

工厂方法创建 “一种” 产品，他的着重点在于"怎么创建"。
抽象工厂需要创建一些列产品，着重点在于"创建哪些"产品上。

3.代理模式

其实每个模式名称就表明了该模式的作用，代理模式就是多一个代理类出来，替原对象进行一些操作，比如我们在租房子的时候回去找中介，为什么呢？因为你对该地区房屋的信息掌握的不够全面，希望找一个更熟悉的人去帮你做，此处的代理就是这个意思。再如我们有的时候打官司，我们需要请律师，因为律师在法律方面有专长，可以替我们进行操作。

	//接口类：
	package proxy.staticproxy;
	public interface Person {
		void giveMoney();
	}
	
	//一个实现了接口类的实体类：
	package proxy.staticproxy;
	public class Student implements Person {
		@Override
		public void giveMoney() {
			System.out.println(name +" 上交班费50元！");
		}
		private String name;

		public Student(String name){
			this.name = name;
		}
	}
	
	//一个代理类，代理类实现了接口类，并且还“爱管闲事”，调用了上面实体类的方法。
	package proxy.staticproxy;
	/**
	 * 如果使用动态代理这个类会被自动创建， 代理类的工作就是把实体类接过来，然后调用它的方法，也就是说本来实体类可以自己执行的方法现在由代理类来触发执行，这样做的好处是，在调用实体类方法的前后我们可以插入监控方法。比如这里只插入了一句话“这位同学最近学习有进步”
	 */
	public class StudentProxy implements Person {
		@Override
		public void giveMoney() {
			System.out.println("这位同学最近学习有进步！");
			stu.giveMoney();
		}

		Student stu;

		public StudentProxy (Person stu){
			if(stu.getClass() == Student.class){ //person 可以是学生，老师等， 但是这里只为学生交钱
				this.stu = (Student)stu;
			}
		}
	}
	
	//最后有一个统管类, 生成一个实体类，并指挥代理类去调用实体类：
	public class StaticProxyTest {
		public static void main(String[] args) {
			Person zhangsan = new Student("张三");

			Person monitor = new StudentProxy(zhangsan); // 为了帮张三交班费而生产一个班长角色
			monitor.giveMoney();
		}
	}

代理模式的应用场景：
如果已有的方法在使用的时候需要对原有的方法进行改进，此时有两种办法：

1、修改原有的方法来适应。这样违反了“对扩展开放，对修改关闭”的原则。

2、就是采用一个代理类调用原有的方法，且对产生的结果进行控制。这种方法就是代理模式。使用代理模式，可以将功能划分的更加清晰，有助于后期维护！

4.单例模式

单例类只能有一个实例；单例类必须自己创建自己的唯一实例；单例类必须给所有其他对象提供这一实例。

主要解决：一个全局使用的类频繁地创建与销毁。

（1）懒汉式，线程不安全

是否 Lazy 初始化：是
是否多线程安全：否
实现难度：易
描述：这种方式是最基本的实现方式，这种实现最大的问题就是不支持多线程。因为没有加锁 synchronized，所以严格意义上它并不算单例模式。这种方式 lazy loading 很明显，不要求线程安全，在多线程不能正常工作。

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

（2）懒汉式，线程安全

是否 Lazy 初始化：是
是否多线程安全：是
实现难度：易
描述：这种方式具备很好的 lazy loading，能够在多线程中很好的工作，但是，效率很低，99% 情况下不需要同步。
优点：第一次调用才初始化，避免内存浪费。
缺点：必须加锁 synchronized 才能保证单例，但加锁会影响效率。getInstance() 的性能对应用程序不是很关键（该方法使用不太频繁,其实只有在创建对象的时候才需要加锁）。

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

（3）饿汉式

是否 Lazy 初始化：否
是否多线程安全：是
实现难度：易
描述：这种方式比较常用，但容易产生垃圾对象。
优点：没有加锁，执行效率会提高。
缺点：类加载时就初始化，浪费内存。
描述：它基于 classloader 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用 getInstance 方法，但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance 显然没有达到 lazy loading 的效果。

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

（4）双检锁/双重校验锁

JDK 版本：JDK1.5 起
是否 Lazy 初始化：是
是否多线程安全：是
实现难度：较复杂
描述：这种方式采用双锁机制，安全且在多线程情况下能保持高性能。getInstance() 的性能对应用程序很关键。

	public class Singleton {  
			private volatile static Singleton singleton;  
			private Singleton (){}  
			public static Singleton getSingleton() {  
			if (singleton == null) {  
				synchronized (Singleton.class) {  
				if (singleton == null) {  
					singleton = new Singleton();  
				}  
				}  
			}  
			return singleton;  
			}  
		}

（5）登记式/静态内部类

是否 Lazy 初始化：是
是否多线程安全：是
实现难度：一般
描述：这种方式能达到双检锁方式一样的功效，但实现更简单。对静态域使用延迟初始化，应使用这种方式而不是双检锁方式。这种方式只适用于静态域的情况，双检锁方式可在实例域需要延迟初始化时使用（？）。这种方式同样利用了 classloader 机制来保证初始化 instance 时只有一个线程，它跟第 3 种方式不同的是：第 3 种方式只要Singleton 类被装载了，那么 instance 就会被实例化（没有达到 lazy loading 效果），而这种方式是 Singleton 类被装载了，instance 不一定被初始化。因为 SingletonHolder 类没有被主动使用，只有通过显式调用 getInstance 方法时，才会显式装载 SingletonHolder 类，从而实例化 instance。想象一下，如果实例化 instance 很消耗资源，所以想让它延迟加载，另外一方面，又不希望在 Singleton 类加载时就实例化，因为不能确保 Singleton 类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化 instance 显然是不合适的。这个时候，这种方式相比第 3 种方式就显得很合理。

	public class Singleton {  
		private static class SingletonHolder {  
		private static final Singleton INSTANCE = new Singleton();  
		}  
		private Singleton (){}  
		public static final Singleton getInstance() {  
		return SingletonHolder.INSTANCE;  
		}  
	}

（6）枚举

JDK 版本：JDK1.5 起
是否 Lazy 初始化：否
是否多线程安全：是
实现难度：易
描述：这种实现方式还没有被广泛采用，但这是实现单例模式的最佳方法。它更简洁，自动支持序列化机制，绝对防止多次实例化。这种方式是 Effective Java 作者 Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化。不过，由于 JDK1.5 之后才加入 enum 特性，用这种方式写不免让人感觉生疏，在实际工作中，也很少用。不能通过 reflection attack 来调用私有构造方法。

	public enum Singleton {  
		INSTANCE;  
		public void whateverMethod() {  
		}  
	}

经验之谈：一般情况下，不建议使用第 1 种和第 2 种懒汉方式，建议使用第 3 种饿汉方式。只有在要明确实现 lazy loading 效果时，才会使用第 5 种登记方式。如果涉及到反序列化创建对象时，可以尝试使用第 6 种枚举方式。如果有其他特殊的需求，可以考虑使用第 4 种双检锁方式。

优点：

1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。

2、避免对资源的多重占用（比如写文件操作）。

缺点：

1、违反了单一责任链原则，测试困难

单例类的职责过重，在一定程度上违背了“单一职责原则”。因为单例类既充当了工厂角色，提供了工厂方法，同时又充当了产品角色，包含一些业务方法，将产品的创建和产品的本身的功能融合到一起。

2、扩展困难

由于单例模式中没有抽象层，因此单例类的扩展有很大的困难。修改功能必须修改源码。

3、共享资源有可能不一致。

现在很多面向对象语言(如Java、C#)的运行环境都提供了自动垃圾回收的技术，因此，如果实例化的共享对象长时间不被利用，系统会认为它是垃圾，会自动销毁并回收资源，下次利用时又将重新实例化，这将导致共享的单例对象状态的丢失。

应用场景：

1、要求生产唯一序列号。

2、WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。

3、创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。

做自己想变成的那个人

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录