abstracte Klassen und deren Unterklassen

[Guest]

Hallo,

ich habe da eine Frage bezüglich meinem Code ,genauer Klasse Test.

Folgendes ich will von der Klasse Test aus die Methoden in den Unterklassen von Bin ,also Sub,Div ,Add ausführen.
Die Klasse abstract Expr ist meine Oberklasse, Const ist die Unterklasse von Expr , die Klasse Bin abstracte Klasse und Unterklasse von Expr.
Die weiteren Rechenoperationsklassen Div,Sub,Mul,Add Unterklasse von Bin.

Mein Verständnisproblem:

Wie führe ich in der Klasse Test die Methoden in den Unterklassen (Sub ,Add...) von Bin aus ?
Wenn ich Test extends Bin mache funktioniert das nicht wirklich,dann wird eine Struktur mit den ganzen Methoden eval,print usw. verlangt und es besteht der Fehler noch immer das die in Test vorkommenden Methodenaufrufen nicht gefunden werden.


Hier der etwas zu lang geratene Code =)

 abstract class  Expr {
	
	protected double g;
	
	public Expr (double k) {
		g=k;
	}
	
	public abstract double eval (double g);
	
	public abstract void print (String g);
		
}


 class Const extends Expr{
	 
	 	protected double zahl;

		public Const(double k) {
			super(k);
		}


		public double eval(double g) {
			return 0;
		}


		public void print(String g) {
			String out = new String (g);
			System.out.println(out);
		}
	}

 

abstract class Bin extends Expr{
	
	protected double e,f;
	
	public Bin(double k) {
		super(k);
	}


 	public abstract String oper () ; 

 	public abstract  void print(String g);

 }


 class Add extends Bin{

	public Add(double k) {
		super(k);
	}


	public double eval(double g) {
		return 0;
	}


	public String oper() {
		return "+";
	}


	@Override
	public void print(String g) {
		// TODO Auto-generated method stub
		
	}
	

}


 class Sub extends Bin{

	public Sub(double k) {
		super(k);
	}

	public double eval(double g) {
		return 0;
	}

	public String oper() {
		return "-";
	}

	@Override
	public void print(String g) {
		// TODO Auto-generated method stub
		
	}

}


 class Mul extends Bin{

	public Mul(double k) {
		super(k);
	}

	
	public double eval(double g) {
		return 0;
	}

	public String oper() {
		return "*";
	}


	@Override
	public void print(String g) {
		// TODO Auto-generated method stub
		
	}

}


class Div extends Bin {

 	public Div(double k) {
 		super(k);
 	}

 	

	public String oper() {
		return "/";
	}


	@Override
	public void print(String g) {
		// TODO Auto-generated method stub
		
	}


	@Override
	public double eval(double g) {
		// TODO Auto-generated method stub
		return 0;
	}



 }



 class Test{
	
	public static void main (String [] args){
		
		Expr x= new Add(new Const(2),new Mul(new Const(3),new Const(4)));
		x.print();
		System.out.println(" -> " + x.eval());
	}
	
}

 

[SlaterB]

was genau willst du durchführen, welche Fehlermeldungen kommen?
x.eval() oder x.print() rufst du doch schon auf, was willst du mehr?

allerdings erwartet z.B. eval einen double-Parameter, den du nicht übergibst, das kann also nicht klappen

----

an den Unterobjekten Const, Mul, Const und Const solltest du überhaupt nix aufrufen,
darum müßte sich eigentlich die eval()-Methode von Add kümmern,

aber die macht bisher noch gar nix, es gibt auch keinen Konstruktor, der zwei andere Exp erlaubt usw.,
das ganze sieht also noch gar nicht programmiert aus,

Beispiel:
Add braucht einen Konstruktor, der zwei Exp aufnimmt und intern speichert,
bzw. dafür hast du ja auch die Bin-Zwischenklasse, die macht das aber bisher auch noch nicht

die eval-Methode von Add ist dann ungefähr

public double eval(double g) {
return getExp1().eval(g)+getExp2().eval(g);
}

------

fange einfach an, erstmal nur mit der Const-Klasse,
diese dann testen,
dann eine weitere, wieder testen usw.

-------

Expr selber braucht gar keinen Konstruktor und kein private double g,
lösche das erstmal, bevor es noch mehr Verwirrung gibt

 

[Landei]

abstract class  Expr {
   public abstract double eval ();
   public abstract void print();
}


class Const extends Expr{
       private double zahl;
       Const(double zahl) {
         this.zahl = zahl;
      }
      public double eval() {
         return zahl;
      }
      public void print() {
         System.out.print(zahl);
      }
   }


abstract class Bin extends Expr{
   protected Expr left;
   protected Expr right;
   private String oper;

   public Bin(Expr left, Expr right, String oper) {
      this.left = left;
      this.right = right;
      this.oper = oper;
   }

   public void print(String g) {
      System.out.print("(");
      left.print();
      System.out.print(oper); 
      right.print();
      System.out.print(")");
   }

}


class Add extends Bin{
   public Add(Expr left, Expr right) {
      super(left, right, "+");
   }

   public double eval() {
      return left.eval + right.eval;
   }

}


class Sub extends Bin{

   public Sub(Expr left, Expr right) {
      super(left, right, "-");
   }

   public double eval() {
      return left.eval - right.eval;
   }

}

//etc

class Test{
   
   public static void main (String [] args){
      
      Expr x= new Add(new Const(2),new Mul(new Const(3),new Const(4)));
      x.print();
      System.out.println(" -> " + x.eval());
   }
}

 

[Guest]

ah ok ,mein Fehler,sorry.

Habt recht mit der abstrakten Klasse Expr. wird so garnicht verlangt wie ich es bisher gemacht hab.

Ich werde alles nochmal durchgehen,danke für die Hilfe euch beiden =)

 

[Guest]

So ich hab das mal so gemacht wie es in der Aufgabe verlangt wurde,dank eurer Hilfe: (oper() Methode hab ich in der Oberklasse Bin erstmal weggelassen)

Das einzige Problem das ich nun habe ist das die Methode print() in den Unterklassen Add,Sub,Div,Mul vorhanden sein muss, weil seine Oberklasse Bin auch diese Methode beinhaltet bzw. Bin auch die abstrakte Methode von der Ober"ober"Klasse Expr erbt.

Es kommt folgerichtig "->14" heraus ,wenn die Klasse Test aufgerufen wird um das Ergebnis auszurechnen.

Aber die einzelnen Zahlen die zum Ergebnis führen sind nicht vorhanden ,auch die Klammern die in der Methode Print () der Klasse Bin definiert wurden nicht.

Ich glaube es liegt daran das ich die Methode print() in der Oberklasse Bin von den Unterklassen Sub,Mul etc. überschrieben werden und den dortigen print() Methoden nix definiert ist.
Wenn ich nun versuche per super in den print() Methoden der jeweiligen Unterklassen Sub,Mul,Div,Add die print() die Methode print () der Oberklasse Bin aufzurufen kommt ein Fehler das es nicht funktioniert, weil print () eine abstrakte Methode von Expr ist.

Wie kann ich nun realisieren,das die Methoden print() in den Unterklassen Sub,Mul usw. vorhanden sind ,aber sie die print() Methode der Oberklasse Bin und nicht von der Oberklasse Expr aufruft ?

Verständnisfrage: Ist es so das ich per super Befehl in den Klassen Sub etc. eigentlich nicht die Methoden der Oberklasse Bin sondern die der Ober"ober"klasse Expr aufrufe und daher der beschriebene Fehler entsteht ?

Sorry für den vielen Text,ich wills nur genau verstehen ^^

Gruss
conspectu

abstract class Expr {
public abstract double eval ();
public abstract void print();
}


class Const extends Expr{

private double zahl;

Const(double zahl) {
this.zahl = zahl;
}
public double eval() {
return zahl;
}
public void print() {
System.out.print(zahl);
}
}


abstract class Bin extends Expr{
public Expr left;
public Expr right;
//private String oper;

public abstract String oper();

public Bin(Expr left, Expr right) {
this.left = left;
this.right = right;
}

public void print(String g) {
System.out.print("(");
left.print();
right.print();
System.out.print(")");
}

}


class Add extends Bin{
public Add(Expr left, Expr right) {
super(left, right);
}

public double eval() {
return left.eval() + right.eval();
}

public void print() {
}

public String oper() {
return "+";
}
}


class Sub extends Bin{

public Sub(Expr left, Expr right) {
super(left, right);
}

public double eval() {
return left.eval() - right.eval();
}

public void print() {
}

public String oper() {
return "-";
}
}


class Mul extends Bin{
public Mul(Expr left, Expr right) {
super(left, right);
}

public double eval() {
return left.eval() * right.eval();
}

public void print() {
}

public String oper() {
return "*";
}
}



class Div extends Bin{
public Div(Expr left, Expr right) {
super(left, right);
}

public double eval() {
return left.eval() / right.eval();
}

public void print() {
}

public String oper() {
return "/";
}
}



class Test{

public static void main (String [] args){

Expr x= new Add(new Const(2),new Mul(new Const(3),new Const(4)));
x.print();
System.out.println(" -> " + x.eval());
}
}

 

[Guest]

uups 1000 mal sorry. ich hab aus versehen den quote anstatt den code tag für den Code gesetzt:

hier nochmal als code:

abstract class  Expr {
   public abstract double eval ();
   public abstract void print();
}


class Const extends Expr{
	
       private double zahl;
       
       Const(double zahl) {
         this.zahl = zahl;
      }
      public double eval() {
         return zahl;
      }
      public void print() {
         System.out.print(zahl);
      }
   }


abstract class Bin extends Expr{
   public Expr left;
   public Expr right;
   //private String oper;

   public abstract String oper();
   
   public Bin(Expr left, Expr right) {
      this.left = left;
      this.right = right;
   }

   public void print(String g) {
      System.out.print("(");
      left.print();
      right.print();
      System.out.print(")");
   }

}


class Add extends Bin{
   public Add(Expr left, Expr right) {
      super(left, right);
   }

   public double eval() {
      return left.eval() + right.eval();
   }

  public void print() {
	}

   public String oper() {
	   return "+";
   }
}


class Sub extends Bin{

   public Sub(Expr left, Expr right) {
      super(left, right);
   }

   public double eval() {
      return left.eval() - right.eval();
   }

	public void print() {
		}

	public String oper() {
	return "-";
	}
}


class Mul extends Bin{
	   public Mul(Expr left, Expr right) {
	      super(left, right);
	   }

	   public double eval() {
	      return left.eval() * right.eval();
	   }

	   public void print() {
	   }

	   public String oper() {
		   return "*";
	}
}

	
	
class Div extends Bin{
		public Div(Expr left, Expr right) {
			super(left, right);
			}

		public double eval() {
			return left.eval() / right.eval();
		   	}

		public void print() {
			}

		public String oper() {
			return "/";
			}
	}
	


class Test{
   
   public static void main (String [] args){
     
      Expr x= new Add(new Const(2),new Mul(new Const(3),new Const(4)));
      x.print();
      System.out.println(" -> " + x.eval());
   }
}

 

[Landei]

Du brauchst in den Unterklassen gar kein print(), das von Bin ist doch schon OK:

abstract class Bin extends Expr{
//...
  public void print() {
    System.out.print("(");
    left.print(); 
    System.out.print(oper());
    right.print();
    System.out.print(")");
  }

}

Theoretisch kannst du natürlich auch schreiben:

class Add extends Bin{ 
 //...
    public void print() {
       super.print();
    }
}

... aber das wäre hier völlig zweckfrei.

 

[SlaterB]

> uups 1000 mal sorry. ich hab aus versehen den quote anstatt den code tag für den Code gesetzt:

viel schlimmer ist, dass du dich nicht registriert hast,
als normaler User könntest du dein Posting editieren..

 

[conspectumortis]

K hab nu wieder meine account-Daten =)

Ich hab nun rausbekommen warum der obige Fehler bei mir auftrat,jedoch nicht genau den Zusammenhang.


Ich hab in der Methode print() in der Oberklasse Bin die Methode falsch definiert und zwar hieß sie so:

   public void print(String g) {}

,das ist aber falsch weil die abstrakte Klasse mit

   public void print(){}

überschrieben wird ,also ohne das "String g" in den Klammern.

Nun geht alles einwandfrei =)


Verständnisfrage: Was ist genau passiert als ich die print() Methode in der Oberklasse Bin nicht richtig definiert habe und die richtige print() Methode nur in der abstrakten Klasse Expr vorhanden war ? Ích frage deshalb,weil die komischen Fehlermeldungen bei mir wie oben beschrieben auftraten und ich nicht genau wusste ,nur vermutete, das es irgendwas mit dem indirekten Zugriff der Unterklassen sub,mul etc. auf die abstrakte Klasse Expr zu tuen hat.


Edit: So sieht das fertige Ergebnis aus und wie in der Aufgabe gewollt auch oper als abstrakte Methode der Klasse Bin die durch die von den jeweiligen oper() Methoden der Unterklassen Sub,Mul überschrieben wird.

abstract class  Expr {
   public abstract double eval ();
   public abstract void print();
}


class Const extends Expr{
   
       private double zahl;
       
       Const(double zahl) {
         this.zahl = zahl;
      }
      public double eval() {
         return zahl;
      }
      public void print() {
         System.out.print(zahl);
      }
   }


abstract class Bin extends Expr{
   protected Expr left;
   protected Expr right;


   public abstract String oper();
   
   public Bin(Expr left, Expr right) {
      this.left = left;
      this.right = right;
   }

   public void print() {
      System.out.print("(");
      left.print();
      System.out.print(oper());
      right.print();
      System.out.print(")");
   }

}


class Add extends Bin{
   public Add(Expr left, Expr right) {
      super(left, right);
   }

   public double eval() {
      return left.eval() + right.eval();
   }


   public String oper() {
      return "+";
   }
}


class Sub extends Bin{

   public Sub(Expr left, Expr right) {
      super(left, right);
   }

   public double eval() {
      return left.eval() - right.eval();
   }

   public String oper() {
   return "-";
   }
}


class Mul extends Bin{
      public Mul(Expr left, Expr right) {
         super(left, right);
      }

      public double eval() {
         return left.eval() * right.eval();
      }


      public String oper() {
         return "*";
   }
}

   
   
class Div extends Bin{
      public Div(Expr left, Expr right) {
         super(left, right);
         }

      public double eval() {
         return left.eval() / right.eval();
            }

      public String oper() {
         return "/";
         }
   }
   


class Test{
   
   public static void main (String [] args){
     
      Expr x= new Add(new Const(2),new Mul(new Const(3),new Const(4)));
      x.print();
      System.out.println(" -> " + x.eval());
   }
}

 

[SlaterB]

> Was ist genau passiert als ich die print() Methode in der Oberklasse Bin nicht richtig definiert habe und die richtige print() Methode nur in der abstrakten Klasse Expr vorhanden war ?

print(g) war irrelevant,
die abstrakte Methode print() nicht überschrieben -> nicht vorhanden -> Fehlermeldung dass was fehlt

ich würde da nicht von 'was ist genau passiert?' sprechen, da finden doch keine ganzen Vorgänge statt

 

[Landei]

Als kleinen stilistischen Hinweis:
Die print-Methode funktioniert so, verstößt aber gegen ein wichtiges Prinzip, das nämlich eine Methode auch nur eine Aufgabe erfüllen sollte ("Separation of Concerns"). print() tut gleich zwei Dinge: Es erstellt eine textuelle Repräsentation deiner Klasse, und gibt selbige auf der Konsole aus. Damit ist die Methode nicht so flexibel wie die Verwendung von zwei separaten Methoden, einer für die Erstellung des Strings, und einer für das Ausdrucken. Nun gibt es für die Erstellung eines Strings bereits die Standardmethode toString(), die du idealerweise überschreiben solltest, um den String zusammenzubasteln. Dann funktioniert System.out.println(new Add(...)); "automatisch", und du kannst sie auch nutzen, wenn du den String irgendwo anders (z.B. in einer Datei oder in deiner Benutzeroberfläche) benötigst. Aber das nur am Rande.