java设计模式学习之工厂模式学习

工厂模式

1.实例化对象，用工厂方法代替new操作
2.包括工厂方法模式和抽象工厂模式（工厂模式方法的扩展）

工厂模式意图

定义一个接口来创建对象，但是让子类来决定哪些类需要被实例化。
工厂方法把实例化的工作推迟到子类中去实现

哪些情况适合？

有一组类似的对象需要创建
编码时不能预见需要创建哪种类的实例
系统需要考虑扩展性，不依赖产品实例如何创建，组合和表达的细节

项目中的现状：

在软件系统中经常面临着“对象”的创建工作，由于需求的变化，这个对象可能随之也会发生变化，但它却拥有比较稳定的接口。为此，我们需要提供一种封装机制来隔离出这个易变对象的变化，从而保持系统中其他依赖该对象的对象不随着需求的变化而变化。

package Factory;
/**
 * 发型接口 
 */
public interface HairInterface {

    public void draw();
}

---

package Factory;

public class LeftHair implements HairInterface{

    @Override
    public void draw() {
        System.out.println("画了一个左偏分的发型");
    }
}

---

package Factory;

public class RightHair implements HairInterface{

    @Override
    public void draw() {
        System.out.println("右偏分发型");
    }
}

---

package Factory;

import java.util.Map;

public class HairFactory {
    public HairInterface getHair(String type) {
        if ("left".equals(type)) {
            return new LeftHair();
        } else if ("right".equals(type)) {
            return new RightHair();
        }
        return null;
    }

    /**
     * 根据类名生成对象 
     */
    public HairInterface getHairByClass(String className) {
        try {
            HairInterface hair = (HairInterface)Class.forName(className).newInstance();
            return hair;
        } catch (InstantiationException e) {
            e.printStackTrace();
            return null;
        } catch (IllegalAccessException e) {
            e.printStackTrace();
            return null;
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            return null;
        }
    }

    public HairInterface getHairBykey(String key) {
        try {
            Map<String, String> map = new PropertiesReader().getProperties();
            HairInterface hair = (HairInterface)Class.forName(map.get(key)).newInstance();
            return hair;
        } catch (InstantiationException e) {
            e.printStackTrace();
            return null;
        } catch (IllegalAccessException e) {
            e.printStackTrace();
            return null;
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            return null;
        }
    }
}

---

package Factory;

import java.io.IOException;
import java.io.InputStream;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

public class PropertiesReader {
    public Map<String, String> getProperties() {
        Properties properties = new Properties();
        Map<String, String> map = new HashMap<String,String>();

        try {
            InputStream inputStream = getClass().getResourceAsStream("type.properties");
            properties.load(inputStream);
            Enumeration en = properties.propertyNames();
            while (en.hasMoreElements()) {
                String key = (String) en.nextElement();
                String property = properties.getProperty(key);
                map.put(key, property);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return map;
    }
}

type.properties [新增了类型之后只需要增加接口实现和此处的配置文件即可]

left=Factory.LeftHair
right=Factory.RightHair

package Factory;

public class Test {

    public static void main(String[] args) {
//      HairInterface left = new LeftHair();
//      left.draw();

        HairFactory factory = new HairFactory();
        HairInterface left = factory.getHair("left");
        left.draw();

        HairInterface right = factory.getHairByClass(RightHair.class.getName());
        right.draw();

        HairInterface right1 = factory.getHairBykey("right");
        right1.draw();
    }
}

---

抽象工厂模式

package Factory;

public interface Boy {
    public void drawBoy();
}

package Factory;

public interface Girl {
    public void drawWomen();
}

package Factory;

public class HnBoy implements Boy{

    @Override
    public void drawBoy() {
        System.out.println("生成新年系列的男孩");        
    }
}

package Factory;

public class HnGirl implements Girl{

    @Override
    public void drawWomen() {
        System.out.println("生成新年系列的男孩");
    }
}

package Factory;

public interface PersonFactory {
    public Boy getBoy();

    public Girl getGirl();
}

package Factory;

public class HnFactory implements PersonFactory{

    @Override
    public Boy getBoy() {
        return new HnBoy();
    }

    @Override
    public Girl getGirl() {
        return new HnGirl();
    }
}

package Factory;

public class McFactory implements PersonFactory{

    @Override
    public Boy getBoy() {
        return new McBoy();
    }

    @Override
    public Girl getGirl() {
        return new McGirl();
    }
}

package Factory;

public class Test {

    public static void main(String[] args) {
        PersonFactory factory2 = new McFactory();
        Girl girl = factory2.getGirl();
        girl.drawWomen();
    }
}

工厂模式的常见应用

1.JDBC
2.Spring beanFactory,作为Spring基础的Ioc容器，是Spring的一个Bean工厂。

对比

1.工厂模式是一种极端情况的抽象工厂模式，而抽象工厂模式是工厂模式的推广
2.工厂模式用来创建一个产品的等级结构，而抽象工厂模式是用来创建多个产品的等级结构
3.工厂模式只有一个抽象产品类，而抽象工厂模式有多个抽象产品类

好处

1.系统可以在不修改具体工厂角色的情况下引进新的产品
2.客户端不必关心对象如何创建，明确了职责
3.更好的理解面向对象的原则，面向接口编程，而不是面向实现编程