工厂模式,细分下来为(简单工厂模式,工厂方法模式,抽象工厂模式 ),每一种模式的使用都是在应用场景的不同来决定;
案例一:(简单工厂模式)
简单工厂模式,根据工厂接收的类型来决定,返回的对象的具体实例,简单工厂模式在扩展性方面表现不足,(增加对象需要修改工厂代码,才能完成)
简单工厂模式,实际上就是一个工厂非常简单的运用,工厂根据接收不同的类型,返回不同
的实例对象,(想要扩展必须要修改工厂代码才行)
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