Methoden in JAVA: Unterschied zwischen den Versionen

Am Ende des Kapitels solltest du

• die verschiedenen Arten von Methoden, die wir innerhalb einer Klasse verwenden, unterscheiden können,
• wissen, wie eine Methode mit Rückgabewert aufgebaut ist und funktioniert,
• Getter- und Setter-Methoden erstellen können und ihre Funktion verstehen.

Aufgabe 1

Erstelle eine Klasse Kreis, die drei verschiedene Konstruktoren enthält und zwei Methoden mit denen die Größe und die Position des Kreises verändert und der aktuelle Wert ausgegeben werden kann.

public class Kreis{
int xPos;
int yPos;
int radius;
 
public Kreis(){
    xPos=100;
    yPos=100;
    radius=30;
}
 
public Kreis(int xPos, int yPos){
    radius=30;
    this.xPos=xPos;
    this.yPos=yPos;
}
 
public Kreis(int xPos, int yPos, int radius){
    this.radius=radius;
    this.xPos=xPos;
    this.yPos=yPos;
}
 
 
public void groesseAendern(int radiusNeu){
    radius=radiusNeu;
    System.out.println("Neuer Radius: "+radius);
}
 
public void positionAendern(int xPosNeu, int yPosNeu){
    xPos=xPosNeu;
    yPos=yPosNeu;
    System.out.println("Neue Position: ("+xPos+","+yPos);
}
 
}

Aufgabe 2

Erstelle eine Klasse Schueler, mit der Schueler-Objekte erzeugt werden können, die als Attribute Name, Vorname und Klasse enthalten. Daneben soll eine Methode ausgeben() erstellt werde, die die Daten auf der Konsole ausgibt. Diese Methode kann direkt aus dem Konstruktor heraus aufgerufen werden.

public class Schueler
{
//Attribute
private String name;
private String vorname;
private String klasse;
 
//Konstruktor
public Schueler(String name, String vorname, String klasse){
this.name=name;
this.vorname=vorname;
this.klasse=klasse;
 
ausgeben();
}   
 
//Methode
private void ausgeben(){
System.out.println(name);
System.out.println(vorname);
System.out.println(klasse);
System.out.println();
}
}

Aufgabe 3

Erstelle eine Klasse Auto mit der Auto-Objekte erzeugt werden können. Die Klasse soll die Attribute Kennzeichen, Typ, Kilometerstand und Tankinhalt enthalten. Neben dem Konstruktor, der einen Neuwagen erzeugen soll, besitzt die Klasse noch zwei Methoden tanken() und fahren(). Die Methode fahren() aktualisiert dabei Kilometerstand und Tankinhalt, wobei von einem mittleren Verbrauch von 7l/100km ausgegangen wird. Es soll dabei auch sichergestellt werden, dass nicht mit leerem Tank gefahren wird. Hinweis: Die verbrauchte Benzinmenge errechnet sich aus (Strecke * Verbrauch in l)/100.

public class Auto{
//Attribute
    private String kennzeichen;
    private String typ;
    private double kilometerstand;
    private double tankinhalt;
 
//Konstruktor
public Auto(String kennzeichen, String typ){
this.kennzeichen = kennzeichen;
this.typ = typ;
 
kilometerstand = 0.0;
tankinhalt = 0.0;
}
 
public void tanken(double tankmenge){
tankinhalt = tankinhalt + tankmenge;
}
 
public void fahren(double strecke){
if(tankinhalt<=0){System.out.println("Ohne Benzin fahre ich keinen Meter!");}else{
kilometerstand = kilometerstand + strecke;
tankinhalt = tankinhalt - strecke*7/100;}
}
}

Aufgabe 4

Zu erstellen ist eine Methode quadratwurzelBerechnen, die die Quadratwurzel einer Zahl näherungsweise berechnet.Dabei sollen die gesuchte Zahl und die Genauigkeit, mit der die Wurzel berechnet werden soll (z.B. 0.00000001), als Parameter eingegeben werden.
Als Grundlage der Berechnung soll das Prinzip der Intervallschachtelung benutzt werden: Die Intervallschachtelung startet mit einem Intervall, welches so groß gewählt werden muss, dass sich das Ergebnis in diesem Intervall befindet. (Für Zahlen größer 1 bieten sich 1 als Untergrenze und die Zahl selbst als Obergrenze an.) Dann teilt man dieses Intervall in der Mitte in zwei Teilintervalle und überlegt sich, in welchem der beiden Teilintervalle das Ergebnis liegen muss. Dann fährt man mit diesem Teilintervall fort und teilt es erneut. Dies wiederholt man nun solange, bis die Obergrenze und die Untergrenze des Intervalls nahe genug beieinander liegen (d.h. die gewünschte Genauigkeit des Ergebnisses erreicht ist). Die Mitte dieses letzten Intervalls gibt man dann als Ergebnis aus.

Um auch die Wurzel von Zahlen < 1 berechnen zu können wählt man 0 als Untergrenze und 1 als Obergrenze. Die Methode muss für diesen Sonderfall erweitert werden.

Es bietet sich nun noch an, das Ergebnis mit der Berechnung über die entsprechende Methode aus dem Package java.lang.Math zu vergleichen.

public void quadratwurzelBerechnen(double zahl, double genauigkeit){
 
// Das Ausgangsintervall
double untergrenze = 1.0;
double obergrenze = zahl;
double mitte;
 
//Sonderfall zahl<1
if(zahl < 1.0) {
untergrenze = 0.0;
obergrenze = 1.0;
}
 
// Intervallschachtelung
while ((obergrenze - untergrenze) > genauigkeit) {
 
// Ermittlung der Mitte des Intervalls
mitte = (obergrenze + untergrenze) / 2.0;
 
// Testen, in welcher Hälfte die Wurzel liegt
if (zahl < mitte * mitte) {
obergrenze = mitte;
}
else {
untergrenze = mitte;
}
} 
 
System.out.println("Intervallschachtelung: Die Quadratwurzel von "+zahl+" ist : " + mitte);
System.out.println("Kontrolle: "+Math.sqrt(zahl));
}

Aufgabe 5

Für viele Zwecke in der Mathematik oder der Kryptographie ist es notwendig Zahlen in ihre Primfaktoren zu zerlegen. Dazu bietet sich folgendes Verfahren an: In einer Zählschleife wird wiederholt von 2 (kleinster Primfaktor) bis n (Zahl) gezählt, wobei bei jedem Durchlauf überprüft wird, ob die Zählvariable ganzzahliger Teiler der Zahl ist (Modulofunktion: %). Ist dies der Fall, ist ein neuer Primfaktor gefunden und wird als Teil des Produkts der Primzahlen auf der Konsole ausgegeben. Die ganze Schleife wird daraufhin "zurückgesetzt", indem n durch n/Primfaktor ersetzt wird und der Zähler erneut bei 2 beginnt. (Die Zählvariable muss dabei auf 1 (!) gesetzt werden, da am Ende der Schleife diese ja um 1 erhöht wird.). Hinweis: Um eine formal saubere Ausgabe zu erhalten, muss der Faktor 1 als Teil des Produkts verwendet werden.
Erstelle eine Methode primfaktorZerlegung, die nach Übergabe einer Zahl die Zerlegung in ihre Primfaktoren anzeigt.

public void primfaktorZerlegung(long zahl){
 
//Primfaktor 1 ausgeben
System.out.print("1");
 
for (long j = 2; j <= zahl; j++ ) {
            // Ist j Primfaktor?
            if (zahl % j == 0) {
 
                // Primfaktor ausgeben
                System.out.print("*"+j);
 
                // Wert für zahl ändern (Neuer Ausgangswert)
                zahl = zahl/j;
 
                // j erneut auf Startwert 2 (1++ !) setzen
                j = 1;
            }
        }
}

Aufgabe 6

Die Collatz-Vermutung (auch bekannt als 3n+1-Vermutung) ist eine mathematisches Problem, für das bis heute kein Beweis gefunden werden konnte. Es handelt sich um eine Zahlenreihe, für die folgende Bildungsregel gilt:

Ist die aktuelle Zahl gerade, wird sie durch 2 geteilt, ist sie ungerade, wird sie mit 3 multipliziert und anschließend 1 hinzugezählt.

Die Vermutung lautet, dass bei jeder beliebigen Zahl, diese Reihe schließlich bei 1 endet bzw. in der Wiederholung der Folge 1 - 4 - 2 - 1. Es wurde bisher kein Gegenbeispiel gefunden, aber mathematisch bewiesen werden konnte die Vermutung noch nicht. Erstelle nun eine Methode collatz(int n), die für eine Zahl n ausgibt, in wievielen Schritten die Reihe bei 1 endet.

Erweiterung: Es soll ermittelt werden, bei welcher Zahl innerhalb eines Bereichs von 0 bis n diese Reihe am längsten ist.

public class Collatz{
 
public void collatz(int m){
//Übertrag auf Variable n um den Anfangswert zu bewahren
int n=m;
//counter speichert die Anzahl der Schritte ab
int counter=0;
//die while-Schleife läuft solange bis der Endwert 1 erreicht ist
while(n!=1){if(n%2==0){n=n/2;counter++;}else{n=3*n+1;counter++;}};
{System.out.println("Die Reihe mit der Anfangszahl "+m+" endet nach "+counter+" Schritten bei 1.");}
}
 
//Die Erweiterung erfordert einen rekursiven Aufruf der Methode collatz(), 
//so dass diese zuerst als Methode mit Rückgabewert erstellt werden muss
public int collatz2(int m){
int n=m;
int counter=0;
while(n!=1){if(n%2==0){n=n/2;counter++;}else{n=3*n+1;counter++;}};
return counter;
}
 
public void collatzMax(int m){
int n=m;
//saveM speichert den jeweils aktuellen Wert der Zahl mit der höchsten Schrittzahl ab
int saveM=n;
int counter=0;
//max speichert die höchste Anzahl von Schritten ab
int max=0;
 
for(int i=2; i<=m;i++){
counter=collatz2(i);
if(counter>max){max=counter;saveM=i;};
}
System.out.println("Die Anfangszahl "+saveM+" ergibt die längste Reihe mit "+max+" Schritten.");
}
}

Vorlesungausschnitt, in dem die Collatz-Vermutung zur Einführung in JAVA benutzt wird:

Aufgabe 7

Für diese Aufgabe sind vier Methoden zu erstellen. Eine Methode winkelfunktionen(double x), die für einen beliebigen Eingabewert (x>=0) die drei Winkelfunktionen sin, cos und tan ausgibt. Für die Ermittlung der drei Winkelfunktionen soll jeweils eine eigene Methode mit Rückgabewert erstellt werden, die auf die entsprechende Funktion aus java.lang.Math zurückgreift. Beachte, dass tan x nicht definiert ist, wenn cos x=0 !
Der eingegebene Wert in Grad muss mittels der Methode Math.toRadians(double x) in das Bogenmaß umgerechnet werden.
Um Berechnungsungenauigkeiten aufzufangen, soll folgende Methode eingesetzt werden, um die Ergebnisse auf 8 Stellen zu runden:

private double runden(double wert, int stellen) {
        return  Math.round(wert * Math.pow(10, stellen)) / Math.pow(10, stellen);
    }

Natürlich lässt sich das Problem einfacher lösen, indem man die entsprechenden Funktionen gleich in der Methode winkelfunktionen (double x) aufruft. Es soll jedoch hier das Prinzip der Dekomposition näher erläutert werden. Der Begriff beschreibt einen Prozess in der Programmierung, bei dem ein komplexes Problem oder System in kleinere Einheiten zerlegt wird, die leichter zu erfassen, zu verstehen, zu programmieren und damit auch zu modifizieren sind. Zudem erhöht sich dadurch die Möglichkeit der Wiederverwendbarkeit von Programmteilen.

Vergegenwärtige dir nach Abschluss der Aufgabe das Zusammenspiel der verschiedenen Methoden.

public void winkelfunktionen (double x){
//Umrechnung des Winkels von Grad in rad; Hilfsvariable y um Ursprungswert von x zu "konservieren"
double y=Math.toRadians(x);
System.out.println("Der Sinus von "+x+" Grad = "+sinus(y));
System.out.println("Der Cosinus von "+x+" Grad = "+cosinus(y));
if(cosinus(y)==0){System.out.println("Der Tangens von "+x+" Grad ist nicht definiert!");}else
{System.out.println("Der Tangens von "+x+" Grad = "+tangens(y));}
}
 
//Eigentliche Berechnung der Winkelfunktionen auf 8 Stellen Genauigkeit durch Aufruf der Methode zum Runden
private double sinus(double x){
        return runden(Math.sin(x),8);}
 
private double cosinus(double x){
        return runden(Math.cos(x),8);}
 
private double tangens(double x){
        return runden(Math.tan(x),8);}
 
 
private double runden(double wert, int stellen) {
        return  Math.round(wert * Math.pow(10, stellen)) / Math.pow(10, stellen);
    }

Aufgabe 8

In einer Klasse Kreistabelle sollen drei Methoden erstellt werden: Die Methode kreistabelleAnzeigen() gibt für Radien von 5 bis 100 in 5er-Schritten den jeweilgen Umfang und Flächeninhalt aus. Die Berechnung von Umfang und Flächeninhalt wird in zwei weitere Methoden ausgelagert.

public class Kreistabelle{
 
public void kreistabelleAnzeigen(){
//Ausdruck der Kopfzeile
System.out.println("Radius    Umfang                 Flaeche");
 
//Veränderung des Radius in 5er-Schritten. Zählvariable i ist gleichzeitig der Radius
for(int i=5;i<=100;i=i+5){
System.out.println(i+"         "+umfang(i)+"        "+flaeche(i));
}
 
}
 
//Methode mit Rückgabewert zur Berechnung des Umfangs
private double umfang(double radius){
return 2*radius*Math.PI;
}
 
//Methode mit Rückgabewert zur Berechnung der Fläche
private double flaeche(double radius){
return Math.pow(radius,2)*Math.PI;
}
 
}

Aufgabe 9

Ergänze die Klasse Auto aus Aufgabe 3 um eine Methode getTankinhalt(), die den aktuellen Tankinhalt zurückgibt und sicherstellt, dass nicht mit leerem Tank gefahren wird, bzw. bei einem Tankinhalt von weniger als 10 Litern zum Tanken auffordert.

public double getTankinhalt(){
if (tankinhalt<=0){System.out.println("Ohne Benzin läuft ein Auto nicht !!");}
else if (tankinhalt<10){System.out.println("Höchste Zeit um an die Tanke zu fahren !!"); return tankinhalt;}
return tankinhalt;
}

Aufgabe 10

Erstelle eine Klasse Rechteck mit den Attributen laenge und breite. Neben dem entsprechenden Konstruktor enthält die Klasse Getter- und Setter-Methoden für die beiden Werte. In den Setter-Methoden soll zusätzlich sichergestellt werden, dass die Kantenlänge des Rechtecks den Wert 100 nicht überschreitet. Für den Fall einer Überschreitung wir der Hinweis auf einen unzulässigen Wert ausgegeben. Zusätzlich soll zum Testen eine Methode zur Ausgabe der Werte für laenge und breite angelegt werden.

public class Rechteck {
 
private int laenge;
private int breite;
 
public Rechteck(int laenge, int breite){
this.laenge=laenge;
this.breite=breite;
}
 
public int getLaenge(){
   return laenge;
}
 
public int getBreite(){
   return breite;
}
 
public void setLaenge(int l){
if(l>=100){System.out.println("Unzulaessiger Wert !");}else{
   laenge=l;}
}
 
public void setBreite(int b){
if(b>=100){System.out.println("Unzulaessiger Wert !");}else{
   breite=b;
}
}
 
public void ausgeben(){
System.out.println("Laenge: "+getLaenge());
System.out.println("Breite: "+getBreite());
}
}