首页 > 代码库 > Java设计模式学习笔记，二：工厂模式

Java设计模式学习笔记，二：工厂模式

2024-11-28 11:54:39   201人阅读

　　工厂模式，主要实现了创建者和调用者的分离。

　　分类：1、简单工厂模式；2、工厂方法模式；3、抽象工厂模式。

　　核心：实例化对象时，用工厂方法代替new操作。

 

　　一、简单工厂模式

　　　　也叫静态工厂模式，工厂类中实现静态方法，根据入参，生产不同的产品，工程项目中常用。

　　　　工厂类作为类使用，产品类作为接口使用，具体产品实现接口，用来生产同一等级结构中的任意产品，当新增产品时，需要修改已有的代码。

 1 package com.corey.factory.simpleFactory;
 2 
 3 /**
 4  * 产品类接口
 5  * @author Corey
 6  *
 7  */
 8 public interface Computer {
 9     void calcData();
10 }
 1 package com.corey.factory.simpleFactory;
 2 
 3 /**
 4  * 具体产品实现接口
 5  * @author Corey
 6  *
 7  */
 8 public class HighEndComputer implements Computer{
 9 
10     @Override
11     public void calcData() {
12         System.out.println("高端电脑计算速度快！");
13     }
14 
15 }
 1 package com.corey.factory.simpleFactory;
 2 
 3 /**
 4  * 具体产品实现接口
 5  * @author Corey
 6  *
 7  */
 8 public class LowEndComputer implements Computer{
 9 
10     @Override
11     public void calcData() {
12         System.out.println("低端电脑计算速度慢！");
13     }
14 
15 }
 1 package com.corey.factory.simpleFactory;
 2 
 3 /**
 4  * 产品工厂类，生产同一等级结构中的任意产品
 5  * @author Corey
 6  *
 7  */
 8 public class ComputerFactory {
 9     
10     public static Computer CreateComputer(String type){
11         Computer computer = null;
12         
13         switch(type){
14             case "HighEnd":
15                 computer = new HighEndComputer();
16                 break;
17             case "LowEnd":
18                 computer = new LowEndComputer();
19                 break;
20             default:
21                 break;
22         }
23         return computer;
24     }
25 }
 1 package com.corey.factory.simpleFactory;
 2 
 3 /**
 4  * 测试简单工厂模式
 5  * @author Corey
 6  *
 7  */
 8 public class Test {
 9     
10     public static void main(String[] args) {
11         Computer c1 = ComputerFactory.CreateComputer("HighEnd");
12         c1.calcData();
13         
14         Computer c2 = ComputerFactory.CreateComputer("LowEnd");
15         c2.calcData();
16         
17     }
18     
19 }


运行结果：


高端电脑计算速度快！ 
低端电脑计算速度慢！




 


　　二、工厂方法模式


　　　　工厂类作为接口使用，固定产品工厂类实现接口，用来生产统一等级结构中的固定产品，可扩展任意产品。




 1 package com.corey.factory.factoryMethed;
 2 
 3 /**
 4  * 产品工厂类作为接口使用
 5  * @author Corey
 6  *
 7  */
 8 public interface ComputerFactory {
 9     
10     Computer CreateComputer();
11 }






 1 package com.corey.factory.factoryMethed;
 2 
 3 /**
 4  * 具体产品工厂类实现接口
 5  * @author Corey
 6  *
 7  */
 8 public class HighEndComputerFactory implements ComputerFactory{
 9 
10     @Override
11     public Computer CreateComputer() {
12         return new HighEndComputer();
13     }
14 
15 }






 1 package com.corey.factory.factoryMethed;
 2 
 3 /**
 4  * 具体产品工厂类实现接口
 5  * @author Corey
 6  *
 7  */
 8 public class LowEndComputerFactory implements ComputerFactory{
 9 
10     @Override
11     public Computer CreateComputer() {
12         return new LowEndComputer();
13     }
14 
15 }






 1 package com.corey.factory.factoryMethed;
 2 
 3 /**
 4  * 测试工厂方法模式
 5  * @author Corey
 6  *
 7  */
 8 public class Test {
 9     
10     public static void main(String[] args) {
11         Computer c1 = new HighEndComputerFactory().CreateComputer();
12         c1.calcData();
13         
14         Computer c2 = new LowEndComputerFactory().CreateComputer();
15         c2.calcData();
16         
17     }
18     
19 }




 


　　三、抽象工厂模式


　　　　工厂类作为接口使用，内含生产配件方法接口，产品配件类作为接口使用，具体产品配件类实现接口，具体产品工厂类实现工厂类，用来生产不同产品族的全部产品，无法增加新产品，可扩展产品族。




 1 package com.corey.factory.abstractFactory;
 2 
 3 /**
 4  * 工厂类作为接口使用，内含组装配件方法接口
 5  * @author Corey
 6  *
 7  */
 8 public interface ComputerFactory {
 9     MainBoard createMainBoard();    //生产主板配件
10     HardDisk createHardDisk();        //生产硬盘配件
11     Memory createMemory();        //生产内存配件
12     
13 }






 1 package com.corey.factory.abstractFactory;
 2 
 3 /**
 4  * 产品配件类作为接口使用
 5  * 
 6  * @author Corey
 7  *
 8  */
 9 public interface HardDisk {
10     void speed();    //硬盘实现方法
11 }






 1 package com.corey.factory.abstractFactory;
 2 
 3 /**
 4  * 具体产品配件类实现接口
 5  * @author Corey
 6  *
 7  */
 8 public class HighEndHardDisk implements HardDisk{
 9 
10     @Override
11     public void speed() {
12         System.out.println("高端硬盘速度快！");
13     }
14 
15 }






 1 package com.corey.factory.abstractFactory;
 2 
 3 /**
 4  * 具体产品工厂类实现工厂类，用来生产不同产品族的全部产品
 5  * @author Corey
 6  *
 7  */
 8 public class HighEndComputerFactory implements ComputerFactory {
 9 
10     @Override
11     public MainBoard createMainBoard() {
12         return new HighEndMainBoard();
13     }
14 
15     @Override
16     public HardDisk createHardDisk() {
17         return new HighEndHardDisk();
18     }
19 
20     @Override
21     public Memory createMemory() {
22         return new HighEndMemory();
23     }
24 
25 }






 1 package com.corey.factory.abstractFactory;
 2 
 3 /**
 4  * 测试抽象工厂模式
 5  * @author Corey
 6  *
 7  */
 8 public class Test {
 9     
10     public static void main(String[] args) {
11         ComputerFactory h = new HighEndComputerFactory();
12         HardDisk hHardDisk = h.createHardDisk();
13         MainBoard hMainBoard = h.createMainBoard();
14         Memory hMemory = h.createMemory();
15         hHardDisk.speed();
16         hMainBoard.speed();
17         hMemory.speed();
18         
19         ComputerFactory l = new LowEndComputerFactory();
20         HardDisk lHardDisk = l.createHardDisk();
21         MainBoard lMainBoard = l.createMainBoard();
22         Memory lMemory = l.createMemory();
23         lHardDisk.speed();
24         lMainBoard.speed();
25         lMemory.speed();
26     }
27 }




运行结果：




高端硬盘速度快！
高端主板速度快！
高端内存速度快！
低端硬盘速度慢！
低端主板速度慢！
低端内存速度慢！




 


工厂模式基本就这些内容。


另，简单工厂还有另一种实现方式，就是编写不同的静态方法创建不同的产品，而无需传参，但是调用者需要知道更多的方法名。
Java设计模式学习笔记，二：工厂模式






























        

            
                
                  
                
                

                    联系

                    我们