wo liegt hier der fehler?

[lola]

Hallo ich habe ein Problem mit meinem Java Programm. Ich kann mir nicht erklären wo genau hier der Fehler liegt.
es wäre nett, wenn sich das mal jemand ansehen könnte. das konkrete problem habe ich im spript vermerkt und markiert.
groß lola

import IOulm.*;
public class calculator {
  public calculator() {}


  public static String eingabe() {
      String mystring;
      if (Urc.readString());
      mystring = Urc.getString();
      return mystring;
  }


   
   public static void main( String[] args) {


   ADTDeluxeStruct DeluxeStruct = new DeluxeStruct(150);
   int zeichen;
   Object zahlen;
   calculate Add = new Add();

   //Eingelesene Ziele wird an angegebenen Zeichen getrennt
   String[] OperandenundOpereatoren = eingabe().split("[ ,;]");



   
   for (int i=0; i<OperandenundOpereatoren.length; i++) {

     if(OperandenundOpereatoren[i]=="+") {

        Add.calc(DeluxeStruct);
      } else if(OperandenundOpereatoren[i] =="-") {
        //Methode für die Subtraction;
      } else if(OperandenundOpereatoren[i] =="*") {
        //Methode für die Multiplikation;
      } else if(OperandenundOpereatoren[i] =="/") {
        //Methode für die Division;
      } else if(OperandenundOpereatoren[i]=="!") {
        //Methode für die Fakultät;
      } else {

          zahlen = new Integer(OperandenundOpereatoren[i]);
      
    

   /* irgend wo hier muss der fehler liegen, egal, was ich mache, der stack bleibt leer, d.h die zahlen die     draufgeschrieben werden sollten werden nicht draufgeschrieben. wie muss ich diese methode korrekt aufrufen???*/
            
 DeluxeStruct.push(zahlen);
        }

   }
    /* wie muss ich die elemente vom stack naher wieder korrekt aufrufen*/
     zahlen = DeluxeStruct.pop();

    System.out.print(zahlen);


  }
}

public interface calculate {

    public int calc(ADTDeluxeStruct DeluxeStruct);
}

public class Add  implements calculate{
   //Konstruktor
   public Add() {
   }
   
   public int calc(ADTDeluxeStruct DeluxeStuct) {
   Object A = DeluxeStuct.pop();
   if(A==null) {
    System.out.println("Nicht genug Elemente auf dem Stack!");
    return 0;
   }


   
   Object B = DeluxeStuct.pop();
   if(B==null) {
    System.out.println("Nicht genug Elemente auf dem Stack!");
    DeluxeStuct.add(A);
    return 0;
  }
  
  int a = ((Integer)A).intValue();
  int b = ((Integer)B).intValue();
  DeluxeStuct.add(new Integer(a+b));
  return (a+b);
  }

   
   

}

public interface ADTDeluxeStruct {
    public boolean isEmpty();
    public boolean isFull();
    public Object top();
    public boolean push(Object element);
    public Object pop();
    public Object remove();
    public boolean add(Object element);
    public Object shift();                  // neue Methode
    public boolean unshift(Object element); // neue Methode
}

 

[Ralf Ueberfuhr]

Klasse calculator, Zeilen 32ff:

Ersetze jeweils

OperandenundOpereatoren=="+"

durch

OperandenundOpereatoren.equals("+")

Es gibt einen Unterschied zwischen Referenzen- und Inhaltsgleichheit. Die if-Bedingung wird nie ausgefüllt, da "+" immer neu instanziert wird.

 

[lola]

ah ok, dankeschön, das wusste ich bisher nicht!!!
aber die zahlen, die eingelesen werden sollen, kommen trotzdem nicht auf den stack (DeluxeStruct ist eigentlich ein stack). was muss ich da ändern ???
hier noch deluxe struct

/* Beispielloesung zu Aufgabe 3 -- AI 2 -- SS 06

   Implementierung des Interfaces ADTDeluxeStruct

   Bis auf die Implementierung beiden neuen Methoden shift/unshift,
   entspricht die Loesung derjenigen aus Aufgabe 1. 
   
   Fuer Kommentare: siehe entsprechende Beispielloesung.
   
   nh - 04/2006 
*/

import IOulm.*;

public class DeluxeStruct implements ADTDeluxeStruct {
    private static final int maxSize = 100;
    private Object[] deluxe;
    private int size;
    private int head;
    private int tail;
    
    public DeluxeStruct() {
        deluxe = new Object[maxSize];
        size = 0;
        head = 0;
        tail = 0;
    }
    
    public DeluxeStruct( int maxsize ) {
    deluxe = new Object[size];

    head = 0;
    tail = 0;
    size = 0;
  }
    
    public boolean isEmpty() {
        return size == 0;
    }

    public boolean isFull() {
        return size >= deluxe.length;
    }
    
    public Object remove() {
        if (isEmpty())
            return null;
        Object element = deluxe[head];
        head = (head + 1) % deluxe.length;
        size--;
        return element;
    }
    
    public boolean add(Object element) {
        if (isFull())
            return false;
        deluxe[tail] = element;
        tail = (tail + 1) % deluxe.length;
        size++;
        return true;
    }
    
    public Object top() {
        if (isEmpty())
            return null;
        int tmptail;
        if (tail == 0) {
            tmptail = deluxe.length - 1;
        } else {
            tmptail = tail - 1;
        }
        return deluxe[tmptail];
    }
    
    public boolean push(Object element) {
    if(isFull()) return false;
    deluxe[head] = element;
    head = (head+1)%size;
    size++;
    return true;
  }
    
    

    
    public Object pop() {
    Object x;
    if ( isEmpty () ) return null ;
    head= (head - 1);
    if(head<0) head=size-1;
    x = deluxe[head];
    size--;
    return x;
  }

    /* Genau wie die Methode push() weiter oben erfordert die Methode shift()
       keine neuerliche "echte" Implementierung, da das, was sie leisten
       soll, bereits implementierten Methode "remove()" bietet.
       Daher genuegt es hier, die Methode "remove()" aufzurufen und ihren
       Rueckgabewert zu verwenden. */
    public Object shift () {
       return remove();
    }
    
    /* Dieses ist nun eine tatsaechlich neue Methode: sie muss hier
       erstmals implementiert werden. */
    public boolean unshift(Object element) {
        if (isFull())
            return false;
        if (head == 0) {
            head = deluxe.length - 1;
        } else {
            head--;
        }
        deluxe[head] = element;
        size++;
        return true;
    }
}

 

[bygones]

Es gibt einen Unterschied zwischen Referenzen- und Inhaltsgleichheit. Die if-Bedingung wird nie ausgefüllt, da "+" immer neu instanziert wird.

nicht ganz richtig - siehe FAQs zum Stringvergleich - Stichpunkt Stringpool