TIJ_工厂方法

工厂模式简单的讲就是用工厂方法代替了new的操作，
在通俗点就是说，你new一个对象的时候直接调用工厂方法就行了，

在编程时，需要定义一个工厂接口，由不同的的子类去实现，再定一个具体工厂类，定义一个产生实例的方法，我们通过这个方法来获得实例就行了。

工厂模式主要的功能是可以简化或者说是统一化创建对象，便于扩展和维护。

例如：

1：定义一个接口A，A里面有一个抽象出来的公共call( )方法；定义一个A的工厂类接口B，创建一个A getA()方法用于创建返回A类型，以便于利用多态去调用A的子类去不同实现

2：每有一个新类型（也就是实现了A的产品），就实现call( )方法；同时定义一个此产品的工厂类去实现B，用于返回这个新产品的对象（也就是去实现B的抽象方法）。(Tips：如果创建方式是同样的话，创建越多的对象，或者说创建初始化一个新产品越复杂，工厂模式就越能体现便利)。

3：创建一个静态方法用于统一管理创造对象。

public static void AManeger(B b){

A a=b.getA( );

a.call();

}

4:使用的时候就直接调用AManeger()这个方法就可以了，只要是实现A的新产品，都可以调用这个方法来创建对象，并且调用实现的call( )方法

工厂方法：

public class Factories {
public static void serviceConsumer(ServiceFactory fact){
Service s=fact.getService();
s.method1();
s.method2();
}
public static void main(String[] args) {
serviceConsumer(new Implementation1Factory());
serviceConsumer(new Implementation2Factory());
}
}
interface Service{
void method1();
void method2();
}
interface ServiceFactory{
Service getService();
}


class Implementation1 implements Service{
public void method1() {System.out.println("Implementation1.method1");}
public void method2() {System.out.println("Implementation1.method2");}
}
class Implementation1Factory implements ServiceFactory{
public Service getService() {return new Implementation1();}
}


class Implementation2 implements Service{
public void method1() {System.out.println("Implementation2.method1");}
public void method2() {System.out.println("Implementation2.method2");}
}
class Implementation2Factory implements ServiceFactory{
public Service getService() {return new Implementation2();}
}

抽象工厂模式

代码：

//抽象工厂类

public abstract class AbstractFactory {
    public abstract Vehicle createVehicle();
    public abstract Weapon createWeapon();
    public abstract Food createFood();
}

//具体工厂类，其中Food,Vehicle，Weapon是抽象类，

public class DefaultFactory extends AbstractFactory{
    @Override
    public Food createFood() {
        return new Apple();
    }
    @Override
    public Vehicle createVehicle() {
        return new Car();
    }
    @Override
    public Weapon createWeapon() {
        return new AK47();
    }
}

//测试类

public class Test {
    public static void main(String[] args) {
        AbstractFactory f = new DefaultFactory();
        Vehicle v = f.createVehicle();
        v.run();
        Weapon w = f.createWeapon();
        w.shoot();
        Food a = f.createFood();
        a.printName();
    }
}

总结。

（1）简单工厂模式是由一个具体的类去创建其他类的实例，父类是相同的，父类是具体的。 
（2）工厂方法模式是有一个抽象的父类定义公共接口，子类负责生成具体的对象，这样做的目的是将类的实例化操作延迟到子类中完成。 

（3）抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无须指定他们具体的类。它针对的是有多个产品的等级结构。而工厂方法模式针对的是一个产品的等级结构

许多人都掉进了这种诱惑的陷阱，只要有可能就去创建接口和工厂。这实际上已经变成了一种草率的设计优化。

任何抽象性都应该是应真正的需求而产生的。当必要时，你应该重构接口而不是到处添加额外级别的间接性，并由此带来的额外的复杂性。

恰当的原则应该是优先选择类而不是接口。从类开始，如果接口的必需性变得非常明确，那么就进行重构。接口是一种重要的工具，但是容易被滥用。