设计模式之-6大设计原则简单易懂的理解以及它们的适用场景和代码示列
设计模式之-单列设计模式,5种单例设计模式使用场景以及它们的优缺点
设计模式之-3种常见的工厂模式简单工厂模式、工厂方法模式和抽象工厂模式,每一种模式的概念、使用场景和优缺点。
设计模式之模板方法模式,通俗易懂快速理解,以及模板方法模式的使用场景
设计模式之-建造者模式通俗易懂理解,以及建造者模式的使用场景和示列代码
设计模式之-代理模式,快速掌握理解代理模式,以及代理模式的使用场景
设计模式之-原型模式,快速掌握原型模式,通俗易懂的理解原型模式以及使用场景
设计模式之-中介者模式,快速掌握中介者模式,通俗易懂的讲解中介者模式以及它的使用场景
设计模式之-责任链模式,快速掌握责任链模式,通俗易懂的讲解责任链模式以及它的使用场景
设计模式之-装饰模式,快速掌握装饰模式,通俗易懂的讲解装饰模式以及它的使用场景
当谈到工厂模式时,通常指的是三种常见的工厂模式:简单工厂模式、工厂方法模式和抽象工厂模式。下面我将详细讲解每一种模式的概念、使用场景和优缺点。
概念:简单工厂模式通过一个工厂类来创建不同类型的对象,客户端只需要知道所需对象的类型即可。
使用场景:当对象的创建逻辑相对简单且不需要频繁修改时,可以使用简单工厂模式。
优点:客户端代码与具体产品解耦,易于扩展和维护。
缺点:违反了开闭原则,新增产品需要修改工厂类的代码,不符合开放封闭原则。
概念:工厂方法模式将对象的创建延迟到子类中,由子类决定具体创建哪个对象。
使用场景:当需要创建一组相关或相互依赖的对象时,可以使用工厂方法模式。
优点:符合开闭原则,新增产品只需要添加相应的工厂类,不需要修改现有代码。
缺点:增加了系统的复杂度,每个产品都需要一个对应的工厂类。
概念:抽象工厂模式提供一个接口,用于创建一系列相关或相互依赖的对象,而不需要指定具体的类。
使用场景:当需要创建一组相关对象的产品族时,可以使用抽象工厂模式。
优点:符合开闭原则,新增产品族只需要添加相应的具体工厂类,不需要修改现有代码。
缺点:增加了系统的复杂度,每个产品族都需要一个对应的具体工厂类。
// 产品接口
interface Product {
void operation();
}
// 具体产品A
class ConcreteProductA implements Product {
@Override
public void operation() {
System.out.println("ConcreteProductA operation");
}
}
// 具体产品B
class ConcreteProductB implements Product {
@Override
public void operation() {
System.out.println("ConcreteProductB operation");
}
}
// 简单工厂类
class SimpleFactory {
public static Product createProduct(String type) {
if (type.equals("A")) {
return new ConcreteProductA();
} else if (type.equals("B")) {
return new ConcreteProductB();
}
return null;
}
}
// 客户端代码
public class Main {
public static void main(String[] args) {
Product productA = SimpleFactory.createProduct("A");
productA.operation();
Product productB = SimpleFactory.createProduct("B");
productB.operation();
}
}
// 产品接口
interface Product {
void operation();
}
// 具体产品A
class ConcreteProductA implements Product {
@Override
public void operation() {
System.out.println("ConcreteProductA operation");
}
}
// 具体产品B
class ConcreteProductB implements Product {
@Override
public void operation() {
System.out.println("ConcreteProductB operation");
}
}
// 工厂接口
interface Factory {
Product createProduct();
}
// 具体工厂A
class ConcreteFactoryA implements Factory {
@Override
public Product createProduct() {
return new ConcreteProductA();
}
}
// 具体工厂B
class ConcreteFactoryB implements Factory {
@Override
public Product createProduct() {
return new ConcreteProductB();
}
}
// 客户端代码
public class Main {
public static void main(String[] args) {
Factory factoryA = new ConcreteFactoryA();
Product productA = factoryA.createProduct();
productA.operation();
Factory factoryB = new ConcreteFactoryB();
Product productB = factoryB.createProduct();
productB.operation();
}
}
// 产品接口A
interface ProductA {
void operation();
}
// 具体产品A1
class ConcreteProductA1 implements ProductA {
@Override
public void operation() {
System.out.println("ConcreteProductA1 operation");
}
}
// 具体产品A2
class ConcreteProductA2 implements ProductA {
@Override
public void operation() {
System.out.println("ConcreteProductA2 operation");
}
}
// 产品接口B
interface ProductB {
void operation();
}
// 具体产品B1
class ConcreteProductB1 implements ProductB {
@Override
public void operation() {
System.out.println("ConcreteProductB1 operation");
}
}
// 具体产品B2
class ConcreteProductB2 implements ProductB {
@Override
public void operation() {
System.out.println("ConcreteProductB2 operation");
}
}
// 抽象工厂接口
interface AbstractFactory {
ProductA createProductA();
ProductB createProductB();
}
// 具体工厂1
class ConcreteFactory1 implements AbstractFactory {
@Override
public ProductA createProductA() {
return new ConcreteProductA1();
}
@Override
public ProductB createProductB() {
return new ConcreteProductB1();
}
}
// 具体工厂2
class ConcreteFactory2 implements AbstractFactory {
@Override
public ProductA createProductA() {
return new ConcreteProductA2();
}
@Override
public ProductB createProductB() {
return new ConcreteProductB2();
}
}
// 客户端代码
public class Main {
public static void main(String[] args) {
AbstractFactory factory1 = new ConcreteFactory1();
ProductA productA1 = factory1.createProductA();
ProductB productB1 = factory1.createProductB();
productA1.operation();
productB1.operation();
AbstractFactory factory2 = new ConcreteFactory2();
ProductA productA2 = factory2.createProductA();
ProductB productB2 = factory2.createProductB();
productA2.operation();
productB2.operation();
}
}
更多【简单工厂模式-设计模式之-3种常见的工厂模式简单工厂模式、工厂方法模式和抽象工厂模式,每一种模式的概念、使用场景和优缺点。】相关视频教程:www.yxfzedu.com