Java常用设计模式

最新推荐文章于 2024-05-11 15:59:02 发布

青衫红叶

最新推荐文章于 2024-05-11 15:59:02 发布

阅读量209

点赞数

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

本文链接：https://blog.csdn.net/Lyh_2015/article/details/107367213

版权

Java 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

一、单例模式

参考博客：https://www.cnblogs.com/happy4java/p/11206105.html

1、枚举实现

/**
 * 枚举类实现单例模式，保证单一性和线程安全
 * @author DELL
 *
 */
public enum Singleton1 {

	/**
	 * 单例变量
	 */
	INSTANCE;
	
	public void doSomething() {
		System.out.println("do something ...");
	}
	
	/**
	 * 程序入口
	 * @param args
	 */
	public static void main(String[] args) {
		Singleton1.INSTANCE.doSomething();
	}
}

2、饿汉式

2.1 代码实现

/**
 * 饥汉模式
 * @author DELL
 *
 */
public class Singleton2 {

	/**
	 * 初始化直接创建单例
	 */
	private static final Singleton2 instance = new Singleton2();
	
	/**
	 * 构造器私有化
	 */
	private Singleton2() {
	}

	/**
	 * 获取单例接口
	 * @return
	 */
	public static Singleton2 getInstance() {
		return instance;
	}
	
	
	/**
	 * 程序入口
	 * @param args
	 */
	public static void main(String[] args) {
		System.out.println(Singleton2.getInstance().hashCode());
		
		System.out.println(Singleton2.getInstance().hashCode());
	}

}

2.2 JDK源码使用示例

Runtime类

3、懒汉式（双重检查加锁）

/**
 * 懒汉模式
 * @author DELL
 *
 */
public class Singleton3 {

	/**
	 * 初始化不创建单例
	 */
	private static volatile Singleton3 instance;
	
	/**
	 * 构造器私有化
	 */
	private Singleton3() {
	}

	/**
	 * 获取单例接口，双重检查加锁，保证线程安全
	 * @return
	 */
	public static Singleton3 getInstance() {
		if(null == instance) {
			synchronized (Singleton3.class) {
				if(null == instance) {
					instance = new Singleton3();
				}
			}
		}
		return instance;
	}
	
	
	/**
	 * 程序入口
	 * @param args
	 */
	public static void main(String[] args) {
		System.out.println(Singleton3.getInstance().hashCode());
		
		System.out.println(Singleton3.getInstance().hashCode());
	}

}

4、静态内部类实现懒汉式

/**
 * 静态内部类实现单例
 * @author DELL
 *
 */
public class Singleton4 {
	
	/**
	 * 静态内部类只会初始化一次，线程安全懒加载
	 * @author DELL
	 *
	 */
	public static class Inner{
		/**
		 * 单例对象初始化放到静态内部类中
		 */
		private static Singleton4 instance = new Singleton4();
	}
	
	/**
	 * 构造器私有化
	 */
	private Singleton4(){
	}
	
	/**
	 * 获取单例对象
	 * @return
	 */
	public Singleton4 getInstance() {
		return Inner.instance;
	}
	
	/**
	 * 程序入口
	 * @param args
	 */
	public static void main(String[] args) {
		System.out.println(Inner.instance);
	}

}

二、策略模式

1、Comparator接口实现示例

按照不同策略给Dog对象排序，sort方法传入不同比较器即可

策略1使用匿名内部类实现Comparator接口创建对象

策略2使用lambda表达式实现Comparator接口创建对象

策略3使用lambda表达式实现Comparator接口创建对象

import java.util.Arrays;
import java.util.Comparator;

public class Strategy {

	public static void main(String[] args) {
		Dog[] ds = {new Dog(1, 5), new Dog(3, 4), new Dog(2, 6)};
		
		/**
		 * 按体重排序，从小到大
		 */
		Arrays.sort(ds, new Comparator<Dog>() {
			@Override
			public int compare(Dog o1, Dog o2) {
				return o1.weight - o2.weight;
			}
		});
		System.out.println("按体重正序排序： "+ Arrays.toString(ds));
		
		/**
		 * 按身高排序，从小到大
		 */
		Arrays.sort(ds, (Dog o1, Dog o2) -> {
			return o1.height - o2.height;
		});
		System.out.println("按身高正序排序： "+ Arrays.toString(ds));
		
		/**
		 * 按体重加身高排序，从小到大
		 */
		Arrays.sort(ds, (Dog o1, Dog o2) -> (o1.weight + o1.height) - (o2.weight + o2.height));
		System.out.println("按体重加身高正序排序： "+ Arrays.toString(ds));
	}

}

class Dog{
	public int weight;
	public int height;
	
	public Dog(int weight, int height) {
		super();
		this.weight = weight;
		this.height = height;
	}

	@Override
	public String toString() {
		return "Dog [weight=" + weight + ", height=" + height + "]";
	}
	
}

三、工厂模式

参考博客：https://blog.csdn.net/A1342772/article/details/91349142

产品类实现代码

interface Product {
	void show();
}

class ProductA implements Product {

	@Override
	public void show() {
		System.out.println("产品A");
	}
}

class ProductB implements Product {

	@Override
	public void show() {
		System.out.println("产品B");
	}
}

1、简单工厂/静态工厂

简单工厂代码：

/**
 * Simple Factory
 * @author DELL
 *
 */
public class SimpleFactory {
	
	public Product createProductA() {
		return new ProductA();
	}
	
	public Product createProductB() {
		return new ProductB();
	}

	/**
	 * main方法
	 * @param args
	 */
	public static void main(String[] args) {
		
		Product p1 = new SimpleFactory().createProductA();
		p1.show();
		
		Product p2 = new SimpleFactory().createProductB();
		p2.show();
	}
}

静态工厂代码：

/**
 * Static Factory
 * @author DELL
 *
 */
public class StaticFactory {

	/**
	 * createProduct
	 * @param productType
	 * @return
	 */
	public static Product createProduct(String productType) {
		Product product = null;
		if("A".equals(productType)) {
			product = new ProductA();
		}else if("B".equals(productType)) {
			product = new ProductB();
		}
		return product;
	}

	/**
	 * main方法
	 * @param args
	 */
	public static void main(String[] args) {
		
		Product p1 = StaticFactory.createProduct("A");
		p1.show();
		
		Product p2 = StaticFactory.createProduct("B");
		p2.show();
	}
}

说明：当工厂类的生产方法被声明为静态方法时，也可称之为静态工厂

简单工厂/静态工厂：将创建产品过程封装到工厂类的创建方法中。

缺点：新增产品后，需要修改工厂类的创建方法

2、工厂方法

工厂方法代码：

/**
 * Factory Method
 * @author DELL
 *
 */
public class FactoryMethod {
	/**
	 * main
	 * @param args
	 */
	public static void main(String[] args) {
		Product p1 = new FactoryA().create();
		p1.show();

		Product p2 = new FactoryB().create();
		p2.show();
	}
}

interface Factory {
	Product create();
}

class FactoryA implements Factory {
	@Override
	public Product create() {
		return new ProductA();
	}
}

class FactoryB implements Factory {
	@Override
	public Product create() {
		return new ProductB();
	}
}

说明：工厂方法将具体产品的创建推迟到子类，由具体工厂实现创建产品过程

优点：新增产品后，只需要新增对应具体工厂即可

缺点：具体产品与具体工厂耦合，创建产品时需要创建具体工厂