学习了一下关于工厂的设计模式,写个例子整理一下,例子是生产不同厂商的鼠标,可能不太合适,记录一下想法。
1.简单工厂
这个模式在factory里面动态选择使用哪个类
public class Factory {
public static Made getMade(String o) {
Made made = null;
switch (o) {
case "logutech":
made = new LogitechMade();
break;
case "lenovo":
made = new LenovoMade();
break;
default:
made = new LogitechMade();
}
return made;
}
}
Made类是一个抽象类,规定了制作的方法。
public abstract class Made {
public abstract void made();
}
在工厂中通过客户端传入的需求,实例化不同的made对象。两个厂商的made类继承自Made类。另一个相同,重写抽象类的生产方法
public class LogitechMade extends Made {
@Override
public void made() {
System.out.println("logutech made mouse");
}
}
接下来是main客户端
public class Main {
public static void main(String[] args) {
Made made = Factory.getMade("lenovo");
made.made();
}
}
首先声明一个Made的实例对象,从factory里面获得,根据用户数需求实例化不同的厂商made对象,然后实例对象执行made制造方法,就制造了相应厂商的鼠标。
这就是简单工厂模式。
项目结构截图
2.工厂模式
通过观察,简单工厂扩展性很差,每次增加厂商都要修改工厂类factory。工厂模式来解决,工厂模式只是增强了可扩展性,为每个生产类增加了一个工厂,类的数量增多,工厂类factory负担减少。
首先是工厂类,这里做成抽象类,减轻负担,只规定了一个获得生产方法的方法。
public abstract class AbstractFactory {
public abstract Made getMade();
}
然后每个厂商都有一个工厂类,继承自这个抽象的工厂类。重写获取制造方法的方法,这里由于就是罗技的工厂,所以在获取制造方法的方法里直接返回与简单工厂相同的类LogitechMade。这个类也是继承自Made类,这里与简单工厂相同。
public class LogutechFactory extends AbstractFactory {
@Override
public Made getMade() {
return new LogitechMade();
}
}
剩下的类基本与简单工厂一样,接下来是mian。声明一个AbstractFactory的引用,申请为LogitechFactory,这样factory就是LogitechFactory的factory。然后从这个factory里面获得made制造方法,然后调用made.made方法。就是调用的LogitechMade的制造方法,制造出的就是Logitech的鼠标。
public class Main {
public static void main(String[] args) {
AbstractFactory factory = new LogitechFactory();
Made made = factory.getMade();
made.made();
}
}
工厂模式就是为每个执行方法的类做一个工厂,这样达到了便于扩展的目的。
项目的截图:
3.抽象工厂
然后是每个厂商不只是生产鼠标,还要生产键盘,涉及到产品族的问题,就要用到抽象工厂。
这里想放上项目的结构的截图:
Mouse类:类似于之前的Made类,为抽象类,有一个制作鼠标的方法,Keyboard与这个相同。
public abstract class Mouse {
public abstract void MouseMade();
}
LogitechMouseMade为具体的生产类,继承Mouse类,重写mousemade方法,made包下的制造类分贝继承device包下的类。
public class LogitechMouseMade extends Mouse {
@Override
public void MouseMade() {
System.out.println("LogitechMouse");
}
}
这里的工厂增加了获取制造键盘的的方法的抽象方法。
public abstract class AbstractFactory {
public abstract Mouse madeMouse();
public abstract Keyboard madeKeyboard();
}
具体厂商的工厂继承抽象工厂,重写方法:在方法中调用相应的类。
public class LogitechFactory extends AbstractFactory {
@Override
public Mouse madeMouse() {
return new LogitechMouseMade();
}
@Override
public Keyboard madeKeyboard() {
return new LogitechKeyboardMade();
}
}
main:还是获得一个罗技的工厂,调用罗技工厂的做鼠标方法和做键盘方法,就制作出来了。
public class Main {
public static void main(String[] args) {
AbstractFactory factory = new LogitechFactory();
Mouse mouse = factory.madeMouse();
Keyboard keyboard = factory.madeKeyboard();
mouse.MouseMade();
keyboard.KeyboardMade();
}
}
3种模式各有利弊,在不同的情况用不同的方式,使代码易维护,可扩展。