Wir modellieren die Klasse in Java:  Objekte dieser Klasse sollen erzeugt, die Punkte verschoben und am Ursprung gespiegelt werden können. Standardmäßig wird beim Erzeugen eines nicht weiter spezifizierten Punktes der Punkt (0|0) erzeugt werden. Man soll aber auch jeden beliebigen Punkt P(x₀|y₀) der Zahlenebene gezielt erzeugen können. Mit den  Punkten wollen wir aber auch operieren können, d.h. sie z.B. in dem Koordinatensystem verschieben oder am Ursprung spiegeln können. Um eine optische Darstellung der Punkte scheren wir uns nicht. In UML hat die Klasse dann die Darstellung:

Abb.15.1.1 UML-Darstellung der Klasse Punkt

Download:
Punkt.java

class Punkt {

  public int x,y;

  public Punkt() {

    x=0;

    y=0;

  }

  public Punkt(int xNeu, int yNeu) {

    x = xNeu;

    y = yNeu;

  }

  public void verschiebe(int dx, int dy) {

    x += dx;

    y += dy;

  }

  public void spiegleAmUrsprung() {

    x = -x;

    y = -y;

  }

}

Punkt(){};

Der Kompiler würde ihn automatisch hinzufügen. Da zwischen den geschweiften Klammern kein weiterer Text steht, kann man mit ihm zwar Objekte anlegen, diese haben aber noch keine Eigenschaften.¹⁾ Im Falle unseres Punktes macht das wenig Sinn. Wenn wir wollen, dass die Koordinaten des Punktes, der mit dem Standardkonstruktor erzeugt wird, immer 0 sind, der Standardkonstruktor also immer den Punkt P(0|0) erzeugt, so überschreiben wir den implizit vorhanden Konstruktor durch:

public Punkt() {
   x = 0;
   y = 0;
}

Große Flexibilität erreichen wir dadurch, dass Java erlaubt für eine Klasse mehrere Konstruktoren zu implementieren. Es kann Sinn machen, z.B. auch einen Punkte zu erzeugen, deren Koordinaten vor dem Erzeugen berechnet wurden. In diesem Fall wäre folgender Konstruktor sinnvoll:

public Punkt(int xNeu, int yNeu) {
  x = xNeu;
  y = yNeu;
}

Natürlich tragen beide Konstruktoren  den gleichen Bezeichner. Damit ein Kompiler die beiden Konstruktoren unterscheiden kann, müssen sie sich in der Signatur unterscheiden., die Parameterliste müssen also unterschiedlich viele Parameter haben oder, wenn die Anzahl der Parameter bei beiden gleich ist, müssen sie sich mindestens im Typ einer Variablen in der Poarameterliste unterscheiden.
 

import info1.*;

public class PunktDemo{

  public static void main(String[] args){

    int x,y;

    System.out.print("x-Wert: ");

    x = Console.in.readInt();

    System.out.print("y-Wert: ");

    y = Console.in.readInt();



    Punkt p1 = new Punkt();

    Punkt p2 = new Punkt(x,y);

    

    System.out.println("P1(" + p1.x +"/" + p1.y +")");

    System.out.println("P2(" + p2.x +"/" + p2.y +")");



    p1.verschiebe(2,5);

    p2.spiegleAmUrsprung();

    

    System.out.println("P1 ist um 2 in x- und 

                         5 in y-Richtung verschoben");

    System.out.println("P1(" + p1.x +"/" + p1.y +")");

    System.out.println("P2 ist am Ursprung gespiegelt");

    System.out.println("P2(" + p2.x +"/" + p2.y +")");

    

  }

}

x-Wert: 4

y-Wert: 4

P1(0/0)

P2(4/4)

P1 ist um 2 in x- und 5 in y-Richtung verschoben

P1(2/5)

P2 ist am Ursprung gespiegelt

P2(-4/-4)

Wie man auf die Koordinaten der Objekte zugreift, erkennt man in den Ausgaben. So liefert p1.x die x-Koordinate des Objektes p1  und p2.y die y-Koordinate des Objektes p2. Es handelt sich in beiden Fällen um einen direkten, lesenden Zugriff auf die Attribute der Objekte p1 und p2. Ein entsprechend direkter schreibende Zugriff sieht so aus:

p1.y = 4;

Damit hat man den y-Wert des Objektes p1 direkt geändert. Diese direkte Zugriffe auf Attribute eines Objektes versucht man in aller Regel zu vermeiden, ja zu verhindern. Direkte Zugriffe auf Objektattribute widersprechen nämlich dem Prinzip des 'Information hiding's.
 

¹⁾