java简单工厂设计模式
- 格式：pdf
- 大小：111.55 KB
- 文档页数：4
java简单⼯⼚设计模式
⼀、基本定义
/*
*简单⼯⼚设计模式：
*⽂字描述理解：
* 简单⼯⼚模式属于类的创建型模式，⼜叫做静态⼯⼚⽅法模式。
* 通过专门定义⼀个类来负责创建其它类的实例，被创建的实例通常
* 都具有共同的⽗类。
* */
⼆、⾸先创建Apple、Banana实体类
public class Apple {
public void eat(){
System.out.println("吃苹果");
}
}
public class Banana {
public void eat(){
System.out.println("吃⾹蕉");
}
}
编写测试类：
public class MainClass {
public static void main(String[] args) {
//实例Apple
Apple apple = new Apple();
//实例Banana
Banana banana = new Banana();
apple.eat();
banana.eat();
//可以发现Apple、Banana可以共同抽象出⼀个接⼝eat
}
}
在运⾏中，我们发现Apple、Banana类都有共同的⽅法。那么我们就可以抽象出来⼀个接⼝来实现。修改代码如下：
public interface Fruit {
void eat();
}
public class Apple implements Fruit {
@Override
public void eat() {
System.out.println("吃苹果");
}
}
public class Banana implements Fruit{
@Override
public void eat() {
System.out.println("吃⾹蕉");
}
}public class MainClass {
public static void main(String[] args) {
/*
//实例Apple
Apple apple = new Apple();
//实例Banana
Banana banana = new Banana();
apple.eat();
banana.eat();
**/
//可以发现Apple、Banana可以共同抽象出⼀个接⼝eat,多态实例化
Fruit apple = new Apple();
Fruit banana = new Banana();
apple.eat();
banana.eat();
//按照定义：通过专门定义⼀个类来负责创建其他类的实例，那么我们就需要创建FruitFactory实例，具体代码如下。
}
}
创建FruitFactory⼯⼚类：
public class FruitFactory {
/*
*获得Apple类的实例
* */
public Fruit getApple(){
return new Apple();
}
/*
*获得Banana类的实例
* */
public Fruit getBanana(){
return new Banana();
}
}
MainClass测试类；
public class MainClass {
public static void main(String[] args) {
/*
//实例Apple
Apple apple = new Apple();
//实例Banana
Banana banana = new Banana();
apple.eat();
banana.eat();
**/
//可以发现Apple、Banana可以共同抽象出⼀个接⼝eat,多态实例化
// Fruit apple = new Apple();
// Fruit banana = new Banana();
// apple.eat();
// banana.eat();
//按照定义：通过专门定义⼀个类来负责创建其他类的实例FruitFactory
Fruit apple = new FruitFactory().getApple();
Fruit banana = new FruitFactory().getBanana();
apple.eat();
banana.eat();
}
}那么我们有没有具体什么需要改进的地⽅？FruitFactory表明静态⽅法。这样就不⽤再新建实例化了。
public class FruitFactory {
/*
*获得Apple类的实例
* */
public static Fruit getApple(){
return new Apple();
}
/*
*获得Banana类的实例
* */
public static Fruit getBanana(){
return new Banana();
}
}
//直接类名调⽤即可。
Fruit apple = FruitFactory.getApple();
Fruit banana = FruitFactory.getBanana();
apple.eat();
banana.eat();
三、模式中包含的⾓⾊和职责
1.⼯⼚（Creator）⾓⾊简单⼯⼚模式的核⼼，它负责实现创建所有实例的内部逻辑。⼯⼚类可以被外界直接调⽤，创建所需的产品对象。
⽐如：我们本次创建的FruitFactory
2.抽象（Product）⾓⾊，简单⼯⼚模式所创建的所有对象的⽗类，它负责描述所有实例所共有的公共接⼝。
3.具体产品（Concrete Product）⾓⾊简单⼯⼚模式所创建的具体实例对象
FruitFactory我们需要抽象⼀个具体⽅法，get所有的对象实例化。
public class FruitFactory {
// /*
// *获得Apple类的实例
// * */
// public static Fruit getApple(){
// return new Apple();
// }
//
// /*
// *获得Banana类的实例
// * */
// public static Fruit getBanana(){
// return new Banana();
// }
//get所有的对象
public static Fruit getFruit(String name) throws IllegalAccessException, InstantiationException {
if (name.equalsIgnoreCase("apple")){
return Apple.class.newInstance();
}else if (name.equalsIgnoreCase("banana")){
return Banana.class.newInstance();
}else {
return null;
}
}
}
//测试类
Fruit apple = FruitFactory.getFruit("apple");
Fruit banana = FruitFactory.getFruit("banana");
apple.eat();
banana.eat();
FruitFactory⾥⾯的get实例，我们可以继续优化。public class FruitFactory {
// /*
// *获得Apple类的实例
// * */
// public static Fruit getApple(){
// return new Apple();
// }
//
// /*
// *获得Banana类的实例
// * */
// public static Fruit getBanana(){
// return new Banana();
// }
//get所有的对象
public static Fruit getFruit(String name) throws IllegalAccessException, InstantiationException, ClassNotFoundException {
// if (name.equalsIgnoreCase("apple")){
// return Apple.class.newInstance();
// }else if (name.equalsIgnoreCase("banana")){
// return Banana.class.newInstance();
// }else {
// return null;
// }
Class aClass = Class.forName(name);
return (Fruit) aClass.newInstance();
}
}
注意：测试类测试传⼊的String类型；
Fruit apple = FruitFactory.getFruit("Apple");
Fruit banana = FruitFactory.getFruit("Banana");
apple.eat();
banana.eat();
Class aClass = Class.forName(name);
这部分代码的调⽤，⽐之前相⽐⽐较灵活了。
在这个模式中，⼯⼚类是整个模式的关键所在。它包含必要的判断
逻辑，能够根据外界给定的信息，决定究竟应该创建哪个具体类的
对象。⽤户在使⽤时可以直接根据⼯⼚类去创建所需的实例，⽽⽆
需了解这些对象是如何创建以及如何组织的。有利于整个软件体系
结构的优化。
不难发现，简单⼯⼚模式的缺点也正体现在其⼯⼚类上，由于⼯⼚类集中
了所有实例的创建逻辑，所以“⾼内聚”⽅⾯做的并不好。另外，当系统中的
具体产品类不断增多时，可能会出现要求⼯⼚类也要做相应的修改，扩展
性并不很好。在具体调⽤⽐较⿇烦。
⼀般推荐第⼆种⽐较好。
那么，这种模式具体会在哪些⽅⾯应⽤⽐较多。
⽐如：在JDBC不同数据库实现⽅⾯。
