Adressbuch

scratchy1

Bekanntes Mitglied
Hallo Leute,
ich möchte eine Klasse ArrayAdressBook1 für einfache Adressbücher schreiben mit folgenden Eigenschaften:
Ein Adressbuch besitzt ein Attribut persons, welches vom Typ Person[]
ist (wir verwenden hier die Klasse Person:
Java:
public class Person {
    String name;
    int birthday; /* in der Form JJJJMMTT */

    Person(String name, int birthday) {
        this.name = name;
        this.birthday = birthday;
    }

void print() {
System.out.println("Name: " + this.name);
System.out.println("Geburtsdatum: " + this.birthday);
}
boolean isBirthday(int date) {
return birthday % 10000 == date % 10000;
// Das Prozentzeichen ist der Modulo-Operator, welcher
// den Rest einer ganzzahligen Division liefert.
}
}
).
Dieses Attribut soll im Konstruktor des Adressbuchs mit einem neu erzeugten Array initialisiert
werden, wobei die Größe des Arrays dem Konstruktor als Parameter
übergeben wird. Wird eine Größe kleiner als 1 übergeben, soll 1 als Größe
verwendet werden.
Dies habe ich versucht in unterem noch folgendem Code zu implementieren.
Ich möchte aber noch folgendes zusätzlich tun:

Das Adressbuch hat eine Methode addPerson(), welche eine Referenz auf
ein Person-Objekt als Parameter akzeptiert und die übergebene Person an
die erste noch freie Stelle in das Array persons schreibt. Das Array wird
also „von unten“ (beginnend mit Index 0) befüllt. Um die Einfügestelle ermitteln
zu können, bekommt das Adressbuch ein Attribut, welches den Index
des nächsten noch unbelegten Array-Elements repräsentiert. Dieses Attribut
muss natürlich bei Veränderungen aktualisiert werden.
Ok und nun kommt mein Versuch:

Java:
public class ArrayAdressBook1 {
    Person[] persons;

    int startarraylength;

    ArrayAdressBook1(int startarraylength) {

        this.startarraylength = startarraylength;
        // this.startarraylength ist das Attribut des Objektes ArrayAdressBook.
        if (this.startarraylength < 1) {
            this.startarraylength = 1;
        }
        this.persons = new Person[startarraylength];

    }


    void addPerson(){
        for (int i=0;i<persons.length;i++){
        persons[i]= this.persons[i];
        }
     }
}
Nun meine Frage:
Ich dachte, ich hätte mit persons[i]=this.persons das i.te Person-Objekt aus persons mit this angesprochen(das implizit übergeben wurde) und im Array an i-ter Stelle eingefügt.
Ich bin totaler Anfänger und wollte euch fragen, was ihr davon haltet, ob meine Idee schonmal in die richtige Richtung geht oder ich mir ganz was anderes überlegen/wissen sollte.[/i]
 
Zuletzt bearbeitet von einem Moderator:

mihe7

Top Contributor
Bitte benutze Code-Tags: [code=Java]Dein Code[/code]. Dann ist Dein Code für alle leichter lesbar. Außerdem werden Array-Indizes der Art [i] sonst durch kursive Formatierung ersetzt.
 

Javinner

Top Contributor
Ich bin totaler Anfänger und wollte euch fragen, was ihr davon haltet, ob meine Idee schonmal in die richtige Richtung geht oder ich mir ganz was anderes überlegen/wissen sollte
Schön, dass du dich für ein sehr facettenreiches Hobby entschieden hast. Ich persönlich halte nicht viel davon, weil es ein reiner Krampf zu werden scheint. Da gibt es bessere Übungsmethoden, sich mit Arrays vertraut zu machen.

Wie habe ich es umgesetzt?
die Person hat:
  • Vorname (String)
  • Nachname (String)
  • Geburtsdatum (LocalDate)
  • Adresse (eine eigenständige Klasse, bietet mehreren Adressen Platz)
  • Kontaktdaten (eine eigenständige Klasse, bietet mehreren Einträgen Platz (Telefon, eMail))
  • Information (Anmerkungen, Informationen in Textform) (List<String>)
Ein PersonenBuch hat
  • List<Person> personen
man kann
  • Personen hinzufügen
  • Personen entfernen
  • Personen gruppieren
  • Personenlisten verwalten

Was braucht man dafür an Kenntnissen
  • Grundkenntnisse über imperative Programmierung
  • Grundkenntnisse über Objektorientierte Programmierung
  • Grundkenntnisse über Listen und Umgang mit diesen
  • Grundkenntnisse über grafische Oberflächen in Java (Swing, FX)
Wenn die Kenntnisse noch ausstehen, dann würde ich das Projekt auf die Wartebank schieben und mich den Grundlagen widmen. Umso schneller kommt man im Endeffekt ans Ziel!
 

Robat

Top Contributor
  • Grundkenntnisse über grafische Oberflächen in Java (Swing, FX)
Wenn die Kenntnisse noch ausstehen, dann würde ich das Projekt auf die Wartebank schieben und mich den Grundlagen widmen. Umso schneller kommt man im Endeffekt ans Ziel!
Warum braucht man dafür Grundkenntnisse über grafische Oberflächen? So ein Programm lässt sich mEn wunderbar als Konsolenapplikation umsetzen und dient super zur Übung / Festigung der anderen "Grundkenntnisse"
 

Javinner

Top Contributor
Das grafische Darstellen des Buches so wie der sich langsam einstellende Erfolg lösten euphorische Zustände bei mir aus, eventuell ist dieser Kick auf für den TE! :)

Aber du hast Recht, GUI ist hier nicht entscheidend und kann im Nachhinein hinzugefügt werden.
 

mihe7

Top Contributor
täglich bräuchte ich das nich mehr
Darum geht es nicht. Das ist 8-Bit-Technik, knapp 1 MHz Takt und 64 KiB RAM, wovon ein Teil durch Geräte und ROM belegt ist. Die CPU hat nur eine Handvoll Register, der Befehlssatz ist mehr als überschaubar. Die Herausforderung besteht also darin, aus dem wenigen, das man zur Verfügung hat, das Maximum herauszuholen. Das würde dem ein oder anderen heutzutage auch nicht schaden :)
 

scratchy1

Bekanntes Mitglied
Hallo Leute,
Danke für die Kommentare, ich liess sie in mein Problemlösungsversuch einfliessen.
Also ich kann das Problem jetzt runterbrechen auf das Befüllen des Arrays persons mit einer übergebenen Person :
in der Methode addPerson(Person p) befülle ich folgendermaßen:
Java:
i=0;
persons[i]=p;
Damit hätte ich die übergebene Person ins erste Arrayelement getan. Ich weiss nicht, ob meine Idee mich weiterbringt.
Falls ihr noch weitere Tipps/Bemerkungen habt, bin dafür immer dankbar.
Viele Grüße
Scratchy
 

scratchy1

Bekanntes Mitglied
Hallo Leut, meine aktuelle Version sieht so aus
Java:
public class ArrayAdressBook1 {
    Person[] persons;

    int startarraylength;
    boolean[] freiindex;

    ArrayAdressBook1(int startarraylength) {

        this.startarraylength = startarraylength;
        // this.startarraylength ist das Attribut des Objektes ArrayAdressBook.
        if (this.startarraylength < 1) {
            this.startarraylength = 1;
        }
        this.persons = new Person[startarraylength];

    }

    for(int i = 0;i<persons.length;i++){
      

    void addPerson(Person p) {
        freiindex[i]=true;
       if (freiindex[i]=true){
        persons[i]=p;
        freiindex[i]=false;
        i=i+1;
        }
      }
}}
 
Zuletzt bearbeitet von einem Moderator:

VfL_Freak

Top Contributor
Moin,
sieht irgendwie falsch aus.
alleine dieser Teil ist schon ausgesprochen humorvoll:
Java:
for(int i = 0;i<persons.length;i++)
{
    void addPerson(Person p)
    {
        freiindex[I]=true;
        if(freiindex[I]=true)
        {
            persons[I]=p;
            freiindex[I]=false;
            i=i+1;
        }
    }
}
(a) Du kannst doch nicht innerhalb einer Schleife ein neue Methode deklarieren :eek:
(b) was ist 'I' ?????
(c) "if(freiindex=true)" ist eine Zuweisung, KEIN Vergleich !!
(d) wo sollte hier 'p' herkommen??
(e) wo kommt 'freiindex' her (und bedeutet das??) ??

VG Klaus
 

temi

Top Contributor
(f) Selbst wenn if(freiindex[i]=true) ein Vergleich wäre. Was denkst du, was er nach diesen Zeilen ergeben würde?
Java:
freiindex[i]=true;
if(freiindex[i]=true)
[/i]
 
Zuletzt bearbeitet von einem Moderator:

scratchy1

Bekanntes Mitglied
Hi Leute,
Moin,

alleine dieser Teil ist schon ausgesprochen humorvoll:
Java:
for(int i = 0;i<persons.length;i++)
{
    void addPerson(Person p)
    {
        freiindex[i]=true;
        if(freiindex[i]=true)
        {
            persons[i]=p;
            freiindex[i]=false;
            i=i+1;
        }
    }
}
(a) Du kannst doch nicht innerhalb einer Schleife ein neue Methode deklarieren :eek:
(b) was ist 'I' ?????
(c) "if(freiindex=true)" ist eine Zuweisung, KEIN Vergleich !!
(d) wo sollte hier 'p' herkommen??
(e) wo kommt 'freiindex' her (und bedeutet das??) ??

VG Klaus
Zu (a) Ich hab einen Tipp wo anders bekommen:
Der Index 0 ist ja nur richtig, wenn addPerson() das erste Mal aufgerufen wird. Das ist Ihnen wohl auch irgendwie klar, weswegen Sie mit Schleifen herumexperimentieren. Aber: /Ein/ Aufruf der Methode entspricht /einem/ Hinzufügen /einer/ Person. Eine Schleife innerhalb der Methode kann also nicht der richtige Weg sein. Stattdessen müssen Sie dafür sorgen, dass beim nächsten Aufruf der nächste Slot gewählt wird. Die Methode selbst hat aber keine Möglichkeit, zu wissen, wie oft sie aufgerufen wurde. Diese Information muss also außerhalb der Methode gespeichert sein. Mein neuer Versuch ist somit:
Java:
public class ArrayAdressBook1 {
    Person[] persons;

    int startarraylength;
    boolean[] freiindex;

    ArrayAdressBook1(int startarraylength) {

        this.startarraylength = startarraylength;
        // this.startarraylength ist das Attribut des Objektes ArrayAdressBook.
        if (this.startarraylength < 1) {
            this.startarraylength = 1;
        }
        this.persons = new Person[startarraylength];

    }

    for(int i = 0;i<persons.length;i++){
    
        freiindex[i]=true;

     void addPerson(Person p) {
      
      persons[i]=p;
     }
        i=i+1;
    
    freiindex[i]=false;
    }
}
(f) Selbst wenn if(freiindex[I]=true) ein Vergleich wäre. Was denkst du, was er nach diesen Zeilen ergeben würde?
Java:
freiindex[i]=true;
if(freiindex[i]=true)
[/I]
Ja das stimmt, es wäre immer true, aber das Adressbuch ist am Anfang sowieso leer. Ich hatte den Tipp bekommen:
"Damit es kein Chaos gibt, befüllt das Adressbuch das Array schön der Reihe nach, beginnend mit dem Index 0. Dazu muss es sich aber noch etwas merken und bei jedem Befüllen anpassen, nämlich die nächste freie Stelle im Array."
Ich hab das wahrscheinlich nicht richtig umgesetzt.Ich möchte die Information, welcher der nächste freie Index ist in freiindex speichern.

Zu (b): I soll eigentlich i sein, aber wenn ich Tags um meinen Code mache, wird es manchmal nicht richtig übernommen.
zu (c)Wenn ich vergleichen will, kann/soll/darf ich dann if (freiindex[I]==true) schreiben? Oder wie macht man das in Java?
Zu(D): p ist die an die Methode addPerson übergebene Person p. Ich habe noch eine zusätzliche Klasse Person geschrieben, die da lautet:
Java:
public class Person {
    String name;
    int birthday; /* in der Form JJJJMMTT */

    Person(String name, int birthday) {
        this.name = name;
        this.birthday = birthday;
    }

void print() {
System.out.println("Name: " + this.name);
System.out.println("Geburtsdatum: " + this.birthday);
}
boolean isBirthday(int date) {
return birthday % 10000 == date % 10000;

}
}
zu (e) darin soll der nächste freie Index des Arrays persons stehen, damit ich die übergebene Person darin speichern kann.
[/I]
 
Zuletzt bearbeitet von einem Moderator:

VfL_Freak

Top Contributor
Moin,

zu (a) immer noch keine Code-Tags :( Schau doch mal in meine Signatur ...
Weiterhin gilt imm ernoch, dass Du innerhalb einer Schleife KEINE Methode deklarieren kannst !!
Hast Du mal versucht Dienen Code zu compilieren ??

zu (b) zu den Code-Tags siehe (a) ;)

zu (c)
Java:
freiindex = true;  // ist eine Zuweisung
if( freiindex == true ) ...  // der Vergleich, ob die Variable den Wert TRUE hat
if( freiindex )  // reicht zur Prüfung auf TRUE
if( ! freiindex )  // reicht zur Prüfung auf FALSE

zu (d) ich würde ggf. noch Getter und Setter hinzufügen
ABER:
Java:
int birthday; /* in der Form JJJJMMTT */
ein Integer der Form "JJJJMMTT" ??? Ist das SO vorgegeben??
Es gibt doch Datum-/Zeit-Klassen und -bibliotheken!!

VG Klaus
 

mihe7

Top Contributor
Dein Betreuer (vermute ich mal) hat Dir richtigerweise geschrieben:
Eine Schleife innerhalb der Methode kann also nicht der richtige Weg sein.
Das heißt aber nicht, dass Du eine Schleife um die Methode legen sollst, sondern dass Du überhaupt keine Schleife verwenden sollst.

Weiter wird ausgeführt:
Stattdessen müssen Sie dafür sorgen, dass beim nächsten Aufruf der nächste Slot gewählt wird. Die Methode selbst hat aber keine Möglichkeit, zu wissen, wie oft sie aufgerufen wurde. Diese Information muss also außerhalb der Methode gespeichert sein.
Da steht alles haarklein drin, er hätte Dir fast schon den Code schreiben können.
 

temi

Top Contributor
zu (e) darin soll der nächste freie Index des Arrays persons stehen, damit ich die übergebene Person darin speichern kann.
Wozu muss das ein Array von Booleans sein? Es reicht doch ein einfacher Integerwert für den Index:
int index = 0;
Damit kannst du den Inhalt zuweisen:
persons[index] = p;
Anschließend musst du den Index nur noch erhöhen.
 

scratchy1

Bekanntes Mitglied
Hallo Temi,
ja diese Idee hatte ich ja auch, ich hatte
Java:
 int i=0;
persons[i]=p;
i=i+1;
Nun soll das aber nur bis zur Länge des Arrays persons.length gemacht werden. Wie kann ich das ohne Schleife machen, oder geschieht das etwa automatisch, weil die Arraylänge schon vorher bekannt ist?
 

scratchy1

Bekanntes Mitglied
hmm, meinst Du
Java:
 if (i==persons.length)
?
Und dann müsste ichs mit dem nächsten Befehl stoppen.
Falls nicht, muss ich mal noch weiter überlegen
 

mihe7

Top Contributor
Code:
public void add(Person p) {
   if (noch platz) {
      füge p an nächsten freien platz ein
   } else {
      let it be
   }
}
 

scratchy1

Bekanntes Mitglied
Hallo Leute,
Danke für die Tipps,
Ok dann versuch ichs:
Java:
 int i = 0;
   if (i<=persons.length){
       
        freiindex[i]=true;
   }
   if (freiindex[i]=true) {
     void addPerson(Person p) {
       
      persons[i]=p;
      freiindex[i]=false;
     }
        i=i+1;
}
 

VfL_Freak

Top Contributor
Moin,
Java:
if( freiindex[i] = true )   // (A)
{
    void addPerson(Person p)     // (B)
    {
        persons[i]=p;
        freiindex[i]=false;
    }
    i=i+1;  // ist Quark wegen (B)!!
}
ein letztes Mal erkläre ich es Dir noch !!! :rolleyes:

zu (A) dies ist eine Zuweisung, kein Vergleich !!!
zu (B) Du kannst an dieser Stelle KEINE neue Methode deklarieren !!!

Bitte bitte - verinnerliche das, andernfalls bin ich hier raus!!
VG Klaus
 

scratchy1

Bekanntes Mitglied
Moin,

ein letztes Mal erkläre ich es Dir noch !!! :rolleyes:

zu (A) dies ist eine Zuweisung, kein Vergleich !!!
zu (B) Du kannst an dieser Stelle KEINE neue Methode deklarieren !!!

Bitte bitte - verinnerliche das, andernfalls bin ich hier raus!!
VG Klaus
Und das ganze "Freiindex"-Gedönse ist völlig überflüssig, aber das hatten wir ja schon geklärt...
Ach ja stimmt.
Dann probier ichs mal so rum:
Java:
 int i = 0;
  
   
     void addPerson(Person p) {
            if (i<persons.length){
      persons[i]=p;
      i=i+1;
     }
}
 

scratchy1

Bekanntes Mitglied
Da es Dir mihe7 gefallen hat, ergänze ich es dann mal noch:
Java:
int i = 0;

    void addPerson(Person p) {
        if (i < persons.length) {
            persons[i] = p;

            i = i + 1;
        }
        else if (i == persons.length) {
            persons[i] = p;
        }
 

VfL_Freak

Top Contributor
Moin,
und was glaubst Du damit erreicht zu haben??

Im übrigen ginge dies dann auch kürzer
Java:
int i = 0;
if( i <= persons.length )
{
    persons[i] = p;
    // i = i + 1;   ist hier flüssiger als flüssig, da Du ja keine Schleife mehr hast !!
}

VG Klaus
 

temi

Top Contributor
Java:
    // i = i + 1;   ist hier flüssiger als flüssig, da Du ja keine Schleife mehr hast !!

Da stimme ich nicht ganz zu. "i" muss schon inkrementiert werden, um auf den nächsten Index zu kommen. Wichtig ist dabei allerdings, dass "i" eine Instanzvariable sein muss und nicht, wie oben innerhalb der Methode deklariert.

Java:
class Adressbuch {
    private int i = 0;

    // Konstruktor
    public Adressbuch(int max) {
        // Code
    }

    void addPerson(Person p) {
        if (i < persons.length) {
            persons[i++] = p;
        }
    }

    // mehr Zeug...
}

Probierst du eigentlich auch aus, was du uns hier präsentierst?
 

scratchy1

Bekanntes Mitglied
Hallo Leut,
ja ich probiers aus, ich hab bis jetzt einen Syntaxerror und einen Klammerungsfehler, die sich hartnäckig halten, ich versuch das noch zu beseitigen.
Ich will erreichen:

Damit die Anzahl der Personen, die aufgenommen werden können, nicht
begrenzt ist, soll beim Hinzufügen einer Person mit addPerson() zunächst
überprüft werden, ob das Array bereits voll belegt ist. Wenn ja, soll
ein neues Array doppelter Größe angelegt und das alte Array dort hineinkopiert
werden. Das Verdoppeln und Umkopieren soll in eine eigene Methode
ausgelagert werden.

Zusammen mit euren Tipps bin ich bis jetzt soweit gekommen (Ixh stocke bis jetzt am Auslagern einer weiteren Methode) und ich weiss, es ist noch nicht fertig und es gibt ev. noch überflüssiges, aber es ist sozusagen meine Baustelle:
Java:
public class ArrayAdressBook1 {
    Person[] persons;

    int startarraylength;
    int freiindex;
    Person[] newpersons;

    ArrayAdressBook1(int startarraylength) {

        this.startarraylength = startarraylength;
        // this.startarraylength ist das Attribut des Objektes ArrayAdressBook.
        if (this.startarraylength < 1) {
            this.startarraylength = 1;
        }
        this.persons = new Person[startarraylength];

    }

    int i = 0;

    void addPerson(Person p) {
        if (i < persons.length-1) {
            persons[i] = p;

            i = i + 1;
        }
        else if (i == persons.length-1) {
            persons[i] = p;
        }
        else if (i==persons.length) {
        this.newpersons = new Person[persons.length+persons.length];
        int j=0;
        this.newpersons[j]= persons[i];
      
        }

    }

    void addArray(Person[arraylength]) {
        if (i>persons.length) {
            persons= new Person[arraylength+arraylength];
        }
    }
So, für heut, hab ich halt noch soviel Bammel, dass ich noch wie Scratchy ende ;)
 

Javinner

Top Contributor
ob das Array bereits voll belegt ist
Das ist genau der Punkt: nach deiner Vorgehensweise ist dasArray immer genau so lang, wie bereits Personen vorhanden. Wenn eine neue Person dazu kommt, dann, je nach dem ob vorn oder hinten die Person hinzugefügt werden muss, muss man
  • den vorhandenen Array kopieren
  • ein neues Array plus Eins erstellen
  • altes Array hinein kopieren
  • die neue Person hinzufügen
Dabei ist die Prüfung, ob die Person bereits vorhanden ist, noch gar nicht eingebaut.
 

Javinner

Top Contributor
Java:
public class ArraysForScratchy
{

    public static void main(String[] args)
    {

        String alex = "Alex";
        String natalie = "Natalie";
        String sinje = "Sinje";

        String[] names = new String[]
        {
            alex, natalie, sinje
        };
        showArrayContent(names);
        System.out.println("Length of Array \"names\" : " + names.length);

        String nameToAdd = "Victor";
        names = addNewName(names, nameToAdd);
        showArrayContent(names);
        System.out.println("Length of Array \"names\" : " + names.length);

        String[] newNamesToAdd =
        {
            "Sonja", "Pavel", "Irene", "Lilly"
        };
        names = addNewNames(names, newNamesToAdd);
        showArrayContent(names);
        System.out.println("Length of Array \"names\" : " + names.length);
    }

    static void showArrayContent(String[] names)
    {
        for (int i = 0; i < names.length; i++)
        {
            if (i < names.length - 1)
            {
                System.out.print(names[i].concat(", "));
            } else
            {
                System.out.print(names[i]);
            }
        }
        System.out.println();
    }

    /**
     * Erstelle ein neues Array mit Laenge names plus eins
     * Copiere das Array names in das neuerstellte Array
     * fuege an letzter Stelle im neuen Array den neuen Namen ein
     * gebe das neue Array zurueck
     */
    static String[] addNewName(String[] names, String nameToAdd)
    {
        //To do
    }

    /**
     * Erstelle ein neues Array mit Laenge names und newNamesToAdd
     * fuege das Array names in das neue Array ein
     * reihe das Array newNamesToAdd nach dem Array names in das neue Array ein
     * gebe das neuerstellte Array zurueck
     */
    static String[] addNewNames(String[] names, String[] newNamesToAdd)
    {
        //To do
    }

}
/** Output */
Alex, Natalie, Sinje
Length of Array "names" : 3
Alex, Natalie, Sinje, Victor
Length of Array "names" : 4
Alex, Natalie, Sinje, Victor, Sonja, Pavel, Irene, Lilly
Length of Array "names" : 8
Class System
Schau dir die erste Methode an ;)
 

mihe7

Top Contributor
Mal ein paar Worte zum Code. Du willst ein Adressbuch haben. Stellen wir uns einmal ein Büchlein vor, in das auf jeder Seite genau ein Eintrag passt.

Die Einträge sollen dabei in einem Array verwaltet werden:
Java:
Person[] persons;
passt also.

Ein Array hat eine Länge, die in Deinem Fall die "aktuelle Kapazität" des Adressbuchs, d. h. das entspräche der Anzahl an (ggf. leeren) Seiten im Adressbuch. Die Kapazität lässt sich über persons.length ermitteln. Die Variable startarraylength ist also überflüssig -> raus damit.

Was wir auch wissen müssen, ist die nächste freie Seite im Buch, d. h. wie viele Seiten wir umblättern müssen, um die erste freie Seite zu erhalten. Jetzt kommt es darauf an, was beim Entfernen eines Eintrags passiert: reißt man die Seite raus oder überklebt man sie nur mit einem weißen Blatt?

Am einfachsten wird es, wenn man die Seite rausreißt: dann nämlich hängen die Anzahl der Einträge im Adressbuch mit der nächsten freien Seitennummer unmittelbar zusammen.

freiindex wäre also durchaus möglich. Der Name ist allerdings nicht schön. freiIndex entspricht zwar eher der Benennungskonventionen, ist aber auch nicht viel besser. nextIndex käme eher hin. Ich würde allerdings den anderen Weg gehen und mir die Anzahl der Einträge merken, z. B. count, numberOfPersons oder ähnliches. Ich nehme mal size - die Größe des Adressbuchs, gegeben in Anzahl an Einträgen.

newpersons brauchst Du nicht als Instanzvariable -> raus damit.

Weiter unten: i als Instanzvariable ganz schlechte Idee. Außerdem haben wir ja freiindex (= size) schon -> doppelt gemoppelt -> raus damit.

Bis jetzt haben wir also:
Java:
public class ArrayAdressBook1 {
    Person[] persons;
    int size;

    ArrayAdressBook1(int startarraylength) {
        if (startarraylength < 1) {
            startarraylength = 1;
        }
        this.persons = new Person[startarraylength];
    }

Machen wir mal bei addPerson weiter: die Fallunterscheidung bzgl. persons.length kannst Du Dir sparen. Wir verwenden ja die Größe und die wächst immer an, wenn etwas hinzugefügt wird.

D. h. zunächst wäre das:
Java:
    void addPerson(Person p) {
        if (size < persons.length) {
            persons[size] = p;
            size++;
        }
        else {
...
Im else-Zweig soll jetzt die Kapazität des Arrays erhöht werden. Außerdem muss die übergebene Person dann auch gespeichert werden. Das wäre dann etwas wie
Java:
    void addPerson(Person p) {
        if (size < persons.length) {
            persons[size] = p;
            size++;
        }
        else {
            increaseCapacity();
            persons[size] = p;
            size++;
        }
    }
Jetzt haben wir Code doppelt. Das ist nicht gut, deshalb formulieren wir um:
Java:
    void addPerson(Person p) {
        if (size >= persons.length) {
            increaseCapacity();
        }
        persons[size] = p;
        size++;
    }
Die Methode increaseCapacity macht nun genau die ersten drei Punkte, die Dir @Javinner geschrieben hat. Den vierten haben wir in addPerson schon erschlagen.
 

scratchy1

Bekanntes Mitglied
Hallo Leute,
Vielen Dank für die hilfreichen Beiträge.Es ist mir einiges klarer geworden. @Javinner: Ich bin noch beim Anschauen der ersten Methode Deines Codes, aber dafür brauch ich noch etwas länger :) . Aus den übrigen Beiträgen habe ich dann mich ans Erklimmen gemacht. Ich bin mir noch nicht sicher, ob ich
Das ist genau der Punkt: nach deiner Vorgehensweise ist dasArray immer genau so lang, wie bereits Personen vorhanden. Wenn eine neue Person dazu kommt, dann, je nach dem ob vorn oder hinten die Person hinzugefügt werden muss, muss man
  • den vorhandenen Array kopieren
  • ein neues Array plus Eins erstellen
  • altes Array hinein kopieren
  • die neue Person hinzufügen
Dabei ist die Prüfung, ob die Person bereits vorhanden ist, noch gar nicht eingebaut.
richtig umgesetzt habe und manches habe ich noch doppelt gemoppelt gelassen, damit ichs besser verstehe.
Mein momentaner Stand ist:
Java:
public class ArrayAdressBook1 {
    Person[] persons;

    int startarraylength;
    int personenSchonDrin;

    ArrayAdressBook1(int startarraylength) {

        this.startarraylength = startarraylength;
        // this.startarraylength ist das Attribut des Objektes ArrayAdressBook.
        if (this.startarraylength < 1) {
            this.startarraylength = 1;
        }
        this.persons = new Person[startarraylength];

    }

    void addPerson(Person p) {
        if (personenSchonDrin < persons.length) {
            persons[personenSchonDrin] = p;

            personenSchonDrin = personenSchonDrin + 1;
        } else {
            verdoppleKapazität();
            persons[personenSchonDrin] = p;

            personenSchonDrin = personenSchonDrin + 1;
          }

    }

   

    void verdoppleKapazität() {
        Person[] newpersons;

        this.newpersons = new Person[persons.length + persons.length];
        this.newpersons = persons;

        persons = newpersons;
    }
}
 

mihe7

Top Contributor
manches habe ich noch doppelt gemoppelt gelassen,
Die Instanzvariable int startarraylength; wird ausschließlich im Konstruktor benutzt. Was willst Du denn damit?

addPerson ist zwar nicht schön, aber wenn es dem Verständnis dient :)

Vielleicht noch kurz zum Verständnis: da bei Dir am Ende eines jeden Zweiges, also sowohl im then- als auch im else-Zweig, exakt der gleiche Code ausgeführt wird, kannst Du die betreffenden Zeilen einfach "nach unten ziehen".
Java:
    void addPerson(Person p) {
        if (personenSchonDrin < persons.length) {
        } else {
            verdoppleKapazität();
        }
        persons[personenSchonDrin] = p;
        personenSchonDrin = personenSchonDrin + 1;
    }
Damit kein leerer then-Zweig in der Gegend rumhängt, wird nun noch die Bedingung negiert:
Java:
    void addPerson(Person p) {
        if (personenSchonDrin >= persons.length) {
            verdoppleKapazität();
        }
        persons[personenSchonDrin] = p;
        personenSchonDrin = personenSchonDrin + 1;
    }
Und schon hast Du den Code wie gezeigt :)

Zurück zum Thema: verdoppleKapazität ist falsch. Du legst erst - völlig richtig - ein neues Array an und speicherst die Referenz auf dieses neue Array in newpersons (übrigens: da es eine lokale Variable ist, muss es newpersons und nicht nicht this.newpersons heißen):
Java:
newpersons = new Person[persons.length + persons.length];
Im nächsten Schritt speicherst Du die Referenz auf this.persons in newpersons.
Java:
newpersons = this.persons;
Damit hast Du den ersten Schritt zunichte gemacht. Genauso gut könntest Du auch
Java:
    void verdoppleKapazität() {
        Person[] newpersons;
        newpersons = persons;
        persons = newpersons;
    }
und damit
Java:
    void verdoppleKapazität() {
    }
schreiben. Hätte den gleichen Effekt.
 

scratchy1

Bekanntes Mitglied
Hallo mihe7,
vielen Dank für die Tipps. Ich sehe ein, dass startarraylength nur im Konstruktor gebraucht wird, aber dann steht: startarraylength cannot be resolved or is not a field als Fehlermeldung. Das mit dem if -Zweig hab ich jetzt nachgeholt, das hatte ich mir vorher aber auch zum Verständnis, dass ja beides äquivalent ist , dringelassen :).

Bei verdoppleKapazität hatte ich wohl irgendwie noch nicht verinnerlicht, dass ich damit wirklich nur verdoppeln will.
Jetzt sieht es so aus:
Java:
public class ArrayAdressBook1 {
    Person[] persons;

    int personenSchonDrin;

    ArrayAdressBook1(int startarraylength) {

        this.startarraylength = startarraylength;
        // this.startarraylength ist das Attribut des Objektes ArrayAdressBook.
        if (this.startarraylength < 1) {
            this.startarraylength = 1;
        }
        this.persons = new Person[startarraylength];

    }

    void addPerson(Person p) {
        if (personenSchonDrin >= persons.length) {
            verdoppleKapazität();
        }
        persons[personenSchonDrin] = p;
        personenSchonDrin = personenSchonDrin + 1;
    }
 
    void verdoppleKapazität() {
        Person[] newpersons;

        newpersons = new Person[persons.length + persons.length];

        persons = newpersons;
    }
}
 

VfL_Freak

Top Contributor
Moin,
startarraylength cannot be resolved or is not a field als Fehlermeldung.
klar, weil Du ja auch keine Variable mit diesem Namen mehr als Attribut der Klasse hast !!
Was soll den hier überhaupt als Länge übergeben werden ??
Wo wird der Konstruktor 'ArrayAdressBook1' denn aufgerufen??
Außerdem würdest Du im Konstruktor bei jedem Aufruf ein neue Array 'person' erstellen ... wozu ??
Und warum keine fixe Länge??

VG Klaus
 

mihe7

Top Contributor
Wie @VfL_Freak bereits geschrieben hat: this.startarraylength gibt es nicht mehr.

Java:
    ArrayAdressBook1(int startarraylength) {
        if (startarraylength < 1) {
            startarraylength = 1;
        }
        this.persons = new Person[startarraylength];
    }
oder kürzer:
Java:
    ArrayAdressBook1(int startarraylength) {
        this.persons = new Person[startarraylength < 1 ? 1 : startarraylength];
    }
oder:
Java:
    ArrayAdressBook1(int startarraylength) {
        this.persons = new Person[Math.max(1, startarraylength)];
    }
Bei verdoppleKapazität hatte ich wohl irgendwie noch nicht verinnerlicht, dass ich damit wirklich nur verdoppeln will.
Du musst allerdings die Elemente des alten Arrays noch im neuen Array speichern.
 

scratchy1

Bekanntes Mitglied
Hallo Leute, danke für die Tipps, ich räum dann schonmal im Konstruktor auf:
Java:
public class ArrayAdressBook1 {
    Person[] persons;

    int personenSchonDrin;

    ArrayAdressBook1(int startarraylength) {

        // this.startarraylength ist das Attribut des Objektes ArrayAdressBook.
        if (startarraylength < 1) {
            startarraylength = 1;
        }
        this.persons = new Person[startarraylength];

    }

    void addPerson(Person p) {
        if (personenSchonDrin >= persons.length) {
            verdoppleKapazität();
        }
        persons[personenSchonDrin] = p;
        personenSchonDrin = personenSchonDrin + 1;
    }
   
    void verdoppleKapazität() {
        Person[] newpersons;

        newpersons = new Person[persons.length + persons.length];

        persons = newpersons;
        newpersons=persons;
    }
}
Ok, jetzt sagtest Du mihe7, dass ich das alte Array im neuen speichern soll. Ich hoffe, das habe ich erreicht, und dass es sich diesmal nicht aufhebt.
@VfL_Freak : Das Adressbuch mache ich als Übung. Und die ist noch nicht vorbei, d.h. ich mache das in Teilabschnitten. Als nächstes werde ich versuchen, das Adressbuch zu testen. Ich mache:
Um das Adressbuch sinnvoll testen zu können, bekommt es eine Methode
print(). Diese gibt zunächst eine Zeile aus, in der steht, wie viele Einträge
zur Zeit im Adressbuch sind, dann eine, in der steht, wie groß seine Kapazität
zur Zeit ist. Anschließend ruft sie auf allen im Adressbuch enthaltenen
Person-Objekten deren Methode print() auf.
 

temi

Top Contributor
Ok, jetzt sagtest Du mihe7, dass ich das alte Array im neuen speichern soll. Ich hoffe, das habe ich erreicht, und dass es sich diesmal nicht aufhebt.
Nein, das hast du nicht erreicht.
Du überschreibst die Referenz auf das gefüllte "persons"-Array, mit der Referenz auf das leere "newpersons"-Array. Damit ist "persons" sozusage verloren, weil du keine gültige Referenz mehr darauf hast. Den Inhalt des Arrays kannst du so nicht kopieren. Dazu musst du jedes enthaltene Element einzeln in das neue Array kopieren. Es gibt auch andere Methoden mit Hilfe der Standardbibliothek, aber mach es erst mal so.
 

scratchy1

Bekanntes Mitglied
Hallo temi, geht es so, ich hab mir dies ausgedacht?
Java:
 void verdoppleKapazität() {
        Person[] newpersons;
        Person[] persons2;
        newpersons = new Person[persons.length + persons.length];
        persons2= new Person[persons.length + persons.length];
        persons = persons2;
        persons2=newpersons;
        newpersons = persons;
    }
Oder wie meintest Du es, dass ich sie einzeln kopieren soll? (Vielleicht mit Hilfe von Indizes?)
 

temi

Top Contributor
Hallo temi, geht es so, ich hab mir dies ausgedacht?
Oder wie meintest Du es, dass ich sie einzeln kopieren soll? (Vielleicht mit Hilfe von Indizes?)
Genau das ist damit gemeint.

Was deinen Code angeht:
Java:
 void verdoppleKapazität() {
        Person[] newpersons;
        Person[] persons2;
        // Hier erstellst du ein neues LEERES Array
        // newpersons enthält danach eine Referenz auf dieses Array
        newpersons = new Person[persons.length + persons.length];
        // Hier erstellst du ein zweites LEERES Array
        // persons2 enthält danach eine Referenz auf dieses Array
        persons2= new Person[persons.length + persons.length];

        // Hier überschreibst du die Referenz auf das gefüllte Array mit der Referenz auf das leere Array.
        // damit geht die ursprüngliche Referenz auf das gefüllte Array verloren
        persons = persons2;
        // Der Rest ist sinnlose Referenz-Schieberei...
        // Hier wird die Referenz auf das neue leere Array mit einer anderen Referenz auf ein zweites leeres Array überschrieben
        persons2=newpersons;
        // und die wird dann wieder mit der Referenz auf das erste leere Array überschrieben...
        newpersons = persons;
    }
 

temi

Top Contributor
Da du anscheinend noch Probleme bei Grundlagen hast, experimentiere doch einfach mal etwas herum:
Java:
import java.util.Arrays;

public class Main {

    public static void main(String[] args) {

        int[] intArr1 = new int[5];


        intArr1[0] = 0;
        intArr1[1] = 1;

        System.out.print("intArr1: ");
        System.out.println(Arrays.toString(intArr1));

        // das ist KEINE Kopie, auch wenn es auf den ersten Blick so aussieht!
        // intArr2 referenziert danach das selbe Array wie intArr1
        // d.h. du greifst über die zwei Variablen intArr1 und intArr2 auf DASSELBE Array zu!
        // Eine Kopie wäre ein unabhängiges Array mit dem gleichen Inhalt.

        int[] intArr2 = intArr1;

        System.out.print("intArr2: ");
        System.out.println(Arrays.toString(intArr2));

        intArr1[2] = 2;

        System.out.print("intArr1: ");
        System.out.println(Arrays.toString(intArr1));
        System.out.print("intArr2: ");
        System.out.println(Arrays.toString(intArr2));

        intArr2[3] = 3;

        System.out.print("intArr1: ");
        System.out.println(Arrays.toString(intArr1));
        System.out.print("intArr2: ");
        System.out.println(Arrays.toString(intArr2));
    }
}
 

Ähnliche Java Themen

Neue Themen


Oben