文章目录
一、工厂模式是什么？
工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。二、工厂模式
案例
- AnimalFactory（抽象）
// 号称什么宠物都有
public interface AnimalFactory {
// 可以获取任何的宠物
Animal createAnimal();
}
- Animal（抽象）
public abstract class Animal {
// 所有的动物都会吃东西
public abstract void eat();
}
- DogFactory CatFactory（具体）
// 继承着宠物工厂
public class DogFactory implements AnimalFactory {
// 创建狗
@Override
public Animal createAnimal() {
return new Dog();
}
}
// 继承着宠物工厂
public class CatFactory implements AnimalFactory {
@Override
// 创建猫
public Animal createAnimal() {
return new Cat();
}
}
- Dog Cat（具体）
public class Dog extends Animal {
// 狗喜欢吃肉
@Override
public void eat() {
System.out.println("狗吃肉");
}
}
public class Cat extends Animal {
// 猫喜欢吃鱼
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}
- test
public class test {
public static void main(String[] args) {
// 去找狗工厂拿一只狗过来
AnimalFactory f = new DogFactory();
// 店主就拿到了一只狗给Java3y
Animal a = f.createAnimal();
a.eat();
System.out.println("===========");
// 去找猫工厂拿一只猫过来
AnimalFactory ff = new CatFactory();
// 店主就拿到了一只猫给Java3y
Animal aa = ff.createAnimal();
aa.eat();
}
}
- 结果
工厂模式的优缺点
优点
- 客户端不需要在负责对象的创建,明确了各个类的职责
- 如果有新的对象增加,只需要增加一个具体的类和具体的工厂类即可
- 不会影响已有的代码,后期维护容易,增强系统的扩展性
缺点
- 需要额外的编写代码,增加了工作量
三、简单/静态工厂模式
简单工厂比工厂少一层工厂
案例
1.Factory
public class AnimalFactory {
public static Dog createDog() {
return new Dog();
}
public static Cat createCat() {
return new Cat();
}
// 外界想要猫要狗，这里创建就好了
public static Animal createAnimal(String type) {
switch (type) {
case "dog":
return new Dog();
case "cat":
return new Cat();
default:
return null;
}
}
}
- Animal（抽象）
public abstract class Animal {
// 所有的动物都会吃东西
public abstract void eat();
}
- Cat（实现）
public class Cat extends Animal {
// 猫喜欢吃鱼
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}
- Dog（实现）
public class Dog extends Animal {
// 狗喜欢吃肉
@Override
public void eat() {
System.out.println("狗吃肉");
}
}
- Test
public class Test {
public static void main(String[] args) {
// 拿到狗
Animal A = AnimalFactory.createAnimal("dog");
A.eat();
// 拿到猫
Animal B = AnimalFactory.createAnimal("cat");
B.eat();
}
}
7.结果
简单/静态工厂模式的优缺点
优点
- 具体的工厂来创建对象，代码量少
缺点
- 需求改变了,就要改代码
四、抽象工厂模式
抽象工厂比工厂多一层工厂
案例
- AnimalFactory
public interface AnimalFactory {
Animal1 createDog();
Animal1 createCat();
}
- Animal1
public abstract class Animal1 {
// 所有的动物都会吃东西
public abstract void eat();
// 所有的动物都有性别
public abstract void gender();
}
- MaleAnimalFactory FemaleAnimalFactory
public class MaleAnimalFactory implements AnimalFactory {
// 生产公狗和公猫
@Override
public Animal1 createDog() {
return new MaleDog();
}
@Override
public Animal1 createCat() {
return new MaleCat();
}
}
public class FemaleAnimalFactory implements AnimalFactory {
// 生产母狗和母猫
@Override
public Animal1 createDog() {
return new FemaleDog();
}
@Override
public Animal1 createCat() {
return new FemaleCat();
}
}
- Dog Cat
public abstract class Dog extends Animal1 {
// 狗喜欢吃肉
@Override
public void eat() {
System.out.println("狗吃肉");
}
}
public abstract class Cat extends Animal1 {
// 猫喜欢吃鱼
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}
- FMaleDog FMaleCat
public class MaleDog extends Dog{
public void gender() {
System.out.println(" Male dog");
}
}
public class MaleCat extends Cat {
public void gender() {
System.out.println("MaleCat Cat");
}
}
public class FemaleDog extends Dog{
public void gender() {
System.out.println("female dog");
}
}
public class FemaleCat extends Cat {
public void gender() {
System.out.println("female Cat");
}
}
- test
public class test {
public static void main(String[] args) {
// 需要性别为母的就去找母工厂
AnimalFactory af = new FemaleAnimalFactory();
// 需要一只母猫
af.createCat().gender();
// 需要一只母狗
af.createDog().gender();
System.out.println("======================");
// 需要性别为公的就去找公工厂
AnimalFactory aff = new MaleAnimalFactory();
// 需要一只公狗
aff.createDog().gender();
// 需要一只公猫
aff.createCat().gender();
}
}
- 结果
抽象工厂模式的优缺点
优点
- 多了一层抽象，减少了工厂的数量
缺点
- 扩展产品族