Java设计模式——工厂模式

本文主要是介绍Java设计模式——工厂模式，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

**工厂模式的简单概述：**工厂模式是使用工厂方法替代new操作产生实例对象的一种设计模式
**工厂模式的优势：**符合软件开发中的开闭原则，并且降低了代码的耦合性

一、简单工厂模式
1.抽象产品类：具有相似的行为（方法），一般声明为接口或抽象类
2.具体产品类：继承抽象产品类，并且实现自己的行为（方法）
3.工厂类：通过静态方法返回具体产品类的实例对象

	public interface Birds {
    	public void eat();
    }

   public class Crow implements Birds {
    @Override
    public void eat() {
        System.out.println("favourite food is insect");
    }
} 

public class Cuckoo implements Birds {
    @Override
    public void eat() {
        System.out.println("favourite food is fish");
    }
}

public class BirdsFactory {
    public static Birds getBirdsType(String type){
        switch (type){
            case "乌鸦":
                return new Crow();
            case "杜鹃":
                return new Cuckoo();
            default:
        }
        return null;
    }
}

二、工厂模式
对于一般的情况，一个工厂只会专门生成一种类别的产品，比如奥迪汽车工厂只会生产奥迪汽车，比亚迪汽车工厂只会生产比亚迪汽车

/**
 * 汽车基类
 */
public interface BaseCar {
    void run();
}

/**
 * 奥迪汽车
 */
public class AudiCar implements BaseCar {
    @Override
    public void run() {
        System.out.println("奥迪汽车的百公里加速时间为5s");
    }
}

/**
 * 比亚迪汽车
 */
public class BYDCar implements BaseCar {
    @Override
    public void run() {
        System.out.println("比亚迪汽车的百公里加速时间为7s");
    }
}

/**
 * 汽车工厂基类
 */
public interface BaseFactory {
    BaseCar createCar();
}

/**
 * 奥迪汽车工厂，专门生产比奥迪汽车
 */
public class AudiCarFactory implements BaseFactory {
    @Override
    public BaseCar createCar() {
        return new AudiCar();
    }
}

/**
 * 比亚迪汽车工厂，专门生产比亚迪汽车
 */
public class BYDCarFactory implements BaseFactory {
    @Override
    public BaseCar createCar() {
        return new BYDCar();
    }
}

三、抽象工厂模式
系统内存在一系列相互依赖的对象，在创建这样一组对象时，使用抽象工厂模式就十分方便。以创建不同风格的房屋来说明抽象工厂模式
1.房屋各个模块的基类

/**屋顶基类**/
public abstract class BaseRoof{
	public abstract void Create();
}

/**地板基类**/
public abstract class BaseFloor{
    public abstract void Create();
}

/**窗户基类**/
public abstract class BaseWindow{    
	public abstract void Create();
}

/**房门基类**/
public abstract class BaseDoor{
    public abstract void Create();
}

2.欧式风格的房屋模块

/**地板(欧式)*/
public class EuropeanFloor extends BaseFloor {
    @Override    
    public void Create() {
		System.out.println("创建欧式的地板");
    }
}

/**屋顶(欧式)*/
public class EuropeanRoof extends BaseRoof {
    @Override
    public void Create() {
		System.out.println("创建欧式的屋顶");
	}
}

/**窗户(欧式)*/
public class EuropeanWindow extends BaseRoof {
    @Override
    public void Create() {
		System.out.println("创建欧式的窗户");
	}
}

/**房门(欧式)*/
public class EuropeanDoor extends BaseRoof {
    @Override
    public void Create() {
		System.out.println("创建欧式的房门");
	}
}

3.中式风格的房屋模块

/**地板(中式)*/
public class ChineseFloor extends BaseRoof {
    @Override
    public void Create() {
		System.out.println("创建中式的地板");
	}
}

/**屋顶(中式)*/
public class ChineseRoof extends BaseRoof {
    @Override
    public void Create() {
		System.out.println("创建中式的屋顶");
	}
}

/**窗户(中式)*/
public class ChineseWindow extends BaseRoof {
    @Override
    public void Create() {
		System.out.println("创建中式的窗户");
	}
}

/**房门(中式)*/
public class ChineseDoor extends BaseRoof {
    @Override
    public void Create() {
		System.out.println("创建中式的房门");
	}
}

4.创建基类工厂

/**抽象工厂基类*/
public abstract class BaseFactory {    
	/**创建屋顶*/    
	public abstract BaseRoof CreateRoof();
	    
	/**创建地板*/    
	public abstract BaseFloor CreateFloor();
	
	/**创建窗户*/
	public abstract BaseWindow CreateWindow();
	
	/**创建房门*/
	public abstract BaseDoor CreateDoor();
}

5.创建欧式工厂对象

/**创建对象工厂(欧式)*/
public class EuropeanFactory extends BaseFactory {
    /**创建房顶(欧式)*/
    @Override
    public BaseRoof CreateRoof() {
        return new EuropeanRoof();
    }

    /**创建地板(欧式)*/
    @Override
    public BaseFloor CreateFloor() {
        return new EuropeanFloor();
    }

    /**创建窗户(欧式)*/
    @Override
    public BaseWindow CreateWindow() {
        return new EuropeanWindow();
    }

    /**创建房门(欧式)*/
    @Override
    public BaseDoor CreateDoor() {
        return new EuropeanDoor();
    }
}

6.创建中式工厂对象

/**创建对象工厂(中式)*/
public class ChineseFactory extends BaseFactory {
    /**创建房顶(中式)*/
    @Override
    public BaseRoof CreateRoof() {
        return new ChineseRoof();
    }

    /**创建地板(中式)*/
    @Override
    public BaseFloor CreateFloor() {
        return new ChineseFloor();
    }

    /**创建窗户(中式)*/
    @Override
    public BaseWindow CreateWindow() {
        return new ChineseWindow();
    }

    /**创建房门(中式)*/
    @Override
    public BaseDoor CreateDoor() {
        return new ChineseDoor();
    }
}

7.抽象工厂使用

public void testCreateCar() {
    //创建房子工厂(欧式)
    BaseFactory europeanFactory = new EuropeanFactory();
    europeanFactory.CreateRoof().Create();
    europeanFactory.CreateFloor().Create();
    europeanFactory.CreateWindow().Create();
    europeanFactory.CreateDoor().Create();
    
    //创建房子工厂(中式)
    BaseFactory chineseFactory = new ChineseFactory();
    chineseFactory.CreateRoof().Create();
    chineseFactory.CreateFloor().Create();
    chineseFactory.CreateWindow().Create();
    chineseFactory.CreateDoor().Create();
}

三种工厂模式的适用场景：
1.对于简单业务可以采用简单工厂模式，这也是最常用的工厂。
2.对于专业对象，建议采用工厂模式。
3.需要创建一系列相互依赖对象，建议采用抽象工厂模式。

这篇关于Java设计模式——工厂模式的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！