设计模式-工厂模式

大体上分为简单工厂、静态工厂、工厂方法、抽象工厂四种。

简单工厂只要返回个东西就是简单工厂，静态工厂方法是静态的而已可以结合单例

工厂方法：

每弄出一个类就弄一个对应的工厂方法类,比如有个Dog类就写个DogFactory，有个Cat类就写个CatFactory

/**
 * 工厂方法：每弄出一个类就弄一个对应的工厂方法类
 */
public class DogFactoryMethod {
    public static Dog create(){
        return new Dog();
    }
}

抽象工厂：

这哥们讲究产品簇，比如Dog簇，Dog的玩具，食物...，那Cat簇也有Cat的玩具，食物... 我们先写个抽象工厂类

/**
 * 抽象工厂，造一个产品簇的抽象产品
 */
public abstract class AbstractFactory {
    abstract Food createFood();
    abstract Toy createToy();
}

抽象产品类：

public abstract class Food {
    abstract void foodName();
}

public abstract class Toy {
    abstract void printName();
}

具体产品类：

public class Apple extends Food {
    @Override
    void foodName() {
        System.out.println("苹果");
    }
}

public class Fish extends Food {
    @Override
    void foodName() {
        System.out.println("鱼");
    }
}

public class Clew extends Toy{
    @Override
    void printName() {
        System.out.println("线团");
    }
}

public class Tone extends Toy {
    @Override
    void printName() {
        System.out.println("骨头");
    }
}

具体工厂：

public class CatFactory extends AbstractFactory {
    @Override
    Food createFood() {
        return new Fish();
    }

    @Override
    Toy createToy() {
        return new Clew();
    }
}

public class DogFactory extends AbstractFactory {
    @Override
    Food createFood() {
        return new Apple();
    }

    @Override
    Toy createToy() {
        return new Tone();
    }
}

具体使用：

public class Test1 {
    public static void main(String[] args) {
        //狗狗簇
        DogFactory dogFactory = new DogFactory();
        Food food = dogFactory.createFood();
        Toy toy = dogFactory.createToy();
        //猫猫簇
        CatFactory catFactory = new CatFactory();
        Food food1 = catFactory.createFood();
        Toy toy1 = catFactory.createToy();

    }
}

简单谈两个问题：

1.当抽象工厂的产品簇里只有一个产品的时候，就差不多退化成了工厂方法

2.为什么抽象工厂的这些类使用抽象类而不是接口

当然使用接口也可以实现功能，但是Food，Toy这东西是事物最好设计成抽象类，事物的属性最好设计成接口。 简单一句话，名词设计成抽象类，形容词设计成接口，形容词可以无限组合。