首页 > 代码库 > 大话设计模式_工厂方法(Java代码)

大话设计模式_工厂方法(Java代码)

2024-07-07 08:20:10   227人阅读

工厂方法模式：定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

简单描述：1个产品抽象类(或者接口)，多个具体产品，1个工厂抽象类(拥有生成抽象产品的方法)，多个具体工厂，其中每个具体工厂可生成各个不同的产品。

大话设计模式中的截图：

例子代码：

Product抽象类：

 1 package com.longsheng.factorymethod;
 2 
 3 public abstract class Product {
 4 
 5     public abstract void Method1();
 6     
 7     public abstract void Method2();
 8     
 9     public abstract void Method3();
10 
11 }
Product

ConcreteProductA具体Product类：

 1 package com.longsheng.factorymethod;
 2 
 3 public class ConcreteProductA extends Product {
 4 
 5     @Override
 6     public void Method1() {
 7         System.out.println("ConcreteProductA--Method1");
 8     }
 9 
10     @Override
11     public void Method2() {
12         System.out.println("ConcreteProductA--Method2");
13     }
14 
15     @Override
16     public void Method3() {
17         System.out.println("ConcreteProductA--Method3");
18     }
19 
20 }
ConcreteProductA

ConcreteProductB具体Product类：

 1 package com.longsheng.factorymethod;
 2 
 3 public class ConcreteProductB extends Product {
 4 
 5     @Override
 6     public void Method1() {
 7         System.out.println("ConcreteProductB--Method1");
 8     }
 9 
10     @Override
11     public void Method2() {
12         System.out.println("ConcreteProductB--Method2");
13     }
14 
15     @Override
16     public void Method3() {
17         System.out.println("ConcreteProductB--Method3");
18     }
19 
20 }
ConcreteProductB

ConcreteProductC具体Product类：

 1 package com.longsheng.factorymethod;
 2 
 3 public class ConcreteProductC extends Product {
 4 
 5     @Override
 6     public void Method1() {
 7         System.out.println("ConcreteProductC--Method1");
 8     }
 9 
10     @Override
11     public void Method2() {
12         System.out.println("ConcreteProductC--Method2");
13     }
14 
15     @Override
16     public void Method3() {
17         System.out.println("ConcreteProductC--Method3");
18     }
19 
20 }
ConcreteProductC

Factory抽象类：

1 package com.longsheng.factorymethod;
2 
3 public abstract class Factory {
4 
5     public abstract Product createProduct();
6     
7 }
Factory

生产ConcreteProductA实例的ConcreteFactoryA：

 1 package com.longsheng.factorymethod;
 2 
 3 public class ConcreteFactoryA extends Factory {
 4 
 5     @Override
 6     public Product createProduct() {
 7         return new ConcreteProductA();
 8     }
 9 
10 }
ConcreteFactoryA

生产ConcreteProductB实例的ConcreteFactoryB：

 1 package com.longsheng.factorymethod;
 2 
 3 public class ConcreteFactoryB extends Factory {
 4 
 5     @Override
 6     public Product createProduct() {
 7         return new ConcreteProductB();
 8     }
 9 
10 }
ConcreteFactoryB

生产ConcreteProductC实例的ConcreteFactoryC：

 1 package com.longsheng.factorymethod;
 2 
 3 public class ConcreteFactoryC extends Factory {
 4 
 5     @Override
 6     public Product createProduct() {
 7         return new ConcreteProductC();
 8     }
 9 
10 }
ConcreteFactoryC

客户端代码：

 1 package com.longsheng.factorymethod;
 2 
 3 public class Client {
 4 
 5     public static void main(String[] args) {
 6         Factory mFactory = new ConcreteFactoryA();
 7         Product Product1 =  mFactory.createProduct();
 8         Product Product2 =  mFactory.createProduct();
 9         Product Product3 =  mFactory.createProduct();
10         Product1.Method1();
11         Product2.Method1();
12         Product3.Method1();
13     }
14 
15 }
Client

工厂方法模式实现时，客户端需要决定实例化哪一个工厂来实现产品类，选择判断的问题还是存在的，也就是说工厂方法把简单工厂的内部逻辑判断移到了客户端代码来进行。要想增加功能，本来是修改工厂类，现在变成修改客户端。但是当添加新的Product时，并不需要修改工厂，只需要添加Product和生产Product的工厂，克服了简单工厂违背的开放封闭原则。


联系
我们