java工厂模式

  1 1、简单模式
  2 //所有车的接口  有一个共同改的方法 开车
  3 public interface Car {
  4     public void drive();
  5 }
  6 //奥迪类  实现car接口因为奥迪车也是车 肯定可以开的嘛
  7 public class Audi implements Car {
  8     public Audi(){
  9         System.out.println("生产出一辆奥迪");
 10     }
 11     @Override
 12     public void drive() {
 13         System.out.println("开奥迪");
 14     }
 15 }
 16 //宝马类  实现car接口因为宝马车也是车 肯定也可以开
 17 public class Bmw implements Car{
 18     public Bmw(){
 19         System.out.println("生产出一辆宝马");
 20     }
 21     @Override
 22     public void drive() {
 23         System.out.println("开宝马");
 24     }
 25 }
 26 //生产车的工厂  该工厂接收一个车名 你只需要告诉他你要生产什么车  就可以生产出对应的车出来
 27 public class CarFactory {
 28     public static Car getCar(String caename){
 29         if(caename.equals("audi")){
 30             return new Audi();
 31         }else if(caename.equals("bmw")){
 32             return new Bmw();
 33         }
 34             return null;
 35     }
 36 }
 37 //测试
 38 public class Test {
 39     public static void main(String[] args) {
 40         //告诉工厂类 你需要生产出一辆奥迪车  那么给昂他传一个参数audi进去
 41         Car audi = CarFactory.getCar("audi");
 42         //就可以生产出奥迪的车 调用开车的方法就可以开车啦
 43         audi.drive();
 44         //宝马类似
 45         Car bmw = CarFactory.getCar("bmw");
 46         bmw.drive();
 47     }
 48 }
 49 输出：
 50 成产出一辆奥迪
 51 开奥迪
 52 生产出一辆宝马
 53 开宝马
 54 /**
 55 *2、工厂方法模式
 56 *根据以上代码 大家可以发现 比传统的new方法  Audi  audi = new Audi();要方便很多 如果说你因为需求 要加一个奔驰的车  那你还要Bnez  benz = new Bnez(); 这样的**话岂不是很麻烦,用工厂模式的话  客户端就不用在new对象 将生成对象的细节可代码都交给了工厂管理和实现 你只需要写一个getObject();方法获取到你想要的对象就ok了 *囚你要加一辆奔驰的话 只需要写一个benz的类 实现car接口  然后在工厂类中进行添加相应的逻辑代码就好了  
 57 *这种模式虽然好一些 但是囚我们每次要加一个汽车类的话，都要在工厂类里面修改判断逻辑代码，还是有一定的局限性，不符合开闭原则，因此我们下面介绍更好一点的方式*：工厂方法模式
 58 */
 59 //首先我们将carFactory工厂类 抽象成一个接口
 60 public interface CarFactory {
 61     public Car getCar();
 62 }
 63 //然后我们再写两个首先该接口的具体工厂类（奥迪和宝马）
 64 public class AudiFactory implements CarFactory {
 65     @Override
 66     public Car getCar() {
 67         return new Audi();
 68     }
 69 }
 70     public class BmwFactory implements CarFactory {
 71     @Override
 72     public Car getCar() {
 73         return new Bmw();
 74     }
 75 }
 76 //测试
 77 public class Test {
 78     public static void main(String[] args) {
 79         //实例化奥迪工厂类
 80         CarFactory factory = new AudiFactory();
 81         //调用奥迪工厂类里面的生产奥迪的方法
 82         Car audi = factory.getCar();
 83         audi.drive();
 84         //宝马和奥迪一样
 85         CarFactory factory2 = new BmwFactory();
 86         Car bmw = factory2.getCar();
 87         bmw.drive();
 88     }
 89 }
 90 输出结果：
 91 生产出一辆奥迪
 92 开奥迪
 93 生产出一辆宝马
 94 开宝马
 95 //这样的话 奥迪工厂类  就只专注生产奥迪的车 宝马一样只生产宝马车，如果我们需要加奔驰的话 只需要再写一个上产奔驰的工厂类去实现CarFactory接口  和一个奔驰实///体类实现car接口就好了代码如下：
 96 public class Bnez implements Car{
 97 
 98     public Bnez() {
 99         System.out.println("生产出一辆奔驰");
100     }
101     @Override
102     public void drive() {
103         System.out.println("开奔驰");
104     }
105 }
106 public class BnezFactory implements CarFactory{
107     @Override
108     public Car getCar() {
109         return null;
110     }
111 }
112 //在Test里面调用：
113 CarFactory factory = new BenzFactory();
114 Car benz = factory.getCar();
115 benz.drive();
116 /**
117 *3、抽象工厂模式
118 *但是大家又会觉得 奥迪和宝马也不止一种车啊   也有奥迪跑车 和奥迪越野车， 宝马跑车和宝马越野车啊 的确这样 那么以上两种方就实现不了  因为car这个接口就不能通*用了，他只能生产car，不能生产出跑车和越野车，所以第三种方法 我们需要将car这个接口里面的getCar()方法变成两个方法（一个上产跑车的方法getPaoche();一个生产越*野车的方法getYueye()） 所以引进第三种工厂模式：抽象工厂模式
119 */
120 //跑车接口
121 public interface Paoche {
122     public void drive();
123 }
124 //越野车接口
125 public interface Yueye {
126     public void drive();
127 }
128 //那么这样的话奥迪车是不是就变成了两个实体类了 之前只是一个audi这个类 现在变成了 奥迪跑车类和奥迪越野车类  加上宝马的话就有四个具体实现的类了
129 //奥迪跑车
130 public class AudiPaoche implements Paoche {
131     public AudiPaoche(){
132         System.out.println("奥迪工厂上产出一辆奥迪跑车");
133     }
134     public void drive() {
135         System.out.println("奥迪跑车在路上跑");
136     }
137 }
138 //奥迪越野车
139 public class AudiYueye implements Yueye {
140     public AudiYueye(){
141         System.out.println("奥迪工厂生产出一辆奥迪越野车");
142     }
143     public void drive() {
144         System.out.println("奥迪越野车在路上跑");
145     }
146 }
147 //宝马跑车
148 public class BmwPaoche implements Paoche{
149     public BmwPaoche(){
150         System.out.println("宝马工厂生产出一辆宝马跑车");
151     }
152     public void drive() {
153         System.out.println("宝马跑车在路上跑");
154     }
155 }
156 //宝马越野车
157 public class BmwYueye implements Yueye {
158     public BmwYueye(){
159         System.out.println("宝马工厂生产出一辆宝马越野车");
160     }
161     public void drive() {
162         System.out.println("宝马越野车");
163     }
164 }
165 //生产跑车和越野车的接口
166 public interface CarFactory {
167     public Paoche getPaoche();
168     public Yueye getYueye();
169 }
170 //生产奥迪的工厂类实现CarFactory
171 public class AudiFactory implements CarFactory{
172     @Override
173     public Paoche getPaoche() {
174         return new AudiPaoche();
175 }
176     @Override
177     public Yueye getYueye() {
178         return new AudiYueye();
179     }
180 }
181 //生产宝马的工厂类实现CarFactory
182 public class BmwFactory implements CarFactory {
183     @Override
184     public Paoche getPaoche() {
185         return new BmwPaoche();
186     }
187     @Override
188     public Yueye getYueye() {
189         return new BmwYueye();
190     }
191 }
192 //测试
193 public class Test {
194     public static void main(String[] args) {
195         //实例化生产宝马的工厂类 来上产宝马跑车和宝马越野车  宝马工厂有 生产宝马跑车和宝马越野车  这两个方法  具体是生产跑车还是越野车  看客户端选择
196         CarFactory factory = new BmwFactory();
197         //在这里选择的是生产跑车  调用的是上产跑车的方法
198         Paoche paoche = factory.getPaoche();
199         paoche.drive();
200 
201         CarFactory factory2 = new AudiFactory();
202         Yueye yueye = factory2.getYueye();
203         yueye.drive();
204     }
205 }
206 输出结果：
207 宝马工厂生产出一辆宝马跑车
208 宝马跑车在路上跑
209 奥迪工厂生产出一辆奥迪越野车
210 奥迪越野车在路上跑
211 //写了这么多 希望对大家有所帮助吧