重温设计模式 - 工厂模式

工厂模式

定义：

工厂模式分为简单工厂模式，一般工厂模式和抽象工厂模式，用于封装对象的创建过程，将对象的创建延迟到子类中进行。这三种模式逐步抽象，并且更具一般性。

适用场景：

对象创建需要一系列步骤
根据不同的条件，创建不同的子类

代码实现

• 简单工厂模式的两种实现

Animal.java

public interface Animal{
    void speak();
}

Cat.java

public class Cat implements Animal{
    public void speak(){
        System.out.println("miao...");
    }
}

Dog.java

public class Dog implements Animal{
    public void speak(){
        System.out.println("wang...");
    }
}

Factory.java

public class Factory{
    public Animal produce(String type){
        if("cat".equalsIgnorCase(type)){
            return new Cat();
           }else if("dog".equalsIgnorCase(type)){
            return new Dog();
           }
    }

}

Animal.java

public interface Animal{
    void speak();
}

Cat.java

public class Cat implements Animal{
    public void speak(){
        System.out.println("miao...");
    }
}

Dog.java

public class Dog implements Animal{
    public void speak(){
        System.out.println("wang...");
    }
}

Factory.java

public class Factory{
    public static Animal produceCat(){
        return new Cat();    
    }
    public static Animal produceDog(){
        return new Dog();    
    }

}

简单工厂模式一旦有新的子类需要创建，就需要在现有的代码里面做更改，违反开闭原则。由此引出工厂和抽象模式，将工厂抽象出来，每每出现新的子类，则实现新的工厂去创建对应的子类，这样之前的代码就不需要再更改。

• 工厂模式

Animal.java

public interface Animal{
    void speak();
}

Cat.java

public class Cat implements Animal{
    public void speak(){
        System.out.println("miao...");
    }
}

Dog.java

public class Dog implements Animal{
    public void speak(){
        System.out.println("wang...");
    }
}

Factory.java

public abstract class Factory{
    public abstract Animal produce(){
       
    }
}

DogFactory.java

public class DogFactory extends Factory{
    @override
    public Animal produce(){
        return new Dog();
    }
}

CatFactory.java

public class CatFactory extends Factory{
    @override
    public Animal produce(){
        return new Cat();
    }
}

• 抽象工厂模式

Screenl.java

public interface Screen{
    void display();
}

HPScreen.java

public class HPScreen implements Screen{
    public void display(){
        System.out.println("hp screen...");
    }
}

DellScreen.java

public class DellScreen implements Screen{
    public void display(){
        System.out.println("dell screen...");
    }
}

Keyboard.java

public interface Keyboard{
    void type();
}

HPKeyboard.java

public class HPKeyboard implements Keyboard{
    public void type(){
        System.out.println("hp...");
    }
}

DellKeyboard.java

public class DellKeyboard implements Keyboard{
    public void type(){
        System.out.println("dell...");
    }
}

Factory.java

public abstract class Factory{
    public abstract Screen produceScreen();
    public abstract Keyboard produceKeyboard();
}

HPFactory.java

public class HPFactory extends Factory{
    @override
    public Screen produceScreen(){
        return new HPScreen();
    }

    @override
    public Keyboard produceKeyboard(){
        return new HPKeyboard();
    }
}

DellFactory.java

public class DellFactory extends Factory{
    @override
    public Screen produceScreen(){
        return new DellScreen();
    }

    @override
    public Keyboard produceKeyboard(){
        return new DellKeyboard();
    }
}

区别

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

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

转载于:https://www.cnblogs.com/developerERA/p/6688900.html