Applet JApplet - Verständnissproblem

[corrosive]

Hallo!

ich habe in der Uni die Aufgabe bekommen, einen Pythagorasbaum mit einem JApplet zu erstellen:

Wie ich den Baum nun genau mache, dass will und werd ich schon alleine rausfinden.
Mein Problem ist, das ich gar nicht genau weiß, wie so ein JApplet jetzt funktioniert.
Ich habe das jetzt so verstanden, dass die init() Funktion, im Sinne der Main Klasse die Einstiegsklasse ist, die bei dem Aufrufen im Browser einmal ausgeführt wird.
Da der Baum ja rekursiv durchlaufen soll, dachte ich mir, dass ich in der init()-Methode einfach paint mit den Anfangsparametern aufrufe, dass sich dann wiederrum mit repaint() rekursiv mit neuen Parametern bis zur Abbruchbedingung aufruft. Jetzt lese ich, dass man paint() eigentlich nicht überschreiben sollte....

Wer übergibt paint() denn eigentlich das Graphics-Object? Wo wird die Methode aufgerufen?

Ich will eigentlich nur eine Methode mit gewissen Parametern aufrufen, die dann rekursiv meinen Baum zeichnet...

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.Polygon;
import javax.swing.JApplet;

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

/**
 *
 * @author Max
 */
public class Pythagoras extends JApplet {

   int tiefe = 7;
   int count = 0;
   double faktor = 1;
   double wL;
   double wR;
   Point a = new Point(100, 100);
   Point b;
   Point c;
   Point d;
   Point e;
   Graphics g;

   @Override
   public void init() {
      paint(g, faktor, a);
   }

   public void paint(Graphics g, double faktor, Point a) {
      setSize(400, 400);
      int w = getWidth();
      int h = getHeight();

//      g.clearRect(0, 0, w, h);

      this.a.setLocation(a.getX(), a.getY());
      b.setLocation(a.getX()+(100*faktor), a.getY());
      c.setLocation(b.getX(), b.getY()-(100*faktor));
      d.setLocation(c.getX()-(100*faktor), c.getY());
      e.setLocation(d.getX()+(50*faktor), d.getY()-(50*faktor));
      g.drawLine((int)a.getX(), (int)a.getY(), (int)b.getX(), (int)b.getY());
      g.drawLine((int)b.getX(), (int)b.getY(), (int)c.getX(), (int)c.getY());
      g.drawLine((int)c.getX(), (int)c.getY(), (int)d.getX(), (int)d.getY());
      g.drawLine((int)d.getX(), (int)d.getY(), (int)a.getX(), (int)a.getY());
      g.drawLine((int)d.getX(), (int)d.getY(), (int)e.getX(), (int)e.getY());
      g.drawLine((int)c.getX(), (int)c.getY(), (int)e.getX(), (int)e.getY());

//      int abstand = (int)Math.sqrt(Math.pow((b.getX()-a.getX()),2) + Math.pow((b.getY()-a.getY()),2));

      count++;

      if(count <= tiefe) {
         repaint(g, faktor, d);
      }

   }

   public void repaint(Graphics g, double faktor, Point a) {
       paint(g, faktor, a);
   }

}

 

[Marco13]

paint wird sozusagen "vom Betriebssystem" (d.h. dem Fenstermanager) aufgerufen. Das passiert z.B. bei Größenänderungen des Fensters, ggf. beim Scrollen, oder wenn das Fenster kurz durch ein anderes verdeckt war. (Genaugenommen kommt der eigentliche Aufruf natürlich "von der JVM", aber in ... "enger Kooperation" mit dem Fenstermanager ).

Das entscheidende ist, dass man sie i.a. nicht SELBST aufrufen sollte, sondern nur dafür sorgen muss, dass alles gezeichnet wird, wenn sie (von außen) aufgerufen wird. Man könnte dafür direkt die paint-Methode des Applets überschreiben (und in vielen einfachen Beispielen wird das auch gemacht), aber es hat Vorteile (in bezug auf die Flexibilität), bei einem JApplet NICHT paint zu überschreiben, sondern stattdessen nur ein JPanel in das Applet zu legen, das das Zeichnen übernimmt. Bei so einem JPanel würde man dann allerdings die paintComponent-Methode überschreiben:

class PaintPanel extends JPanel
{
    private float irgendwelcheParameterFürDasFraktal = 1234;

    @Override
    public void paintComponent(Graphics g)
    {
        super.paintComponent(g);
        paintFractal(g, irgendwelcheParameterFürDasFraktal);
    }

    private void paintFractal(Graphics g, float parameter)
    {
        ...
        paintFractal(g, parameter-1); // Rekursion...
    }

}

 

[corrosive]

Danke für deine Antwort.

Aber ich muss das mit der JApplet Klasse machen, da wir nicht einfach was nehmen dürfen, was wir noch nicht hatten.

Mit welcher Methode kann ich denn den Einstieg des Applets festlegen? Wo ich ihm sage führe am Anfang z.B. zeichne() aus?
Kann ich auch in einer eigenen Methode ein Graphics.Object mit g.drawLine zeichnen lassen? Wenn ja, wofür ist dann paint()?

Versteh das alles noch nicht richtig :noe:

Grüße,
corrosive

 

[Marco13]

Aber ich muss das mit der JApplet Klasse machen, da wir nicht einfach was nehmen dürfen, was wir noch nicht hatten.

Du hast ja ein Applet. Da liegt dann ein JPanel drin :bahnhof: Frag' vielleicht nochmal nach, kann ja nicht sein, dass es "verboten" ist, zu versuchen, das Programm flexibler zu machen. Wenn du paint überschreibst, und dann z.B. noch Buttons hinzufügen willst, kommt Murks raus...

Mit welcher Methode kann ich denn den Einstieg des Applets festlegen? Wo ich ihm sage führe am Anfang z.B. zeichne() aus?
Kann ich auch in einer eigenen Methode ein Graphics.Object mit g.drawLine zeichnen lassen? Wenn ja, wofür ist dann paint()?

Hm. Was sollte eine "zeichne()"-Methode denn machen? Alles, was gezeichnet wird, muss von der paint-Methode aus gezeichnen werden - und zwar NUR in das dort übergebene Graphics-Objekt. (Präventiv: Solche Sachen wie ein "Zwischenspeichern" eines Graphics-Objektes, oder Aufrufe von "getGraphics" führen praktisch immer zu Problemen).