Java 键入casting并获取数组以查看一般结果

我正在编写一个程序，它继承了MyStackGeneric的一些特性，称为MyStackInteger。我的作业快做完了，但我遇到了一个问题。只要我在方法binaryOperator中得到两个变量，它就会尝试对返回和出错的字符串进行加、减或乘。我试过打字和移动东西，但我不能让它工作。我工作的一个限制是，MyStackGeneric中当前的所有方法都必须留在那里。我不能把它们放在MyStackInteger中，因为我们将来会用它来表示复数

class `MyStackInteger`:

import java.util.ArrayList;
import java.util.Scanner;
import java.util.Iterator;

public class MyStackInteger extends MyStackGeneric<java.lang.Integer>{

//Creates a new ArrayList and runs readInput as long as there is input
public static void main(String[] args){
  MyStackInteger my = new MyStackInteger(){};
  my.readInput(new Scanner(System.in));
}

//Subtracts two variables
@Override
protected java.lang.Integer minus(java.lang.Integer o1, java.lang.Integer o2){
    o2 = o2-o1;
    return o2;
}

//Multiplies two variables
@Override
protected java.lang.Integer multiply(java.lang.Integer o1, java.lang.Integer o2){
    o2 = o2*o1;
    return o2;
}

//Creates a new element in the Array
@Override
protected java.lang.Integer newElement(java.lang.String w){
    return new Integer(w);
}

//Adds two variables
@Override
protected java.lang.Integer plus(java.lang.Integer o1, java.lang.Integer o2){
    o2 = o2+o1;
    return o2;
}

//Adds a zero to the array
@Override
protected java.lang.Integer zero(){
    Integer blank = 0;
    return blank;
}
}

class MyStackGeneric<E>:

abstract class MyStackGeneric<E> extends ArrayList<E>{

//Generics being implemented by MyStackInteger
protected abstract E multiply(E o1, E o2);

protected abstract E minus(E o1, E o2);

protected abstract E plus(E o1, E o2);

protected abstract E zero();

protected abstract E newElement(java.lang.String w);

//Grabs the top element of the ArrayList
public E peek(){
   return this.get(getSize()-1);
}  

//Removes the top element of the ArrayList
public E pop(){
    E o = this.get(getSize()-1);
    this.remove(getSize()-1);
    return o;
} 

//Pushes an element onto the ArrayList
public void push(E o) {
    this.add(o);
}

//Makes the ListArray A string
@Override
public String toString() {
    return "stack: " + this.toString();
}   

//Iterates while there is input
public void readInput(Scanner s) {
    while (s.hasNext()) {
        String s2 = s.next();
            //Pushes any numerical input to the stack
            if (s2.matches("[+-]?\\d+")) {
                push((E) s2);
            //Goes to binaryOperator if +, - or * is implemented
            } else if (("+".equals(s2)) || 
                      ("-".equals(s2)) || 
                      ("*".equals(s2))) {
                binaryOperator(s2);
            //Prints the stack
            } else if (s2.matches("p")) {
                print();
            //Runs an error if the input is too long
            } else if (s2.length() > 1) {
                System.out.println("Exception: too long: " + s2);
            //Runs an error if there is one unknown char
            } else if (s2.length() == 1) {
                System.out.println("Exception: Unknown Command " + s2);
            }

    }
}

//Prints the stack
public void print(){
   System.out.println("Print Stack: ");
   Iterator<E> s = this.iterator();

   while(s.hasNext()){
       System.out.print(s.next() + (s.hasNext() ? ", " : "\n" ));
   System.out.println("");
   }
}

//Checks if the ArrayList is empty
public boolean empty(){
    return this.isEmpty();
}

//Gets the total size of the ArrayList
public int getSize(){
    return this.size();
}

//Tries to grab the top two elements of the ArrayList, then execute a 
//arithmetic operation on them.
public void binaryOperator(java.lang.String op){
    E var1; 
    E var2;
    boolean exist = true;
    try {
        var1 = peek();
        }catch (ArrayIndexOutOfBoundsException e) {
        System.out.println("Exception: Need two operands");
        var1 = null;
        exist = false;
    }
    if (exist)
       pop();
    try {
        var2 = peek();
        }catch (ArrayIndexOutOfBoundsException e) {
        System.out.println("Exception: Need two operands");
        var2 = null;
        exist = false;
    }
    if (exist)
        pop();
    //This is where the program breaks. At this point, both var1
    //and var2 are Strings so when it tries to run plus or minus
    //or multiply, it returns the error of not being able to turn
    //a string into an int.
    if ("+".equals(op)){
       push(plus(var1, var2));
    }
    if ("-".equals(op)){
       push(minus(var1, var2));
    }
    if ("*".equals(op)){
       push(multiply(var1, var2));
    }  
}
}

class`MyStackInteger`:
导入java.util.ArrayList；
导入java.util.Scanner；
导入java.util.Iterator；
公共类MyStackInteger扩展了MyStackGeneric{
//创建一个新的ArrayList，只要有输入，就运行readInput
公共静态void main（字符串[]args）{
MyStackInteger my=new MyStackInteger（）{}；
my.readInput（新扫描仪（System.in））；
}
//减去两个变量
@凌驾
受保护的java.lang.Integer减号（java.lang.Integer o1，java.lang.Integer o2）{
o2=o2-o1；
返回氧气；
}
//将两个变量相乘
@凌驾
受保护的java.lang.Integer乘法（java.lang.Integer o1，java.lang.Integer o2）{
o2=o2*o1；
返回氧气；
}
//在数组中创建新元素
@凌驾
受保护的java.lang.Integer新元素（java.lang.String w）{
返回新的整数（w）；
}
//添加两个变量
@凌驾
受保护的java.lang.Integer plus（java.lang.Integer o1、java.lang.Integer o2）{
o2=o2+o1；
返回氧气；
}
//将零添加到数组中
@凌驾
受保护的java.lang.Integer零（）{
整数空白=0；
返回空白；
}
}
类通用：
抽象类MyStackGeneric扩展了ArrayList{
//由MyStackInteger实现的泛型
受保护的抽象E乘法（eO1，eO2）；
受保护的抽象E-（eO1，eO2）；
受保护的抽象E+型（eO1，eO2）；
受保护的抽象E zero（）；
受保护的抽象E新元素（java.lang.String w）；
//获取ArrayList的顶部元素
公共E peek（）{
返回此.get（getSize（）-1）；
}  
//删除ArrayList的顶部元素
公共E-pop（）{
eo=this.get（getSize（）-1）；
删除（getSize（）-1）；
返回o；
} 
//将元素推送到ArrayList上
公共推送（EO）{
本条增补（o）；
}
//使ListArray成为字符串
@凌驾
公共字符串toString（）{
return“stack:+this.toString（）；
}   
//有输入时进行迭代
公共无效读取输入（扫描仪）{
而（s.hasNext（））{
字符串s2=s.next（）；
//将任何数字输入推送到堆栈中
如果（s2.匹配（“[+-]？\\d+”）{
推送（（E）s2）；
//如果实现了+、-或*，则转到binaryOperator
}else如果（“+”.equals（s2））||
（“-”。等于（s2））||
（“*”.equals（s2）））{
二进制运算符（s2）；
//打印堆栈
}如果（s2.匹配（“p”））{
打印（）；
//如果输入太长，则运行错误
}else if（s2.length（）>1）{
System.out.println（“异常：太长：+s2”）；
//如果存在一个未知字符，则运行错误
}else if（s2.length（）==1）{
System.out.println（“异常：未知命令”+s2）；
}
}
}
//打印堆栈
公开作废印刷品（）{
System.out.println（“打印堆栈：”）；
迭代器s=this.Iterator（）；
而（s.hasNext（））{
System.out.print（s.next（）+（s.hasNext（）？“，”：“\n”）；
System.out.println（“”）；
}
}
//检查ArrayList是否为空
公共布尔空（）{
返回此。i空（）；
}
//获取ArrayList的总大小
公共int getSize（）{
返回此.size（）；
}
//尝试获取ArrayList的前两个元素，然后执行
//对它们进行算术运算。
公共void二进制运算符（java.lang.String op）{
E-var1；
E-var2；
布尔存在=真；
试一试{
var1=peek（）；
}捕获（阵列索引边界外异常e）{
System.out.println（“异常：需要两个操作数”）；
var1=null；
存在=错误；
}
如果（存在）
pop（）；
试一试{
var2=peek（）；
}捕获（阵列索引边界外异常e）{
System.out.println（“异常：需要两个操作数”）；
var2=null；
存在=错误；
}
如果（存在）
pop（）；
//这是程序中断的地方。在这一点上，两个var1
//var2是字符串，所以当它尝试运行加号或减号时
//或者乘以，返回无法转动的错误
//将字符串转换为int。
如果（“+”。等于（op））{
推（加（var1，var2））；
}
如果（“-”。等于（op））{
推（减（var1，var2））；
}
如果（“*”。等于（op））{
推（乘法（var1，var2））；
}  
}
}

你不能这样做。您不能对

字符串执行任意强制转换。如果您注意编译器，您将看到警告消息

Type safety: Unchecked cast from String to E

主要问题在于您的设计。方法
readInput
不属于
MyStackGeneric
类。类应该只做一件事，那就是作为实现具体堆栈的基础。输入和输出应由类的用户处理，这些用户可以对输入数据进行正确的解析/转换

或者，换句话说，转换输入数据以匹配泛型类型需要的信息（具体参数类型）由于类型擦除而对
MyStackGeneric
类不可用。您可以将
readInput（）
的具体版本放在具体类中。对于
MyStackInteger
，这些行将变为

        if (s2.matches("[+-]?\\d+")) {
            push(Integer.valueOf(s2));

但这仍然违反了单一责任原则

你不能这样做。您不能对
字符串执行任意强制转换。如果你是payi
        if (s2.matches("[+-]?\\d+")) {
            push(Integer.valueOf(s2));