java设计模式之-工厂模式
java设计模式之-工厂模式
工厂模式分为：简单工厂、工厂方法模式、抽象工厂。实际上简单工厂并不属于设计模式。但是简单工厂提出来了工厂的概念。
一、简单工厂
1 //咖啡的父类，所有的咖啡都要继承该类。我把他定义成抽象方法。 2 public abstract class Coffee { 3 public abstract void creatCoffee(); 4 } 5 6 //以下是咖啡的几个子类 7 public class Coffee01 extends Coffee{ 8 public void creatCoffee() { 9 System.out.println("创建Coffee01"); 10 } 11 } 12 13 14 public class Coffee02 extends Coffee{ 15 public void creatCoffee() { 16 System.out.println("创建Coffee02"); 17 } 18 } 19 20 21 public class Coffee03 extends Coffee{ 22 public void creatCoffee() { 23 System.out.println("创建Coffee03"); 24 } 25 }
既然是工厂模式，那么我们还需要定义一个工厂他的作用就是实例化我们需要的类。
1 public class CoffeeFactory { 2 3 public Coffee createCoffee(String coffee) { 4 if(coffee.equals("coffee01")) { 5 return new Coffee01(); 6 }else if(coffee.equals("coffee02")) { 7 return new Coffee02(); 8 }else { 9 return new Coffee03(); 10 } 11 } 12 13 public static void main(String[] args) { 14 new CoffeeFactory().createCoffee("coffee01").creatCoffee(); 15 } 16 17 }
他是通过简单的入参判断需要实例化哪个类，写法也是比较简单，实用性也不强。
二、工厂方法模式
工厂方法模式主要是在工厂上做文章，每一个产品可以对应一个工厂，至于消费者要什么工厂由子类来确定。但是也有缺点，如果产品太多的话，那就要对应很多工厂，那么类将会异常的庞大
1 //工厂父类，所有工厂都需要继承该类 2 public abstract class CoffeeFactory { 3 public abstract Coffee createFactory(); 4 } 5 6 7 public class CoffeeFactory01 extends CoffeeFactory{ 8 @Override 9 public Coffee createFactory() { 10 // TODO Auto-generated method stub 11 return new Coffee01(); 12 } 13 } 14 15 16 public class CoffeeFactory02 extends CoffeeFactory{ 17 @Override 18 public Coffee createFactory() { 19 // TODO Auto-generated method stub 20 return new Coffee02(); 21 } 22 } 23 24 public class CoffeeFactory03 extends CoffeeFactory{ 25 @Override 26 public Coffee createFactory() { 27 // TODO Auto-generated method stub 28 return new Coffee03(); 29 } 30 } 31 32 33 public class CoffeeFactory04 extends CoffeeFactory{ 34 @Override 35 public Coffee createFactory() { 36 // TODO Auto-generated method stub 37 return new Coffee04(); 38 } 39 }
三、抽象工厂模式
抽象工厂是工厂方法的模式的升级版。现在是这么个情况，上边的例子不是都是生产咖啡的吗？现在呢，我想在引进茶，那你该怎么办？是修改上诉代码，还是再添加一个和上边工厂方法模式结构一样的一些类呢？不管是用哪种方法都是不利于维护以及后续拓展，于是就有了抽象工厂模式诞生，他用一个超级工厂做所有工厂的父类，那么我们后期如果有新的需求，我们可以直接添加就可以，而不用去修改以前的代码了。
1 public abstract class CFactory { 2 public abstract Coffee createCoffee(); 3 public abstract Tea createTea(); 4 } 5 6 7 public abstract class CoffeeFactory extends CFactory { 8 public abstract Coffee createCoffee(); 9 } 10 public class Coffee01Factory extends CoffeeFactory { 11 12 @Override 13 public Coffee createCoffee() { 14 // TODO Auto-generated method stub 15 return new Coffee01(); 16 } 17 @Override 18 public Tea createTea() { 19 // TODO Auto-generated method stub 20 return null; 21 } 22 } 23 public class Coffee02Factory extends CoffeeFactory { 24 @Override 25 public Coffee createCoffee() { 26 // TODO Auto-generated method stub 27 return new Coffee02(); 28 } 29 30 @Override 31 public Tea createTea() { 32 // TODO Auto-generated method stub 33 return null; 34 } 35 } 36 37 38 39 public abstract class TeaFactory extends CFactory { 40 public abstract Tea createTea(); 41 } 42 public class RedTeaFactory extends TeaFactory { 43 @Override 44 public Tea createTea() { 45 // TODO Auto-generated method stub 46 return new GreenTea(); 47 } 48 @Override 49 public Coffee createCoffee() { 50 // TODO Auto-generated method stub 51 return null; 52 } 53 } 54 public class GreenTeaFactory extends TeaFactory { 55 @Override 56 public Tea createTea() { 57 // TODO Auto-generated method stub 58 return new RedTea(); 59 } 60 @Override 61 public Coffee createCoffee() { 62 // TODO Auto-generated method stub 63 return null; 64 } 65 }
结构还是比较简单的，容易上手。说实在的23中设计模式我熟练的也就3种。还有20种不会的，以后有时间一定要学习一下
