创建型模式-简单工厂-工厂方法-抽象工厂

简单工厂模式

例题

uml

代码

package simpleFactory;  
  
import java.lang.management.OperatingSystemMXBean;  
import java.util.Scanner;  
  
//定义Person  
class Person{  
public void say(){}  
  
}  
class Man extends Person{  
public void say()  
{  
System.out.println("I am a man");  
}  
  
};  
  
class Woman extends Person{  
public void say()  
{  
System.out.println("I am a woman");  
}  
  
};  
  
class Robot extends Person{  
public void say()  
{  
System.out.println("I am a robot");  
}  
  
}  
  
//定义简单工厂  
class Factory{  
public static Person createPerson(String op)  
{  
Person person =null;  
switch (op)  
{  
case "M":  
person = new Man();  
break;  
case "W" :  
person = new Woman();  
break;  
case "R" :  
person = new Robot();  
break;  
}  
  
return person;  
}  
  
}  
  
  
  
  
public class Test {  
public static void main(String[] args) {  
System.out.println("请输入:1.M 2.W 3.R");  
Scanner sc= new Scanner(System.in);  
  
String s=sc.next();  
  
Person person = Factory.createPerson(s);  
  
person.say();  
  
}  
}

总结
简单工厂模式,工厂返回产品

工厂方法模式

例题

uml

代码

package factoryMethod;  
  
  
import java.util.Scanner;  
  
class Person{  
public void say(){};  
}  
class Man extends Person {  
public void say()  
{  
System.out.println("I am a man");  
}  
};  
  
class Woman extends Person {  
public void say()  
{  
System.out.println("I am a woman");  
}  
  
};  
  
class Robot extends Person {  
public void say()  
{  
System.out.println("I am a robot");  
}  
  
}  
  
  
//创建工厂接口  
interface Factory{  
Person createPerson();  
}  
  
class WomanFac implements Factory{  
  
@Override  
public Person createPerson() {  
return new Woman();  
}  
}  
class ManFac implements Factory{  
  
@Override  
public Person createPerson() {  
return new Man();  
}  
}  
class RobotFac implements Factory{  
  
@Override  
public Person createPerson() {  
return new Robot();  
}  
}  
  
  
  
public class Test2 {  
public static void main(String[] args) {  
System.out.println("请输入:1.M 2.W 3.R");  
Scanner sc= new Scanner(System.in);  
String op=sc.next();  
Factory fac = null;  
switch (op)  
{  
case "M":  
fac = new ManFac();  
break;  
case "W" :  
fac = new WomanFac();  
break;  
case "R" :  
fac = new RobotFac();  
break;  
}  
  
Person p=fac.createPerson();  
p.say();  
}  
}

总结
一个工厂接口,多个工厂类去实现该接口,这样可以将返回的不同产品进行不同包装

抽象工厂模式

例题

uml

代码

package abstractFactory;  
interface Refrigerator{  
void say();  
}  
class HaiRefrigerator implements Refrigerator{  
  
@Override  ![在这里插入图片描述](https://i-blog.csdnimg.cn/direct/6f1e676ac852447db913289060c01250.png#pic_center)

public void say() {  
System.out.println("我是海尔冰箱");  
}  
}  
  
class TclRefrigerator implements Refrigerator{  
  
@Override  
public void say() {  
System.out.println("我是TCL冰箱");  
}  
}  
  
interface Television {  
void say();  
}  
class HaiTelevison implements Television{  
  
@Override  
public void say() {  
System.out.println("我是海尔电视机");  
}  
}  
class TclTelevison implements Television{  
  
@Override  
public void say() {  
System.out.println("我是TCL电视机");  
}  
}  
  
interface Factory{  
Refrigerator createRefrigerator();  
Television createTelevision();  
}  
  
class HaiFac implements Factory{  
  
@Override  
public Refrigerator createRefrigerator() {  
return new HaiRefrigerator();  
}  
  
@Override  
public Television createTelevision() {  
return new HaiTelevison();  
}  
}  
  
class TCLFac implements Factory{  
  
@Override  
public Refrigerator createRefrigerator() {  
return new TclRefrigerator();  
}  
  
@Override  
public Television createTelevision() {  
return new TclTelevison();  
}  
}  
  
  
  
  
  
public class Test3 {  
public static void main(String[] args) {  
// Factory fac=new TCLFac();  
//抽象工厂接口  
Factory fac=new HaiFac();  
//抽象产品接口  
Refrigerator refrigerator = fac.createRefrigerator();  
Television television = fac.createTelevision();  
  
refrigerator.say();  
television.say();  
}  
}

总结
有多个产品,产品分属不同类型

总结

1. 定义与目的

简单工厂模式（Simple Factory Pattern）：

• 定义：简单工厂模式又称为静态工厂方法模式，是通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。
• 目的：提供一个创建对象的接口，客户端通过调用工厂类的静态方法来获取对象实例，而无需关心对象的具体创建过程。

工厂方法模式（Factory Method Pattern）：

• 定义：定义一个创建产品对象的工厂接口，将产品对象的实际创建工作推迟到具体子工厂类当中。
• 目的：将对象的创建与使用分离，降低客户端与具体产品类之间的耦合，提高系统的灵活性和可扩展性。

抽象工厂模式（Abstract Factory Pattern）：

• 定义：抽象工厂模式提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。
• 目的：创建一系列相关或相互依赖的对象，而无需指定它们具体的类，以便在运行时动态地创建对象族。

2. 实现方式

简单工厂模式：

• 通过一个工厂类，根据传入的参数决定创建哪个类的实例。工厂类包含必要的逻辑判断，动态实例化相关的类。
• 优点：简单、易于实现；缺点：违反了开放-封闭原则（对扩展开放，对修改封闭），因为每增加一个新的产品类都需要修改工厂类。

工厂方法模式：

• 定义一个创建对象的接口，但让子类决定要实例化的类是哪一个。工厂方法让类的实例化推迟到子类中进行。
• 优点：支持增加任意产品，只需增加相应的工厂类即可，遵循了开放-封闭原则；缺点：每增加一个产品，就需要增加一个相应的工厂类，增加了系统的复杂度。

抽象工厂模式：

• 提供一个创建产品族的接口，客户端通过调用这个接口可以获取到一系列相关或相互依赖的对象的实例。
• 优点：支持增加产品族，但不支持增加新的产品（在不修改现有工厂接口的情况下）；每个工厂类都可以创建多个产品实例，形成产品族；缺点：当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。

3. 优缺点对比

简单工厂模式：

• 优点：简单、易于实现，封装了对象创建的逻辑，提高了代码的可维护性和可扩展性。
• 缺点：违反了开放-封闭原则，增加新产品时需要修改工厂类。

工厂方法模式：

• 优点：支持增加任意产品，遵循了开放-封闭原则，提高了系统的灵活性和可扩展性。
• 缺点：每增加一个产品，就需要增加一个相应的工厂类，增加了系统的复杂度。

抽象工厂模式：

• 优点：支持增加产品族，客户端不需要知道对象创建的细节，只需要知道产品类的共同接口。
• 缺点：当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改，增加了系统的抽象性和理解难度。

4. 适用场景

简单工厂模式：适用于产品数量较少且变化不频繁的场景。

工厂方法模式：适用于产品种类较多且可能会频繁增加的情况，客户端只需要知道创建对象的接口，而不需要知道具体的实现类。

抽象工厂模式：适用于有多个产品系列，且产品系列中的产品需要一起使用的情况，客户端需要创建一系列相互依赖或关联的对象，且这些对象属于不同的产品族。