笔记大全

怎么使用Java工厂模式创建对象及提高代码复用率和灵活性

更新时间：2023-11-12

前言

工厂模式是一种创建型设计模式，它提供了一种统一的方式来创建对象，而不需要在代码中直接使用构造函数。使用工厂模式可以提高代码的复用率和灵活性，使代码更易于维护和扩展。

Java中的工厂模式分为简单工厂模式、工厂方法模式和抽象工厂模式三种形式。其中，简单工厂模式由一个工厂类负责创建所有的对象，工厂方法模式则由子类来创建对象，而抽象工厂模式则是通过提供一个接口来创建相关或依赖对象的家族。

简单工厂模式

简单工厂模式是最基础的工厂模式，它通过一个工厂类来创建对象。下面是一个简单的示例:

public interface Animal {
    void sound();
}

public class Cat implements Animal {
    @Override
    public void sound() {
        System.out.println("喵喵喵");
    }
}

public class Dog implements Animal {
    @Override
    public void sound() {
        System.out.println("汪汪汪");
    }
}

public class AnimalFactory {
    public static Animal createAnimal(String type) {
        if("cat".equalsIgnoreCase(type)) {
            return new Cat();
        } else if("dog".equalsIgnoreCase(type)) {
            return new Dog();
        } else {
            throw new IllegalArgumentException("Unsupported animal type: " + type);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Animal cat = AnimalFactory.createAnimal("cat");
        cat.sound();  // 输出: 喵喵喵
        
        Animal dog = AnimalFactory.createAnimal("dog");
        dog.sound();  // 输出: 汪汪汪
    }
}

在上面的示例中，AnimalFactory是一个简单工厂类，它根据传入的type参数来创建对应的Animal对象。通过创建工厂类来统一创建对象，可以将对象的创建逻辑抽离出来，提高代码的复用率和灵活性。

工厂方法模式

工厂方法模式是简单工厂模式的延伸，它将对象的创建交给具体的子类实现。下面是一个示例:

public interface Animal {
    void sound();
}

public class Cat implements Animal {
    @Override
    public void sound() {
        System.out.println("喵喵喵");
    }
}

public class Dog implements Animal {
    @Override
    public void sound() {
        System.out.println("汪汪汪");
    }
}

public interface AnimalFactory {
    Animal createAnimal();
}

public class CatFactory implements AnimalFactory {
    @Override
    public Animal createAnimal() {
        return new Cat();
    }
}

public class DogFactory implements AnimalFactory {
    @Override
    public Animal createAnimal() {
        return new Dog();
    }
}

public class Main {
    public static void main(String[] args) {
        AnimalFactory catFactory = new CatFactory();
        Animal cat = catFactory.createAnimal();
        cat.sound();  // 输出: 喵喵喵
        
        AnimalFactory dogFactory = new DogFactory();
        Animal dog = dogFactory.createAnimal();
        dog.sound();  // 输出: 汪汪汪
    }
}

在上面的示例中，AnimalFactory是一个工厂接口，每个具体的Animal工厂类都实现了该接口并负责创建对应的Animal对象。通过将对象的创建委派给子类，工厂方法模式可以在不修改现有代码的情况下，轻松添加新的产品类型，提高代码的灵活性。

抽象工厂模式

抽象工厂模式通过提供一个接口来创建一系列相关或依赖的对象，它是工厂方法模式的升级版。下面是一个示例:

public interface Animal {
    void sound();
}

public interface AnimalFactory {
    Animal createAnimal();
    Food createFood();
}

public class Cat implements Animal {
    @Override
    public void sound() {
        System.out.println("喵喵喵");
    }
}

public class Dog implements Animal {
    @Override
    public void sound() {
        System.out.println("汪汪汪");
    }
}

public interface Food {
    void feed();
}

public class Fish implements Food {
    @Override
    public void feed() {
        System.out.println("喂食: 鱼");
    }
}

public class Bone implements Food {
    @Override
    public void feed() {
        System.out.println("喂食: 骨头");
    }
}

public class CatFactory implements AnimalFactory {
    @Override
    public Animal createAnimal() {
        return new Cat();
    }
    
    @Override
    public Food createFood() {
        return new Fish();
    }
}

public class DogFactory implements AnimalFactory {
    @Override
    public Animal createAnimal() {
        return new Dog();
    }
    
    @Override
    public Food createFood() {
        return new Bone();
    }
}

public class Main {
    public static void main(String[] args) {
        AnimalFactory catFactory = new CatFactory();
        Animal cat = catFactory.createAnimal();
        cat.sound();  // 输出: 喵喵喵
        
        Food fish = catFactory.createFood();
        fish.feed();  // 输出: 喂食: 鱼
        
        AnimalFactory dogFactory = new DogFactory();
        Animal dog = dogFactory.createAnimal();
        dog.sound();  // 输出: 汪汪汪
        
        Food bone = dogFactory.createFood();
        bone.feed();  // 输出: 喂食: 骨头
    }
}

在上面的示例中，AnimalFactory是一个抽象工厂接口，每个具体的Animal工厂类都实现了该接口并负责创建对应的Animal对象和Food对象。通过使用接口来创建一系列相关或依赖的对象，抽象工厂模式可以保证这些对象始终是与彼此兼容的。

总结

工厂模式是一种常见的创建型设计模式，它提供了一种统一的方式来创建对象，并可以提高代码的复用率和灵活性。在Java中，有简单工厂模式、工厂方法模式和抽象工厂模式三种形式。简单工厂模式由一个工厂类负责创建所有的对象，工厂方法模式则由子类来创建对象，而抽象工厂模式则通过提供一个接口来创建相关或依赖对象的家族。根据实际需求，选择适合的工厂模式可以使代码更易于维护、扩展和重用。

c语言编程笔录