11.3

今天写了软件设计课程的实验报告以下是源代码及其展示成果

[实验任务一]：人与肤色
使用抽象工厂模式，完成下述产品等级结构：

实验要求：
1.画出对应的类图；
2.提交源代码；
3.注意编程规范。
1.
2.1. 抽象产品 - Human.java
package abstractfactory;

/**

• 抽象产品 - 人类

• 定义人类的通用接口
  */
  public abstract class Human {
  // 获取肤色
  public abstract String getColor();

  // 说话行为
  public abstract void talk();

  // 获取性别
  public abstract String getSex();

  // 显示信息
  public void display() {
  System.out.println("肤色: " + getColor());
  System.out.println("性别: " + getSex());
  talk();
  System.out.println("-------------------");
  }
  }
  2.抽象工厂 - AbstractHumanFactory.java
  package abstractfactory;

/**

• 抽象工厂 - 人类工厂
• 定义创建人类的通用接口
  /
  public abstract class AbstractHumanFactory {
  /*
  • 创建人类对象
  • @return 人类对象
    */
    public abstract Human createHuman();
    }

3. 具体工厂类
   YellowHumanFactory.java
   package abstractfactory;

/**

• 具体工厂 - 黄色人种工厂

• 负责创建黄色人种对象
  */
  public class YellowHumanFactory extends AbstractHumanFactory {

  @Override
  public Human createHuman() {
  // 在实际应用中，这里可以根据配置决定创建男性还是女性
  return new MaleYellowHuman();
  }

  /**

  • 创建指定性别的黄色人种
  • @param gender 性别 ("male" 或 "female")
  • @return 对应的人类对象
    */
    public Human createHuman(String gender) {
    if ("female".equalsIgnoreCase(gender)) {
    return new FemaleYellowHuman();
    }
    return new MaleYellowHuman();
    }
    }
    WhiteHumanFactory.java
    package abstractfactory;

/**

• 具体工厂 - 白色人种工厂

• 负责创建白色人种对象
  */
  public class WhiteHumanFactory extends AbstractHumanFactory {

  @Override
  public Human createHuman() {
  return new MaleWhiteHuman();
  }

  /**

  • 创建指定性别的白色人种
  • @param gender 性别 ("male" 或 "female")
  • @return 对应的人类对象
    */
    public Human createHuman(String gender) {
    if ("female".equalsIgnoreCase(gender)) {
    return new FemaleWhiteHuman();
    }
    return new MaleWhiteHuman();
    }
    }
    BlackHumanFactory.java
    package abstractfactory;

/**

• 具体工厂 - 黑色人种工厂

• 负责创建黑色人种对象
  */
  public class BlackHumanFactory extends AbstractHumanFactory {

  @Override
  public Human createHuman() {
  return new MaleBlackHuman();
  }

  /**

  • 创建指定性别的黑色人种
  • @param gender 性别 ("male" 或 "female")
  • @return 对应的人类对象
    */
    public Human createHuman(String gender) {
    if ("female".equalsIgnoreCase(gender)) {
    return new FemaleBlackHuman();
    }
    return new MaleBlackHuman();
    }
    }

4. 具体产品类
   黄色人种具体产品
   MaleYellowHuman.java
   package abstractfactory;

/**

• 具体产品 - 男性黄色人种
  */
  public class MaleYellowHuman extends Human {

  @Override
  public String getColor() {
  return "黄色";
  }

  @Override
  public void talk() {
  System.out.println("黄色人种男性说话，通常使用单音节语言");
  }

  @Override
  public String getSex() {
  return "男";
  }
  }
  FemaleYellowHuman.java
  package abstractfactory;

/**

• 具体产品 - 女性黄色人种
  */
  public class FemaleYellowHuman extends Human {

  @Override
  public String getColor() {
  return "黄色";
  }

  @Override
  public void talk() {
  System.out.println("黄色人种女性说话，声音较为柔和");
  }

  @Override
  public String getSex() {
  return "女";
  }
  }

白色人种具体产品
MaleWhiteHuman.java
package abstractfactory;

/**

• 具体产品 - 男性白色人种
  */
  public class MaleWhiteHuman extends Human {

  @Override
  public String getColor() {
  return "白色";
  }

  @Override
  public void talk() {
  System.out.println("白色人种男性说话，语速较快");
  }

  @Override
  public String getSex() {
  return "男";
  }
  }
  FemaleWhiteHuman.java
  package abstractfactory;

/**

• 具体产品 - 女性白色人种
  */
  public class FemaleWhiteHuman extends Human {

  @Override
  public String getColor() {
  return "白色";
  }

  @Override
  public void talk() {
  System.out.println("白色人种女性说话，语调起伏较大");
  }

  @Override
  public String getSex() {
  return "女";
  }
  }
  黑色人种具体产品
  MaleBlackHuman.java
  package abstractfactory;

/**

• 具体产品 - 男性黑色人种
  */
  public class MaleBlackHuman extends Human {

  @Override
  public String getColor() {
  return "黑色";
  }

  @Override
  public void talk() {
  System.out.println("黑色人种男性说话，节奏感强");
  }

  @Override
  public String getSex() {
  return "男";
  }
  }
  5.客户端测试类 - Client.java
  6.import abstractfactory.*;

/**

• 客户端测试类

• 演示抽象工厂模式的使用
  */
  public class Client {
  public static void main(String[] args) {
  System.out.println("=== 抽象工厂模式演示 - 人与肤色系统 ===\n");

   // 1. 创建黄色人种工厂并生产人类
   System.out.println("1. 黄色人种工厂生产:");
   AbstractHumanFactory yellowFactory = new YellowHumanFactory();
   Human yellowHuman1 = yellowFactory.createHuman();
   yellowHuman1.display();
   
   // 使用扩展方法创建女性黄色人种
   Human yellowHuman2 = ((YellowHumanFactory)yellowFactory).createHuman("female");
   yellowHuman2.display();
   
   // 2. 创建白色人种工厂并生产人类
   System.out.println("2. 白色人种工厂生产:");
   AbstractHumanFactory whiteFactory = new WhiteHumanFactory();
   Human whiteHuman1 = whiteFactory.createHuman();
   whiteHuman1.display();
   
   Human whiteHuman2 = ((WhiteHumanFactory)whiteFactory).createHuman("female");
   whiteHuman2.display();
   
   // 3. 创建黑色人种工厂并生产人类
   System.out.println("3. 黑色人种工厂生产:");
   AbstractHumanFactory blackFactory = new BlackHumanFactory();
   Human blackHuman1 = blackFactory.createHuman();
   blackHuman1.display();
   
   Human blackHuman2 = ((BlackHumanFactory)blackFactory).createHuman("female");
   blackHuman2.display();
   
   // 4. 演示多态性
   System.out.println("4. 多态性演示:");
   AbstractHumanFactory[] factories = {
       new YellowHumanFactory(),
       new WhiteHumanFactory(), 
       new BlackHumanFactory()
   };
   
   for (AbstractHumanFactory factory : factories) {
       Human human = factory.createHuman();
       System.out.println("工厂类型: " + factory.getClass().getSimpleName());
       human.display();
   }
   
   // 5. 演示产品族概念
   System.out.println("5. 产品族演示 - 同一工厂创建不同性别:");
   YellowHumanFactory yellowFamilyFactory = new YellowHumanFactory();
   Human yellowMale = yellowFamilyFactory.createHuman("male");
   Human yellowFemale = yellowFamilyFactory.createHuman("female");
   
   System.out.println("黄色人种产品族:");
   yellowMale.display();
   yellowFemale.display();
  

  }
  }

7.增强版工厂管理器 - HumanFactoryManager.java
package abstractfactory;

import java.util.HashMap;
import java.util.Map;

/**

• 工厂管理器

• 提供统一的工厂访问接口
  */
  public class HumanFactoryManager {
  private static Map<String, AbstractHumanFactory> factoryMap = new HashMap<>();

  static {
  // 注册所有工厂
  factoryMap.put("yellow", new YellowHumanFactory());
  factoryMap.put("white", new WhiteHumanFactory());
  factoryMap.put("black", new BlackHumanFactory());
  }

  /**

  • 根据类型获取工厂
  • @param type 工厂类型
  • @return 对应的工厂对象
    */
    public static AbstractHumanFactory getFactory(String type) {
    AbstractHumanFactory factory = factoryMap.get(type.toLowerCase());
    if (factory == null) {
    throw new IllegalArgumentException("不支持的工厂类型: " + type);
    }
    return factory;
    }

  /**

  • 创建指定类型和性别的人类

  • @param type 人类类型

  • @param gender 性别

  • @return 人类对象
    */
    public static Human createHuman(String type, String gender) {
    AbstractHumanFactory factory = getFactory(type);

    if (factory instanceof YellowHumanFactory) {
    return ((YellowHumanFactory) factory).createHuman(gender);
    } else if (factory instanceof WhiteHumanFactory) {
    return ((WhiteHumanFactory) factory).createHuman(gender);
    } else if (factory instanceof BlackHumanFactory) {
    return ((BlackHumanFactory) factory).createHuman(gender);
    }

    return factory.createHuman();
    }

  /**

  • 获取所有支持的工厂类型
  • @return 工厂类型数组
    /
    public static String[] getSupportedTypes() {
    return factoryMap.keySet().toArray(new String[0]);
    }
    }
    import abstractfactory.;

/**

• 增强版客户端测试类

• 演示使用工厂管理器的功能
  */
  public class EnhancedClient {
  public static void main(String[] args) {
  System.out.println("=== 增强版抽象工厂模式演示 ===\n");

   // 使用工厂管理器
   System.out.println("1. 使用工厂管理器创建人类:");
   
   try {
       // 创建黄色男性
       Human human1 = HumanFactoryManager.createHuman("yellow", "male");
       human1.display();
       
       // 创建白色女性
       Human human2 = HumanFactoryManager.createHuman("white", "female");
       human2.display();
       
       // 创建黑色男性
       Human human3 = HumanFactoryManager.createHuman("black", "male");
       human3.display();
       
       // 显示所有支持的工厂类型
       System.out.println("\n2. 支持的工厂类型:");
       String[] types = HumanFactoryManager.getSupportedTypes();
       for (String type : types) {
           System.out.println("- " + type);
       }
       
   } catch (IllegalArgumentException e) {
       System.out.println("错误: " + e.getMessage());
   }
   
   // 演示异常情况
   System.out.println("\n3. 异常情况演示:");
   try {
       Human human4 = HumanFactoryManager.createHuman("red", "male");
   } catch (IllegalArgumentException e) {
       System.out.println("捕获异常: " + e.getMessage());
   }
  

  }
  }
  3.运行结果