工厂模式就是实现创建者和调用者的分离,可以分为
(1)简单工厂模式:
也叫静态工厂模式,就是工厂类-般是使用静态方法,通过接收的参数的不同来返回不同的对象实例。对于增加折产品无能为力!不修改代码的话,是无法扩展。
实例及代码:我要new两部手机(xiaomi,iphone)对吧,但我不直接去创建,让手机工厂(PhoneFactory)帮我来完成,首先准备一个Phone的接口:
package com.FCJ.simpleFactory;
public interface Phone {
void phoneType(); //实现类有xiaomi,iphone
}
两部手机:
package com.FCJ.simpleFactory;
public class Iphone implements Phone{
@Override
public void phoneType() {
System.out.println("苹果手机");
}
}
package com.FCJ.simpleFactory;
public class Xiaomi implements Phone{
@Override
public void phoneType() {
System.out.println("小米手机");
}
}
手机工厂:
package com.FCJ.simpleFactory;
public class PhoneFactory {
//注意是静态方法,后面的客户端Client01才可以调用该方法
public static Phone createPhone(String type) {
if("iphone".equals(type)) {
return new Iphone();
}else if("xiaomi".equals(type)) {
return new Xiaomi();
}//开闭原则,就是增加新功能尽量不要修改原来的代码,这个else显然就修改了
else {
return null;
}
}
}
客户端:
package com.FCJ.simpleFactory;
public class Client01 {
public static void main(String[] args) {
Phone p1 = PhoneFactory.createPhone("iphone");
Phone p2 = PhoneFactory.createPhone("xiaomi");
p1.phoneType();
p2.phoneType();
}
}
(2)工厂方法模式
实例演示:
和前面的步骤一样:
一个Phone的接口:
package com.FCJ.simpleFactory;
public interface Phone {
void phoneType(); //实现类有xiaomi,iphone
}
两部手机:
//iphone实现类
package com.FCJ.simpleFactory;
public class Iphone implements Phone{
@Override
public void phoneType() {
System.out.println("苹果手机");
}
}
//xiaomi实现类
package com.FCJ.simpleFactory;
public class Xiaomi implements Phone{
@Override
public void phoneType() {
System.out.println("小米手机");
}
}
PhoneFactory增加接口
package com.FCJ.simpleFactory;
public interface PhoneFactory {
public Phone createPhone();
}
再加多一个PhoneFactor的IphoneFactory、XiaomiFactory实现类
package com.FCJ.simpleFactory;
public class IphoneFactory implements PhoneFactory{
@Override
public Phone createPhone() {
return new Iphone();
}
}
package com.FCJ.simpleFactory;
public class XiaomiFactory implements PhoneFactory{
@Override
public Phone createPhone() {
// TODO Auto-generated method stub
return new Xiaomi();
}
}
客户端:
package com.FCJ.simpleFactory;
public class Client01 {
public static void main(String[] args) {
Phone p1 = new IphoneFactory().createPhone();
Phone p2 = new XiaomiFactory().createPhone();
p1.phoneType();
p2.phoneType();
}
}
在一般的工作中一般使用的是简单的工厂模式。
(3)抽象工厂模式
主要是创建 产品族
实例代码:
package com.FCJ.abstractFactory;
/**
* CPU接口,以下有两个实现类,高端和低端CPU
* @author 佳
*
*/
public interface CPU {
void run();
void start();
}
class LuxuryCPU implements CPU{
@Override
public void run() {
System.out.println("人上人高端机就是好,处理速度来的快");
}
@Override
public void start() {
System.out.println("开机启动快,可以自动启动停止");
}
}
class LowerCPU implements CPU{
@Override
public void run() {
System.out.println("处理速度的慢");
}
@Override
public void start() {
System.out.println("启动慢");
}
}
package com.FCJ.abstractFactory;
/**
* 手机的软件接口,统一有高端机和低端机的实现类
* @author 方楚佳
*
*/
public interface SoftWare {
void massage();
}
class LuxurySoftWare implements SoftWare{
@Override
public void massage() {
System.out.println("高端软件可以自动显示人上人");
}
}
class LowerSoftWare implements SoftWare{
@Override
public void massage() {
System.out.println("低端座椅软件不可以自动显示人上人");
}
}
package com.FCJ.abstractFactory;
/**
* 屏幕接口,以下同样有两个实现类
* @author 方楚佳
*
*/
public interface Screen {
void light();
}
class LuxuryScreen implements Screen{
@Override
public void light() {
System.out.println("高端屏幕亮色好");
}
}
class LowerScreen implements Screen{
@Override
public void light() {
System.out.println("低端屏幕亮色不好");
}
}
package com.FCJ.abstractFactory;
/**
* PhoneFactory这个接口负责创建手机的CPU,软件和屏幕
* @author 方楚佳
*
*/
public interface PhoneFactory {
CPU createCPU();
SoftWare createSoftWare();
Screen createScreen();
}
//高端工厂,对应创建高端配件
class LuxuryPhoneFactory implements PhoneFactory{
@Override
public CPU createCPU() {
return new LuxuryCPU();
}
@Override
public SoftWare createSoftWare() {
return new LuxurySoftWare();
}
@Override
public Screen createScreen() {
return new LuxuryScreen();
}
}
//低端工厂,对应创建低端配件
class LowerPhoneFactory implements PhoneFactory{
@Override
public CPU createCPU() {
return new LowerCPU();
}
@Override
public SoftWare createSoftWare() {
return new LowerSoftWare();
}
@Override
public Screen createScreen() {
return new LowerScreen();
}
}
测试:
package com.FCJ.abstractFactory;
public class Client {
public static void main(String[] args) {
PhoneFactory factory = new LuxuryPhoneFactory();
CPU c = factory.createCPU();
c.run();
c.start();
Screen s = factory.createScreen();
s.light();
SoftWare S = factory.createSoftWare();
S.massage();
}
}
OCP(open-closed principle)原则:就是一个软件对扩展开发,对修改关闭,即假如要在软件中实现新的功能,增加类就可以了,不要对原来的代码进行修改。
DIP(依赖倒转原则):针对接口编程,不要针对实现编程。
LOD(迪米特法则):比如类,与直接的类相联系,少和不相干的发生联系。