Skip to Content

7.5 Lösungen

7.5.1 Telefonbuchanwendung (1)

package block7;
/**
*
* @author stsch
*/
public class Telefonbuch1 {
private String[] vorname;
private String[] nachname;
private String[] telefonnummer;
/**
* Anlegen eines Telefonbuchs für 4 EInträge
*/
public Telefonbuch1 () {
// Telefonbuch mit initial 4 Einträgen
vorname = new String[4];
nachname = new String[4];
telefonnummer = new String[4];
}
/**
* Einfügen einer neuen Telefonnummer mit automatischem
* Vergrössern um 50% des Telefonbuchs
* @param vn Vorname
* @param nn Nachname
* @param nr Telefonnummer
*/
public void einfuegen(String vn, String nn, String nr) {
//Leere Einträge haben keine Telefonummer!
int pos=0; //Suchposition
while ((pos<telefonnummer.length)
&& !(telefonnummer[pos]==null)
) pos++;
if (pos>=telefonnummer.length) // kein freier Eintrag!
{ // Feld um 50% vergroessern und alles umkopieren
String[] tempFeld;
tempFeld = new String[vorname.length*3/2];
System.arraycopy(vorname,0,tempFeld,0,vorname.length);
vorname = tempFeld;

tempFeld = new String[nachname.length*3/2];
System.arraycopy(nachname,0,tempFeld,0,nachname.length);
nachname = tempFeld;

tempFeld = new String[telefonnummer.length*3/2];
System.arraycopy(telefonnummer,0,tempFeld,0,telefonnummer.length);
telefonnummer = tempFeld;
// Jetzt ist Platz um etwas pos zu speichern!
}
vorname[pos]= vn;
nachname[pos]= nn;
telefonnummer[pos] = nr;
}
/**
* Loeschen eines Datensatzes wenn alle Parameter identisch sind
* @param vn vorname
* @param nn
* @param nr
*/
public void loesche(String vn, String nn, String nr) {
//Leere Einträge haben keine Telefonummer!
int pos=0; //Suchposition
while ((pos<telefonnummer.length) && (telefonnummer[pos]!=null)
&& !(telefonnummer[pos].equals(nr))
&& !(vorname[pos].equals(vn))
&& !(nachname[pos].equals(nn))
) pos++;
if (pos<telefonnummer.length) // Kandidat zum loeschen steht aus pos
{ // Suche hoechsten Eintrag
int loesche = pos;
while ((pos<telefonnummer.length)
&& (telefonnummer[pos]!=null)
) pos++;
pos--; // Einmal zurücksetzen
// Höchsten Datensatz umkopieren und dann ausnullen
// Der alte Datensatz wird dereferenziert
vorname[loesche] = vorname[pos];
vorname[pos] = null;
nachname[loesche] = nachname[pos];
nachname[pos] = null;
telefonnummer[loesche] = telefonnummer[pos]; telefonnummer[pos]=null;
}
}
/**
* Ausdrucken des Telefonbuchs
*/
public void drucken() {
System.out.println("Telefonbuch. Groesse: " + telefonnummer.length);
for (int i=0; i<telefonnummer.length; i++ ){
System.out.print("[" + i + "]: ");
System.out.print( vorname[i] + " | ");
System.out.print( nachname[i] + " | ");
System.out.println( telefonnummer[i] + " |");
}
}
/**
* Testroutine
*/
public static void test() {
Telefonbuch1 buch = new Telefonbuch1();
System.out.println("*** Leeres Telefonbuch ***");
buch.einfuegen("Manuel","Neuer","0171 1");
buch.einfuegen("Philipp","Lahm","0171 2");
buch.einfuegen("Jérome","Boateng","0171 3");
buch.einfuegen("Mats","Hummels","0171 4");
buch.einfuegen("Benedikt","Höwedes","0171 5");
buch.einfuegen("Christoph","Kramer","0171 6");
buch.einfuegen("Bastian","Schweinsteiger","0171 8");
buch.einfuegen("Thomas","Müller","0171 9");
buch.einfuegen("Toni","Kroos","0171 10");
buch.einfuegen("Per","Mertesacker","0171 11");
buch.einfuegen("Miroslav","Klose","017 12");
//
System.out.println("*** Ganze Mannschaft im Telefonbuch ***");
buch.drucken();
System.out.println("*** Kramer raus, Schürrle rein ***");
buch.loesche("Christoph","Kramer","0171 6");
buch.einfuegen("André","Schürrle","0171 7");
buch.drucken();
System.out.println("*** Klose raus, Götze rein ***");
buch.einfuegen("Miroslav","Klose","017 12");
buch.einfuegen("Mario","Götze","0171 13");
buch.drucken();
System.out.println("... und Weltmeister");
}
/**
* Hauptprogramm
* @param args
*/
public static void main(String[] args) {
test();
}
}

7.5.2 Telefonbuch (2)

Klasse Person

package block7;
/**
*
* @author stsch
*/
public class Person {
final public String vorname;
final public String nachname;
final public String telefonnummer;
/**
* Der Konstruktor erlaubt das Belegen der Attribute. Sie können
* spaeter nicht mehr geändert werden
* @param vn Vorname
* @param nn Nachname
* @param nr Telefonnummer
*/
public Person (String vn, String nn, String nr) {
vorname = vn;
nachname = nn;
telefonnummer = nr;
}
/**
* Standardisierte Vergeleichsoperation in Java
* @param o Das Objekt mit dem verglichen werden soll
* @return wahr wenn Objekte gleich sind
*/
@Override
public boolean equals(Object o) {
Person p = (Person) o;
return ((vorname.equals(p.vorname))
&&(nachname.equals(p.nachname))
&&(telefonnummer.equals(p.telefonnummer)));
}
/**
* Standardisierte Methode zum Konvertieren eines Objekts in eine
* Zeichenkett
* @return Das Objekt in einer Repräsentation als Zeichenkette
*/
@Override
public String toString(){
return (" " +vorname + " | " + nachname + " | " + telefonnummer +" |");
}
}

Klasse Telefonbuch2 (Hauptprogramm)

package block7;
/**
 *
 * @author stsch
 */
public class Telefonbuch2 {
    private Person[] leute;
    /**
     * Anlegen eines Telefonbuchs für 4 EInträge
     */
    public Telefonbuch2 () {
        // Telefonbuch mit initial 4 Einträgen
        leute = new Person[4];
    }
    /**
     * Einfügen einer neuen Telefonnummer mit automatischem
     * Vergrössern um 50% des Telefonbuchs
     * @param p Person
     */
    public void einfuegen(Person p) {
        //Leere Einträge haben keine Telefonummer!
        int pos=0; //Suchposition
        while ((pos<leute.length)
               && (leute[pos]!=null)
                ) pos++;
        if (pos>=leute.length) // kein freier Eintrag!
        { // Feld um 50% vergroessern und alles umkopieren
            Person[] tempFeld; 
            tempFeld = new Person[leute.length*3/2];
            System.arraycopy(leute,0,tempFeld,0,leute.length);
            leute = tempFeld;
            // Jetzt ist Platz um etwas pos zu speichern!
        }
        leute[pos]= p;
    }
    /**
     * Loeschen eines Datensatzes wenn alle Parameter identisch sind
     * @param p zu löschende Person
     */
    public void loesche(Person p) {
        //Leere Einträge haben keine Telefonummer!
        int pos=0; //Suchposition
        while ((pos<leute.length) // Noch nicht am Ende des Feldes
                && (leute[pos]!=null) // Es gibt einen Eintrag
                && !(leute[pos].equals(p)) ) // Er passt nicht
            pos++;
        if (pos<leute.length) // Kandidat zum loeschen steht aus pos
        { // Suche hoechsten Eintrag
            int loesche = pos;
            while ((pos<leute.length)
               && (leute[pos]!=null)
                    ) pos++;
            pos--; // Einmal zurücksetzen
            // Höchsten Datensatz umkopieren und dann ausnullen
            // Der alte Datensatz wird dereferenziert
            leute[loesche] = leute[pos];
            leute[pos] = null;
        }
    }
    /**
     * Ausdrucken des Telefonbuchs
     */
    public void drucken() {
        System.out.println("Telefonbuch. Groesse: " + leute.length);
        for (int i=0; i< leute.length; i++)
            System.out.println("[" + i + "]: " +leute[i]);
    }
    /**
     * Testroutine
     */
    public static void test() {
        Telefonbuch2 buch = new Telefonbuch2();
        System.out.println("*** Leeres Telefonbuch ***");
        buch.einfuegen(new Person("Manuel","Neuer","0171 1"));
        buch.einfuegen(new Person("Philipp","Lahm","0171 2"));
        buch.einfuegen(new Person("Jérome","Boateng","0171 3"));
        buch.einfuegen(new Person("Mats","Hummels","0171 4"));
        buch.einfuegen(new Person("Benedikt","Höwedes","0171 5"));
        buch.einfuegen(new Person("Christoph","Kramer","0171 6"));
        buch.einfuegen(new Person("Bastian","Schweinsteiger","0171 8"));
        buch.einfuegen(new Person("Thomas","Müller","0171 9"));
        buch.einfuegen(new Person("Toni","Kroos","0171 10"));
        buch.einfuegen(new Person("Per","Mertesacker","0171 11"));
        buch.einfuegen(new Person("Miroslav","Klose","017 12"));
        //
        System.out.println("*** Ganze Mannschaft im Telefonbuch ***");
        buch.drucken();
        System.out.println("*** Kramer raus, Schürrle rein ***");
        buch.loesche(new Person("Christoph","Kramer","0171 6"));
        buch.einfuegen(new Person("André","Schürrle","0171 7"));
        buch.drucken();
        System.out.println("*** Klose raus, Götze rein ***");
        buch.einfuegen(new Person("Miroslav","Klose","017 12"));
        buch.einfuegen(new Person("Mario","Götze","0171 13"));
        buch.drucken();
        System.out.println("... und Weltmeister");
    }
    /**
     * Hauptprogramm
     * @param args 
     */
    public static void main(String[] args) {
    test();
    }

7.5.3 Zufallszahlengenerator

/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package block7;


/**
*
* @author stsch
*/
public class Zufallszahlen {
/**
* Drucke dreiminensionale Felder
* @param feld
*/
public static void feldDrucken(int[][][] feld) {
for (int i=0; i<feld.length; i++) {
System.out.println("*** Kubusebene["+i+"] ***");
feldDrucken(feld[i]);
}
}
/**
* Drucke zweidinensionale Felder
* @param feld
*/
public static void feldDrucken(int[][] feld) {
for (int i=0; i<feld.length; i++) {
System.out.print("["+i+"]: ");
feldDrucken(feld[i]);
System.out.println(""); // Zeilenumbruch provozieren
}
}
/**
* Drucke eindinensionale Felder
* @param feld
*/
public static void feldDrucken(int[] feld) {
for (int i=0; i<feld.length; i++) {
System.out.print(" "+feld[i]+" |"); // kein Zeilenumbruch
}
}
/**
* Suche die am häufigsten vorkommende Zahl
* @param feld Feld mit Häufigkeiten
* @return
*/
public static int haeufigsteZahl(int[][][] feld) {
int max = -1;
int ergebnis = 0;
for (int i=0; i<feld.length; i++)
for (int j=0; j<feld[i].length; j++)
for (int k=0; k<feld[i][j].length;k++)
if (feld[i][j][k] > max) {
max = feld[i][j][k];
ergebnis=i*100+j*10+k;
}
System.out.println("Häufigste Vorkommen: " + max);
return ergebnis;
}
/**
* Suche die am seltensten vorkommende Zahl
* @param feld Feld mit Häufigkeiten
* @return
*/
public static int seltensteZahl(int[][][] feld) {
int min = Integer.MAX_VALUE;
int ergebnis = 0;
for (int i=0; i<feld.length; i++)
for (int j=0; j<feld[i].length; j++)
for (int k=0; k<feld[i][j].length;k++)
if (feld[i][j][k] < min) {
min = feld[i][j][k];
ergebnis=i*100+j*10+k;
}
System.out.println("Seltenstes Vorkommen: " + min);
return ergebnis;
}
public static void main(String[] args) {
int sampleSize = 1000000;
int[] sample = new int[sampleSize];
System.out.println("Feld mit " + sampleSize + " Zellen angelegt." );
for (int i=0; i<1000000; i++)
sample[i] = (int)(Math.random()* 1000D);
System.out.println("Feld mit " + sampleSize + " Zufallszahlen belegt." );
int[][][] verteilung = new int[10][10][10];
for (int wert: sample) {
verteilung[(wert/100)%10][(wert/10)%10][wert%10]++;
}
System.out.println("Verteilungsfeld belegt mit " + sampleSize + " Zufallszahlen." );
feldDrucken(verteilung);
System.out.println("Suche häufigst vorkommende Zahl");
System.out.println("Häufigste Zahl " + haeufigsteZahl(verteilung));
System.out.println("Suche seltenst vorkommende Zahl");
System.out.println("Seltenste Zahl " + seltensteZahl(verteilung));
}
}

7.5.4 Conway's Spiel des Lebens

package block7;

public class Generation {
private boolean[][] alt;
private boolean[][] aktuell;
/**
* Groesse des quadratischen Feldes
*/
private int size = 50;;

/**
* Anlegen aller benoetigten Felder mit Initialwerten
* Alle Feldelemente sollen mit dem Zustand "false" = leer versehen sein
*/
public Generation() {
aktuell= new boolean[size][size];
alt = new boolean[size][size];
for (int i=0; i<size; i++)
for (int j=0; j<size; j++) {
aktuell[i][j]= false;
alt[i][j]= false;
}
}

/**
*
* @return Kantenlaenge des quadratischen Felds
*/
public int groesse() {return size;}

/**
* Berechnen einer neuen Generation.
* Legen Sie ein neues Feld an. Berechnen Sie den neuen Zustand
* aller Feldelement aus dem alten Feld
*/
void neueGeneration() {
alt=aktuell;
aktuell= new boolean[size][size];
for (int i=0; i<size; i++)
for (int j=0; j<size; j++) {
// Zaehle Nachbarn
int nachbar=0;
if ((i>0) && alt[i-1][j]) nachbar++; //links
if ((i+1<size)&& alt[i+1][j]) nachbar++; //rechts
if ( (j>0) && alt[i][j-1]) nachbar++; //oben
if ( (j+1<size)&& alt[i][j+1]) nachbar++; //unten
if ((i>0) &&(j>0) && alt[i-1][j-1])nachbar++; //links,oben
if ((i>0) &&(j+1<size) && alt[i-1][j+1])nachbar++; //links, unten
if ((i+1<size)&&(j>0) && alt[i+1][j-1])nachbar++; //rechts, oben
if ((i+1<size)&&(j+1<size) && alt[i+1][j+1])nachbar++; //rechts, unten

// Übernehmen des alten Status als Default
aktuell[i][j] = alt[i][j];
// Geburt einer neuen Zelle
if((!alt[i][j]) && (nachbar==3)) aktuell[i][j]=true;
// Tod einer alten Zelle wegen Einsamkeit
if((alt[i][j]) && (nachbar<2)) aktuell[i][j]=false;
// Tod einer alten Zelle wegen Überbevölerung
if((alt[i][j]) && (nachbar>3)) aktuell[i][j]=false;
}

}

/**
* Das Feld mit den aktuellen Werten
* @return
*/
public boolean[][] status() {return aktuell;}

}

 7.5.5 Flughafenbeispiel aus der Vorlesung

Mit einem Feld eingebaut

Flughafen

package block7;
public class Flughafen {
String name;

Flugzeug[] gate;
double treibstoffLager;

/**
*
* @param name Name des Flugzeuge
* @param gates Anzahl der Gates
*/
public Flughafen(String name, int gates) {
this.name = name;
gate = new Flugzeug[gates];
}


public static void main(String[] args) {


Flughafen pad = new Flughafen("Paderborn",6);
pad.treibstoffLager = 1000000;


// Boeing 747, https://de.wikipedia.org/wiki/Boeing_747#747-400
Flugzeug lh1 = new Flugzeug("ABTL",450000,200,200);
lh1.einsteigen(120);

double aktGewicht=lh1.gewicht();
System.out.println("gewicht" + aktGewicht);

lh1.drucken();

pad.gate[1] = lh1;
pad.gate[2] = lh1;
System.out.println("Boarding für lh1 nach Mannheim...");
pad.gate[1].einsteigen(17);
pad.gate[1].einsteigen(2);
pad.gate[2].einsteigen();
lh1.einsteigen(2);

lh1.drucken();

// Airbus A380 https://de.wikipedia.org/wiki/Airbus_A380#A380-800
Flugzeug lh2 = new Flugzeug("ABTL",500000,100,200);

lh2.einsteigen(100);

lh2.drucken();

pad.gate[2] = lh2;

pad.drucken();

// Hänge Flugzeug um. mover bewegt Flugzeug
// von Gate 1 nach Gate 3

Flugzeug mover = pad.gate[1];
pad.gate[1]=null;

pad.drucken();

pad.gate[3]= mover;
mover=null;

}

/**
* druckt alle wichtigen Informationen ueber einen Flughafen auf die Konsole
*/
public void drucken() {
System.out.println("*** Unser Flughafen ***");
System.out.println("Flughafen " + name);
for (int i=0; i<gate.length; i++) {
if (gate[i] != null)
System.out.println("Am Gate " + i +": " + gate[i]);
else
System.out.println("Gate " + i +" unbelegt");
}
System.out.println("Treibstoff: " + treibstoffLager);
System.out.println("***********************");
}
}

Flugzeug

package block7;
public class Flugzeug {

public String kennzeichen; // Ein Attribut vom Typ einer Zeichenkette
// 1. Privates Attribut zur Verwaltung der Passagierkapazität
// Tipp: Untersuchen Sie die Druckmethode zur Wahl der
// Variablennamen (1-5)!
private int maxPassagiere;
// 2. Privates Attribut zur Verwaltung der aktuellen Pasagiere
private int passagiere;
// 3. Leergewicht in privates Attribut ändern
public int leergewicht; // Ein Attribut vom Type einer Ganzzahl
// 4. Maximales Gewicht des Flugzeugs
private int maxgewicht;
// 5. Öffentliche Konstante für durchschn. Passagiergewicht
public final int PASSAGIERGEWICHT = 85;

// Anzahl aller erzeugten Flugzeuge
private static int objekte;

/**
* 8. Konstruktor implementieren
* Konstruktur der Klasse Flugzeug
* @param kennz Kennzeichen des Flugzeugs
* @param kapazitaet Passagierkapazität
* @param leergew Leergewicht in kg
* @param maxgew Maximalgewicht in kg
*/
public Flugzeug(String kennz, int kapazitaet, int leergew, int maxgew) {
kennzeichen = kennz;
objekte++;
// Prüfen ob Kapazität größere Null ist
if (kapazitaet >= 0) {
maxPassagiere = kapazitaet;
} else {
maxPassagiere = 0;
}
// Prüfen ob Leergewicht größer Null ist
if (leergew > 0) {
leergewicht = leergew;
} else {
leergewicht = 0;
}
// Prüfen ob Maximalgewicht größer-gleich Leergeicht ist.
if (maxgew > leergewicht) {
maxgewicht = maxgew;
} else {
maxgewicht = leergewicht; // Viel Spass...
}
}

/**
* 10. Fügt einen Passagier zum aktuellen Flugzeug hinzu
*/
public void einsteigen() {
if (passagiere < maxPassagiere) {
passagiere++;
}
}

/**
*
* @param anzahl Anzahl der Passagiere die einsteigen sollen
*/
public void einsteigen(int anzahl) {
if ((anzahl >0) && (passagiere+anzahl) <= maxPassagiere) {
passagiere+= anzahl;
}
}

/**
* 11. Entfernt einen Passagier des aktuellen Flugzeugs
*/
public void aussteigen() {
if (passagiere > 0) {
passagiere--;
}
}

/**
*
* @param anzahl Anzahl der Passagiere die aussteigen sollen
*/
public void aussteigen(int anzahl) {
if ((anzahl >0) && (passagiere-anzahl) >=0) {
passagiere-= anzahl;
}
}

/**
* 12. Ausgabe der aktuellen Anzahl der Passagiere
* @return aktuelle Anzahl der Passagiere
*/
public int anzahlPassagiere() {return passagiere;}


/**
* 6. Berechnen des aktuellen Gewichts
* @return aktuelles Gewicht
*/
public int gewicht() {
return (leergewicht+ passagiere*PASSAGIERGEWICHT);}

/**
* 13. Ausgabe der maximalen Anzahl der Passagiere
* @return Maximale Anzahl der Passagiere
*/
public int passagierkapazitaet() {return maxPassagiere;}

/**
*
* @return Anzahl aller erzeugten Objekte der Klasse Flugzeug
*/
public static int anzahlFlugzeuge() {return objekte;}

/**
* Eine Methode zum Drucken der Attributbelegung des Objekts
* Die Methode erfordert keine Eingaben. Sie erzeugt keine
* Ausgaben
*/
public void drucken() {
// 7. Vervollständigen der Druckmethode
System.out.println("*****************************");
System.out.println("Kennzeichen: " + kennzeichen);
System.out.println("Leergewicht: " + leergewicht + "kg");
System.out.println("Maximalgewicht: " + maxgewicht + "kg");
System.out.println("Aktuelles Gewicht : " + gewicht() + "kg");
System.out.println("Passagiere: " + passagiere);
System.out.println("Maximal Anzahl P.: " + maxPassagiere);
System.out.println("******************** " + objekte + " Flugz.");
}

/**
* Ueberschriebene Methode die das Kennzeichen anstatt der Objektidentitaet
* druckt
* @return
*/
public String toString() {return kennzeichen;}

}

 



book | by Dr. Radut