创建对象的常见方式就是使用new操作符,然而通过new操作符来实例化对象是典型的针对实现编程。典型的使用接口来接受实例化对象的代码如下:

Fruit fruit=new Apple();

像这样公开进行实例化对象的过程正是产生程序耦合的重要原因之一。

然而创建对象的过程却不仅仅只有使用new操作符这一种，使用工厂模式能够实现在实例化对象的过程中解耦。工厂模式又分为三种实现方式,分别是:简单工厂模式、工厂方法模式和抽象工厂模式。

简单工厂模式,又叫静态工厂方法（static factory method）模式。简单工厂模式就是由一个工厂类根据传入的参数决定创建哪一种的产品类。

其中有4个角色:
1.工厂类角色：是具体产品类角色直接调用者。
2.抽象产品角色：接口或抽象类，负责具体产品角色的定义，及与客户端的交互。
3.具体产品角色：被工厂类创建的对象，也是客户端实际操作对象。
4.客户端：调用工厂类产生实例，并调用实例的方法进行相应工作。

定义接口与实现类:

public interface Fruit {
    void eat();
}

public class Apple implements Fruit {
    public void eat() {
        System.out.println("吃苹果");
    }
}

public class Banana implements Fruit {
    public void eat() {
        System.out.println("吃香蕉");
    }
}

public class Litchi implements Fruit {
    public void eat() {
        System.out.println("吃荔枝");
    }
}

public class Orange implements Fruit {
    public void eat() {
        System.out.println("吃橘子");
    }
}

定义工厂类和调用的客户端:

public class FruitFactory {
    public static Fruit createFruit(String type){
        switch (type) {
        case "apple":
            return new Apple();
        case "banana":
            return new Banana();
        case "litchi":
            return new Litchi();
        case "orange":
            return new Orange();
        default:
            return null;
        }
    }
}


public class FactoryTest {
    public static void main(String[] args) {
        Fruit fruit=FruitFactory.createFruit("apple");
        fruit.eat();
    }
}

工厂方法模式是简单工厂模式的衍生，解决了许多简单工厂模式的问题。工厂方法模式是对简单工厂模式的抽象，也属于模板方法模式。

其中有5个角色:
1.工厂接口:工厂接口是工厂方法模式的核心，与调用者直接交互用来提供产品。
2.工厂实现:在编程中，工厂实现决定如何实例化产品，是实现扩展的途径，需要有多少种产品，就需要有多少个具体的工厂实现。
3.抽象产品角色:接口或抽象类，负责具体产品角色的定义，及与客户端的交互。
4.具体产品角色：被工厂类创建的对象，也是客户端实际操作对象。
5.客户端：调用工厂类产生实例，并调用实例的方法进行相应工作。

简而言之:抽象工厂生产抽象产品，实体工厂生产实体产品。针对于不同的实体产品有不同的工厂。
仅以其中的一种水果作为示例:

public interface IFruitFactory {
    Fruit createFruit();
}

public class AppleFactory implements IFruitFactory {

    @Override
    public Fruit createFruit() {
        return new Apple();
    }

}

public class FactoryTest {
    public static void main(String[] args) {
        IFruitFactory factory=new AppleFactory();
        Fruit fruit=factory.createFruit();
        fruit.eat();
    }
}

抽象工厂模式是工厂方法模式的升级版，工厂方法中的每一具体的工厂类负责生产一种对应的产品。而抽象工厂模式中的一个具体的工厂类负责的是生产一个产品线上的一个或多个产品。相对来说，抽象工厂模式不易扩展商品，但是易扩展生产商品线的工厂类。

public interface IFruitFactory {
    Fruit createApple();
    Fruit createBanana();
    Fruit createLitchi();
    Fruit createOrange();
}

public class FruitFactory implements IFruitFactory {

    @Override
    public Fruit createApple() {
        return new Apple();
    }

    @Override
    public Fruit createBanana() {
        return new Banana();
    }

    @Override
    public Fruit createLitchi() {
        return new Litchi();
    }

    @Override
    public Fruit createOrange() {
        return new Orange();
    }
}

public class FactoryTest {
    public static void main(String[] args) {
        IFruitFactory factory=new FruitFactory();
        Apple apple=(Apple) factory.createApple();
        apple.eat();
    }
}