您的位置: 首页  >  文章  >  设计模式之抽象工厂模式

设计模式之抽象工厂模式

分类: 文章 • 2024-07-18 11:20:58

首先设计一个工厂接口，再设计两个具体工厂实现该接口，设计一个生产内容接口，接着设计四个具体生产内容类实现该接口，再设计一个生产工厂类，最后是客户端调用类。代码如下：

工厂接口：

package com.freshbin.pattern.factory.myexample.gamefactory;

import java.util.Map;

import com.freshbin.pattern.factory.myexample.gametype.Game;

/**
 * 工厂接口
 * 
 * @author freshbin
 * @date 2019-1-4 11:53:02
 */
public interface GameFactory {
	void chooseGame(Integer chooseGame);

	Map<Integer, Game> getGameMap();

	void displayGameList();

	String display();

}

两个具体实现类：

package com.freshbin.pattern.factory.myexample.gamefactory;

import java.util.HashMap;
import java.util.Map;

import com.freshbin.pattern.factory.myexample.gametype.EatChickenGame;
import com.freshbin.pattern.factory.myexample.gametype.Game;
import com.freshbin.pattern.factory.myexample.gametype.GloryOfKing;

/**
 * 移动端游戏
 * 
 * @author freshbin
 * @date 2019-1-4 15:13:09
 */
public class MobileGame implements GameFactory {
	private static Map<Integer, Game> gameMap = new HashMap<>();

	static {
		gameMap.put(1, new GloryOfKing());
		gameMap.put(2, new EatChickenGame());
	}

	@Override
	public void chooseGame(Integer chooseGame) {
		if (!gameMap.containsKey(chooseGame)) {
			return;
		}

		gameMap.get(chooseGame).playGame();
	}

	@Override
	public Map<Integer, Game> getGameMap() {
		return gameMap;
	}

	@Override
	public void displayGameList() {
		if (gameMap == null || gameMap.size() <= 0) {
			return;
		}

		for (Map.Entry<Integer, Game> map : gameMap.entrySet()) {
			System.out.println(map.getKey() + ":" + map.getValue().display());
		}

		System.out.println("请输入序号选择您想玩的游戏(输入0退出)：");
	}

	@Override
	public String display() {
		return "mobile game";
	}
}

package com.freshbin.pattern.factory.myexample.gamefactory;

import java.util.HashMap;
import java.util.Map;

import com.freshbin.pattern.factory.myexample.gametype.CFGame;
import com.freshbin.pattern.factory.myexample.gametype.Game;
import com.freshbin.pattern.factory.myexample.gametype.LOLGame;

/**
 * PC游戏
 * 
 * @author freshbin
 * @date 2019-1-4 11:53:32
 */
public class PCGame implements GameFactory {
	private static Map<Integer, Game> gameMap = new HashMap<>();

	static {
		gameMap.put(1, new LOLGame());
		gameMap.put(2, new CFGame());
	}

	@Override
	public void chooseGame(Integer chooseGame) {
		if (!gameMap.containsKey(chooseGame)) {
			return;
		}

		gameMap.get(chooseGame).playGame();
	}

	@Override
	public Map<Integer, Game> getGameMap() {
		return gameMap;
	}

	@Override
	public void displayGameList() {
		if (gameMap == null || gameMap.size() <= 0) {
			return;
		}

		for (Map.Entry<Integer, Game> map : gameMap.entrySet()) {
			System.out.println(map.getKey() + ":" + map.getValue().display());
		}

		System.out.println("请输入序号选择您想玩的游戏(输入0退出)：");
	}

	@Override
	public String display() {
		return "pc game";
	}
}

生产内容接口： 

package com.freshbin.pattern.factory.myexample.gametype;

/**
 * 游戏基类
 * 
 * @author freshbin
 * @date 2019-1-4 12:04:14
 */
public interface Game {
	void playGame();

	String display();
}

四个具体生产内容类：

package com.freshbin.pattern.factory.myexample.gametype;

/**
 * cf游戏
 * 
 * @author freshbin
 * @date 2019-1-4 15:16:13
 */
public class CFGame implements Game {

	@Override
	public void playGame() {
		System.out.println("play cf!");
	}

	@Override
	public String display() {
		return "CF";
	}
}

package com.freshbin.pattern.factory.myexample.gametype;

/**
 * 吃鸡游戏
 * 
 * @author freshbin
 * @date 2019-1-4 12:05:02
 */
public class EatChickenGame implements Game {

	@Override
	public void playGame() {
		System.out.println("play eatChicken!");
	}

	@Override
	public String display() {
		return "eatChicken";
	}
}

package com.freshbin.pattern.factory.myexample.gametype;

/**
 * 王者荣耀
 * 
 * @author freshbin
 * @date 2019-1-4 12:06:03
 */
public class GloryOfKing implements Game {

	@Override
	public void playGame() {
		System.out.println("play glory of king!");
	}

	@Override
	public String display() {
		return "GloryOfKing";
	}

}

package com.freshbin.pattern.factory.myexample.gametype;

/**
 * LOL游戏
 * 
 * @author freshbin
 * @date 2019-1-4 12:05:02
 */
public class LOLGame implements Game {

	@Override
	public void playGame() {
		System.out.println("play LOL!");
	}

	@Override
	public String display() {
		return "LOL";
	}
}

生产工厂类：

package com.freshbin.pattern.factory.myexample.producer;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.Map;

import com.freshbin.pattern.factory.myexample.gamefactory.GameFactory;
import com.freshbin.pattern.factory.myexample.gamefactory.MobileGame;
import com.freshbin.pattern.factory.myexample.gamefactory.PCGame;

/**
 * 制造游戏工厂
 * 
 * @author freshbin
 * @date 2019-1-4 12:02:19
 */
public class GameFactoryProducer {

	private GameFactory gameFactory;
	private static Map<Integer, GameFactory> gameFactoryMap = new HashMap<>();

	static {
		gameFactoryMap.put(1, new PCGame());
		gameFactoryMap.put(2, new MobileGame());
	}

	public GameFactoryProducer(Integer chooseFactory) {
		do {
			if (!gameFactoryMap.containsKey(chooseFactory)) {
				break;
			}
			gameFactory = gameFactoryMap.get(chooseFactory);
			gameFactory.displayGameList();
			Integer chooseGame = chooseGameFactory(gameFactory);
			if (chooseGame == 0) {
				break;
			}
			gameFactory.chooseGame(chooseGame);
			System.out.println("===================================");
		} while (true);
	}

	public Integer chooseGameFactory(GameFactory gameFactory) {
		Integer chooseGame = 0;
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		try {
			String chooseGameStr = br.readLine();
			chooseGame = Integer.valueOf(chooseGameStr);
		} catch (IOException e) {
			System.out.println("系统异常!请稍后再试!");
			e.printStackTrace();
		}

		return chooseGame;
	}

	public static void displayGameFactory() {
		if (gameFactoryMap == null || gameFactoryMap.size() <= 0) {
			return;
		}

		for (Map.Entry<Integer, GameFactory> gameFactory : gameFactoryMap.entrySet()) {
			System.out.println(gameFactory.getKey() + ":" + gameFactory.getValue().display());
		}
		System.out.println("请输入序号选择您想玩的游戏类型(输入0退出)：");
	}
}

客户端主类：

package com.freshbin.pattern.factory.myexample;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

import com.freshbin.pattern.factory.myexample.producer.GameFactoryProducer;

/**
 * 工厂模式
 * 
 * @author freshbin
 * @date 2019-1-4 11:51:42
 */
public class FactoryMain {
	public static void main(String[] args) {
		do {
			System.out.println("=========游戏选择开始界面=============");
			GameFactoryProducer.displayGameFactory();
			Integer chooseFactory = chooseGameFactory();
			if (chooseFactory == 0) {
				break;
			}
			GameFactoryProducer gameFactoryProducer = new GameFactoryProducer(chooseFactory);
		} while (true);
		System.out.println("您走好，欢迎下次继续玩!");
	}

	private static Integer chooseGameFactory() {
		Integer choose = 0;
		BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
		try {
			String chooseStr = bf.readLine();
			choose = Integer.valueOf(chooseStr);
		} catch (IOException e) {
			System.out.println("系统系统，请稍后再试!");
			e.printStackTrace();
		}

		return choose;
	}
}

下面是演示界面截图：

设计模式之抽象工厂模式

github代码地址：https://github.com/freshbin/designPattern

相关推荐