设计模式一：工厂模式

注：第二篇章讲的是设计模式，主要是LZ对《大话设计模式》这书的记录，以及一些简单例子。

首先工厂模式分为三种：简单工厂模式、工厂方法模式、抽象工厂模式。下面分别介绍这三种模式。

一：简单工厂模式

　　简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个种类（这些种类继承自一个父类或接口）的实例。如上面AnimalFactory是工厂类，Animal类是父类，Bird、Dog都是种类，因此如果要在加一个Pig类，只需要继承父类，并在工     类种加入类型判断即可。代码如下：

//Animal.java
public class Animal {
    private String type;

    public Animal(){

    }

    public void speak(){
        System.out.println( "动物叫" );
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }
}

//Dog.java：里面除了重写了speak方法外，还有自己的属性和方法
public class Dog extends Animal{
    private String color;

    public Dog(String color){
        this.color = color;
    }

    public void speak(){
           System.out.println("狗叫声:"+super.getType() );
    }

    public void dogMethod() {
        System.out.println("狗的颜色："+color);
    }
}

//Bird.java：里面除了重写了speak方法外，还有自己的属性和方法
public class Bird extends Animal{
    private Boolean can_fly;

    public Bird(Boolean can_fly){
        this.can_fly = can_fly;
    }

    public void speak(){
           System.out.println(  "鸟叫声：" + super.getType() );
    }

    public void birdMethod(){
        System.out.println("鸟能飞吗："+can_fly);
    }
}

//AnimalFactory.java：根据参数type来创建对应的实例
public class AnimalFactory {

    public static Animal createAnimal(String type){
        Animal animal = null;
        switch (type) {
            case "dog" : animal = new Dog("黄色"); break;
            case "bird" : animal = new Bird(true); break;
            default:animal = new Animal(); break;
        }
        return animal;
    }
}

//测试类：
public class Test {

    public static void main(String[] args) {
        Animal animal;
        animal = AnimalFactory.createAnimal("dog");
        animal.setType("汪汪");
        animal.speak();
        animal = AnimalFactory.createAnimal("bird");
        animal.setType("吱吱");
        animal.speak();
    }
}

运行结果：

狗叫声:汪汪
鸟叫声：吱吱

二：工厂方法模式

　　工厂方法模式定义一个用于创建对象的接口，让子类决定实例化哪个类。在简单工厂模式中，新增类型需要改动工厂类，而工厂方法模式使之前的体系无需修改，完全符合了开发-封闭原则。但工厂方法模式在客户端中还是需要进行逻辑判断，决定需要实例化哪一个工厂来实现实现类。例子代码如下:

public interface  Animal {

     abstract void eat();

     abstract void sleep();

}

//狗
public class Dog  implements Animal{

    @Override
    public void eat(){
        System.out.println("狗吃东西");
    }

    @Override
    public void sleep(){
        System.out.println("狗睡觉");
    }
}

//鸟
public class Bird implements Animal{

    @Override
    public void eat(){
        System.out.println("鸟吃东西");
    }

    @Override
    public void sleep(){
        System.out.println("鸟睡觉");
    }
}

public interface IAnimalFactory {

    Animal createAnimal();

}

//创建狗的接口类
public class DogFactory implements IAnimalFactory{

    @Override
    public Animal createAnimal() {
        return new Dog();
    }

}

//创建鸟的接口类
public class BirdFactory implements IAnimalFactory{

    @Override
    public Animal createAnimal() {
        return new Bird();
    }

}

//测试类
public class Test {

    public static void main(String[] args) {
        //dog
        IAnimalFactory iAnimalFactory = new DogFactory();
        Animal animal = iAnimalFactory.createAnimal();
        animal.eat();
        animal.sleep();

        //bird
        iAnimalFactory = new BirdFactory();
        animal = iAnimalFactory.createAnimal();
        animal.eat();
        animal.sleep();

    }

}

运行结果：

狗吃东西
狗睡觉
鸟吃东西
鸟睡觉

三：抽象工厂模式

　　抽象工厂模式：多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。 一个抽象工厂类，可以派生出多个具体工厂类。 每个具体工厂类可以创建多个具体产品类的实例。

//抽象产品类1
public interface IProduct1 {
     public void show();
}

//抽象产品类2
public interface IProduct2 {
     public void show();
}

//具体产品类1
public class Product1 implements IProduct1 {
    public void show() {
        System.out.println("产品1");
    }
}

//也是具体产品类1
public class Product1_1 implements IProduct1 {
    public void show() {
        System.out.println("也是产品1");
    }
}

//具体产品类2
public class Product2 implements IProduct2 {
    public void show() {
        System.out.println("产品2");
    }
} 

//抽象工厂类
public interface IFactory {
    public IProduct1 createProduct1();
    public IProduct2 createProduct2();
}

//具体工厂类One
public class OneFactory implements IFactory{
    public IProduct1 createProduct1() {
            return new Product1();
    }
    public IProduct2 createProduct2() {
        return new Product2();
    }
}

//具体工厂类Two
public class TwoFactory implements IFactory{
    public IProduct1 createProduct1() {
        return new Product1_1();
    }
    public IProduct2 createProduct2() {
        return new Product2();
    }
}
//测试类
public class Test {
    public static void main(String[] args){
        IFactory factory = new OneFactory();
        factory.createProduct1().show();
        factory.createProduct2().show();  

        factory = new TwoFactory();
        factory.createProduct1().show();
        factory.createProduct2().show();
    }
}

运行结果：

产品1
产品2
也是产品1
产品2

四：总结：

　　简单工厂模式：用来生产同一等级结构中的任意产品。

　　工厂方法模式 ：用来生产同一等级结构中的固定产品。

　　抽象工厂模式 ：用来生产不同产品族的全部产品。