# 工厂模式 Factory

工厂模式(Factory Pattern)是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。

在工厂模式中,我们在创建对象时不会对客户端暴露创建逻辑,并且是通过使用一个共同的接口来指向新创建的对象。

任何可以产生对象的方法或类, 都可以称之为工厂.

单例也是一种工厂 -- 静态工厂

# 简单工厂

# 实现

# 创建一个接口

Vehicle.java

public interface Vehicle {
    void go();
}
1
2
3

# 定义其子类

Car.java

public class Car implements Vehicle{
    @Override
    public void go() {
        System.out.println("car going...");
    }
}
1
2
3
4
5
6

Plane.java

public class Plane implements Vehicle{
    @Override
    public void go() {
        System.out.println("plane go...");
    }
}
1
2
3
4
5
6

# 创建工厂类

VehicleFactory.java

public class VehicleFactory {
    public Car createCar() {
        return new Car();
    }

    public Plane createPlane() {
        return new Plane();
    }
}
1
2
3
4
5
6
7
8
9

# 特性

简单工厂的扩展性并不好, 每添加一个类都要修改工厂类.

# 静态工厂

单例模式就是一种静态工厂

# 工厂方法

工厂方法就是给每个实体创建一个自己的 Factory, 在产品纬度上容易扩展.

# 实现

创建抽象类

Vehicle.java

public interface Vehicle {
    void go();
}
1
2
3

创建实体

Car.java

public class Car implements Vehicle{
    @Override
    public void go() {
        System.out.println("car going...");
    }
}
1
2
3
4
5
6

创建 Car 的工厂

CarFactory.java

public class CarFactory {
    public static Car createCar() {
        System.out.println("Car Create");
        return new Car();
    }
}
1
2
3
4
5
6

# 抽象工厂

适合生成产品一组

# 实现

# 定义抽象类

为什么不用 interface 而是 abstract ?

因为这是语义的问题

  • 名称用抽象类

  • 形容词用接口

Food.java

public abstract class Food {
    abstract void eat();
}
1
2
3

Vehicle.java

public abstract class Vehicle {
    abstract void go();
}
1
2
3

Weapon.java

public abstract class Weapon {
    abstract void shoot();
}
1
2
3

# 定义实体类

Food 的实现 Bread.java

public class Bread extends Food {
    @Override
    void eat() {
        System.out.println("eat Bread...");
    }
}
1
2
3
4
5
6

Food 的实现 MushRoom.java

public class MushRoom extends Food {
    @Override
    void eat() {
        System.out.println("eat MushRoom...");
    }
}
1
2
3
4
5
6

Weapon 的实现 AK47.java

public class AK47 extends Weapon{
    @Override
    public void shoot() {
        System.out.println("AK47 sort...");
    }
}
1
2
3
4
5
6

Weapon 的实现 MagicStick.java

public class MagicStick extends Weapon{
    @Override
    public void shoot() {
        System.out.println("MagicStick sort...");
    }
}
1
2
3
4
5
6

Vehicle 的实现 Car.java

public class Car extends Vehicle {
    @Override
    public void go() {
        System.out.println("car going...");
    }
}
1
2
3
4
5
6

Vehicle 的实现 Broom.java

public class Broom extends Vehicle {
    @Override
    public void go() {
        System.out.println("Broom going...");
    }
}
1
2
3
4
5
6

# 定义抽象工厂类

AbstractFactory.java

public abstract class AbstractFactory {
    abstract Food createFood();
    abstract Vehicle createVehicle();
    abstract Weapon createWeapon();
}
1
2
3
4
5

# 定义抽象工厂的实现类

ModernFactory.java

public class ModernFactory extends AbstractFactory {
    @Override
    Food createFood() {
        return new Bread();
    }

    @Override
    Vehicle createVehicle() {
        return new Car();
    }

    @Override
    Weapon createWeapon() {
        return new AK47();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

MagicFactory.java

public class MagicFactory extends AbstractFactory {
    @Override
    Food createFood() {
        return new MushRoom();
    }

    @Override
    Vehicle createVehicle() {
        return new Broom();
    }

    @Override
    Weapon createWeapon() {
        return new MagicStick();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# Spring IOC

上次更新时间: 2020/11/7 下午10:53:23