1.静态工厂

调用对象的方法生成一个对象，每次调用都是同一个对象，只要对象里控制了产生对象的方法，就叫静态工厂。(car类里面只有一个静态car对象称为单例，如果是一list的car，就是多例)

示例代码：

测试类
public class Test {
public static void main(String[] args) {
Car c = Car.getInstance();
Car c2 = Car.getInstance();
System.out.println(c==c2);
c.run();
}
}
//输出结果
true
car hohoho ....

car类

public class Car {
private Car() {}; //private方法修饰构造方法，不能被调用
private static Car car = new Car();
public static Car getInstance() { //静态方法产生car对象，只有一个对象
return car;
}
public void run() {
System.out.println("car hohoho ....");
}
}

2.简单工厂(使用抽象类方法，生产对象和生产过程自己控制)

关系图：

172009562.jpg

实现代码：

代码段1：

//调用程序
public class Main {
public static void main(String[] args) {
Factory f = new CarFactory();// = new PlaneFactory();
movable m = f.create();
m.run();
}
}

代码段2：//交通工具类

//共性接口
public interface movable {
void run();
}
//实现接口的car
public class Car implements movable{
public void run() {
System.out.println("car......");
}
}
//实现接口的plane
public class plane implements movable{
@Override
public void run() {
System.out.println("plane......");
}
}

代码段3：//生产交通工具的工厂(VehicleFactory)

//类接口
public interface VehicleFactory {
movable create();
}
//生产car的工厂
public class CarFactory implements VehicleFactory {
@Override
public movable create() {
return new Car();
}
}
//生产plane的工厂
public class PlaneFactory implements VehicleFactory {
@Override
public movable create() {
return new plane();
}
}

3.抽象工厂(工厂生产一系列产品)

关系图：

183742335.jpg

183745334.jpg

代码：

 

 

//调用类
public class Main {
public static void main(String[] args) {
AbstractFactory df = new DefaultFactory();// = new magicFactory();
df.createfood().printname();
df.createVehicle().run();
df.createweapon().shoot();
}
}
//运行结果
apple ....
car ....
ak47 .....
//抽象工厂类
public abstract class AbstractFactory {
public abstract vehicle createVehicle();
public abstract weapon createweapon();
public abstract Food createfood();
}
//工厂一
public class DefaultFactory extends AbstractFactory{
@Override
public vehicle createVehicle() {
return new car();
}
@Override
public Food createfood() {
return new Apple();
}
@Override
public weapon createweapon() {
return new Ak47();
}
}
//工厂2
public class MagicFactory extends AbstractFactory{
@Override
public vehicle createVehicle() {
return new bangzi();
}
@Override
public Food createfood() {
return new mushroom();
}
@Override
public weapon createweapon() {
return new Magicstick();
}
}
//产品抽象类和产品
1 weapon
public abstract class weapon {
public abstract void shoot();
}
11
public class Ak47 extends weapon{
@Override
public void shoot() {
System.out.println("ak47 .....");
}
}
12
public class Magicstick extends weapon{
@Override
public void shoot() {
System.out.println("magicstick ....");
}
}
2 Food
public abstract class Food {
public abstract void printname();
}
21
public class Apple extends Food{
@Override
public void printname() {
System.out.println("apple ....");
}
}
22
public class mushroom extends Food {
@Override
public void printname() {
System.out.println("mushroom ....");
}
}
3 vehicle
public abstract class vehicle {
public abstract void run();
}
31
public class car extends vehicle{
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("car ....");
}
}
32
public class bangzi extends vehicle{
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("bangzi ....");
}
}

总结

抽象类工厂解决了吗实现改变工厂改变一下类产品的问题，但是产品固定。

简单工厂解决了产品和生产过程的工厂自己控制，产品多样。

两种思路是不可调和的，但是可以实现合理安排，例如spring的beanFactory。