Hallo erstmal...
also, vor ein paar Tagen habe ich beschlossen Java zu lernen. Nun dachte ich mir ich könnte ja mal zur Übung einen kleinen Taschenrechner programmieren. Bisher habe ich schon einiges an code geschrieben und soweit funktioniert bisher auch alles wie es soll, nur habe ich das Gefühl dass ich es zu kompliziert gemacht habe. Außerdem werde ich auch das Gefühl nicht los, dass ich den Grundgedanken der objektorientierten Programmierung noch nicht so ganz verinnerlicht habe. Vielleicht kann mir ja jemand auf die Sprünge helfen und mir sagen was ich an dem bisherigen code besser oder vielleicht komplett anders machen sollte. Bisher kann mein "kleines" Programm nur Ausdrücke wie z.B. (((14*(13+4))+3)*12) ausrechnen. Aber hier erstmal der Code:
Vielen Dank schonmal fürs lesen
also, vor ein paar Tagen habe ich beschlossen Java zu lernen. Nun dachte ich mir ich könnte ja mal zur Übung einen kleinen Taschenrechner programmieren. Bisher habe ich schon einiges an code geschrieben und soweit funktioniert bisher auch alles wie es soll, nur habe ich das Gefühl dass ich es zu kompliziert gemacht habe. Außerdem werde ich auch das Gefühl nicht los, dass ich den Grundgedanken der objektorientierten Programmierung noch nicht so ganz verinnerlicht habe. Vielleicht kann mir ja jemand auf die Sprünge helfen und mir sagen was ich an dem bisherigen code besser oder vielleicht komplett anders machen sollte. Bisher kann mein "kleines" Programm nur Ausdrücke wie z.B. (((14*(13+4))+3)*12) ausrechnen. Aber hier erstmal der Code:
Code:
class Taschenrechner
{
public static void main(String[] arg)
{
Expression ausdruck = new Expression("(((14*(13+4))+3)*12)");
System.out.println(ausdruck.show()+" = "+ausdruck.eval());
}
}
class Expression
{
String exp,exp3;
public Expression(String str)
{
exp=str;
exp3=str;
}
//eval berechnet den Wert eines Ausdruckes
public String eval()
{
while(checkop(exp3))
{
exp3 = replace(trunc(),calc(remove(trunc())));
}
return exp3;
}
//show gibt den Ausdruck zurück
public String show()
{
return exp;
}
//trunc gibt den Term zurück der in der innersten Klammer steht
private String trunc()
{
StringBuffer exp2 = new StringBuffer(exp3);
exp2.setLength(find(')',exp2)+1);
exp2.reverse();
exp2.setLength(find('(',exp2)+1);
exp2.reverse();
return exp2.toString();
}
//find gibt die stelle zurück an der ein zeichen in einem String gefunden wurde
private int find(char ch,StringBuffer expr)
{
String str;
str=expr.toString();
if (str.indexOf(ch)==-1)
{
return expr.length();
}
else
{
return str.indexOf(ch);
}
}
//calc gibt den wert (als String) eines einfachen Ausdrucks zurück (z.B. den Wert von (a+b))
private String calc(String ex)
{
StringBuffer Bxe = new StringBuffer (ex);
Bxe.reverse();
Integer a,b,erg;
char op;
a=Integer.parseInt(getfirstnumber(ex));
StringBuffer exB = new StringBuffer(getfirstnumber(Bxe.toString()));
exB.reverse();
b=Integer.parseInt(exB.toString());
op=getop(ex);
switch(op)
{
case '+':
erg=a+b;
return erg.toString();
case '-':
erg=a-b;
return erg.toString();
case '*':
erg=a*b;
return erg.toString();
}
return ex;
}
//replace ersetzt what in unserem Ausdruck durch by
private String replace(String what, String by)
{
int start,end;
StringBuffer whereB = new StringBuffer(exp3);
StringBuffer lastpart = new StringBuffer();
StringBuffer firstpart = new StringBuffer(exp3);
start = exp3.indexOf(what);
end = start + what.length()-1;
lastpart=whereB.reverse();
lastpart.setLength(exp3.length()-end-1);
lastpart.reverse();
firstpart.setLength(start);
firstpart.append(by);
firstpart.append(lastpart);
return firstpart.toString();
}
//getfirstnumber liefert den ersten Zahlenwert eines Ausdrucks als String zurück
private String getfirstnumber(String ex)
{
Character i=new Character('o');
int j=0;
StringBuffer ret = new StringBuffer();
while(i!='+'&&
i!='-'&&
i!='*')
{
i=ex.charAt(j);
ret.append(i);
j++;
}
ret.setLength(ret.length()-1);
return ret.toString();
}
//getop liefert den ersten gefundenen Operator zurück (+,- oder *)
private char getop(String ex)
{
Character i=new Character('o');
int j=0;
while(i!='+'&&
i!='-'&&
i!='*')
{
i=ex.charAt(j);
j++;
}
return i;
}
//remove entfernt das erste und das letzte Zeichen eines Strings
private String remove (String str)
{
StringBuffer strB = new StringBuffer(str);
strB.setLength(strB.length()-1);
strB.reverse();
strB.setLength(strB.length()-1);
strB.reverse();
return strB.toString();
}
//checkop überprüft ob noch ein Operator im übergebenen String enthalten ist
private boolean checkop(String ex)
{
StringBuffer exB=new StringBuffer(ex);
if(find('+',exB)==ex.length() &&
find('-',exB)==ex.length() &&
find('*',exB)==ex.length())
{return false;}
else return true;
}
}Vielen Dank schonmal fürs lesen
