一:什么是工厂模式
我的理解:是一个特殊的产品的功能工厂
官方理解:实例化对象,用工厂方法代替new操作
二:工厂模式作用
因为工厂模式相当于创建实例对象的new,我们经常要根据类Class生成实例对象,如 A a = new A();工厂模式也是用来创建实例对象的,虽然会多做一些工作,但是好处在于会给系统带来更大的可扩展性和尽量少的修改
三:应用场景:
比如在玩游戏极品飞车,游戏者可以选择从不同的品牌选择赛车,那么这个品牌其实就是工厂,每个工厂生产的赛车都不一样,这就是典型的工厂模式的应用场景。
使用简单工厂模式的优势是:让对西那个的调用者和对象创建过程分离,当对象调用者需要对象时,直接向工厂申请即可,从而避免了对象的调用者与对象的实现类以硬编码方式耦合,以提高系统的可维护性、扩展性。
四:工厂模式有哪些
简单工厂(Simple Factory)模式
工厂方法(Factory Method)模式
抽象工厂(Abstract Factory)模式
五:三类工厂模式详解
1:简单工厂模式
简单工厂模式是类的创建,又叫静态工厂方法模式。简单工厂模式是一个由工厂对象决定创造哪一种产品类的实例
例如:有一个农场,生产各种水果,有苹果、桃子等,农场的园丁要根据客户的需求,提供相应的水果。
1 /** 2 * @Author zhangliwei 3 * @Date 2018/7/19 下午2:50 4 */ 5 public class FactoryExample { 6 7 public static Fruit fruitBean (String fruitKind) throws BadFruitException{ 8 if ("apple".equals(fruitKind)){ 9 return new Apple(); 10 } else if ("pench".equals(fruitKind)){ 11 return new Pench(); 12 } else { 13 throw new BadFruitException("bad request"); 14 } 15 } 16 }
1 /** 2 * @Author zhangliwei 3 * @Date 2018/7/19 下午2:50 4 */ 5 public interface Fruit { 6 void plant(); 7 8 void grow(); 9 10 void reward(); 11 }
1 /** 2 * @Author zhangliwei 3 * @Date 2018/7/19 下午2:53 4 */ 5 public class Apple implements Fruit { 6 7 public Apple() { 8 System.out.println("apple"); 9 } 10 11 @Override 12 public void plant() { 13 System.out.println("apple plant"); 14 } 15 16 @Override 17 public void grow() { 18 System.out.println("apple grow"); 19 } 20 21 @Override 22 public void reward() { 23 24 System.out.println("apple reward"); 25 } 26 27 public void color(){ 28 System.out.println("apple color is red"); 29 } 30 }
1 /** 2 * @Author zhangliwei 3 * @Date 2018/7/19 下午2:59 4 */ 5 public class Pench implements Fruit { 6 7 public Pench() { 8 System.out.println("pench"); 9 } 10 11 @Override 12 public void plant() { 13 System.out.println("pentch plant"); 14 } 15 16 @Override 17 public void grow() { 18 System.out.println("pentch grow"); 19 } 20 21 @Override 22 public void reward() { 23 System.out.println("pentch reward"); 24 } 25 26 public void taste (){ 27 System.out.println("pentch taste"); 28 } 29 }
1 /** 2 * @Author zhangliwei 3 * @Date 2018/7/19 下午3:08 4 */ 5 public class BadFruitException extends Exception { 6 7 public BadFruitException(String warnMesg){ 8 super(warnMesg); 9 } 10 }
1 /** 2 * @Author zhangliwei 3 * @Date 2018/7/19 下午3:11 4 */ 5 public class FruitFactoryTest { 6 7 public void test (String fruitKind){ 8 try { 9 FactoryExample.fruitBean(fruitKind); 10 } catch (BadFruitException e){ 11 System.out.println(e.getMessage()); 12 } catch (Exception e){ 13 e.printStackTrace(); 14 } 15 } 16 17 public static void main(String[] args) { 18 FruitFactoryTest test = new FruitFactoryTest(); 19 test.test("apple"); 20 test.test("pench"); 21 test.test("123"); 22 } 23 }
运行后的结果:
apple
pench
bad request
2:工厂方法模式
定义:一个用于创建对象的接口,让子类决定实例化哪一个类。FactoryMethod使一个类的实例延迟到其子类。
适用性:1.当一个类不知道它所必须创建的对象类的时候。
2.当一个类希望由他的子类来制定它创建的对象的时候。
3.当创建对象的指责委托给多个帮助类子类中的某一个,并且希望将哪一个帮助子类是代理者这一信息局部化的时候。
1 /** 2 * @Author zhangliwei 3 * @Date 2018/7/19 下午3:32 4 */ 5 public interface IWorkFactory { 6 Work getWork(); 7 }
1 /** 2 * @Author zhangliwei 3 * @Date 2018/7/19 下午3:27 4 */ 5 public interface Work { 6 void doWork(); 7 }
/** * @Author zhangliwei * @Date 2018/7/19 下午3:33 */ public class StudentWorkFactory implements IWorkFactory { @Override public Work getWork() { return new StudentWork(); } }
1 /** 2 * @Author zhangliwei 3 * @Date 2018/7/19 下午3:41 4 */ 5 public class TeacherWorkFactory implements IWorkFactory{ 6 @Override 7 public Work getWork() { 8 return new TeacherWork(); 9 } 10 }
1 public class TeacherWork implements Work { 2 @Override 3 public void doWork() { 4 System.out.println("teacher work"); 5 } 6 }
1 public class StudentWork implements Work { 2 @Override 3 public void doWork() { 4 System.out.println("student work"); 5 } 6 }
1 public class WorkFactoryTest { 2 public static void main(String[] args) { 3 IWorkFactory stunentWorkFactory = new StudentWorkFactory(); 4 stunentWorkFactory.getWork().doWork(); 5 6 IWorkFactory teacherWorkFactory = new TeacherWorkFactory(); 7 teacherWorkFactory.getWork().doWork(); 8 } 9 }
运行结果:
student work
teacher work
3.抽象工厂
定义一个创建一系列相关或相互依赖对象的接口,而无需指定她们具体的类
适用性:1.一个系统要独立于它的产品的创建、组合和表示时
2.一个系统要由多个产品系列中的一个来配置时。
3.当你要强调一系列相关的产品对象的涉及以便进行联合使用时
4.当你提供一个产品类库时,而只是想显示他们的接口而不是实现时。
1 /** 2 * @Author zhangliwei 3 * @Date 2018/7/19 下午5:28 4 */ 5 public interface IAnimalFactory { 6 ICat createCat(); 7 IDog createDog(); 8 }
1 /** 2 * @Author zhangliwei 3 * @Date 2018/7/19 下午5:32 4 */ 5 public class BlackAnimanalFactory implements IAnimalFactory { 6 @Override 7 public ICat createCat() { 8 return new BlackCat(); 9 } 10 11 @Override 12 public IDog createDog() { 13 return new BlackDog(); 14 } 15 }
1 /** 2 * @Author zhangliwei 3 * @Date 2018/7/19 下午7:59 4 */ 5 public class WhiteAnimanalFactory implements IAnimalFactory { 6 @Override 7 public ICat createCat() { 8 return new WhiteCat(); 9 } 10 11 @Override 12 public IDog createDog() { 13 return new WhiteDog(); 14 } 15 }
1 /** 2 * @Author zhangliwei 3 * @Date 2018/7/19 下午5:30 4 */ 5 public interface ICat { 6 void eat(); 7 } 8 9 10 11 /** 12 * @Author zhangliwei 13 * @Date 2018/7/19 下午5:30 14 */ 15 public interface IDog { 16 void eat(); 17 }
1 /** 2 * @Author zhangliwei 3 * @Date 2018/7/19 下午5:33 4 */ 5 public class BlackCat implements ICat { 6 7 @Override 8 public void eat() { 9 System.out.println("black cat eat"); 10 } 11 } 12 13 14 15 16 /** 17 * @Author zhangliwei 18 * @Date 2018/7/19 下午5:33 19 */ 20 public class BlackDog implements IDog { 21 @Override 22 public void eat() { 23 System.out.println("black dog eat"); 24 } 25 }
1 /** 2 * @Author zhangliwei 3 * @Date 2018/7/19 下午5:37 4 */ 5 public class WhiteCat implements ICat { 6 @Override 7 public void eat() { 8 System.out.println("white cat is eating"); 9 } 10 } 11 12 13 14 /** 15 * @Author zhangliwei 16 * @Date 2018/7/19 下午5:38 17 */ 18 public class WhiteDog implements IDog { 19 @Override 20 public void eat() { 21 System.out.println("white dog is eating"); 22 } 23 }
1 /** 2 * @Author zhangliwei 3 * @Date 2018/7/19 下午8:00 4 */ 5 public class Client { 6 public static void main(String[] args) { 7 IAnimalFactory blackAnimalFactory = new BlackAnimanalFactory(); 8 blackAnimalFactory.createCat().eat(); 9 blackAnimalFactory.createDog().eat(); 10 IAnimalFactory whiteAmimalFactory = new WhiteAnimanalFactory(); 11 whiteAmimalFactory.createCat().eat(); 12 whiteAmimalFactory.createDog().eat(); 13 14 } 15 }
运行结果:
black cat eat
black dog eat
white cat is eating
white dog is eating
六:总结三者区别:
1.简单工厂:用来生产同一等级结构中的任意产品(对于新增加的产品,无能为力)
2.工厂方法:用来生产同一等级结构中的固定产品(支持增加任意产品)
3.抽象工厂:用来生产不同产品族的全部产品(对于增加新的产品,无能为力,支持增加产品族)
其实,无论是简单工厂、工厂方法、抽象工厂模式,她们本质都是将不变的地方抽离出来,将可变的部分做成接口,达到最大程度的复用。究竟要用哪种设计模式,要根据具体的业务来决定。