工厂方法模式

今天把之前在纸上写的一些草稿写到博客上面来，这样记录一下自己以前的学习历程。

简单工厂模式

工厂方法模式

抽象工厂模式

部分内容摘自http://www.cnblogs.com/yinrq/p/5280616.html

如有冒犯请联系我。

下面具体说说简单工厂模式：

简单工厂模式（Simple Factory Pattern）：简单工厂又称为静态工厂方法（Static Factory Method）模式。它属于类创建型模式。在简单工厂模式中，可以根据参数的不同返回不同的实例。简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都有共同的父类。

简单工厂模式包括三个角色：抽象产品角色，具体产品角色，工厂角色。

package com.sei.ecnu.simpleFactory;

public interface Car {
    
    void gotowork();

}

package com.sei.ecnu.simpleFactory;

public class Bike implements Car{

    @Override
    public void gotowork() {
        System.out.println("骑自行车去上班！");
        
    }

}

package com.sei.ecnu.simpleFactory;

public class Bus implements Car{

    @Override
    public void gotowork() {
        System.out.println("坐公交车去上班！");
    }
    

}

package com.sei.ecnu.simpleFactory;


public class SimpleFactory {
    
    public enum CarType{
        BIKE,BUS;
    }
    
    public static Car getCar(CarType car){
        Car simpleCar = null;
        switch(car){
        case BIKE:
            simpleCar = new Bike();
            break;
        case BUS:
            simpleCar = new Bus();
            break;
        default:
            simpleCar = new Bike();
        }
        
        return simpleCar;
    }

}

package com.sei.ecnu.simpleFactory;

import org.junit.Test;

import com.sei.ecnu.simpleFactory.SimpleFactory.CarType;

public class TestSimple {
    
    @Test
    public void test(){
        Car car = SimpleFactory.getCar(CarType.BIKE);
        System.out.println("上班方式：");
        car.gotowork();
        
        Car car2 = SimpleFactory.getCar(CarType.BUS);
        System.out.println("上班方式：");
        car2.gotowork();
    }

}

下面说说工厂方法模式：

工厂方法模式也叫工厂模式，属于类创建模式，工厂父类（接口）负责定义产品对象的公共接口，而子类工厂负责创建具体的产品对象。

目的：是为了把产品的实例化操作延迟到子类工厂中完成，通过工厂子类来决定究竟应该实例化哪一个具体对象。工厂方法模式包含四个部分：

1.抽象产品：产品对象同一的基类，或者是同一的接口。

2.具体的产品：各个不同的实例对象类

3.抽象工厂：所有的子类工厂类的基类，或者是同一的接口

4.具体的工厂子类：负责每个不同的产品对象的事迹创建

代码实现如下：

package com.sei.ecnu;

public interface Car {
    
    void gotowork();

}

package com.sei.ecnu;

public class Bike implements Car{

    @Override
    public void gotowork() {
        System.out.println("骑自行车去上班！");
        
    }

}

package com.sei.ecnu;

public class Bus implements Car{

    @Override
    public void gotowork() {
        System.out.println("开车去上班！");
        
    }

}

package com.sei.ecnu;

public interface ICarFactory {
    
    Car getCar();

}

package com.sei.ecnu;

public class BikeFactory implements ICarFactory{

    @Override
    public Car getCar() {
        
        return new Bike();
    }

}

package com.sei.ecnu;

public class BusFactory implements ICarFactory{

    @Override
    public Car getCar() {
        
        return new Bus();
    }

}

package com.sei.ecnu;

import org.junit.Test;

public class TestFactory {
    
    @Test
    public void test(){
        ICarFactory factory = null;
        //bike
        factory = new BikeFactory();
        Car bike = factory.getCar();
        bike.gotowork();
        
        //bus
        factory = new BusFactory();
        Car bus = factory.getCar();
        bus.gotowork();
    }

}

下面在说一说抽象工厂模式：

抽象工厂模式：提供一个创建一系列的相关的或者依赖的对象的接口，无需指定他们的具体实现类，具体的实现分别在子类工厂中产生。

类似于工厂模式：隔离了具体的生产实现，使得替换具体的工厂实现类很容易。包含有一下模块：

1.抽象产品接口：定义产品的接口，公共的爆漏方法。便于实际的产品类实现。

2.具体的产品类：包含实际产品的类的逻辑处理；

3.抽象工厂接口：定义产生系列对象的接口

4.具体的工厂实现：实现抽象的接口工厂，返回具体的产品类的实现。

下面是具体的代码示例：

package com.sei.ecnu.abstractFactory;

public interface Car {
    
    void gotowork();

}

package com.sei.ecnu.abstractFactory;

public class Bike implements Car{

    @Override
    public void gotowork() {
        System.out.println("骑自行车去上班！");
        
    }

}

package com.sei.ecnu.abstractFactory;

public class Bus implements Car{

    @Override
    public void gotowork() {
        System.out.println("坐公交车去上班！");
        
    }

}

package com.sei.ecnu.abstractFactory;

public interface IBreakFast {
    
    void eat();

}

package com.sei.ecnu.abstractFactory;

public class Milk implements IBreakFast{

    @Override
    public void eat() {
        System.out.println("喝牛奶！");
        
    }

}

package com.sei.ecnu.abstractFactory;

public class Orange implements IBreakFast {

    @Override
    public void eat() {
        System.out.println("吃橘子！");

    }

}

package com.sei.ecnu.abstractFactory;

public interface IAbstractFactory {
    
    Car getCar();
    
    IBreakFast getBreakFast();

}

package com.sei.ecnu.abstractFactory;

public class LowPersonFactory implements IAbstractFactory{

    @Override
    public Car getCar() {
        
        return new Bike();
    }

    @Override
    public IBreakFast getBreakFast() {
        
        return new Orange();
    }

}

package com.sei.ecnu.abstractFactory;

public class HighPersonFactory implements IAbstractFactory{

    @Override
    public Car getCar() {
        
        return new Bus();
    }

    @Override
    public IBreakFast getBreakFast() {
        
        return new Milk();
    }

}

import org.junit.Test;

public class AbstractFactoryTest {
    @Test
    public void test(){
        IAbstractFactory factory = new LowPersonFactory();
        Car car = factory.getCar();
        IBreakFast breakFast = factory.getBreakFast();
        System.out.println("吃的早饭是：");
        breakFast.eat();
        System.out.println("上班的交通工具是：");
        car.gotowork();
        
        IAbstractFactory factory2 = new HighPersonFactory();
        Car car2 = factory2.getCar();
        IBreakFast breakFast2 = factory2.getBreakFast();
        System.out.println("吃的早饭是：");
        breakFast2.eat();
        System.out.println("上班的交通工具：");
        car2.gotowork();
    }

}

输出结果：

吃的早饭是：
吃橘子！
上班的交通工具是：
骑自行车去上班！
吃的早饭是：
喝牛奶！
上班的交通工具：
坐公交车去上班！