Получение ошибки приведения при попытке создать решатель очередей для калькулятора RPN - PullRequest
Новая
       19

Получение ошибки приведения при попытке создать решатель очередей для калькулятора RPN

0 голосов
/ 19 сентября 2018

Я пытаюсь создать калькулятор RPN, который использует стеки и очереди для сложения чисел.Я получил версию стека, чтобы работать отлично.Однако, когда я запускаю очередь, она выдает мне эту ошибку: 

Exception in thread "main" java.lang.ClassCastException: Hwk1.OperationNode cannot be cast to Hwk1.NumberNode
    at Hwk1.RPNCalculator.main(RPNCalculator.java:133)

Что происходит, когда код пытается добавить символ «+».Я не могу понять, как либо удалить его, либо сделать так, чтобы код игнорировал его.Я попытался установить его на нуль и попытался сделать цикл, который бы автоматически игнорировал его.

Вот мой код:

Это мой пакет класса RPN Hwk1; 

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

public class RPNCalculator {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Queue origQ = new Queue();
        Queue calcQ = new Queue();
        Stack origS = new Stack();
        Stack calcS = new Stack();

        File sFile = new File("stackTest.txt");
        File qFile = new File("queueTest.txt");

        //Stack
        try {
            Scanner sc = new Scanner(sFile);

            while(sc.hasNextLine()) {
                String value = sc.nextLine();
                if (value.matches("[0-9]*\\.[0-9]+|[0-9]+")) {
                    origS.push(new NumberNode(Double.parseDouble(value)));
                }
                else {
                    origS.push(new OperationNode(value));
                }
            }

            while(!origS.isEmpty()) {
                LinkedNode next = origS.pop();

                if(next instanceof NumberNode) {
                    calcS.push(next);
                }
                else if (next instanceof OperationNode) {
                    String op = ((OperationNode) next).operator;

                    if (op.equals("+")) {
                        double num1 = ((NumberNode) calcS.pop()).value;
                        double num2 = ((NumberNode) calcS.pop()).value;
                        double res = num1 + num2;
                        calcS.push(new NumberNode(res));
                    }
                    else if (op.equals("-")) {
                        double num1 = ((NumberNode) calcS.pop()).value;
                        double num2 = ((NumberNode) calcS.pop()).value;
                        double res = num1 - num2;
                        calcS.push(new NumberNode(res));
                    }
                    else if (op.equals("*")) {
                        double num1 = ((NumberNode) calcS.pop()).value;
                        double num2 = ((NumberNode) calcS.pop()).value;
                        double res = num1 * num2;
                        calcS.push(new NumberNode(res));
                    }
                    else if (op.equals("/")) {
                        double num1 = ((NumberNode) calcS.pop()).value;
                        double num2 = ((NumberNode) calcS.pop()).value;
                        double res = num1 / num2;
                        calcS.push(new NumberNode(res));
                    }
                    else if (op.equals("%")) {
                        double num1 = ((NumberNode) calcS.pop()).value;
                        double num2 = ((NumberNode) calcS.pop()).value;
                        double res = num1 % num2;
                        calcS.push(new NumberNode(res));
                    }
                    else if (op.equals("^")) {
                        double num1 = ((NumberNode) calcS.pop()).value;
                        double num2 = ((NumberNode) calcS.pop()).value;
                        double res = Math.pow(num1, num2);
                        calcS.push(new NumberNode(res));
                    }
                    else {
                        System.out.println("Invalid operator.");
                    }
                } else {
                    System.out.println("Invalid value");
                }
            }

            double answer = ((NumberNode) calcS.pop()).value;

            System.out.println(answer);

        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } 

        //Queue
        try {
            Scanner sc = new Scanner(qFile);

            while(sc.hasNextLine()) {
                String value = sc.nextLine();
                if (value.matches("[0-9]*\\.[0-9]+|[0-9]+")) {
                    origQ.enqueue(new NumberNode(Double.parseDouble(value)));
                }
                else {
                    origQ.enqueue(new OperationNode(value));
                }
            }

            while(!origQ.isEmpty()) {
                LinkedNode next = origQ.dequeue();

                if(next instanceof NumberNode) {
                    calcQ.enqueue(next);
                }
                else if (next instanceof OperationNode) {
                    String op = ((OperationNode) next).operator;
                    double num1;
                    double num2;
                    double res;

                    if (op.equals("+")) {

                        num1 = ((NumberNode) calcQ.dequeue()).value;
                        num2 = ((NumberNode) calcQ.dequeue()).value;
                        System.out.println(calcQ.dequeue());
                        res = num1+num2;
                        NumberNode newNode = new NumberNode(res);
                        calcQ.enqueue(newNode);

                    }
                    else if (op.equals("*")) {
                        num1 = ((NumberNode) calcQ.dequeue()).value;
                        num2 = ((NumberNode) calcQ.dequeue()).value;
                        res = num1*num2;
                        calcQ.enqueue(new NumberNode(res));
                    }
                    else if (op.equals("/")) {
                        num1 = ((NumberNode) calcQ.dequeue()).value;
                        num2 = ((NumberNode) calcQ.dequeue()).value;
                        res = num1/num2;
                        calcQ.enqueue(new NumberNode(res));
                    }
                    else if (op.equals("%")) {
                        num1 = ((NumberNode) calcQ.dequeue()).value;
                        num2 = ((NumberNode) calcQ.dequeue()).value;
                        res = num1%num2;
                        calcQ.enqueue(new NumberNode(res));
                    }
                    else if (op.equals("-")) {
                        num1 = ((NumberNode) calcQ.dequeue()).value;
                        num2 = ((NumberNode) calcQ.dequeue()).value;
                        res = num1-num2;
                        calcQ.enqueue(new NumberNode(res));
                    }
                    else if (op.equals("^")) {
                        num1 = ((NumberNode) calcQ.dequeue()).value;
                        num2 = ((NumberNode) calcQ.dequeue()).value;
                        res = Math.pow(num1, num2);
                        calcQ.enqueue(new NumberNode(res));
                    }
                    else {
                        System.out.println("Invalid Operator");
                    }
                }
                else {
                    System.out.println("Invalid value");
                }

            }

        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }



    }

}

Это мой класс очереди 

package Hwk1;

public class Queue {
    LinkedNode firstNode;
    LinkedNode lastNode;
    int size;

    public Queue() {

    }

    public boolean isEmpty() {
        return (this.firstNode == null);
    }

    public int size() {
        return this.size;
    }

    public LinkedNode dequeue() {
        if (isEmpty()) {
            System.out.println("Queue is empty.");
            return null;
        }
        else {
            LinkedNode temp = this.firstNode;
            this.firstNode = this.firstNode.nextNode;
            this.size--;
            return temp;

        }
    }
    public void enqueue(LinkedNode node) {
        if (isEmpty()) {
            this.firstNode = node;
            this.lastNode = this.firstNode;
            this.size++;
        }
        else if (this.size == 1) {
            this.lastNode = node;
            this.firstNode.nextNode = this.lastNode;
            this.size++;
        }
        else {
            LinkedNode temp = this.lastNode;
            this.lastNode = node;
            temp.nextNode = this.lastNode;
            this.size++;
        }
    }

}

И вотмой класс стека (на случай, если кто-нибудь захочет) 

package Hwk1;

public class Stack {
    int size;
    LinkedNode topNode;

    public Stack() {

    }

    public boolean isEmpty() {
        return (this.topNode == null);
    }

    public LinkedNode pop() {

        if (isEmpty()) {
            System.out.println("Stack is empty");
            return null;
        }
        else {
            LinkedNode temp = this.topNode;
            this.topNode = temp.nextNode;
            this.size--;
            return temp;
        }
    }

    public void push(LinkedNode node) {

        if (isEmpty()) {
            this.topNode = node;
            this.size++;
        }
        else {
            LinkedNode temp = this.topNode;
            this.topNode = node;
            this.topNode.nextNode = temp;
            this.size++;
        }

    }

    public int size() {
        return this.size;
    }
}

Код NumberNode: 

package Hwk1;

public class NumberNode extends LinkedNode{

    double value;

    public NumberNode(double value) {
        super();
        this.value = value;
    }

}

Код OperationNode: 

package Hwk1;

public class OperationNode extends LinkedNode {
    String operator;

    public OperationNode(String operator) {
        super();
        this.operator = operator;
    }
}
...