Ernsthafte Programme sind in der Praxis viel zu groß, um aus einem Hauptprogramm allein zu bestehen. Man zerlegt deshalb Probleme in kleinere Teile, die von einem Teilprogramm realisiert werden. Mit dieser Modularisierung verfolgt man drei Ziele:

• Programme werden übersichtlicher sowie leichter erstell- und korrigierbar.
• Aufgaben, die mehrfach an verschiedenen Stellen des Programmablaufs benötigt werden, können von einem Unterprogramm erledigt werden.
• Die Entwicklungseffizienz von Programmen wird höher. Schon vorhandene Unter-programme können in neue Programme eingebaut werden und ein umfangreiches Programm kann durch Aufteilung in verschiedene Module von mehreren Entwicklern unabhängig entwickelt werden.

Um diese Ziele zu erreichen, müssen die Unterprogramme Einheiten für sich bilden. Sie sollten nicht ungewollt das Hauptprogramm oder andere Unterprogramme beeinflussen (Seiteneffekte). Weiterhin sollte ein Entwickler, der ein Modul verwenden will, nichts über die interne Realisierung dieser Unterprogramme wissen müssen. Es muss lediglich klar sein, welche Daten das Unterprogramm benötigt und welche Daten das Unterprogramm an den Aufrufenden zurückgibt (Schnittstellen).

Man kann sich das Unterprogramm wie einen Getränkeautomaten vorstellen. Man muss bestimmte Daten an den Automaten übergeben (ein Knopfdruck, ein Geldstück, usw.) und er gibt ein Getränk zurück. Über das Innenleben muss man nichts wissen, zur Benutzung genügt es die Typen und die Reihenfolge der zu übergebenden Daten zu kennen und den Datentyp der zurückkommenden Daten.

Realisiert werden diese Unterprogramme in objektorientierten Sprachen wie JAVA durch selbst erstellte Methoden. Allgemein bezeichnet man in Programmiersprache Unterprogramme auch als Funktionen. Wir wollen als erstes Beispiel eine Methode realisieren, die das Ufo aus dem letzten Kapitel zeichnet. Dies ist sinnvoll, weil das Zeichnen zum Bewegen des Ufos ständig wiederholt werden muss:

//Das ist die ausgelagerte Methode zum Zeichnen des Ufos:
  void zeichneUfo(Graphics g, int xUfo, int yUfo)
  {
     g.drawRect(xUfo,yUfo,30,15);
     g.drawLine(xUfo+15,yUfo-10,xUfo+15,yUfo);
     g.drawLine(xUfo+10,yUfo+15,xUfo+5,yUfo+25);
     g.drawLine(xUfo+20,yUfo+15,xUfo+25,yUfo+25);
  }
//So sieht das eigentliche Programm aus, das die Methode aufruft:
  public void paint(Graphics g)
  {
     int y=100;
     int breite = getWidth();
 
     //Durchlaufe alle x-Koordinaten von 0 bis zur Fensterbreite:
     for(int x=0; x<breite; x++)
     {
        //Zeichne das UFO in roter Farbe:
        g.setColor(Color.red);
        zeichneUfo(g,x,y); //Das ist ein Aufruf der neuen Funktion
 
        //Warteschleife:
        for(int j=1;j<10000000;j++);
 
        //Lösche das Ufo wieder:
        g.setColor(Color.white);
        zeichneUfo(g,x,y); //Das ist ein Aufruf der neuen Methode
     }
  }

• Das Schlüsselwort void bedeutet, dass die Methode keine Variablenwerte an das Hauptprogramm zurückliefert.
• zeichneUfo ist der Name der Methode. Damit kann sie in anderen Programmteilen aufgerufen werden.
• In runden Klammern stehen die Parameter, die bei Aufruf übergeben werden müssen. Dies sind im Wesentlichen die Koordinaten xUfo und yUfo des linken oberen Eckpunktes. Sie sind damit gleichzeitig als Variablen innerhalb der Methode deklariert und erhalten dort als Startwerte die vom Hauptprogramm übergebenen Werte.
• Die Variablen x und y sind hingegen nur im übergeordneten Programmteil gültig, genau genommen innerhalb des Blockes, der durch geschweifte Klammern abgegrenzt ist.
• Der Parameter Graphics g ist aus technischen Gründen nötig, darauf soll zunächst nicht näher eingegangen werden.

Teste das Programm und erweitere es dann so, dass die Farbe als Parameter mit übergeben wird:

 void zeichneUfo(Graphics g, int xUfo, int yUfo, Color farbe) 

Erweitere das Ufo-Programm wie folgt:

Lasse neben dem grünen Ufo von links nach rechts ein blaues Ufo von rechts nach links an einer anderen y-Koordinate fliegen.

Lasse das Ufo sich in x- und y-Richtung bewegen.

Lasse zwei verschiedenfarbige Ufos sich zufällig auf dem Bildschirm bewegen. Richtig interessant wird die Sache natürlich erst, wenn man die Ufos über die Tastatur oder über die Maus steuern kann. Auch das ist natürlich mit JAVA möglich, nur wollen wir das an dieser Stelle zunächst noch zurückstellen.

Es soll eine Methode programmiert werden, die einen Stern mit Mittelpunkt P(x/y) zeichnet. Der Methodenkopf soll wie folgt aussehen:

 void zeichneStern(int x, int y) 

Zeichne dann 100 Sterne an zufälligen Positionen auf dem Bildschirm.

Die Methoden zum Sternzeichnen soll so erweitert werden, dass man die Größe und die Farbe des Sterns übergeben kann. Zeichne erneut 100 Sterne mit zufälliger Größe und Farbe an zufälligen Positionen auf den Schirm.

Dazu benötigt man im Grunde weder Buttons noch Textfelder, denn die Zeichnung kann einfach auf einem gewöhnlichen JFrame erzeugt werden. Wir betrachten dazu ein berühmtes Beispiel:

import java.awt.*;
import javax.swing.*;
 
public class Graf_HaWe extends JFrame
{
  public Graf_HaWe(String title)
  {
    super(title);
    setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
    int frameWidth = 400; 
    int frameHeight = 400;
    setSize(frameWidth, frameHeight);
    Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
    int x = (d.width - getSize().width) / 2;
    int y = (d.height - getSize().height) / 2;
    setLocation(x, y);
    setResizable(false);
    Container cp = getContentPane();
    cp.setLayout(null);
    cp.setBackground(Color.WHITE);
    setVisible(true);
  } // end of public Graf_HaWe
 
  @Override
  public void paint(Graphics g)  // die zentrale Methode, die
  // eine Zeichenfläche vom Typ Graphics als Parameter übergibt
  // (mit dem etwas kurz geratenen Namen g)
  {
    g.drawString("Hallo Welt!",100,100); //drawString schreibt einen Text in die
    // vorher angegebene Grafikfläche g an die Pixelposition 100 waagrecht und
    // 100 senkrecht gerechnet von links oben.
    g.setColor(Color.red); //selbsterklärend
    g.drawLine(100,110,210,110); //unterstreicht den Schriftzug, angegeben sind
    // die Koordinaten des Anfangs- und des Endpunktes der Linie
  }
 
  public static void main(String[] args)
  {
    new Graf_HaWe("Graf_HaWe");
  } // end of main
} // end of class Graf_HaWe

Die Ausgabe von Grafik basiert übrigens auf einem zweidimensionalen Koordinatensystem, dessen Ursprung (0,0) in der linken oberen Ecke liegt. Positive x-Werte erstrecken sich nach rechts, positive y-Werte nach unten. Als Maßeinheit werden Bildschirmpixel verwendet, d.h. je nach Rechner steht ein größerer oder kleinerer Bereich zur Verfügung:

Wir verwenden im folgenden noch die Methode clearRect(x1,y1, breite, höhe), die ein Rechteck mit linkem oberem Punkt (x1/y1) und der angegebenen Breite und Höhe löscht.

Erstelle ein Programm, das 100 Linien mit zufälligen Anfangs- und Endpunkten zeichnet. Lösung

Erstelle ein Programm, das einen zufälligen Polygonzug (d.h. der Anfangspunkt der nächsten Linie ist der Endpunkt der vorherigen Linie) mit 100 Linien in ein Frame zeichnet. Der Start soll im Ursprung sein. Lösung

In der folgenden Aufgabe sollen farbige Linien verwendet werden. Dazu gibt es die bereits bekannte Farbklasse Color, die die Standardfarben als Methode beherrscht (z.B. Color.red, s.o.). Daneben kann man Farben aus ihren Rot- Blau und Grünanteilen mischen. Diese Anteile werden durch Zahlen zwischen 0 und 255 angegeben:

Color farbe = new Color(rotanteil,gruenanteil, blauanteil); g.setColor(farbe);

Das Programmstück ist wie folgt zu verstehen: In den Int-Variablen rotanteil, blauanteil, gruenanteil stehen die Zahlen für die entsprechenden Anteile. Der gewählte Name für die Instanz der Klasse Color, in der die Farbe gespeichert wird, ist (sinnigerweise) „farbe“. Der Befehl setColor mit einem Parameter vom Typ Color setzt die Zeichenfarbe solange auf die gewählte Farbe, bis ein neuer Zeichenbefehl diese Farbe ändert. Außerdem verwenden wir einen weiteren Befehl zum Zeichnen von Rechtecken:

g.drawRect(x1,y1,breite,hoehe)

Dabei ist P(x1,y1) der linke obere Punkt des Rechtecks. Lösung

Erstelle nun ein Programm, das 100 zufällige Rechtecke in zufälligen Farben in ein Java-Fenster zeichnet. Lösung

Zeichne das dargestellte Muster, so dass es sich an die Höhe und Breite des Fensters anpasst: Lösung

Ändere die letzte Aufgabe so ab, dass nur grüne Linien auf schwarzem Hintergrund gezeichnet werden. Das Abändern des Hintergrunds passiert mit dem Befehl setBackground, der einen Parameter vom Typ Color erwartet, also z.B. setBackground(Color.black). Lösung

Es soll ein Ufo gezeichnet werden, das die folgenden Abmessungen hat: Die Koordinaten sollen dabei relativ, d.h. in Bezug zur linken oberen Ecke formuliert werden, der obere Punkt des unbekannten Flugobjekts hat also die Koordinaten (x+15/y-10). Nach dem Zeichnen soll das Ufo natürlich noch über den Bildschirm fliegen. Ergänze das Programm zunächst so, dass es sich horizontal über den gesamten Bildschirm bewegt! Lösung

 public void paint(Graphics g)
  {
     int y=100;
     int x=10;
 
     //Zeichne das UFO in roter Farbe:
     g.setColor(...);
     g.drawRect(...);
     ...
 
  }