工厂模式，细分下来为（简单工厂模式，工厂方法模式，抽象工厂模式 ），每一种模式的使用都是在应用场景的不同来决定；
案例一：（简单工厂模式）
简单工厂模式，根据工厂接收的类型来决定，返回的对象的具体实例，简单工厂模式在扩展性方面表现不足，（增加对象需要修改工厂代码，才能完成）
简单工厂模式，实际上就是一个工厂非常简单的运用，工厂根据接收不同的类型，返回不同
的实例对象，（想要扩展必须要修改工厂代码才行）
package com.oop.demo5.ajiandan;
/**
* 手机标准规范，零件有很多，这里就模拟两种零件（屏幕，电池）
* @author Liudeli
*
*/
public interface Phone {
/**
* 做手机屏幕
*/
public void doScreen();
/**
* 做手机电池
*/
public void doBattery();
}
package com.oop.demo5.ajiandan;
/**
* 三星手机对象
* @author Liudeli
*
*/
public class SamsungPhone implements Phone {
public void doScreen() {
System.out.println("制作三星手机屏幕...");
}
public void doBattery() {
System.out.println("制作三星手机电池...");
}
}
package com.oop.demo5.ajiandan;
/**
* 华为手机对象
* @author Liudeli
*
*/
public class HuaweiPhone implements Phone {
public void doScreen() {
System.out.println("制作华为手机屏幕...");
}
public void doBattery() {
System.out.println("制作华为手机电池...");
}
}
package com.oop.demo5.ajiandan;
/**
* 定义一个工厂，此工厂用于生成手机
* @author Liudeli
*
*/
public class Factory {
/**
* 生成出什么牌子的手机
* @param phone 传入给工厂信息类型
* @return 返回真正手机实例
*/
public static Phone getPhone(String phone) {
Phone resultPhone = null;
if ("huawei".equals(phone)) {
resultPhone = new HuaweiPhone();
} else {
resultPhone = new SamsungPhone();
}
return resultPhone;
}
}
package com.oop.demo5.ajiandan;
import java.util.Scanner;
/*
* 简单工厂方法，实际上就是一个工厂非常简单的运用，工厂根据接收不同的类型，返回不同
* 的实例对象，（想要扩展必须要修改工厂代码才行）
*/
/**
* 测试程序 （简单工厂模式）
* @author Liudeli
*
*/
public class Test {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("input huawei/samsung ...");
String type = scanner.nextLine();
Phone phone = Factory.getPhone(type);
phone.doBattery();
phone.doScreen();
}
}
运行结果：
案例二：（工厂方法模式）
工厂方法模式，定义创建对象接口，让子类去决定，到底要实现，那一个实例对象，此模式把开放封闭式原则，表现出来了，扩展性好；
package com.oop.demo5.bfangfa;
/**
* 手机标准规范，零件有很多，这里就模拟两种零件（屏幕，电池）
* @author Liudeli
*
*/
public interface Phone {
/**
* 做手机屏幕
*/
public void doScreen();
/**
* 做手机电池
*/
public void doBattery();
}
package com.oop.demo5.bfangfa;
/**
* 三星手机对象
* @author Liudeli
*
*/
public class SamsungPhone implements Phone {
public void doScreen() {
System.out.println("制作三星手机屏幕...");
}
public void doBattery() {
System.out.println("制作三星手机电池...");
}
}
package com.oop.demo5.bfangfa;
/**
* 华为手机对象
* @author Liudeli
*
*/
public class HuaweiPhone implements Phone {
public void doScreen() {
System.out.println("制作华为手机屏幕...");
}
public void doBattery() {
System.out.println("制作华为手机电池...");
}
}
package com.oop.demo5.bfangfa;
/**
* 定义出抽象的工厂
* @author Liudeli
*
*/
public interface IFactory {
/**
* 创造手机
* @return 返回抽象手机
*/
public Phone createPhone();
}
package com.oop.demo5.bfangfa;
/**
* 华为工厂对象
* @author Liudeli
*
*/
public class HuaweiFactory implements IFactory{
public Phone createPhone() {
return new HuaweiPhone();
}
}
package com.oop.demo5.bfangfa;
/**
* 三星工厂对象
* @author Liudeli
*
*/
public class SamsungFactory implements IFactory {
public Phone createPhone() {
return new SamsungPhone();
}
}
package com.oop.demo5.bfangfa;
/*
* 工厂方法模式，创建一个对象的接口，让子类决定去实例化那个类
* 可扩展，遵守了 开放封闭式原则
*/
/**
* 测试程序（工厂方法模式）
* @author Liudeli
*
*/
public class Test {
public static void main(String[] args) {
// 用华为工厂去生成华为手机
IFactory factory = new HuaweiFactory();
Phone iphone = factory.createPhone();
iphone.doBattery();
iphone.doScreen();
}
}
运行结果：
修改工厂改变结果：
IFactory factory = new SamsungFactory();运行结果：
案例三：（抽象工厂模式）
抽象工厂模式是在工厂方法模式基础上演变而来的，与其说工厂方法模式是单维的，抽象工厂模式
就是多维的，在生活中去举例的话：生成公司，要生产（汽车，摩托车，客车，拖拉机），意思就是每一个工厂，都具备有生成（汽车，摩托车，客车，拖拉机）的能力；
package com.oop.demo5.cchouxiang;
/**
* 手机标准规范，零件有很多，这里就模拟两种零件（屏幕，电池）
* @author Liudeli
*
*/
public interface Phone {
/**
* 做手机屏幕
*/
public void doScreen();
/**
* 做手机电池
*/
public void doBattery();
}
package com.oop.demo5.cchouxiang;
/**
* 三星手机对象
* @author Liudeli
*
*/
public class SamsungPhone implements Phone {
public void doScreen() {
System.out.println("制作三星手机屏幕...");
}
public void doBattery() {
System.out.println("制作三星手机电池...");
}
}
package com.oop.demo5.cchouxiang;
/**
* 华为手机对象
* @author Liudeli
*
*/
public class HuaweiPhone implements Phone {
public void doScreen() {
System.out.println("制作华为手机屏幕...");
}
public void doBattery() {
System.out.println("制作华为手机电池...");
}
}
package com.oop.demo5.cchouxiang;
/**
* 抽象出电脑接口
* @author Liudeli
*
*/
public interface Computer {
/**
* 做电脑适配器电源
*/
public void doAdapter();
}
package com.oop.demo5.cchouxiang;
/**
* 华为电脑具体对象
* @author Liudeli
*
*/
public class HuaweiComputer implements Computer {
public void doAdapter() {
System.out.println("华为电脑适配器....");
}
}
package com.oop.demo5.cchouxiang;
/**
* 三星电脑具体对象
* @author Liudeli
*
*/
public class SamsungComputer implements Computer {
public void doAdapter() {
System.out.println("三星电脑适配器....");
}
}
package com.oop.demo5.cchouxiang;
/**
* 定义抽象工厂接口
* @author Liudeli
*
*/
public interface IFactory {
/**
* 创建手机(手机有很多种，手机是抽象的概念)
* @return 返回手机
*/
public Phone createPhone();
/**
* 创建电脑（电脑有很多种类，电脑是被抽象出来的概念）
* @return 返回电脑
*/
public Computer createComputer();
}
package com.oop.demo5.cchouxiang;
/**
* 三星工厂对象
* @author Liudeli
*
*/
public class SamsungFactory implements IFactory {
public Phone createPhone() {
return new SamsungPhone();
}
public Computer createComputer() {
return new SamsungComputer();
}
}
package com.oop.demo5.cchouxiang;
/**
* 华为工厂对象
* @author Liudeli
*
*/
public class HuaweiFactory implements IFactory{
public Phone createPhone() {
return new HuaweiPhone();
}
public Computer createComputer() {
return new HuaweiComputer();
}
}
package com.oop.demo5.cchouxiang;
/**
* 抽象工厂模式是在工厂方法模式基础上演变而来的，与其说工厂方法模式是单维的，抽象工厂模式
* 就是多维的，在生活中去举例的话：生成公司，要生产（汽车，摩托车，客车，拖拉机），意思就是每一个工厂，都具备有生成（汽车，摩托车，客车，拖拉机）的能力
*/
/**
* 测试程序（抽象工厂模式）
*/
public class Test {
public static void main(String[] asgs) {
// 创建华为工厂
IFactory factory = new HuaweiFactory();
// 造手机
Phone phone = factory.createPhone();
phone.doBattery();
phone.doScreen();
// 造电脑
Computer computer = factory.createComputer();
computer.doAdapter();
}
}运行结果：
Project结构图：
谢谢大家的观看，更多精彩技术博客，会不断的更新，请大家访问，
刘德利CSDN博客， http://blog.csdn.net/u011967006