简单工厂模式简单实例

简单⼯⼚模式简单实例

最近在看设计模式，那么简单⼯⼚模式是什么呢？简单的例⼦来记录下吧：

⾸先来两个例⼦来简单的说明吧：

1.第⼀个例⼦

简单的假设，我们现在需要创建很多的实例，并且这些实例是有⼀定共性的。

简单例⼦：现在我们需要创建⼀个关于usb的设备，只要⽀持usb的设备我们都需要将其创建出来，⽐如⼿机，电脑，相机很多很多种不同的设备，他们有⼀些共性（属于电⼦产品，⽀持usb接⼝等）那么我们创建这些产品的实例的时候我们会怎么创建呢？

⼀般创建⽅法

public static void main(String [] args){ //创建电脑实例

Computer comp = new Computer(); //创建⼿机实例

Phone p = new Phone(); //创建打印机实例

Printer prin = new Printer(); //创建⿏标实例

Mouse mouse = new Mouse(); }

在我们创建的过程中就会感觉⾮常的臃肿，当然简单⼯⼚的设计模式并不是仅仅只是解决这么⼀个⾮常⼩的问题。

我们细细的想，这些产品它是有很多共性的，但是有些东西使他们特有的，那么我们可以怎么做？

这⾥我们就需要将这些具有共性的东西抽离出来形成⼀个⽗类（当然是要⽤到⾯向对象的思想的）

这样做的好处？

对于⽤户来说：现在有⼀个例⼦，我们现在有⼀个⼯⼚（⼀个制造电⼦产品的⼯⼚），他能够给我们制造出⽀出usb的设备，那么作为⼀个客户我们不需要去知道⼯⼚具体怎么去操作，我们只要有需求就可以向⼯⼚提交我们需要制造的产品就可以。

对于⼯⼚来说：我们需要的是满⾜客户的需求制造出产品，那么⼯⼚有⾮常多的⽣产线，我们需要将每⼀个⽣产线能够⽣产什么东西罗列出来，然后分类，但是他们都有⽀持usb产品的属性，那么就让这些继承产品这个类，作为⼦类。（这样我们某⼀条⽣产线发⽣了改变，⽐如iphone6上市后，后⾯产品的迭代需要更新iphone7，那么我们只需要更改⼀个产品线就可以，其他的所有东西都可以不需要改变）那么下⾯就是简单的代码笔记：

下⾯这个例⼦：⼀个⼯⼚⽣产出⽀持usb的电⼦产品，那么有电脑和⿏标，简单的例⼦

运⽤简单⼯⼚设计模式（这个是⼯⼚⽅法，负责对产品进⾏实例化）

/**

* 这是简单⼯⼚模式的⼯⼚类，主要是⽤来创建其他电⼦产品的实例的 * @author lijunhong * */

public class ElectronFactory {

USBElectron device = null;//这个是设备

public USBElectron creatDevice(String name){ switch (name) { case \"computer\":

device = new Computer(name); break;

case \"mouse\":

device = new Mouse(name); break; default: break; }

return device; } }

这个抽象类将产品中的功能抽象出来，每个产品都有相应的功能

/**

* 这是⼀个⽗类，将⽀持usb中的设备抽象出来 * @author lijunhong *

*/

public abstract class USBElectron {

public abstract void function();//抽象出设备的功能}

电脑类，继承⾃上⾯的⽗类，并且实现了产品的功能

public class Computer extends USBElectron { private String name;

public Computer(String name){ this.name = name; }

public void function() { //这个⽅法是电脑的⽅法

System.out.println(this.name+\":电脑可以上⽹，聊天，学习\"); }}

⿏标类：

public class Mouse extends USBElectron { private String name;

public Mouse(String name){ this.name = name; }

@Override

public void function() { //这个是⿏标的⽅法

System.out.println(this.name+\":⿏标可以打字\"); }}

上⾯这⼏个类简单的构成了简单⼯⼚模式；那么现在开始运⽤这个简单⼯⼚模式⽣产产品

当⼀个客户需要⽣产产品⽐如：⼀台电脑或者⼀个⿏标亦或者其他东西我们都可以运⽤

客户端程序

public class FactoryMain { /**

* @param args */

public static void main(String[] args) { //简单⼯⼚创建实例演⽰ //创建⼯⼚

ElectronFactory factory = new ElectronFactory(); //创建电脑实例

USBElectron computer = factory.creatDevice(\"computer\"); computer.function(); //创建⿏标实例

USBElectron mouse = factory.creatDevice(\"mouse\"); mouse.function(); }}

2.第⼆个例⼦

例⼦：现在我们需要做⼀个游戏，这个游戏中有很多怪物，不同种类的怪物，我们根据游戏的进展需要去除案件不同的怪物。（妖猴，狐狸精，狸猫，吸⾎⿁等）

下⾯就是离⼦的实现过程：

怪物的⽗类（Monster）

//这是⼀个怪物的抽象类（⽗类）public abstract class Monster {

public abstract void skill();//怪物技能

public abstract void getName();//怪物名字

public abstract void eat();//怪物吃东西}

猴⼦的实现类（Monkey）

public class Monkey extends Monster { public Monkey(){

}

@Override

public void skill() {

System.out.println(\"猴⼦会使⽤⾦箍棒。\"); }

@Override

public void getName() { System.out.println(\"猴⼦\"); }

@Override

public void eat() {

System.out.println(\"猴⼦吃桃⼦\"); }

public void life(){

System.out.println(\"猴⼦长⾝不⽼\"); }}

狸猫的实现类（Tanuki）

public class Tanuki extends Monster { public Tanuki(){ }

@Override

public void skill() {

System.out.println(\"狸猫的魅惑技能\"); }

@Override

public void getName() { System.out.println(\"狸猫\"); }

@Override

public void eat() {

System.out.println(\"狸猫吃太⼦\"); } }

吸⾎⿁的实现类（Vampire）

public class Vampire extends Monster { public Vampire(){ }

@Override

public void skill() {

System.out.println(\"吸⾎⿁吸⾎\"); }

@Override

public void getName() {

System.out.println(\"吸⾎⿁\"); }

@Override

public void eat() {

System.out.println(\"吸⾎⿁吸⾎\"); }}

客户端

public class MonsterMain {

public static MonsterFactory monsterfactory;//⼯⼚ public static Monster monster;

public static void main(String[] args) {

//创建猴⼦实体对象 //创建喜欢⾎⿁

monster = MonsterFactory.creatMonster(\"吸⾎⿁\"); monster.eat();

monster.getName(); monster.skill();

//创建狸猫

monster = monsterfactory.creatMonster(\"狸猫\"); monster.eat();

monster.getName(); monster.skill();

//这⾥转型，从⽽可以调⽤life⽅法

Monkey monster = (Monkey)monsterfactory.creatMonster(\"猴⼦\"); monster.eat(); monster.skill();

monster.getName(); monster.life(); }}

运⾏结果如下

记录学习的每⼀步，记录每⼀次的成长