模板网站开发营销,深圳电器公司是国企吗,怎么做网站的搜索栏,湘潭网站建设 AA磐石网络文章目录 单例模式饿汉模式懒汉模式对比 工厂模式简单工厂模式#xff08;Simple Factory Pattern#xff09;工厂方法模式#xff08;Factory Method Pattern#xff09;抽象工厂模式#xff08;Abstract Factory Pattern#xff09;对比 单例模式
什么是单例#xff… 文章目录 单例模式饿汉模式懒汉模式对比 工厂模式简单工厂模式Simple Factory Pattern工厂方法模式Factory Method Pattern抽象工厂模式Abstract Factory Pattern对比 单例模式
什么是单例 系统运行期间有且仅有一个实例。为什么要有单例系统中的一些对象只需要初始化一次即可例如KTV中的播放器或者初始化系统参数单例模式的要求 一个类只有一个实例 只提供私有的构造器。 private SingletonClass(){ } 必须自己创建这个实例 定义该类的静态私有对象。 private static SingletonClass single; 必须自己向系统提供这个实例。 创建一个公共的静态方法返回这个实例。 public static SingletonClass getSingleton(){if(singlenull){initSingleton();}return single;
}饿汉模式
不管你用不用我都给你创建这个实例。官方语言在类加载的时候创建这个实例。 天然线程安全的每个类中获取这个对象的耗时基本一样
下面是饿汉模式使用静态内部类实现延迟加载。
public class SingleTon {private SingleTon() {}private static SingleTon singleTon;// 静态内部类public static class SingletonHelper{private static final SingleTon INSTANCE new SingleTon();}public static SingleTon getSingleTon() {singleTon SingletonHelper.INSTANCE;return singleTon;}}懒汉模式
在你调用的时候才创建这个实例。不是线程安全第一次获取此对象会耗时较多
线程安全问题double check 加锁优化编译器JIT,CPU有可能对指令执行重新排序导致使用到尚未初始化的实例nullpointException可以通过添加volatile关键字进行修饰对于volatile修饰的字段可以防止指令重排。
/*** 手写一个单例模式*/
public class SingletonClass {// 1.私有化构造方法收回创建实例的权限private SingletonClass(){}// 2.自己声明这个实例对象private volatile static SingletonClass singletonClass;// 3.向系统提供一个公共的方法获取这个实例public static SingletonClass getInstance(){if(singletonClassnull){ // 为空才加同步锁锁的范围越小越好synchronized (SingletonClass.class){if(singletonClassnull){ // 判断是否为空防止实例化两次singletonClass new SingletonClass();// 字节码 其中2和3可能存在重排的问题如果3在前在多线程的情况下会出现空指针// 1.分配空间// 2.初始化// 3.引用赋值}}}return singletonClass;}}对比
线程安全饿汉式天生就是线程安全的懒汉式本身是非线程安全的。资源加载和性能饿汉式在类创建的同时就实例化一个静态对象出来不管之后会不会使用这个单例都会占据一定的内存但是相应的在第一次调用时速度也会更快因为其资源已经初始化完成而懒汉式顾名思义会延迟加载在第一次使用该单例的时候才会实例化对象出来第一次调用时要做初始化如果要做的工作比较多性能上会有些延迟之后就和饿汉式一样了。
工厂模式
什么是工厂? 将对象的创建过程封装在一个工厂类中,通过调用工厂类的方法来获取对象实例,而不需要直接使用new关键字来创建对象为什么要有工厂模式? 工厂模式能够提供更好的代码组织结构、更好的封装性、更好的可扩展性和更好的解耦性从而提高了代码的质量和可维护性工厂模式的要求
抽象产品定义产品的共同接口或抽象类描述产品的特征和行为。具体产品实现抽象产品接口或继承抽象产品类是工厂创建的目标对象。
// 抽象产品接口
public interface Product {void operation1();void operation2();
}// 具体类A
public class ConcreteProductA implements Product {Overridepublic void operation1() {// 具体类A的操作1}Overridepublic void operation2() {// 具体类A的操作2}
}// 具体类B
public class ConcreteProductB implements Product {Overridepublic void operation1() {// 具体类B的操作1}Overridepublic void operation2() {// 具体类B的操作2}
}抽象工厂定义工厂的共同接口或抽象类描述创建产品的方法。具体工厂实现抽象工厂接口或继承抽象工厂类负责实际创建产品的类。客户端使用工厂创建产品的代码通过工厂接口来创建所需的产品对象。
# 定义抽象工厂接口
class AbstractFactory:def create_product_a(self):passdef create_product_b(self):pass# 实现具体的工厂类
class ConcreteFactory1(AbstractFactory):def create_product_a(self):return ProductA1()def create_product_b(self):return ProductB1()class ConcreteFactory2(AbstractFactory):def create_product_a(self):return ProductA2()def create_product_b(self):return ProductB2()# 定义产品接口
class AbstractProductA:def do_something(self):passclass AbstractProductB:def do_something(self):pass# 实现具体类
class ProductA1(AbstractProductA):def do_something(self):print(Product A1)class ProductA2(AbstractProductA):def do_something(self):print(Product A2)class ProductB1(AbstractProductB):def do_something(self):print(Product B1)class ProductB2(AbstractProductB):def do_something(self):print(Product B2)# 客户端代码
def client_code(factory):product_a factory.create_product_a()product_b factory.create_product_b()product_a.do_something()product_b.do_something()# 使用具体工厂1
factory1 ConcreteFactory1()
client_code(factory1)# 使用具体工厂2
factory2 ConcreteFactory2()
client_code(factory2)简单工厂模式Simple Factory Pattern
简单工厂模式又称为静态工厂模式它由一个工厂类来负责创建所有的产品对象。客户端只需要通过工厂类来创建产品对象而不需要直接实例化具体产品类。简单工厂模式的核心是一个工厂类它包含一个创建产品的方法根据客户端传入的参数来决定创建哪种产品。
# 定义产品接口
class Product:def show(self):pass# 定义具体类A实现接口
class ConcreteProductA(Product):def show(self):print(Concrete Product A)# 定义具体类B实现接口
class ConcreteProductB(Product):def show(self):print(Concrete Product B)# 定义静态工厂类
class StaticFactory:staticmethoddef create_product(product_type):if product_type A:return ConcreteProductA()elif product_type B:return ConcreteProductB()else:raise ValueError(Invalid product type)# 客户端代码
if __name__ __main__:product_a StaticFactory.create_product(A) # 使用静态工厂类创建具体Aproduct_a.show() # 调用具体A的方法输出 Concrete Product Aproduct_b StaticFactory.create_product(B) # 使用静态工厂类创建具体Bproduct_b.show() # 调用具体B的方法输出 Concrete Product B工厂方法模式Factory Method Pattern
工厂方法模式将具体产品的创建过程延迟到子类中进行每个具体产品都对应一个具体工厂类。客户端通过调用工厂方法来创建产品对象工厂方法由子类实现以创建对应的具体产品对象。
// 抽象类
public abstract class Product {public abstract void use();
}// 具体类A
public class ConcreteProductA extends Product {Overridepublic void use() {System.out.println(使用具体类A);}
}// 具体类B
public class ConcreteProductB extends Product {Overridepublic void use() {System.out.println(使用具体类B);}
}// 抽象工厂类
public abstract class Factory {public abstract Product createProduct();
}// 工厂类A
public class ConcreteFactoryA extends Factory {Overridepublic Product createProduct() {return new ConcreteProductA();}
}// 工厂类B
public class ConcreteFactoryB extends Factory {Overridepublic Product createProduct() {return new ConcreteProductB();}
}// 客户端代码
public class Client {public static void main(String[] args) {Factory factoryA new ConcreteFactoryA();Product productA factoryA.createProduct();productA.use();Factory factoryB new ConcreteFactoryB();Product productB factoryB.createProduct();productB.use();}
}抽象工厂模式Abstract Factory Pattern
抽象工厂模式提供了一种创建一系列相关或相互依赖对象的接口而无需指定其具体类。抽象工厂模式包含一个抽象工厂接口定义了用于创建产品对象的方法具体工厂类实现了抽象工厂接口并负责创建一系列相关产品。每个具体工厂类都对应于一个产品族可以创建该产品族的多个产品。
// 定义抽象A
interface AbstractProductA {void operationA();
}// 定义具体A1
class ConcreteProductA1 implements AbstractProductA {public void operationA() {System.out.println(Product A1);}
}// 定义具体A2
class ConcreteProductA2 implements AbstractProductA {public void operationA() {System.out.println(Product A2);}
}// 定义抽象B
interface AbstractProductB {void operationB();
}// 定义具体B1
class ConcreteProductB1 implements AbstractProductB {public void operationB() {System.out.println(Product B1);}
}// 定义具体B2
class ConcreteProductB2 implements AbstractProductB {public void operationB() {System.out.println(Product B2);}
}// 定义抽象工厂
interface AbstractFactory {AbstractProductA createProductA();AbstractProductB createProductB();
}// 定义具体工厂1
class ConcreteFactory1 implements AbstractFactory {public AbstractProductA createProductA() {return new ConcreteProductA1();}public AbstractProductB createProductB() {return new ConcreteProductB1();}
}// 定义具体工厂2
class ConcreteFactory2 implements AbstractFactory {public AbstractProductA createProductA() {return new ConcreteProductA2();}public AbstractProductB createProductB() {return new ConcreteProductB2();}
}// 调用方
public class Client {public static void main(String[] args) {// 创建工厂1AbstractFactory factory1 new ConcreteFactory1();// 使用工厂1创建A和BAbstractProductA productA1 factory1.createProductA();AbstractProductB productB1 factory1.createProductB();productA1.operationA();productB1.operationB();// 创建工厂2AbstractFactory factory2 new ConcreteFactory2();// 使用工厂2创建A和BAbstractProductA productA2 factory2.createProductA();AbstractProductB productB2 factory2.createProductB();productA2.operationA();productB2.operationB();}
}对比
简单工厂模式适用于对象种类较少且不会频繁变化的情况工厂方法模式适用于对象种类较多且可能会有新产品增加的情况抽象工厂模式适用于创建一组相关或相互依赖的产品且可能会有新的产品组合增加的情况。根据具体的需求和场景选择适合的工厂模式可以提高代码的灵活性和可维护性。简单工厂模式是通过一个工厂类来创建所有的产品对象根据不同的参数返回不同的具体产品对象。在多线程环境下如果多个线程同时调用工厂的创建方法可能会导致线程安全问题。解决这个问题的一种方式是在工厂类的创建方法上加锁保证同一时间只有一个线程能够调用该方法。工厂方法模式将产品的创建延迟到子类中每个产品有一个对应的工厂类来创建。在多线程环境下每个线程独立使用各自的工厂类创建产品对象不存在线程安全问题。不同的线程可以并发调用不同的工厂类创建产品互不干扰。抽象工厂模式通过提供一个接口来创建一系列相关或依赖对象的家族而不需要指定具体的类。在多线程环境下如果多个线程同时调用不同的具体工厂类创建产品对象也不存在线程安全问题。不同的线程可以并发调用不同的具体工厂类创建产品互不干扰。
