我需要用 Java 编写一个简单的算术表达式表示。 算术表达式只能有 +/- 符号,并应按以下方式在类中表示:
表达式 - 抽象类
AtomicExpression - 扩展了 Expression 类并且应该表示一个原子序数(例如:5/9/332...)
CompoundExpression - 扩展 Expression 的抽象类,应包含 2 个 Expression 实例。
AdditionExpression/SubtractionExpression - 两个扩展 CompoundExpression 的类,将表示加法/减法表达式(例如 5+3/9-2...)
我的问题是 CompoundExpression 类和应该从它继承的两个类(AdditionExpression 和 SubtractionExpression) 我不知道如何编写这些类,我应该在每个类中放置哪些参数以及如何表示它们。 这是我到现在为止写的:
package Q1;
public abstract class Expression {
/*Empty Constructor for Expression object */
public Expression(){
}
/*Calculate the value of the expression
* @return double This the value of the expression
*/
public double calculate(){
String toClac = new String(this.expression); //Copy the expression to calculate to temporary object
double answer=0;
int i=1, operator = 0; //0 signal + operator and 1 signal - operator.
while (toClac!=null && !toClac.isEmpty()){
//Assumes correct input - start with a digit and not a sign '+' or '-'
while (i<toClac.length() && Character.isDigit(toClac.charAt(i)))
i++;
// i equal to the first index that is not a number in the expression
if (operator == 0){
answer += Integer.parseInt(toClac.substring(0,i));
}else answer -= Integer.parseInt(toClac.substring(0,i));
if (i<toClac.length()) //mean that while stopped because found char that is not number
{
//check if the next operator is - or +
if (toClac.charAt(i)=='-')
operator = 1;
else operator = 0;
toClac = toClac.substring(i+1,toClac.length()); //cut and save the continue of the string to parse
}else toClac = null;
i=0;
}
return answer;
}
/*
* Check if two expressions are equal. two expressions are equals if their calculated value is the same
* @Override equals - return true if two expressions are equals
*/
public boolean equals(Object second)
{
double firstAnswer, secondAnswer;
firstAnswer = this.calculate();
secondAnswer = ((Expression)(second)).calculate();
return (firstAnswer == secondAnswer);
}
}
package Q1;
public class AtomicExpression extends Expression {
int numericExpression;
//maybe delete
/*Empty Constructor for AtomicExpression object */
public AtomicExpression(){
super();
}
/*Constructor for AtomicExpression object*/
public AtomicExpression(int realNum){
super();
this.numericExpression = realNum;
}
/*Return the string representation of the expression
*/
public String toString(){
return Integer.toString(this.numericExpression);
}
}
package Q1;
public abstract class CompoundExpression extends Expression {
Expression firstOperand, secondOperand;
//Constructor of CompundExpression object containing two expressions
public CompoundExpression(Object first, Object second){
if(first instanceof Integer)
this.firstOperand = new AtomicExpression((Integer)(first));
else this.firstOperand = (Expression)first;
if(second instanceof Integer)
this.secondOperand = new AtomicExpression((Integer)(second));
else this.secondOperand = (Expression)second;
}
}
包Q1;
//表示加法表达式的类 公共(public)类 AdditionExpression 扩展了 CompoundExpression{
public AdditionExpression(Expression first, Expression second){
super(first, second);
}
public String toString(){
String str = this.firstOperand.expression+ " + " + this.secondOperand.expression;
return str;
}
package Q1;
//Class representing an subtraction expression
public class SubtractionExpression extends CompoundExpression{
int left, right;
public SubtractionExpression(Expression first, Expression second){
super(first, second);
}
public String toString(){
String str = this.firstOperand.expression+ " - " + this.secondOperand.expression;
return str;
}
}
最佳答案
我想你还没有理解这个练习的原理,以及抽象类和多态的原理。
一个表达式有一个 calculate() 方法,它返回这个表达式的值。这个方法应该是抽象的,因为根据 Expression 的实际子类,calculate() 方法不会做同样的事情。
这是一个原子表达式:15。对于这样的表达式,calculate() 方法很容易实现:它应该简单地返回数字的值:15。因此,AtomicExpression 有一个 double 类型的字段,并且它的 calculate() 方法只返回这个 double 值。
复合表达式有点复杂:它有两个表达式类型的操作数(即两个字段)。这两个操作数组合在一起以计算实际值。但是 CompoundExpression 还是一个抽象类:两个操作数的组合方式取决于实际的子类。
AdditionExpression 是 CompoundExpression 的一个具体子类:它接受它的两个操作数,计算它们的值(使用它们的 calculate() 方法),并通过将它们相加来组合它们:
public double calculate() {
return a.calculate() + b.calculate();
}
SubtractionExpression 做同样的事情,但用减法代替:
public double calculate() {
return a.calculate() - b.calculate();
}
这里的目标不是让你解析一个字符串。目标只是让您使用多态性将算术表达式表示为对象:
(a + b) - (c + d)
是一个
Subtraction(a + b, c + d)
这是一个
Subtraction(Addition(a, b), Addition(c, d))
这是一个
Subtraction(Addition(Atomic(a), Atomic(b)), Addition(Atomic(c), Atomic(d)))
关于java - Java算术表达式程序的类和构造函数设计,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/23322736/