1、在实验三的基础上改进设计，功能点如下：
（1）设计算式接口IEqualtion，提供了算式两个操作数（short）、操作符（char）的getter及setter抽象方法，以及calculate抽象方法，它应返回算式的计算结果。
（2）设计算式抽象类AbstractEquation，它实现了IEquation的部分方法，包括getter、setter，它还覆盖实现equals、hashCode方法。
（3）设计算式子类AddEquation、SubEquation，它们继承AbstractEquation，并实现calculate方法。各自增加静态内部类，AddEquationBuilder、SubEquationBuilder，可以使用构造模式来构造算式。
（4）设计算式约束接口EquationChecker，它有方法bool check(IEqualtion equation)。设计实现该接口的实体类EquationCheckerOfRange。它的构造方法是：EquationCheckerOfRange(int min, int max)，min指出操作数及结果的最小值（含），max指出操作数及结果的最大值（含），该类主要实现check方法，限定操作数及结果。
（5）设计工厂类EquationFactory，它有方法IEqualtion getEquation(String type)，IEqualtion getEquationRandom()。根据type（“Add”/“Sub”）返回AddEquation，或者SubEquation；或者随机返回算式。
（6）设计算式产生类EquationCollection。它有产生算式的方法：void generate(int n, EquationChecker checker)，使用EquationFactory产生n个，无重复的（内部使用HashSet），受约束（checker实例检查）的算式。产生时操作数要随机，加减法算式要随机。EquationCollection，需要将产生的算式暴露出来，它实现了接口java.util.Iterable，这样我们可以使用java.util.Iterator迭代器来遍历这些产生的算式
（7）设计Main类。读入数目n，产生（EquationCollection/EquationCheckerOfRange）n个加减法算式（AddEquation/SubEquation），产生次序随机，且操作数介于0到100（含）。遍历（Iterator）算式，并在终端输出算式。
2、使用Java反射机制类来解析AddEquation
（8）根据类名字符串“AddEquation”，查询其字段和方法，并根据其无参构造方法产生实例。
public interface IEqualtion {
// 获取第一个操作数
short getNum1();
// 设置第一个操作数
void setNum1(short num1);
// 获取第二个操作数
short getNum2();
// 设置第二个操作数
void setNum2(short num2);
// 获取操作符
char getOperator();
// 设置操作符
void setOperator(char operator);
// 计算结果
short calculate();
}import java.util.Objects;
public abstract class AbstractEquation implements IEqualtion {
private short num1;
private short num2;
private char operator;
public AbstractEquation(short num1, short num2, char operator) {
this.num1 = num1;
this.num2 = num2;
this.operator = operator;
}
// 实现接口的getter方法
@Override
public short getNum1() {
return num1;
}
@Override
public short getNum2() {
return num2;
}
@Override
public char getOperator() {
return operator;
}
// 实现接口的setter方法
@Override
public void setNum1(short num1) {
this.num1 = num1;
}
@Override
public void setNum2(short num2) {
this.num2 = num2;
}
@Override
public void setOperator(char operator) {
this.operator = operator;
}
// 覆盖实现equals方法
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (obj == null || getClass() != obj.getClass()) return false;
AbstractEquation that = (AbstractEquation) obj;
return num1 == that.num1 && num2 == that.num2 && operator == that.operator;
}
// 覆盖实现hashCode方法
@Override
public int hashCode() {
return Objects.hash(num1, num2, operator);
}
}public class AddEquation extends AbstractEquation implements IEqualtion{
private short num1;
private short num2;
private char operator;
public AddEquation(){
super((short)0,(short)0,'+');
}
public AddEquation(short num1, short num2) {
super(num1, num2, '+');
}
@Override
public short calculate(){
return (short)(getNum1()+getNum2());
}
public static class AddEquationBuilder {
private short num1;
private short num2;
public AddEquationBuilder setNum1(short num1) {
this.num1 = num1;
return this;
}
public AddEquationBuilder setNum2(short num2) {
this.num2 = num2;
return this;
}
public AddEquation build() {
return new AddEquation(num1, num2);
}
}
}public class SubEquation extends AbstractEquation implements IEqualtion{
public SubEquation(short num1, short num2) {
super(num1, num2, '-');
}
@Override
public short calculate(){
return (short)(getNum1()-getNum2());
}
public static class SubEquationBuilder{
private short num1;
private short num2;
public SubEquationBuilder setNum1(short num1) {
this.num1 = num1;
return this;
}
public SubEquationBuilder setNum2(short num2) {
this.num2 = num2;
return this;
}
public SubEquation build() {
return new SubEquation(num1, num2);
}
}
}
// 定义算式约束接口
public interface EquationChecker {
boolean check(software4.IEqualtion equation);
}
// 实现EquationChecker接口的实体类，用于检查操作数及结果是否在指定范围内
class EquationCheckerOfRange implements software4.EquationChecker {
private int min;
private int max;
public EquationCheckerOfRange(int min, int max) {
this.min = min;
this.max = max;
}
@Override
public boolean check(IEqualtion equation) {
int result = equation.calculate();
int num1 = equation.getNum1();
int num2 = equation.getNum2();
// 检查操作数和结果是否在指定范围内
return (num1 >= min && num1 <= max) &&
(num2 >= min && num2 <= max) &&
(result >= min && result <= max);
}
}import java.util.*;
import java.util.Iterator;
public class EquationCollection implements Iterable<IEqualtion> {
private Set<IEqualtion> equations;
private EquationChecker checker;
private Random random;
public EquationCollection(EquationChecker checker) {
this.equations = new HashSet<>();
this.checker = checker;
this.random = new Random();
}
public void generate(int n) {
while (equations.size() < n) {
// 随机选择"Add"或"Sub"
String type = (random.nextBoolean()) ? "Add" : "Sub";
IEqualtion equation = EquationFactory.getEquation(type);
if (checker.check(equation)) {
equations.add(equation);
}
}
}
@Override
public Iterator<IEqualtion> iterator() {
return equations.iterator();
}
}import java.util.Random;
public class EquationFactory {
private static final String[] types = {"Add", "Sub"};
private static final Random random = new Random();
public static IEqualtion getEquation(String type) {
int num1 = random.nextInt(101);
int num2 =random.nextInt(101);
if ("Add".equals(type)) {
return new AddEquation((short)num1,(short)num2); // 生成0-100的随机数作为操作数
} else if ("Sub".equals(type)) {
return new SubEquation((short)num1,(short)num2); // 生成0-100的随机数作为操作数
} else {
throw new IllegalArgumentException("Invalid type: " + type);
}
}
public static IEqualtion getEquationRandom() {
String randomType = types[random.nextInt(types.length)]; // 随机选择"Add"或"Sub"作为等式类型
return getEquation(randomType); // 根据随机选择的类型生成等式对象并返回
}
}
import java.util.*;
import java.util.stream.Collectors;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("请输入数目n: ");
int n = scanner.nextInt();
EquationChecker checker = new EquationCheckerOfRange(0, 100);
EquationCollection collection = new EquationCollection(checker);
collection.generate(n);
System.out.println("产生的加减法算式为:");
Iterator<IEqualtion> iterator = collection.iterator();
while (iterator.hasNext()) {
IEqualtion equation = iterator.next();
System.out.println(equation.getNum1() + " " + equation.getOperator() + " " +
equation.getNum2() + " = " + equation.calculate());
}
try {
// 加载AddEquation类
Class<?> addEquationClass = Class.forName("software4.AddEquation");
// 查询字段
Field[] fields = addEquationClass.getDeclaredFields();
System.out.println("Fields:");
for (Field field : fields) {
System.out.println(field.toString());
}
// 查询方法
Method[] methods = addEquationClass.getDeclaredMethods();
System.out.println("Methods:");
for (Method method : methods) {
System.out.println(method.toString());
}
// 获取无参构造方法并创建实例
Constructor<?> constructor = addEquationClass.getDeclaredConstructor();
Object instance = constructor.newInstance();
System.out.println("Created instance of AddEquation class: " + instance);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
}
}参考资料
构造模式：
https://howtodoinjava.com/design-patterns/creational/builder-pattern-in-java/
工厂模式：
迭代器模式：
Iterable (Java Platform SE 8 )
Java反射案例
4797
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
