当前位置：移动技术网 > IT编程>开发语言>Java > 设计模式

设计模式

2018年05月29日 | 移动技术网IT编程 | 我要评论

一、单例模式

参考博客：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);
	}

}

二、策略模式

按照不同策略给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();
	}
}

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

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

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

3、抽象工厂

主要针对产品族的扩展，新增产品族时，只需要新增工厂即可

Food接口对象与Cloth接口对象组成一个产品集合，同一系列的产品成为一个产品族

/**
 * Abstract Factory
 * @author DELL
 *
 */
public abstract class AbstractFactory {
	abstract Food CreateFood();
	abstract Cloth CreateCloth();

	public static void main(String[] args) {
		System.out.println("创建A族产品：");
		AbstractFactory fA = new AFactory();
		Food foodA = fA.CreateFood();
		foodA.eat();
		Cloth clothA = fA.CreateCloth();
		clothA.use();
		
		System.out.println("创建B族产品：");
		AbstractFactory fB = new BFactory();
		Food foodB = fB.CreateFood();
		foodB.eat();
		Cloth clothB = fB.CreateCloth();
		clothB.use();
	}

}

/**
 * A工厂，生产A族系列产品
 * @author DELL
 *
 */
class AFactory extends AbstractFactory{
	@Override
	Food CreateFood() {
		return new FoodA();
	}

	@Override
	Cloth CreateCloth() {
		return new ClothA();
	}
}

/**
 * B工厂，生产B族系列产品
 * @author DELL
 *
 */
class BFactory extends AbstractFactory{
	@Override
	Food CreateFood() {
		return new FoodB();
	}

	@Override
	Cloth CreateCloth() {
		return new ClothB();
	}
}
/**
 * Food接口
 * @author DELL
 *
 */
interface Food{
	void eat();
}

/**
 * Cloth接口
 * @author DELL
 *
 */
interface Cloth{
	void use();
}

/**
 * Food A系列
 * @author DELL
 *
 */
class FoodA implements Food{

	@Override
	public void eat() {
		System.out.println("A吃法");
	}
}

/**
 * Cloth A系列
 * @author DELL
 *
 */
class ClothA implements Cloth{

	@Override
	public void use() {
		System.out.println("A用法");
	}
}

/**
 * Food B系列
 * @author DELL
 *
 */
class FoodB implements Food{

	@Override
	public void eat() {
		System.out.println("B吃法");
	}
}

/**
 * Cloth B系列
 * @author DELL
 *
 */
class ClothB implements Cloth{

	@Override
	public void use() {
		System.out.println("B用法");
	}
}

本文地址：https://blog.csdn.net/Lyh_2015/article/details/107367213

您可能感兴趣的文章:

如对本文有疑问，点击进行留言回复！！

Flume 史上最全面的大数据学习第十篇（一）别再说不知道flume是什么了

昨天没有增加小粉丝，我反思了一下自己，是不是我写的东西太过枯燥了呀！挺难受的！算了还是不说了，每天都是美好的一天... [阅读全文]
一直想学习Java网络编程，却不知道怎么入门？

其实，我刚学习Netty的时候，也是很迷茫的，直到有一天，一个同事收到了阿里的offer，他要去阿里做中台了，临... [阅读全文]
SpringCloud相关笔记一系统架构的演变(一)

SpringCloudSpringBoot 四种属性注入小结1.@Autowired注入2.构造方法注入3.@B... [阅读全文]
面试官：说说Kafka控制器事件处理全流程

前言大家好，我是 yes。这是Kafka源码分析第四篇文章，今天来说说 Kafka控制器，即 Kafka Con... [阅读全文]
Filecoin爆雷隐患，你都知道吗？

ICO四年之后，有消息称，圈内明星项目Filecoin不就就要主网上线了。这个500亿美元市值的项目，主网上线时... [阅读全文]
JAVA Bridge桥接模式

桥接模式一个复杂类中可能包括了多个维度的属性行为，桥接模式在逻辑上可以将这些维度进行分离，分离为抽象部分（接口）... [阅读全文]
菜鸟初学单片机IO扩展（并转串）

峰峰说学会IO扩展（并转串）还是蛮重要；接下来一起看下以下学习点哈~74HC165是8位并行输入，串行 ... [阅读全文]
荐基于 Servlet+jsp+mysql 开发 javaWeb 学生网络考试系统

你知道的越多，你不知道的越多点赞再看，养成习惯如果您有疑问或者见解，或者没有积分想获取项目，欢迎指教：企鹅：86... [阅读全文]
MySQL相关知识整理

一、MySQL和JAVA字段类型的对应关系1、对应关系表整理2、对应关系应当注意的地方3.timestamp和 ... [阅读全文]
ARM体系架构—ARMv7-A指令集：协处理器指令

ARM体系架构—ARMv7-A指令集一、ARMv7-A指令集二、ARMv7-A协处理器二、ARMv7-A协处理器... [阅读全文]