Abstrakte Klasse bilden?

[kossy]

Hallo nochmal !

Ich habe nochmal eine Frage zu einer anderen Aufgabe. Ich würde gerne wissen, ob mein Lösungsansatz korrekt ist?

Hier ist erstmal der Quellcode:

public class Funktion1{

       public double f1(double x) {
             return x*x -1;
       }

       public void gebeWertelisteAus(double startpunkt, double endpunkt,
                                                double Schrittweite) {

            System.out.format(" x= f(x) ");

            for (double x = startpunkt; x { endpunkt; x += schrittweite) {
                  System.out.format("%8.2f %8.2f\n", x, f1(x));
            }

       }

}

public class Funktion2{

         public double f2(double x) {
                return x*x -1;
         }

         public void gebeWertelisteAus(double startpunkt, double endpunkt, 
                                                  double schrittweite) {

                System.out.format(" x= f(x) ");

                for (double x = startpunkt; x { endpunkt; x += schrittweite) {

                      System.out.format("%8.2f %8.2f\n", x, f2(x));
                }

         }

}

public class Hauptprogramm {

               public static void main (String [] args) {

                     Funktion1 f1 = new Funktion1();
                     Funktion2 f2 = new Funktion2();

                     f1.gebeWertelisteAus(1, 5, 0.2);
                     f2.gebeWertelisteAus(1, 5, 0.2);

              }

}

Meine Aufgabe soll es nun sein, die Klassen zu verbessern. Dabei soll ich in Richtung einer einfachen Erweiterbarkeit (einfacher Einbau einer neuen Funktion) denken.

Mein Lösungsansatz wäre nun, eine abstrakte Oberklasse zu bilden die die Funktion

public void gebeWertelisteAus(double startpunkt, double endpunkt, 
                                                  double schrittweite) {

                  System.out.format(" x= f(x) ");

                  for (double x = startpunkt; x { endpunkt; x += schrittweite) {
                          System.out.format("%8.2f %8.2f\n", x, f2(x));
                  }
}

dort einzubetten. Diese Funktion sollen dann die Klassen Funktion1 und Funktion2 erben bzw. überschreiben. Kann ich hier sonst noch etwas optimieren? Es macht wohl wenig Sinn auch noch die Methoden f1() und f2() in die abstrakte Klasse mit einzubauen oder? Im übrigen ist das auch wieder son tolles Beispiel aus einer Vorlesung für Javagrundlagen.

Die vollständige Lösung wäre dann:

abstract class Basisklasse{

                public void gebeWertelisteAus(double startpunkt, double endpunkt, 
                                                         double schrittweite) {

                        System.out.format(" x= f(x) ");

                        for (double x = startpunkt; x { endpunkt; x += schrittweite) {
                               System.out.format("%8.2f %8.2f\n", x, f2(x));
                        }
                }

}

public class Funktion1 extends Basisklasse{

                public double f1(double x) {
                        return x*x -1;
                }

                public void gebeWertelisteAus(double startpunkt, double endpunkt, 
                                                         double schrittweite) {

                        System.out.format(" x= f(x) ");

                        for (double x = startpunkt; x { endpunkt; x += schrittweite) {
                              System.out.format("%8.2f %8.2f\n", x, f1(x));
                        }
                 }

}

public class Funktion2 extends Basisklasse{

               public double f2(double x) {
                     return x*x -1;
               }

               public void gebeWertelisteAus(double startpunkt, double endpunkt, 
                                                        double schrittweite) {

                      System.out.format(" x= f(x) ");

                      for (double x = startpunkt; x { endpunkt; x += schrittweite) {
                             System.out.format("%8.2f %8.2f\n", x, f2(x));
                      }

               }

}

public class Hauptprogramm {

               public static void main (String [] args) {

                      Funktion1 f1 = new Funktion1();
                      Funktion2 f2 = new Funktion2();

                      f1.gebeWertelisteAus(1, 5, 0.2);
                      f2.gebeWertelisteAus(1, 5, 0.2);

               }

}

So ich habe alle Codezeilen nochmal kenntlich gemacht und besser eingerückt. Danke für die Mithilfe!

 

[ARadauer]

nein so nicht...
fällt dir auf dass du in den drei klassen ziehmlihc viel code verdopplung hast? gebeWertelisteAus ist ja immer gleich...

gebeWertelisteAus aus Funktion1 und Funktion2 raus, und eine

 public abstrct double f2(double x);

in die Basisklasse rein

 

[kossy]

Also Du meinst so:

abstract class Basisklasse{
 
                abstract public double f1(double x);

                abstract public double f2(double x);

                public void gebeWertelisteAus(double startpunkt, double endpunkt, 
                                                         double schrittweite) {

                        System.out.format(" x= f(x) ");

                        for (double x = startpunkt; x { endpunkt; x += schrittweite) {
                               System.out.format("%8.2f %8.2f\n", x, f2(x));
                        }
                }

}

public class Funktion1 extends Basisklasse{

                public double f1(double x) {
                        return x*x -1;
                }

}

public class Funktion2 extends Basisklasse{

               public double f2(double x) {
                     return x*x -1;
               }

}

public class Hauptprogramm {

               public static void main (String [] args) {

                      Funktion1 f1 = new Funktion1();
                      Funktion2 f2 = new Funktion2();

                      f1.gebeWertelisteAus(1, 5, 0.2);
                      f2.gebeWertelisteAus(1, 5, 0.2);

               }

}

 

[ARadauer]

ein Beispiel, das ähnlich zu deinem ist:

package abstracttest;

public abstract class BasisFunktion {
   public abstract double berechne(double d);
   
   public void gibErgebnisAus(double d){
      System.out.println("Ergebnis: "+ berechne(d));
   }   

}

package abstracttest;

public class MalZweiFunktion extends BasisFunktion{

   @Override
   public double berechne(double d) {
      return d*2;
   }

}

package abstracttest;

public class MalDreiFunktion extends BasisFunktion{

   @Override
   public double berechne(double d) {
      return d*3;
   }

}

package abstracttest;

public class Test {

   /**
    * @param args
    */
   public static void main(String[] args) {
      BasisFunktion f1 = new MalZweiFunktion();
      BasisFunktion f2 = new MalDreiFunktion();
      
      System.out.println(f1.berechne(2));
      System.out.println(f2.berechne(2));

   }

}

schau dir das mal genau an... Polymorphismus... sollte man verstehen...

 

[kossy]

Jo anhand Deine Beispieles erkenne ich keinen Fehler in meiner Lösung ???:L Sorry

 

[ARadauer]

dein Programm dürfte nicht funktionieren, da Funktion1 f2 nicht implementiert und Funktion2 f1...

ausserdem benutzt deine Basisklasse nur die f2... mhn stimmt nicht ganz

der sinn dahinter ist, das man eine abstracte Methode declariert und diese benutzt. Aber was jetzt in dieser Methode konkret passiert (bzw vielmer "wie" etwas passiert) entscheidet die abgeleitete Klasse...

In deinem bestimmten Fall, werden Kurven anhand von Funktionen berechnet und die genaue Funktion wird in jeder abgeleiteten Klasse definiert...

 

[kossy]

Ich glaube nun habe ich es verstanden, danke für Deine Zeit und Mithilfe !

abstract class Basisklasse{
 
                abstract public double berechneFunktion(double x);

                public void gebeWertelisteAus(double startpunkt, double endpunkt, 
                                                         double schrittweite) {

                        System.out.format(" x= f(x) ");

                        for (double x = startpunkt; x { endpunkt; x += schrittweite) {
                               System.out.format("%8.2f %8.2f\n", x, f2(x));
                        }
                }

}

public class Funktion1 extends Basisklasse{

                public double berechneFunktion(double x) {
                        return x*x -1;
                }

}

public class Funktion2 extends Basisklasse{

               public double berechneFunktion(double x) {
                     return x*x -1;
               }

}

public class Hauptprogramm {

               public static void main (String [] args) {

                      Funktion1 f1 = new Funktion1();
                      Funktion2 f2 = new Funktion2();

                      f1.gebeWertelisteAus(1, 5, 0.2);
                      f2.gebeWertelisteAus(1, 5, 0.2);

               }

}

 

[ARadauer]

perfekt ... fast..

for (double x = startpunkt; x { endpunkt; x += schrittweite) {
                               System.out.format("%8.2f %8.2f\n", x, berechneFunktion(x));
                        }

 

[kossy]

schau dir das mal genau an... Polymorphismus... sollte man verstehen...

Ich muss nochmal kurz nachhaken. Unter Polymorphismus versteht man doch, dass Objekte von Subklassen sich genauso verhalten können, wie die Objekte ihrer Basisklassen. Die Subklassen erben alle Datenfelder und Protokolle ihrer Basisklassen.

Ist das so korrekt?

 

[maki]

Ist das so korrekt?

Nö.

Polymorphy heist das ein Objekt mehrere Schnittstellen haben kann, eben ein "viel formler".

 

[kossy]

eben ein "viel formler".

Tschuldige, was bitte? Kann ich eine genaue Definiton mal irgendwo nachschlagen? Der Wikipediaartikel gibt auch nciht gerade viel her...

 

[Leroy42]

Was verstehst du denn daran nicht? :shock:

Vielleicht hilft dir der englischsprachige Artikel weiter?

Type polymorphism - Wikipedia, the free encyclopedia