Klasse: Unterschied zwischen den Versionen

Aus Byte-Welt Wiki
Zur Navigation springenZur Suche springen
K
K (Definition)
 
(16 dazwischenliegende Versionen von 2 Benutzern werden nicht angezeigt)
Zeile 1: Zeile 1:
Klassen sind der Bauplan für Objekte. Sie beschreiben die Eigenschaften und das Verhalten von Objekten und orientieren sich dabei an ihren Vorbildern aus der "realen" Welt.
+
Klassen sind der Bauplan für [[Objekt|Objekte]]. Sie beschreiben die Eigenschaften und das Verhalten von Objekten und orientieren sich dabei an ihren Vorbildern aus der "realen" Welt.
  
 
= Vom Chaos zur Klasse =
 
= Vom Chaos zur Klasse =
Zeile 6: Zeile 6:
 
== Ansatz: globale Variablen und Funktionen ==
 
== Ansatz: globale Variablen und Funktionen ==
 
Eine erste Idee kann so aussehen:
 
Eine erste Idee kann so aussehen:
<code=cpp>// Daten: hier als Beispiel ein Rechteck.
+
<syntaxhighlight lang="cpp">// Daten: hier als Beispiel ein Rechteck.
 
// w und h sind Breite und Höhe (width und height)
 
// w und h sind Breite und Höhe (width und height)
 
int w = 6;
 
int w = 6;
Zeile 15: Zeile 15:
 
int size( int x, int y ){
 
int size( int x, int y ){
 
   return x*y;
 
   return x*y;
}</code=cpp>
+
}</syntaxhighlight>
 
 
 
== Ansatz: Strukturen ==
 
== Ansatz: Strukturen ==
 
Dass im obigen Beispiel "w" und "h" ein Rechteck darstellen, ist nicht sehr intuitiv. Im Gegenteil, "w" und "h" könnten alles mögliche sein, und müssen keinen Zusammenhang haben.
 
Dass im obigen Beispiel "w" und "h" ein Rechteck darstellen, ist nicht sehr intuitiv. Im Gegenteil, "w" und "h" könnten alles mögliche sein, und müssen keinen Zusammenhang haben.
  
Möchte man ein zweites Rechteck haben, muss man zwei weitere Variablen einführen... mit dieser Sprache würde der Programmcode explosionsartig wachsen.
+
Möchte man ein zweites Rechteck haben, muss man zwei weitere [[Variable|Variablen]] einführen... mit dieser Sprache würde der Programmcode explosionsartig wachsen.
  
 
Da ist es nur naheliegend, die Variablen in einer Struktur zu kombinieren:
 
Da ist es nur naheliegend, die Variablen in einer Struktur zu kombinieren:
<code=cpp>// Zuerst ein Rechteck als zwei Ganzzahlen definieren.
+
<syntaxhighlight lang="cpp">// Zuerst ein Rechteck als zwei Ganzzahlen definieren.
 
struct Rectangle{
 
struct Rectangle{
 
   int w;
 
   int w;
Zeile 38: Zeile 37:
 
int size( Rectangle x ){
 
int size( Rectangle x ){
 
   return r.w * r.h;
 
   return r.w * r.h;
}</code=cpp>
+
}</syntaxhighlight>
  
 
== Ansatz: Variablen und Funktionen kombinieren ==
 
== Ansatz: Variablen und Funktionen kombinieren ==
Zeile 46: Zeile 45:
  
 
So ist die nächste Idee, den Code um die Daten zu bearbeiten, ebenfalls in die Struktur zu stecken. Das nennt man dann Klasse.
 
So ist die nächste Idee, den Code um die Daten zu bearbeiten, ebenfalls in die Struktur zu stecken. Das nennt man dann Klasse.
<code=cpp>// die Klasse "Rectangle"
+
<syntaxhighlight lang="cpp">// die Klasse "Rectangle"
 
class Rectangle{
 
class Rectangle{
 
   // die Daten dieser Klasse
 
   // die Daten dieser Klasse
Zeile 57: Zeile 56:
 
   }
 
   }
 
};
 
};
</code=cpp>
+
</syntaxhighlight>
  
 
= Definition =
 
= Definition =
Eine Klasse ist eine Struktur bestehend aus Attributen (auch "Daten", "Variablen" oder "Werte"), und Methoden (auch "Funktionen" oder "Operationen")
+
Eine Klasse ist eine Struktur bestehend aus Attributen (auch "Daten", "Variablen" oder "Werte"), und [[Methode|Methoden]] (auch "Funktionen" oder "Operationen")
  
 
Die Attribute definieren den Zustand einer [[Instanz]] einer Klasse "Das Attribut h (Höhe) des Rechteckes hat den Wert 8".
 
Die Attribute definieren den Zustand einer [[Instanz]] einer Klasse "Das Attribut h (Höhe) des Rechteckes hat den Wert 8".
  
Die Methoden definieren das Verhalten einer Klasse "Mit der Methode size kann man die Fläche ausrechnen lassen".
+
Die Methoden definieren das Verhalten einer Klasse "Mit der Methode size() kann man die Fläche ausrechnen lassen".
  
Klassen können von anderen Klassen [[Vererbung|erben]]. Sie erhalten sämtliche Eingenschaften einer anderen Klasse, können eigene Eigenschaften hinzufügen oder alte Eigenschaften abändern.
+
Klassen können von anderen Klassen [[Vererbung|erben]]. Sie erhalten sämtliche Eigenschaften einer anderen Klasse, können eigene Eigenschaften hinzufügen oder alte Eigenschaften abändern.
  
 
Zur [[Laufzeit]] werden [[Instanz|Instanzen]] (oder [[Objekt]]e einer Klasse erstellt).
 
Zur [[Laufzeit]] werden [[Instanz|Instanzen]] (oder [[Objekt]]e einer Klasse erstellt).
 
  
 
=Typen von Klassen=
 
=Typen von Klassen=
Zeile 76: Zeile 74:
 
==Normale Klasse==
 
==Normale Klasse==
 
...ist eine Klasse, die ein in sich abgeschlossenes Objekt repräsentiert. Der übliche Bauplan eines Objektes also.
 
...ist eine Klasse, die ein in sich abgeschlossenes Objekt repräsentiert. Der übliche Bauplan eines Objektes also.
<code=java>
+
<syntaxhighlight lang="java">
 
public class MyClass {
 
public class MyClass {
 
   private int i;
 
   private int i;
Zeile 86: Zeile 84:
 
   public void sum(int i) {
 
   public void sum(int i) {
 
       this.i += i;
 
       this.i += i;
 +
  }
 +
 +
  public int getSum() {
 +
      return this.i;
 
   }
 
   }
 
}   
 
}   
 
+
</syntaxhighlight>
...
+
Der [[Compiler]] erzeugt aus dieser Java-Datei eine Bytecode-Datei namens MyClass.class.
</code=java>
 
  
 
Daneben gibt's dann aber noch vier verschiedene Typen von...
 
Daneben gibt's dann aber noch vier verschiedene Typen von...
Zeile 100: Zeile 101:
 
===Elementklasse===
 
===Elementklasse===
 
Die Elementklasse ist als ein Element einer äußeren Klasse gekapselt.
 
Die Elementklasse ist als ein Element einer äußeren Klasse gekapselt.
<code=java>
+
<syntaxhighlight lang="java">
 
public class MyClass {
 
public class MyClass {
 
   private int i;
 
   private int i;
 
   private MyInnerClass mic;
 
   private MyInnerClass mic;
 
+
 
 
   public MyClass(int i) {
 
   public MyClass(int i) {
 
       this.i = i;
 
       this.i = i;
 
       mic = new MyInnerClass();
 
       mic = new MyInnerClass();
 +
      mic.doSomething();
 
   }
 
   }
 
+
 
 
   public void sum(int i) {
 
   public void sum(int i) {
 
       this.i += i;
 
       this.i += i;
      mic.doSomething();
 
 
   }
 
   }
 
+
 
 +
  public int getSum() {
 +
      return this.i;
 +
  }
 +
 
 
   class MyInnerClass {
 
   class MyInnerClass {
 
       void doSomething() {
 
       void doSomething() {
         System.out.println("MyInnerClass");
+
        sum(2);
 +
         System.out.println("MyInnerClass: "+getSum());
 
       }
 
       }
 
   }
 
   }
 
}   
 
}   
 +
</syntaxhighlight>
 +
Der Compiler erzeugt aus dieser Java-Datei zwei Bytecode-Dateien:
 +
*MyClass.class
 +
*MyClass$MyInnerClass.class
  
 +
===Lokale Klasse===
 +
Die lokale Klasse ist in einem Block, z.B. einer [[Methode]] gekapselt.
 +
<syntaxhighlight lang="java">
 +
public class MyClass {
 
...
 
...
</code=java>
 
  
===Lokale Klasse===
+
  public void somethingToDo {
Die lokale Klasse ist in einem Block, z.B. einer Methode gekapselt.
+
 
 +
      class MyInnerClass {
 +
        void doSomething() {
 +
            System.out.println("MyInnerClass");
 +
        }
 +
      }
 +
  }
 +
...
 +
}
 +
</syntaxhighlight>
  
 
===Anonyme Klasse===
 
===Anonyme Klasse===
Die anonyme Klasse ist eine lokale Klasse ohne referenzierten Namen.
+
Die anonyme Klasse ist eine lokale Klasse, die an keine definierte [[Referenz]] gebunden ist. Sie hat also keinen Namen.
<code=java>
+
<syntaxhighlight lang="java">
 
public class MyClass {
 
public class MyClass {
 
...
 
...
  
   new MyInnerClass() {
+
   public void somethingToDo {
      void doSomething() {
 
        System.out.println("MyInnerClass");
 
      }
 
  };
 
  
 +
      new MyInnerClass() {
 +
        void doSomething() {
 +
            System.out.println("MyInnerClass");
 +
        }
 +
      };
 +
  }
 
...
 
...
</code=java>
+
}
 +
</syntaxhighlight>
  
 
===Schnittstelle===
 
===Schnittstelle===

Aktuelle Version vom 8. April 2018, 17:23 Uhr

Klassen sind der Bauplan für Objekte. Sie beschreiben die Eigenschaften und das Verhalten von Objekten und orientieren sich dabei an ihren Vorbildern aus der "realen" Welt.

Vom Chaos zur Klasse

Zur Laufzeit besteht ein Programm aus zwei Hälften: zum einen gibt es Daten, zum anderen Code um die Daten zu bearbeiten. Diese beiden Hälften müssen irgendwie in einer Programmiersprache abgebildet werden, damit ein Programmierer ein Programm schreiben kann.

Ansatz: globale Variablen und Funktionen

Eine erste Idee kann so aussehen:

// Daten: hier als Beispiel ein Rechteck.
// w und h sind Breite und Höhe (width und height)
int w = 6;
int h = 8;

// Funktion: um zwei Ganzzahlen zu bearbeiten (hier 
// wird die Fläche eines Rechteckes mit Grösse x/y berechnet)
int size( int x, int y ){
  return x*y;
}

Ansatz: Strukturen

Dass im obigen Beispiel "w" und "h" ein Rechteck darstellen, ist nicht sehr intuitiv. Im Gegenteil, "w" und "h" könnten alles mögliche sein, und müssen keinen Zusammenhang haben.

Möchte man ein zweites Rechteck haben, muss man zwei weitere Variablen einführen... mit dieser Sprache würde der Programmcode explosionsartig wachsen.

Da ist es nur naheliegend, die Variablen in einer Struktur zu kombinieren:

// Zuerst ein Rechteck als zwei Ganzzahlen definieren.
struct Rectangle{
  int w;
  int h;
};

// Daten: man erstellt sich ein Rechteck "r", und setzt
// die Breite "w" auf 6, die Höhe "h" auf 8.
Rectangle r;
r.w = 6;
r.h = 8;

// Funktion: nun wird schon klarer, was "size" benötgt
int size( Rectangle x ){
  return r.w * r.h;
}

Ansatz: Variablen und Funktionen kombinieren

Mit der zweiten Idee kommt man schon weiter. Für ein zweites Rechteck benötigt man nur eine zusätzliche Variable. Kann man auch "structs" in "structs" haben, hat man schon genug um komplizierte Datenstrukturen aufzubauen.

Allerdings sind die Daten (das Rechteck) und der bearbeitende Code (die Funktion "size") noch immer getrennt. Hat man ein grösseres Programm mit hunderten von Funktionen und Strukturen, wird es ganz schön schwierig, die richtige Funktion für eine Struktur zu finden.

So ist die nächste Idee, den Code um die Daten zu bearbeiten, ebenfalls in die Struktur zu stecken. Das nennt man dann Klasse.

// die Klasse "Rectangle"
class Rectangle{
  // die Daten dieser Klasse
  int w;
  int h;

  // Der Code um mit den Daten dieser Klasse zu arbeiten
  int size(){
    return w * h;
  }
};

Definition

Eine Klasse ist eine Struktur bestehend aus Attributen (auch "Daten", "Variablen" oder "Werte"), und Methoden (auch "Funktionen" oder "Operationen")

Die Attribute definieren den Zustand einer Instanz einer Klasse "Das Attribut h (Höhe) des Rechteckes hat den Wert 8".

Die Methoden definieren das Verhalten einer Klasse "Mit der Methode size() kann man die Fläche ausrechnen lassen".

Klassen können von anderen Klassen erben. Sie erhalten sämtliche Eigenschaften einer anderen Klasse, können eigene Eigenschaften hinzufügen oder alte Eigenschaften abändern.

Zur Laufzeit werden Instanzen (oder Objekte einer Klasse erstellt).

Typen von Klassen

In Java sind verschiedene Arten von Klassen bekannt.

Normale Klasse

...ist eine Klasse, die ein in sich abgeschlossenes Objekt repräsentiert. Der übliche Bauplan eines Objektes also.

public class MyClass {
   private int i;

   public MyClass(int i) {
      this.i = i;
   }

   public void sum(int i) {
      this.i += i;
   }

   public int getSum() {
      return this.i;
   }
}

Der Compiler erzeugt aus dieser Java-Datei eine Bytecode-Datei namens MyClass.class.

Daneben gibt's dann aber noch vier verschiedene Typen von...

Geschachtelte (innere) Klassen

In Java lassen sich Klassen in Klassen schachteln. Alle Typen dieser Form von Klassen haben also eine Gemeinsamkeit: sie sind innerhalb einer umschließenden Klasse definiert.

Elementklasse

Die Elementklasse ist als ein Element einer äußeren Klasse gekapselt.

public class MyClass {
   private int i;
   private MyInnerClass mic;
   
   public MyClass(int i) {
      this.i = i;
      mic = new MyInnerClass();
      mic.doSomething();
   }
   
   public void sum(int i) {
      this.i += i;
   }
   
   public int getSum() {
      return this.i;
   }
   
   class MyInnerClass {
      void doSomething() {
         sum(2);
         System.out.println("MyInnerClass: "+getSum());
      }
   }
}

Der Compiler erzeugt aus dieser Java-Datei zwei Bytecode-Dateien:

  • MyClass.class
  • MyClass$MyInnerClass.class

Lokale Klasse

Die lokale Klasse ist in einem Block, z.B. einer Methode gekapselt.

public class MyClass {
...

   public void somethingToDo {

      class MyInnerClass {
         void doSomething() {
            System.out.println("MyInnerClass");
         }
      }
   }
...
}

Anonyme Klasse

Die anonyme Klasse ist eine lokale Klasse, die an keine definierte Referenz gebunden ist. Sie hat also keinen Namen.

public class MyClass {
...

   public void somethingToDo {

      new MyInnerClass() {
         void doSomething() {
            System.out.println("MyInnerClass");
         }
      };
   }
...
}

Schnittstelle

Die Schnittstelle, oder auch static geschachtelte Klasse, verhält sich wie Klassenmethoden bzw. Klassenvariablen