文章目录
创建型模式
1.单例模式
单例模式(Singleton Pattern)是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类,该类负责创建自己的对象,同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式,可以直接访问,不需要实例化该类的对象。
- 注意:
- 1、单例类只能有一个实例。
- 2、单例类必须自己创建自己的唯一实例。
- 3、单例类必须给所有其他对象提供这一实例。
import java.util.HashSet;
import java.util.Set;
public class SingleInstance {
/**
* 我用一个private的Static的变量来存放我们的SIngleInstance的实例
*/
private static SingleInstance singleInstance = null;
/**
* 让构造方法编程私有的,这样我们可以防止在外面被其他类直接new出来,构造方 * 法同其它方法一样,也可以用private修饰,私有的构造方法无法在本类外部使 * 用,也就导致本类无法用new实例化,这样可以控制对象的生成。
*/
private SingleInstance() {
}
/**
* 我们提供一个静态的方法来创建我们的单例
* @return
*/
public static SingleInstance instance() throws InterruptedException {
Thread.sleep(1000);
if (singleInstance == null) {
synchronized (SingleInstance.class) {
if (singleInstance == null) {
System.out.println("我被new出来了");
singleInstance = new SingleInstance();
}
}
}
return singleInstance;
}
public static void main(String[] args) {
Runnable runnable = () -> {
try {
instance();
} catch (InterruptedException e) {
e.printStackTrace();
}
};
Set<Thread> threads = new HashSet<>();
for (int i = 0; i < 10; i++) {
threads.add(new Thread(runnable));
}
threads.forEach(t -> t.start());
}
}
参考链接:
https://www.cnblogs.com/qq895139140/p/7774152.html
1.1 懒汉式-线程不安全
单例类的实例在第一次被引用时候才被初始化。
public class Singleton {
private static Singleton instance=null;
private Singleton() {
}
public static Singleton getInstance(){
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
1.2 懒汉式-线程安全
这种方式效率比较低,性能不是太好,不过也可以用,因为是对整个方法加上了线程同步,其实只要在new的时候考虑线程同步就行了,这种方法不推荐使用。
public class Singleton {
private static Singleton instance=null;
private Singleton() {
}
public synchronized static Singleton getInstance(){
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
1.3 饿汉式
单例类的实例在加载的时候就被初始化。
public class Singleton {
private static Singleton instance = new Singleton();
private Singleton() {
}
public static Singleton getInstance(){
return instance;
}
}
1.4 懒汉式-同步代码块
synchronized同步块括号中的锁定对象是采用的一个无关的Object类实例,而不是采用this,因为getInstance是一个静态方法,在它内部不能使用未静态的或者未实例的类对象
public class Singleton {
private static Singleton instance;
private final static Object syncLock = new Object();
private Singleton() {
}
public static Singleton getInstance(){
if (instance == null) {
synchronized (syncLock) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
1.5 懒汉式–同步类(最终)
public class Singleton {
private static Singleton instance;
private Singleton() {
}
public static Singleton getInstance(){
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
2. 简单工厂
简单来说:简单工厂模式主要是工厂类根据参数的不同来创建不同类的实例,通常这些不同类拥有同一个父类。因为静态方法,也叫做静态工厂模式。
其实JDK中也广泛使用了这种模式,如DataFormat类,根据参数不同,会创建data、time、datatime类等等。
2.1 简单实现
- 简单工厂模式属于类创建型模式
- 可以根据参数的不同返回不同的实例
- 专门创建一个类来创建其他类的实例
- 被创建的实例通常具有共同的父类
简单工厂中的角色:
- 抽象产品类
- 产品子类
- 工厂类
abstract class Product{
public void use() {
}
}
class ProductA extends Product {
public void use(){
System.out.println(使用了产品A);
}
}
class ProductB extends Product {
public void use(){
System.out.println(使用了产品B);
}
}
class Factory{
public static Product createProduct(String type){
if (type.equals(A)){
return new ProductA();
}else if (type.equals(B)) {
return new ProductB();
}
return new ProductA();
}
}
*/
2.2 优缺点
-
优点:创建由专门的工厂类负责,客户端成员不用关心其是怎么创建的,直接使用就行。
- (1)工厂类包含必要的逻辑判断,可以决定在什么时候创建哪一个产品的实例。客户端可以免除直接创建产品对象的职责
- (2)客户端无需知道所创建具体产品的类名,只需知道参数即可
-
缺点:工厂类不够灵活,如何新增一个产品,则需要修改逻辑,如果产品越多,则越复杂。
- (1)工厂类集中了所有产品的创建逻辑,职责过重,一旦异常,整个系统将受影响
- (2)使用简单工厂模式会增加系统中类的个数(引入新的工厂类),增加系统的复杂度和理解难度
- (3)系统扩展困难,一旦增加新产品不得不修改工厂逻辑,在产品类型较多时,可能造成逻辑过于复杂,违反开发封闭原则。
2.3适用环境
- (1)工厂类负责创建对的对象比较少,因为不会造成工厂方法中的业务逻辑过于复杂
- (2)客户端只知道传入工厂类的参数,对如何创建对象不关心
2.4 扩充
工厂类:
根据参数,创建A/B产品,普通
直接多个方法,创建A/B产品,多方法
静态方法,创建A/B产品,静态方法
3. 工厂模式
3.1 简单工厂模式:
3.2 工厂模式:
注:从图上看,感觉更复杂了,但是,计算机中有一个“开闭原则”(扩展优于修改),这里举个例子,一个工厂,生产拖拉机,然后又生产口罩,那么为了更好的区别,最好是工厂下有个拖拉机工厂,有一个口罩工厂。
Jdk同样也用了这种思想:
4.抽象工厂方法
对类进行区分,如果都生产手机,你要生产口罩,则工厂方法就显得不合适了,因为接口功能不一样了,所以增加一个产品接口,表示一个大类,然后在工厂接口中,可以同时创建手机和口罩的对象,但是这样明显也违反了“开发封闭”原则。
5. 原型模型
6. 生成器模型
在产品结构比较复杂,构造过程比较繁琐,一次性构造比较难的时候,我们可以采取分而治之的原则,将产品组件化,每个组件由专门的厂商来生产,最后的产品指派给制定的车间进行最后装配.这种方式其实是现代制造业的一种典型的模式.比如汽车,飞机的制造等.这样做的好处是:
- 1.产品的部件由专门的生产厂商来生产,这样分工更加明确,更加精细,生产专业化,可以降低成本;
- 2.整个产品的生产更加简单,也可增加零件的复用.
- 3.转换生产比较容易,比如产品的材质发生变化,只需要找相应提供该材质的厂商即可.