多数设计模式的内容讲解的都是如何设计接口。接口如何产生呢?如果在客户代码(类库的使用者称之为客户)中直接使用具体类,那么就失去了接口的意义。因为接口的使用目的,就是要降低客户对具体类的依赖程度。如果在客户代码中直接使用接口,那么就造成了客户对具体类名称的依赖。(客户最终需要以某种方式指明所需要的具体类,如配置文件或代码,但是只需要指出一次,所以说降低对具体类的依赖程度)。要使客户代码不依赖具体类,唯一的方法,就是让客户代码不依赖具体类的部分不知道具体类的名称。知道具体类名称的部分,仅仅是配置部分。(配置文件或者配置代码)。
依赖不可能完全消除,除非二者毫无联系。但是可以将这种依赖的程度降到最低。
既然不能直接创建具体类,那么就需要通过一个创建者类来创建接口的实现类。这样就产生了工厂类。
抽象工厂是应对产品族概念的。比如说,每个农场可能要同时生产苹果,橘子,大米,玉米,那么每一个农场都要有创建苹果,橘子,大米,玉米的方法。
简单工厂模式:又称静态工厂方法(Static Factory Methord)模式。一个抽象产品类,可以派生多个具体产品类。
用来生产同一等级结构中的任意产品。(对于增加新的产品,无能为力)
public class SimpleFactory {
public static void main(String[] args) {
Fruit f=FactoryTest.getInstance().newApple();
if(f!=null)
f.eat();
Fruit o=FactoryTest.getInstance().newOrange();
if(o!=null)
o.eat();
}
}
interface Fruit {
public void eat();
}
class Apple implements Fruit {
public void eat() {
System.out.println("** 吃苹果。");
}
};
class Orange implements Fruit {
public void eat() {
System.out.println("** 吃橘子。");
}
};
class FactoryTest { // 定义工厂类
private static FactoryTest factory;
private FactoryTest(){}
public static FactoryTest getInstance() {
if(factory==null){
factory=new FactoryTest();
}
return factory;
}
public Apple newApple(){
return new Apple();
}
public Orange newOrange(){
return new Orange();
}
};
工厂方法模式:又称多态性工厂(Polymorphic Factory)模式或虚拟构造子(Virtual Constructor)模式。一个抽象产品类,可以派生出多个具体产品类。
一个抽象工厂类,可以派生出多个具体工厂类。每个具体工厂类只能创建一个具体产品类的实例。
用来生产同一等级结构中的固定产品。(支持增加任意产品)public class FactoryMethod {
public static void main(String[] args) {
FruFac af=new AppleFac();
Fru f=af.getFru();
f.eat();
af=new OrangeFac();
f=af.getFru();
f.eat();
}
}
abstract class Fru
{
String name;
public abstract void eat();
}
class AppleFru extends Fru{
public AppleFru(){
name="apple";
}
@Override
public void eat() {
System.out.println("apple"+name);
}
}
class OrangeFru extends Fru{
public OrangeFru(){
name="orange";
}
@Override
public void eat() {
System.out.println("orange"+name);
}
}
abstract class FruFac{
public FruFac(){
System.out.println("what fruit:"+getFru());
}
public abstract Fru getFru();
}
class AppleFac extends FruFac{
@Override
public Fru getFru() {
// TODO Auto-generated method stub
return new AppleFru();
}
}
class OrangeFac extends FruFac{
@Override
public Fru getFru() {
// TODO Auto-generated method stub
return new OrangeFru();
}
}
抽象工厂模式:又称工具箱(Kit或Toolkit)模式。多个抽象产品类,每个抽象产品类可以派生出多个具体产品类。
一个抽象工厂类,可以派生出多个具体工厂类。
每个具体工厂类可以创建多个具体产品类的实例。用来生产不同产品族的全部产品。(对于增加新的产品,无能为力;支持增加产品族)
package model;
public class AbstractFactory {
public static void main(String[] args) {
Fact f=new WuxiFact();
Frui fr=f.getFru();
fr.eat();
Food fo=f.getFood();
fo.cook();
}
}
abstract class Frui
{
String name;
public abstract void eat();
}
abstract class Food
{
String name;
public abstract void cook();
}
class AppleFrui extends Frui{
public AppleFrui(){
name="apple";
}
@Override
public void eat() {
System.out.println("Fruit:"+name);
}
}
class OrangeFrui extends Frui{
public OrangeFrui(){
name="orange";
}
@Override
public void eat() {
System.out.println("Fruit:"+name);
}
}
class Rice extends Food{
public Rice(){
name="rice";
}
@Override
public void cook() {
System.out.println("Food:"+name);
}
}
class Corn extends Food{
public Corn(){
name="corn";
}
@Override
public void cook() {
System.out.println("Food:"+name);
}
}
abstract class Fact{
public Fact(){
System.out.println("what fruit:"+getFru());
System.out.println("what food:"+getFood());
}
public abstract Frui getFru();
public abstract Food getFood();
}
class WuxiFact extends Fact{
@Override
public Frui getFru() {
// TODO Auto-generated method stub
return new AppleFrui();
}
@Override
public Food getFood() {
// TODO Auto-generated method stub
return new Rice();
}
}
class NanjinFact extends Fact{
@Override
public Frui getFru() {
// TODO Auto-generated method stub
return new OrangeFrui();
}
@Override
public Food getFood() {
// TODO Auto-generated method stub
return new Corn();
}
}
区别:简单工厂模式和工厂方法模式只有一个抽象产品类,而抽象工厂模式有多个。
简单工厂模式只创建一个具体工厂类,工厂方法模式的具体工厂类只能创建一个具体产品类的实例,而抽象工厂模式可以创建多个。