代码：

1. public class Factory
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 ArmFactory af = new ArmFactory();
   
6.                 Arm a = null;
   
7.                 a = af.getArm("Gun");
   
8.                 if(a!=null)
   
9.                 {
   
10.                         a.fire();
    
11.                 }
    
12.                 /*a = af.getArm("tank");
    
13.                 if(a!=null)
    
14.                 {
    
15.                         a.fire();
    
16.                 }*/
    
17.                
    
18.         }
    
19. }
    
20. class ArmFactory//工厂
    
21. {
    
22.         public static Arm getArm(String type)
    
23.         {
    
24.                 Arm a = null;
    
25.                 if ("Gun".equals(type))
    
26.                 {
    
27.                         a = new Gun();
    
28.                 }
    
29.                 else if ("Cannon".equals(type))
    
30.                 {
    
31.                         a = new Cannon();
    
32.                 }
    
33.                 else
    
34.                 {
    
35.                         System.out.println("小厂产不了您要的武器");
    
36.                         return null;
    
37.                 }
    
38.                 return a;
    
39.                         
    
40.         }
    
41. }
    
42. abstract class Arm //抽象武器类
    
43. {
    
44.         //开火
    
45.         public abstract void fire();
    
46.         //没子弹了
    
47.         public abstract void unfire();
    
48. }
    
49. 
    
50. class Gun extends Arm//实体
    
51. {
    
52.         //开火
    
53.         public void fire()
    
54.         {
    
55.                 System.out.println("AK47来啦");
    
56.         }
    
57.         //没子弹了
    
58.         public void unfire()
    
59.         {
    
60.                 System.out.println("子弹打光了，跑吧");
    
61.         }
    
62. }
    
63. 
    
64. class Cannon extends Arm
    
65. //实体
    
66. {
    
67.         //开火
    
68.         public void fire()
    
69.         {
    
70.                 System.out.println("火箭炮来啦");
    
71.         }
    
72.         //没子弹了
    
73.         public void unfire()
    
74.         {
    
75.                 System.out.println("没炮弹啦，跑吧");
    
76.         }
    
77. }

复制代码

模式中包含的角色及其职责：

    工厂（ArmFactory）角色

        简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。工厂类可以被外界直接调用，创建所需的产品对象。

    抽象产品（Arm）角色

       简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。

    具体产品（Gun）角色

        是简单工厂模式的创建目标，所有创建的对象都是充当这个角色的某个具体类的实例。

优点

    工厂类是整个模式的关键.包含了必要的逻辑判断,根据外界给定的信息,决定究竟应该创建哪个具体类的对象.通过使用工厂类,外界可以从直接创建具体产品对象的尴尬局面摆脱出来,仅仅需要负责“消费”对象就可以了。而不必管这些对象究竟如何创建及如何组织的．明确了各自的职责和权利，有利于整个软件体系结构的优化。

缺点

    由于工厂类集中了所有实例的创建逻辑，违反了高内聚责任分配原则，将全部创建逻辑集中到了一个工厂类中；它所能创建的类只能是事先考虑到的，如果需要添加新的类，则就需要改变工厂类了。

实质

    简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类。

代码：

1. public class Factory
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 ArmFactory af = new ArmFactory();
   
6.                 Arm a = null;
   
7.                 a = af.getArm("Gun");
   
8.                 if(a!=null)
   
9.                 {
   
10.                         a.fire();
    
11.                 }
    
12.                 /*a = af.getArm("tank");
    
13.                 if(a!=null)
    
14.                 {
    
15.                         a.fire();
    
16.                 }*/
    
17.                
    
18.         }
    
19. }
    
20. class ArmFactory//工厂
    
21. {
    
22.         public static Arm getArm(String type)
    
23.         {
    
24.                 Arm a = null;
    
25.                 if ("Gun".equals(type))
    
26.                 {
    
27.                         a = new Gun();
    
28.                 }
    
29.                 else if ("Cannon".equals(type))
    
30.                 {
    
31.                         a = new Cannon();
    
32.                 }
    
33.                 else
    
34.                 {
    
35.                         System.out.println("小厂产不了您要的武器");
    
36.                         return null;
    
37.                 }
    
38.                 return a;
    
39.                         
    
40.         }
    
41. }
    
42. abstract class Arm //抽象武器类
    
43. {
    
44.         //开火
    
45.         public abstract void fire();
    
46.         //没子弹了
    
47.         public abstract void unfire();
    
48. }
    
49. 
    
50. class Gun extends Arm//实体
    
51. {
    
52.         //开火
    
53.         public void fire()
    
54.         {
    
55.                 System.out.println("AK47来啦");
    
56.         }
    
57.         //没子弹了
    
58.         public void unfire()
    
59.         {
    
60.                 System.out.println("子弹打光了，跑吧");
    
61.         }
    
62. }
    
63. 
    
64. class Cannon extends Arm
    
65. //实体
    
66. {
    
67.         //开火
    
68.         public void fire()
    
69.         {
    
70.                 System.out.println("火箭炮来啦");
    
71.         }
    
72.         //没子弹了
    
73.         public void unfire()
    
74.         {
    
75.                 System.out.println("没炮弹啦，跑吧");
    
76.         }
    
77. }

复制代码

模式中包含的角色及其职责：

    工厂（ArmFactory）角色

        简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。工厂类可以被外界直接调用，创建所需的产品对象。

    抽象产品（Arm）角色

       简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。

    具体产品（Gun）角色

        是简单工厂模式的创建目标，所有创建的对象都是充当这个角色的某个具体类的实例。

优点

    工厂类是整个模式的关键.包含了必要的逻辑判断,根据外界给定的信息,决定究竟应该创建哪个具体类的对象.通过使用工厂类,外界可以从直接创建具体产品对象的尴尬局面摆脱出来,仅仅需要负责“消费”对象就可以了。而不必管这些对象究竟如何创建及如何组织的．明确了各自的职责和权利，有利于整个软件体系结构的优化。

缺点

    由于工厂类集中了所有实例的创建逻辑，违反了高内聚责任分配原则，将全部创建逻辑集中到了一个工厂类中；它所能创建的类只能是事先考虑到的，如果需要添加新的类，则就需要改变工厂类了。

实质

    简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类。