In Java ist eine Klasse ein grundlegender Baustein der objektorientierten Programmierung (OOP). Eine Klasse dient als Vorlage oder Bauplan zur Erzeugung von Objekten, die bestimmte Eigenschaften (Attribute) und Verhaltensweisen (Methoden) haben. Objekte sind Instanzen von Klassen und repräsentieren individuelle Entitäten in einem Programm.
Die Syntax zur Definition einer Klasse in Java ist wie folgt:
public class MeineKlasse {
// Attribute (Variablen) der Klasse
// Methoden (Funktionen) der Klasse
}
Hier ist eine Erklärung der verschiedenen Elemente einer Klasse:
Hier ist ein einfaches Beispiel für eine Klasse in Java:
public class Auto {
// Felder (Instanzvariablen)
private String marke;
private int baujahr;
// Getter und Setter
public String getMarke() {
return marke;
}
public void setMarke(String marke) {
this.marke = marke;
}
public int getBaujahr() {
return baujahr;
}
public void setBaujahr(int baujahr) {
this.baujahr = baujahr;
}
// Methoden
public void beschleunigen() {
System.out.println("Das Auto beschleunigt!");
}
public void bremsen() {
System.out.println("Das Auto bremst!");
}
}
In diesem Beispiel haben wir keinen expliziten Konstruktor definiert. Daher wird automatisch der Standardkonstruktor bereitgestellt. Du kannst die Klasse wie folgt verwenden, um Objekte zu erstellen und auf ihre Methoden und Felder zuzugreifen: Um ein Objekt dieser Klasse zu erstellen und darauf zuzugreifen, können Sie folgenden Code verwenden:
public class Main {
public static void main(String[] args) {
Auto meinAuto = new Auto();
meinAuto.setMarke("Volkswagen");
meinAuto.setBaujahr(2022);
System.out.println("Marke: " + meinAuto.getMarke());
System.out.println("Baujahr: " + meinAuto.getBaujahr());
meinAuto.beschleunigen(); // Gibt aus: "Das Auto beschleunigt!"
meinAuto.bremsen(); // Gibt aus: "Das Auto bremst!"
}
}
Da wir keinen Konstruktor definiert haben, können wir ein Objekt der Klasse "Auto" einfach mit dem new-Operator erstellen und anschließend auf die Methoden und Felder zugreifen. Beachte, dass die Felder in diesem Fall ihre Standardwerte haben, da wir sie nicht im Konstruktor initialisiert haben.
Für die Benennung von Klassen, Schnittstellen das sogenannte "CamelCase" verwendet. Bei CamelCase werden mehrere Wörter zusammengeschrieben, wobei jedes Wort außer dem ersten mit einem Großbuchstaben beginnt. Es werden keine Leerzeichen oder Unterstriche verwendet. Hier sind einige Beispiele für die Verwendung von CamelCase in Java:
public class MeinAuto {
// Klasseninhalt
}
//Methoden
public void meinMethode() {
// Methode ausführen
}
//Variablen
int meinZahl;
String meinName;
Beachte, dass in Java die Klassennamen üblicherweise mit einem Großbuchstaben beginnen, während Methoden, Variablen und Package-Namen in der Regel mit einem Kleinbuchstaben beginnen.
Je nachdem, welche Art von Daten die Attribute beschreiben, werden unterschiedliche Datentypen verwendet. Ein einfacher Datentyp zur Darstellung von numerischen Werten wie beispielsweise für die Breite und die Länge eines Rechtecks ist der Datentyp int.
Durch Attribute legen Sie die Eigenschaften von Objekten einer Klasse fest. Neben diesen Attributen können auch Methoden zu einer Klasse gehören. Mithilfe von Methoden drücken Sie die Funktionalität der Objekte einer Klasse aus.
In Java können Methoden Parameter akzeptieren, um Daten an die Methode zu übergeben und sie zu verarbeiten. Parameter sind Werte, die von der aufrufenden Stelle an die Methode übergeben werden, damit sie auf diesen Werten arbeiten kann. Parameter werden in den Methodendeklarationen innerhalb der runden Klammern angegeben. Hier ist ein Beispiel für eine Methode in Java mit Parametern:
public class Beispiel {
// Methode mit zwei Parametern
public void addiere(int zahl1, int zahl2) {
int ergebnis = zahl1 + zahl2;
System.out.println("Die Summe von " + zahl1 + " und " + zahl2 + " ist: " + ergebnis);
}
// Methode mit einem Parameter und Rückgabetyp
public int multipliziere(int zahl1, int zahl2) {
int ergebnis = zahl1 * zahl2;
return ergebnis;
}
public static void main(String[] args) {
Beispiel beispiel = new Beispiel();
// Aufruf der Methode addiere mit zwei Argumenten
beispiel.addiere(5, 10); // Gibt aus: "Die Summe von 5 und 10 ist: 15"
// Aufruf der Methode multipliziere mit zwei Argumenten und Ausgabe des Rückgabewerts
int produkt = beispiel.multipliziere(3, 4);
System.out.println("Das Produkt von 3 und 4 ist: " + produkt); // Gibt aus: "Das Produkt von 3 und 4 ist: 12"
}
}
In diesem Beispiel haben wir eine Klasse, die zwei Methoden enthält. Die Methode addiere akzeptiert zwei Parameter (zahl1 und zahl2) und gibt die Summe der beiden Zahlen auf der Konsole aus. Die Methode multipliziere akzeptiert ebenfalls zwei Parameter (zahl1 und zahl2), multipliziert sie und gibt das Ergebnis zurück. Der Rückgabetyp ist in diesem Fall int. Im main-Methode haben wir eine Instanz der Klasse Beispiel erstellt und die beiden Methoden mit verschiedenen Argumenten aufgerufen, um sie zu demonstrieren.
Methoden können einen Rückgabewert haben. Ein Rückgabewert ist der Wert, den die Methode an die aufrufende Stelle zurückgibt, nachdem sie ihre Verarbeitung abgeschlossen hat. Der Rückgabetyp wird in der Methodendeklaration angegeben, und die Methode verwendet das return-Schlüsselwort, um den Wert zurückzugeben. Hier ist ein Beispiel für Methoden mit Rückgabewert in Java:
public class Beispiel {
// Methode mit Rückgabewert (int)
public int multipliziere(int zahl1, int zahl2) {
int ergebnis = zahl1 * zahl2;
return ergebnis;
}
// Methode mit Rückgabewert (String)
public String begruesse(String name) {
return "Hallo, " + name + "!";
}
public static void main(String[] args) {
Beispiel beispiel = new Beispiel();
// Aufruf der Methode multipliziere und Ausgabe des Rückgabewerts
int produkt = beispiel.multipliziere(3, 4);
System.out.println("Das Produkt von 3 und 4 ist: " + produkt); // Gibt aus: "Das Produkt von 3 und 4 ist: 12"
// Aufruf der Methode begruesse und Ausgabe des Rückgabewerts
String begruessung = beispiel.begruesse("Max");
System.out.println(begruessung); // Gibt aus: "Hallo, Max!"
}
}
In diesem Beispiel haben wir eine Klasse, die zwei Methoden mit Rückgabewerten enthält. Die Methode multipliziere akzeptiert zwei Parameter (zahl1 und zahl2), multipliziert sie und gibt das Ergebnis als int-Wert zurück. Die Methode begruesse akzeptiert einen Parameter name (einen String) und gibt einen Grußtext zurück, der den Namen enthält. Im main-Methode haben wir eine Instanz der Klasse Beispiel erstellt und die beiden Methoden aufgerufen, um ihre Rückgabewerte zu erhalten und sie auszugeben. Beachte, dass die Rückgabewerte von den aufrufenden Stellen verwendet werden können, um weitere Berechnungen durchzuführen oder sie auf andere Weise zu nutzen.
In Java ist es möglich, Methoden mit demselben Namen zu definieren, aber mit unterschiedlichen Parametern oder Parametertypen. Dies wird als Methodenüberladung bezeichnet. Wenn mehrere Methoden denselben Namen haben, aber unterschiedliche Parameterlisten haben, kann Java sie anhand der Parameter automatisch unterscheiden und die richtige Methode basierend auf den übergebenen Argumenten aufrufen. Hier ist ein Beispiel für Methodenüberladung in Java:
public class Beispiel {
// Methode mit zwei int-Parametern
public int addiere(int zahl1, int zahl2) {
return zahl1 + zahl2;
}
// Methode mit drei int-Parametern
public int addiere(int zahl1, int zahl2, int zahl3) {
return zahl1 + zahl2 + zahl3;
}
// Methode mit zwei double-Parametern
public double addiere(double zahl1, double zahl2) {
return zahl1 + zahl2;
}
// Methode mit einem String-Parameter
public String gruessen(String name) {
return "Hallo, " + name + "!";
}
public static void main(String[] args) {
Beispiel beispiel = new Beispiel();
int summe1 = beispiel.addiere(5, 10);
System.out.println("Summe (int): " + summe1); // Gibt aus: "Summe (int): 15"
int summe2 = beispiel.addiere(3, 6, 9);
System.out.println("Summe (int): " + summe2); // Gibt aus: "Summe (int): 18"
double summe3 = beispiel.addiere(2.5, 3.7);
System.out.println("Summe (double): " + summe3); // Gibt aus: "Summe (double): 6.2"
String gruss = beispiel.gruessen("Max");
System.out.println(gruss); // Gibt aus: "Hallo, Max!"
}
}
In diesem Beispiel haben wir die Klasse Beispiel erstellt, die vier Methoden enthält, die denselben Namen (addiere und gruessen) haben, aber unterschiedliche Parameter haben. Die Methode addiere ist in der Lage, entweder zwei int-Werte, drei int-Werte oder zwei double-Werte zu akzeptieren. Die Methode gruessen akzeptiert einen String-Parameter. Im main-Methode haben wir verschiedene Varianten der addiere-Methode und die gruessen-Methode aufgerufen, und Java wählt automatisch die passende Methode basierend auf den übergebenen Argumenten aus. Die Methodenüberladung ermöglicht es uns, gleiche oder ähnliche Operationen mit verschiedenen Datentypen oder Anzahlen von Parametern durchzuführen, ohne dass wir verschiedene Methodennamen verwenden müssen.
Statische Variablen und Methoden in Java sind solche, die nicht an eine spezifische Instanz (Objekt) einer Klasse gebunden sind, sondern an die Klasse selbst. Das bedeutet, dass sie auf Klassenebene existieren und nicht für jedes Objekt der Klasse neu erstellt werden. Du kannst auf statische Variablen und Methoden direkt über den Klassennamen zugreifen, ohne ein Objekt der Klasse erstellen zu müssen. Hier ist ein Beispiel für statische Variablen und Methoden in Java:
public class Beispiel {
// Statische Variable
public static int statischeVariable = 10;
// Statische Methode
public static void statischeMethode() {
System.out.println("Dies ist eine statische Methode.");
}
public static void main(String[] args) {
// Zugriff auf die statische Variable
System.out.println("Statische Variable: " + Beispiel.statischeVariable); //"Statische Variable: 10"
// Aufruf der statischen Methode
Beispiel.statischeMethode(); // Gibt aus: "Dies ist eine statische Methode."
// Du kannst auch direkt auf die statischen Elemente zugreifen, ohne ein Objekt zu erstellen
System.out.println("Statische Variable: " + statischeVariable); // Gibt denselben Wert wie oben aus
statischeMethode(); // Gibt denselben Text wie oben aus
}
}
In diesem Beispiel haben wir die Klasse Beispiel erstellt und eine statische Variable statischeVariable sowie eine statische Methode statischeMethode definiert.
Du kannst auf die statische Variable zugreifen, indem du den Klassennamen gefolgt von einem Punkt (.) verwendest, gefolgt von dem Namen der statischen Variable (Beispiel.statischeVariable). Ebenso rufst du die statische Methode auf, indem du den Klassennamen gefolgt von einem Punkt (.) und dem Methodennamen (Beispiel.statischeMethode()) verwendest.
Statische Variablen werden oft verwendet, um gemeinsame Daten zu speichern, die für alle Instanzen einer Klasse gleich sind, und statische Methoden werden oft als Hilfsfunktionen verwendet, die auf Klassenebene arbeiten und keine spezifischen Instanzdaten benötigen. Beachte, dass statische Variablen und Methoden auch ohne die Erstellung einer Objektinstanz zugänglich sind.
1-Erstellung einer einfachen Java-Klasse mit Methoden zur Berechnung von Oberfläche und Volumen eines Quaders
1. Rectangle Werte: L=3.0 H=5.0 Fläche: 15.0 Umfang: 16.0 2. Rectangle Werte: L=4.0 H=6.0 Fläche: 24.0 Umfang: 20.0 3. Rectangle Werte: L=5.0 H=7.0 Fläche: 35.0 Umfang: 24.0
2) Erstellen Sie eine Klasse namens Rechner, die verschiedene Methoden zur Berechnung von Summen,
Produkten und Differenzen überlädt. Diese Klasse soll Methoden mit unterschiedlichen Parametertypen
und -anzahlen enthalten. Implementieren Sie die Methoden so, dass sie die richtige Methode basierend
auf den übergebenen Parametern aufrufen.
a) Erstellen Sie die Klasse Rechner mit folgenden überladenen Methoden:
* addiere(int a, int b): Berechnet die Summe von zwei ganzen Zahlen.
* addiere(double a, double b): Berechnet die Summe von zwei Gleitkommazahlen.
* addiere(int a, int b, int c): Berechnet die Summe von drei ganzen Zahlen.
* multipliziere(int a, int b): Berechnet das Produkt von zwei ganzen Zahlen.
* multipliziere(double a, double b): Berechnet das Produkt von zwei Gleitkommazahlen.
* multipliziere(int a, int b, int c): Berechnet das Produkt von drei ganzen Zahlen.
* subtrahiere(int a, int b): Berechnet die Differenz von zwei ganzen Zahlen.
* subtrahiere(double a, double b): Berechnet die Differenz von zwei Gleitkommazahlen.
b) Erstellen Sie in der main-Methode der Klasse Rechner verschiedene Instanzen der Klasse und
rufen Sie die überladenen Methoden auf. Geben Sie die Ergebnisse jeder Berechnung auf der Konsole aus.