本文小编为大家详细介绍“怎么使用Java工厂模式创建对象及提高代码复用率和灵活性”,内容详细,步骤清晰,细节处理妥当,希望这篇“怎么使用Java工厂模式创建对象及提高代码复用率和灵活性”文章能帮助大家解决疑惑,下面跟着小编的思路慢慢深入,一起来学习新知识吧。
Java工厂设计模式主要分为三种:
简单工厂模式(Simple Factory Pattern):使用一个工厂类来封装对象创建的过程,客户端只需要通过传递不同的参数来获取不同的产品对象,从而避免了客户端直接创建产品对象的操作
工厂方法模式(Factory Method Pattern):将工厂类抽象出来,每个具体产品类对应一个具体工厂类,工厂类通过多态性来创建对应的产品对象,客户端只需要知道工厂接口及其实现类即可,可以根据需求动态切换工厂实现,扩展性更好.
抽象工厂模式(Abstract Factory Pattern):在工厂方法模式的基础上,将工厂类再进行一次抽象,将多个工厂接口放到一个工厂接口中,每个具体产品对应一个具体工厂类,通过多态性来创建对应的产品对象,具有更好的扩展性和更高的抽象程度,但是也增加了系统复杂度
首先先定义一个抽象产品类:
package com.fanqiechaodan.factory.simple.product;
/**
* @Classname Product
* @Description 抽象产品类
*/
public abstract class Product {
public abstract void use();
}
然后定义具体产品类
public class ProductA extends Product{
@Override
public void use() {
System.out.println("使用具体产品类A...");
}
}
public class ProductB extends Product{
@Override
public void use() {
System.out.println("使用具体产品类B...");
}
}
public class ProductC extends Product{
@Override
public void use() {
System.out.println("使用具体产品类C...");
}
}
接下来定义工厂类,用于创建不同的产品
package com.fanqiechaodan.factory.simple.factory;
import com.fanqiechaodan.factory.simple.product.Product;
import com.fanqiechaodan.factory.simple.product.ProductA;
import com.fanqiechaodan.factory.simple.product.ProductB;
import com.fanqiechaodan.factory.simple.product.ProductC;
/**
* @Classname SimpleFactory
* @Description 工厂类
*/
public class SimpleFactory {
public static Product createProduct(String type) {
switch (type) {
case "A":
return new ProductA();
case "B":
return new ProductB();
case "C":
return new ProductC();
default:
throw new RuntimeException("不支持的产品类型:" + type);
}
}
}
测试:
package com.fanqiechaodan.factory.simple;
import com.fanqiechaodan.factory.simple.factory.SimpleFactory;
import com.fanqiechaodan.factory.simple.product.Product;
/**
* @Classname Demo
* @Description 简单工厂模式
*/
public class Demo {
public static void main(String[] args) {
Product productA = SimpleFactory.createProduct("A");
productA.use();
Product productB = SimpleFactory.createProduct("B");
productB.use();
Product productC = SimpleFactory.createProduct("C");
productC.use();
Product productD = SimpleFactory.createProduct("D");
productD.use();
}
}
首先定义一个接口表示产品
package com.fanqiechaodan.factory.method.product;
/**
* @Classname Product
* @Description 产品接口
*/
public interface Product {
void use();
}
其次定义两个具体的产品实现类
public class ProductA implements Product{
@Override
public void use() {
System.out.println("使用具体产品A...");
}
}
public class ProductB implements Product{
@Override
public void use() {
System.out.println("使用具体产品B...");
}
}
然后定义一个工厂接口用于创建产品
package com.fanqiechaodan.factory.method.factory;
import com.fanqiechaodan.factory.method.product.Product;
/**
* @Classname Factory
* @Description 工厂接口
*/
public interface Factory {
Product createProduct();
}
接下来,定义两个具体的工厂实现类,分别用于创建不同的产品
public class FactoryA implements Factory{
@Override
public Product createProduct() {
return new ProductA();
}
}
public class FactoryB implements Factory{
@Override
public Product createProduct() {
return new ProductB();
}
}
测试
package com.fanqiechaodan.factory.method.factory;
import com.fanqiechaodan.factory.method.product.Product;
import com.fanqiechaodan.factory.method.product.ProductB;
/**
* @Classname FactoryB
* @Description 工厂实现类B
*/
public class FactoryB implements Factory{
@Override
public Product createProduct() {
return new ProductB();
}
}
首先定义抽象产品
public interface ProductA {
void doSomething();
}
public interface ProductB {
void doSomething();
}
其次定义具体产品
public class ProductA1 implements ProductA{
@Override
public void doSomething() {
System.out.println("ProductA1 doSomething ...");
}
}
public class ProductA2 implements ProductA{
@Override
public void doSomething() {
System.out.println("ProductA2 doSomething ...");
}
}
public class ProductB1 implements ProductB{
@Override
public void doSomething() {
System.out.println("ProductB1 doSomething ...");
}
}
public class ProductB2 implements ProductB{
@Override
public void doSomething() {
System.out.println("ProductB2 doSomething ...");
}
}
然后定义抽象工厂
package com.fanqiechaodan.factory.abstractfactory.factory;
import com.fanqiechaodan.factory.abstractfactory.product.ProductA;
import com.fanqiechaodan.factory.abstractfactory.product.ProductB;
/**
* @Classname AbstractFactory
* @Description 抽象工厂
*/
public interface AbstractFactory {
ProductA createProductA();
ProductB createProductB();
}
接下来定义具体工厂
public class Factory1 implements AbstractFactory{
@Override
public ProductA createProductA() {
return new ProductA1();
}
@Override
public ProductB createProductB() {
return new ProductB1();
}
}
public class Factory2 implements AbstractFactory{
@Override
public ProductA createProductA() {
return new ProductA2();
}
@Override
public ProductB createProductB() {
return new ProductB2();
}
}
测试
package com.fanqiechaodan.factory.abstractfactory;
import com.fanqiechaodan.factory.abstractfactory.factory.AbstractFactory;
import com.fanqiechaodan.factory.abstractfactory.factory.Factory1;
import com.fanqiechaodan.factory.abstractfactory.factory.Factory2;
import com.fanqiechaodan.factory.abstractfactory.product.ProductA;
import com.fanqiechaodan.factory.abstractfactory.product.ProductB;
/**
* @Classname Demo
* @Description 抽象工厂模式
*/
public class Demo {
public static void main(String[] args) {
// 使用具体工厂1创建产品A和产品B
AbstractFactory factory1 = new Factory1();
ProductA productA1 = factory1.createProductA();
ProductB productB1 = factory1.createProductB();
productA1.doSomething();
productB1.doSomething();
// 使用具体工厂2创建产品A和产品B
AbstractFactory factory2 = new Factory2();
ProductA productA2 = factory2.createProductA();
ProductB productB2 = factory2.createProductB();
productA2.doSomething();
productB2.doSomething();
}
}
读到这里,这篇“怎么使用Java工厂模式创建对象及提高代码复用率和灵活性”文章已经介绍完毕,想要掌握这篇文章的知识点还需要大家自己动手实践使用过才能领会,如果想了解更多相关内容的文章,欢迎关注亿速云行业资讯频道。
亿速云「云服务器」,即开即用、新一代英特尔至强铂金CPU、三副本存储NVMe SSD云盘,价格低至29元/月。点击查看>>
免责声明:本站发布的内容(图片、视频和文字)以原创、转载和分享为主,文章观点不代表本网站立场,如果涉及侵权请联系站长邮箱:is@yisu.com进行举报,并提供相关证据,一经查实,将立刻删除涉嫌侵权内容。
原文链接:https://blog.csdn.net/qq_43135259/article/details/129407352