A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

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

工厂方法模式代码:
  1. interface IProduct //产品接口
  2. {
  3. public void productMethod();
  4. }


  5. class Product implements IProduct //产品实现
  6. {
  7. public void productMethod()
  8. {
  9. System.out.println("产品");
  10. }
  11. }


  12. interface IFactory //工厂接口
  13. {
  14. public IProduct createProduct();
  15. }

  16. class Factory implements IFactory //工厂实现
  17. {
  18. public IProduct createProduct()
  19. {
  20. return new Product();
  21. }
  22. }


  23. pbulic class Client
  24. {
  25. public static void main(String [] args)
  26. {
  27. IFactory factory = new IFactory();

  28. IProduct product = factory.createProduct();

  29. product.productMethod();
  30. }
  31. }
复制代码



工厂模式根据抽象程度的不同分为三种:简单工厂模式(也叫静态工厂模式)、工厂模式、抽象工厂模式三类。
优点:1.可以使代码结构清晰,有效地封装变化。在编程中,产品类的实例化有时候是比较复杂和多边的,通过工厂模式,将产品的实例化封装起来,使得调用者只关心产品的接口就可以了,至于具体的实现,调用者不用考虑。即使变更了具体的实现,但是对调用者来说没有影响。
2.降低耦合度。产品类的实例化通常是很复杂的,它需要依赖很多的类,而这些类对于调用者来说根本无需知道,如果使用了工厂方法,我们需要做的仅仅是实例化好产品类,然后交给调用者使用。对调用者来说,产品所依赖的类都是透明的。

工厂方法模式有四个要素:
1.工厂接口。工厂接口是工厂方法模式的核心,与调用者直接交互用来提供产品。在实际编程中,有时候也会用一个抽象类来作为与调用者交互的接口,其本质上也是一样的。
2.工厂实现。在编程中,工厂实现决定如何实例化产品,是实现扩展的途径,需要有多少种产品,就需要有多少个具体的工厂实现。
3.产品接口。产品接口的主要目的是定义产品的规范,所有的产品实现都必须遵循产品接口定义的规范。产品接口是调用者最为关心的,产品接口定义的优劣直接决定了调用者代码的稳定性。同样,产品接口也可以用抽象类来代替,但要注意最好不要违反里氏替换原则。
4.产品实现。实现产品接口的具体类,决定了产品在客户端的具体行为

适用场景:
1.工厂方法模式作为一种创建类模式,在任何需要生成复杂对象的地方,都可以使用。有一点需要注意的地方就是复杂对象适合使用工厂模式,而简单对象,特别是只需要通过new就可以完成创建的对象,无需使用。
2.工厂模式是一种典型的解耦模式,迪米特法则在工厂模式中表现的尤为明显。加入调用者自己组装产品需要增加依赖关系时,可以考虑使用工厂模式。将会大大降低耦合度。
3.由于工厂模式是依靠抽象架构的,它把实例化产品的任务交由实现类完成,扩展性比较好。也就是说,当需要系统有比较好的扩展性时,可以考虑工厂模式。

下面通过一个例子来体现工厂模式的优点。
例:汽车有发动机、轮胎、底盘组成,现在需要组装一辆车交给调用者。
  1. ...
  2. class Engine
  3. {
  4.         public void getStyle()
  5.         {
  6.                 System.out.println("发动机");
  7.         }
  8. }

  9. class Underpan
  10. {
  11.         public void getStyle()
  12.         {
  13.                 System.out.println("底盘");
  14.         }
  15. }

  16. class Wheel
  17. {
  18.         public void getSytle()
  19.         {
  20.                 System.out.println("轮胎");
  21.         }
  22. }

  23. public class Client
  24. {
  25.         public static void main(String [] args)
  26.         {
  27.                 Engine engine = new Engine();

  28.                 Underpan underpan = new Underpan();

  29.                 Wheel wheel = new Wheel();

  30.                 Car car = new Car(engine,underpan,wheel);
  31.                
  32.                 car.show();
  33.         }
  34. }
复制代码



上面的代码就是我们一般的解决方案,可以看到,调用者为了组装汽车还需要另外实例化发动机、轮胎、底盘。而这些东西与调用者是没有关系的,耦合度太高,不利于扩展。如果我们还后面需要安装导航系统,还要重新的改写Car类。

下面我们用工厂模式来解决这个问题
  1. ...
  2. interface IFactory
  3. {
  4.         public ICar createCar();
  5. }

  6. class Factory implements IFactory
  7. {
  8.         public ICar createCar()
  9.         {
  10.                 Engine engine = new Engine();
  11.                
  12.                 Underpan underpan = new Underpan();
  13.                
  14.                 Wheel wheel = new Wheel();
  15.                
  16.                 ICar car = new Car(engien,underpan,wheel);
  17.                
  18.                 return car;
  19.         }
  20. }

  21. public class Client
  22. {
  23.         public static void main(String [] args)
  24.         {
  25.                 IFactory factory = new Factory();
  26.                
  27.                 ICar car = factory.createCar();
  28.                
  29.                 car.show();
  30.         }
  31. }
复制代码

上面两段代码不太全,大家主要体会一下思想。

5 个回复

倒序浏览
沙发!!
回复 使用道具 举报
似懂非懂。。。。LZ木有解释简单工厂模式、工厂模式、抽象工厂模式
回复 使用道具 举报
小漠 发表于 2014-9-24 20:08
似懂非懂。。。。LZ木有解释简单工厂模式、工厂模式、抽象工厂模式

http://bbs.itheima.com/thread-144832-1-1.html   抽象工厂模式
回复 使用道具 举报
jtshawn 发表于 2014-9-25 09:32
http://bbs.itheima.com/thread-144832-1-1.html   抽象工厂模式

谢谢~~~~
回复 使用道具 举报
!!!!!!!!!!!!!!
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马