Eine Klasse ist die Beschreibung des Datentyps Objekt. Ein Objekt wird dazu verwendet Daten zu formen indem ihnen ein spezieller Zweck zugeordnet wird. Dies geschieht mithilfe von Methoden.
Ein kleines Raumschiff in einem Computerspiel könnte z. B. die Daten für die Position auf dem Bildschirm haben, also die X und Y-Koordinaten. Und vier Methoden zum bewegen in vier verschiedene Richtungen (Beispiel weiter unten).
Eine Klasse hat folgenden Aufbau (zwingende Angaben grün, optionale grau):
modifikator class Name Erweiterung Implementierungen
{
Datenblock
Konstruktorblock
Methodenblock
}
Der Modifikator (protected, private oder public) regelt den Zugriff auf die Klasse. Ist kein Modifikator angegeben so ist die Klasse immer protected, d.h. die Klasse ist für alle anderen Klassen und Unterklassen des selben Packages sichtbar.
Das Schlüsselwort class steht dafür das es sich um eine Klasse handelt. Es ist auch noch interface möglich was dann bewirkt das es sich wie der Name sagt um ein Interface handelt. Genaueres im Kapitel Interface.
Name ist die Bezeichnung der Klasse, und sollte ohne Umlaute und immer großgeschrieben sein.
Die Erweiterung bestehend aus dem Schlüsselwort extends gefolgt von einer Klasse, bezeichnet die Elternklasse. Die Klasse erbt von der Elternklasse auch Superklasse genannt, alle Daten und Methoden. Es kann nur von einer einzigen Klasse geerbt werden.
Im Gegensatz zur Elternklasse kann es beliebig viele Implementierungen geben. Diese bestehen aus dem Schlüsselwort implements gefolgt von einem Interface und stellen weitere Methodendeklarationen (Methoden mit leerem Anweisungsblock, der vom Programmierer vervollständigt werden muss) und Konstanten (Eine Variable mit unveränderlichen Wert, also nicht mehr variable sondern konstant) für spezielle Zwecke zur Verfügung.
Der Datenblock wird in der Regel am Anfang der Klasse aufgeführt und kann eine beliebige Anzahl von allen Arten von Datentypen enthalten (Variable, Konstanten, aber auch Objekte) beinhalten.
Im Konstruktorblock wird der Standardkonstruktor aufgeführt. Außerdem kann der Konstruktor überladen werden, d.h. es können mehrere Konstruktoren aufgeführt werden, um beispielsweise gleich bei der Erstellung des Objekts die Daten zu verändern oder eine bestimmte Methode aufzurufen.
Der Methodenblock kommt in der Regel nach dem Konstruktorblock und enthält eine beliebige Anzahl Methoden zur Manipulation der Daten.
Eine typische Klasse mit überladenem Konstruktor könnte z.B. so aussehen (Schlüsselwörter grün, Variablennamen kursiv):
class Beispiel {
String text = „Hallo Welt“; // Variablendeklaration
public Beispiel() {} // Standardkonstruktor
public Beispiel(String text) { // weiterer Konstruktor zum ändern von text bei Objektbildung
this.text = text;
}
public void Ausgabe() { // Methode zur Ausgabe der Variable text.
System.out.println(this.text);
}
}
In nachfolgendem Beispiel werden zwei Klassen erstellt. Weltraum und Raumschiff. Die Klasse Weltraum ist ein Fenster das ein unsichtbares Eingabefeld und eine schwarze Fläche enthält. Auf der schwarzen Fläche wird wird ein Objekt der Klasse Raumschiff gesetzt, das mit den Cursor-Tasten gesteuert werden kann.
package klassenbeispiel;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JTextField;
public class Weltall extends JFrame implements KeyListener {
/*
* Deklaration von raumschiff. Der Computer reserviert Speicher für eine
* Variable vom Typ Raumschiff
*/
Raumschiff ufo;
JTextField eingabefeld;
JPanel p;
/*
* Die Einstiegsmethode hat mit der Klasse Weltall selbst, nichts zu tun. Sie
* zeigt dem Compiler nur wo er beginnt, wo der Programmeinstieg ist.
*/
public static void main(String[] args) {
new Weltall(); // Es wird ein Objekt der Klasse Weltall gebildet.
}
/* Konstruktor der Klasse */
public Weltall() {
init(); // ruft die Methode init() auf
}
/*
* Die Methode init() definiert das Aussehen des Fensters, erstellt ein
* Raumschiff, ein Eingabefeld mit Keylistener und setzt anschließend das
* Raumschiff ins "Weltall"
*/
public void init() {
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setBounds(0, 0, 1000, 500);
this.setLocationRelativeTo(null);
this.setAlwaysOnTop(true);
this.setLayout(new BorderLayout());
this.getContentPane().setBackground(Color.BLACK);
ufo = new Raumschiff(); // erstellt ein Objekt vom Typ Raumschiff
eingabefeld = new JTextField(); // erstellt ein Eingabefeld..
eingabefeld.addKeyListener(this); // ..indem ein Textfeld mit einem KeyListener versehen wird.
this.add(eingabefeld, BorderLayout.NORTH); // anschließend wird es aufs Fenster, an den oberen Rand gesetzt
this.getContentPane().add(ufo, BorderLayout.CENTER); // Unser Ufo wird in die Mitte der ContentPane gesetzt
this.setVisible(true); // Fenster wird sichtbar gemacht
}
/*
* Die Methode des KeyListeners wird hier überschrieben in der Variable c wird
* der Code der gerade gedrückten Taste gespeichert, in der switch..case
* Verzweigung entsprechend auf Methode des Objekts Raumschiff verwiesen
*/
@Override
public void keyPressed(KeyEvent e) {
int c = e.getKeyCode();
switch (c) {
case 37:
ufo.nachLinks();
eingabefeld.setText("Links");
break;
case 38:
ufo.nachOben();
eingabefeld.setText("Oben");
break;
case 39:
ufo.nachRechts();
eingabefeld.setText("Rechts");
break;
case 40:
ufo.nachUnten();
eingabefeld.setText("Unten");
break;
}
System.out.println("Taste: " + c);
}
@Override
public void keyReleased(KeyEvent e) {
// TODO Automatisch generierter Methodenstub
}
@Override
public void keyTyped(KeyEvent e) {
// TODO Automatisch generierter Methodenstub
}
}
class Raumschiff extends JPanel {
int x; // Deklaration x-Koordinate
int y; // Deklaration y-Koordinate
public Raumschiff() {
this.x = 100; // x-Koordinate wird initialisiert
this.y = 100; // y-Koordinate wird initialisiert
this.setOpaque(false);
}
public void nachOben() {
this.y--; // y wird um 1 verringert, Kurzform von: this.y = this.y - 1
this.repaint(); // Raumschiff wird neu gezeichnet
}
public void nachUnten() {
this.y++; // y wird um 1 erhöht
this.repaint();
}
public void nachLinks() {
this.x--; // x wird um 1 verringert
this.repaint();
}
public void nachRechts() {
this.x++; // x wird um 1 erhöht
this.repaint();
}
/*
* Die paint Methode beinhaltet die Grafik des JPanels. In diesem Falle stellt
* eine Ellipse unser Raumschiff dar
*/
public void paint(Graphics g) {
super.paint(g); // paint(g) des Elternelements muss für korrekte Darstellung aufgerufen werden
g.setColor(Color.BLUE); // Farbe wird definiert
g.fillOval(this.x, this.y, 50, 20); // (x-Koordinate,y-koordinate, Breite, Höhe)
}
}