一、工厂模式之简单工厂模式Simple Factory Pattern
工厂模式，Spring用的比较多
1>我们新建一个Dao接口
package com.kaishengit.factory.simple;
public interface Dao {
public void save();
}
接下来我们新建两个实现类：
1.MySqlDao.java
package com.kaishengit.factory.simple;
public class MySqlDao implements Dao{
@Override
public void save() {
System.out.println("使用MySql存储数据！");
}
}
2.OracleDao.java
package com.kaishengit.factory.simple;
public class OracleDao implements Dao{
@Override
public void save() {
System.out.println("使用Oracle存储数据！");
}
}
2>1.我们在源文件夹中新建一个配置文件bean.properties
#key=beanName oracleDao=com.kaishengit.factory.simple.OracleDao mySqlDao=com.kaishengit.factory.simple.MySqlDao
2.接下来 我们新建一个工厂BeanFactory.java
package com.kaishengit.factory.simple;
import java.io.IOException;
import java.util.Properties;
public class BeanFactory {
private BeanFactory(){}
private static Properties pro;
static{
pro = new Properties();
try {
pro.load(BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties"));
} catch (IOException e) {
e.printStackTrace();
}
}
public static Object getBean(String beanName){
if(pro.containsKey(beanName)){
String className = pro.getProperty(beanName);
try {
return Class.forName(className).newInstance();
} catch (Exception e) {
e.printStackTrace();
}
}
return null;
}
}
3>我们测试一下
Test
package com.kaishengit.factory.simple;
public class Test {
public static void main(String[] args) {
Dao dao = (Dao) BeanFactory.getBean("mySqlDao");
dao.save();
}
}
运行结果：
使用MySql存储数据！
如果我们把beanName换成oracleDao，则运行结果为→使用Oracle存储数据！
...ok...
二、工厂模式之工厂方法模式(Factory Method)
工厂方法模式定义了一个创建对象的接口，但由子类(实现类)决定要实例化的类是
哪一个。工厂方法让类把实例化推迟到子类(实现类)。
这里我们以水果种类为例
1>我们新建一个Fruit接口和一个FruitFactory接口
package com.kaishengit.factory.method;
public interface Fruit {
public void plant();
public void grow();
public void harvest();
}
package com.kaishengit.factory.method;
public interface FruitFactory {
public Fruit createFruit(String type);//根据水果种类划分，例如：苹果、橘子...
}
2>1.这里我们只新建一个AppleFactory：实现FruitFactory接口
package com.kaishengit.factory.method;
public class AppleFactory implements FruitFactory{
@Override
public Fruit createFruit(String type) {
if("hongfushi".equals(type)){
return new HongfushiApple();
}
return null;
}
}
2.我们只新建苹果中的一种品种：HongfushiApple:实现Fruit接口
package com.kaishengit.factory.method;
public class HongfushiApple implements Fruit{
@Override
public void plant() {
System.out.println("种植红富士");
}
@Override
public void grow() {
}
@Override
public void harvest() {
}
}
3>接下来我们测试一下：
package com.kaishengit.factory.method;
public class Test {
public static void main(String[] args) {
FruitFactory ff = new AppleFactory();
Fruit f = ff.createFruit("hongfushi");
f.plant();
}
}
运行结果：
种植红富士
...ok...，方法模式的精髓：根据种类划分，像这里是根据水果种类划分的
三、工厂模式之抽象工厂(Abstract Factory)
抽象工厂模式提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。
这种模式是根据系列划分的，这里我们把水果分为：热带系列和亚热带系列，我们只写一下热带系列
1>我们新建三个接口：Fruit、Veggie、Factory
package com.kaishengit.factory.abstract_p;
public interface Fruit {
}
package com.kaishengit.factory.abstract_p;
public interface Veggie {
}
package com.kaishengit.factory.abstract_p;
public interface Factory {
public Fruit createFruit(String type);
public Veggie createVeggie(String type);
}
2>我们新建一个热带工厂(TropicalFactory)、一个热带水果(TropicalFruit)
package com.kaishengit.factory.abstract_p;
public class TropicalFactory implements Factory{
@Override
public Fruit createFruit(String type) {
return new TropicalFruit();
}
@Override
public Veggie createVeggie(String type) {
return null;
}
}
package com.kaishengit.factory.abstract_p;
public class TropicalFruit implements Fruit{
public TropicalFruit() {
System.out.println("这是一个热带水果");
}
}
3>最后我们测试一下：
package com.kaishengit.factory.abstract_p;
public class Test {
public static void main(String[] args) {
Factory factory = new TropicalFactory();
factory.createFruit("");
}
}
运行结果：
这是一个热带水果
工厂模式：
模式运用最重要的是思想：简单工厂模式适合一个对象，方法模式适合一个品种，抽象模式适合一个系列，也就是它们分别是按对象、种类、系列(群体)来划分的