# Adressbuch



## scratchy1 (4. Dez 2018)

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:

```
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:


```
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]


----------



## mihe7 (4. Dez 2018)

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 (4. Dez 2018)

scratchy1 hat gesagt.:


> 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!


----------



## mihe7 (4. Dez 2018)

Javinner hat gesagt.:


> 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.


@scratchy1 Der zweite Satz hat keinen Bezug zum ersten - vermute ich zumindest stark


----------



## Robat (4. Dez 2018)

Javinner hat gesagt.:


> 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 (4. Dez 2018)

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 (4. Dez 2018)

Robat hat gesagt.:


> So ein Programm lässt sich mEn wunderbar als Konsolenapplikation umsetzen


Jaaaa, auf dem 64er mit Speichern auf der 5,25"-Floppy und Locher-Kapazitätsverdopplung - ich glaub, ich muss das Teil mal wieder auspacken


----------



## Robat (4. Dez 2018)

@mihe7 das ist zum Glück glück nicht mehr meine Zeit gewesen


----------



## mihe7 (4. Dez 2018)

Robat hat gesagt.:


> das ist zum Glück glück nicht mehr meine Zeit gewesen


Zum Glück?  Ich spreche hiermit jedem mein tiefstes Beileid aus, der das nicht mitmachen durfte.


----------



## Robat (4. Dez 2018)

Mal zum reinschnuppern / ausprobieren ja - täglich bräuchte ich das nich mehr


----------



## mihe7 (4. Dez 2018)

Robat hat gesagt.:


> 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


----------



## Robat (4. Dez 2018)

mihe7 hat gesagt.:


> Das würde dem ein oder anderen heutzutage auch nicht schaden


Das stimmt natürlich. Wir mussten letztes Semester mit dem ATTiny (auch 8 Bit) ein paar Projekte machen. War auf jeden Fall interessant - sollte ja ungefähr aufs gleiche herauskommen


----------



## scratchy1 (7. Dez 2018)

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:

```
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 (10. Dez 2018)

Hallo Leut, meine aktuelle Version sieht so aus

```
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;
        }
      }
}}
```


----------



## mihe7 (10. Dez 2018)

sieht irgendwie falsch aus.


----------



## VfL_Freak (11. Dez 2018)

Moin,


mihe7 hat gesagt.:


> sieht irgendwie falsch aus.


alleine dieser Teil ist schon ausgesprochen humorvoll:

```
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 
(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 (11. Dez 2018)

(f) Selbst wenn `if(freiindex[i]=true)` ein Vergleich wäre. Was denkst du, was er nach diesen Zeilen ergeben würde?

```
freiindex[i]=true;
if(freiindex[i]=true)
```
[/i]


----------



## scratchy1 (11. Dez 2018)

Hi Leute,


VfL_Freak hat gesagt.:


> Moin,
> 
> alleine dieser Teil ist schon ausgesprochen humorvoll:
> 
> ...


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:

```
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;
    }
}
```



temi hat gesagt.:


> (f) Selbst wenn `if(freiindex[I]=true)` ein Vergleich wäre. Was denkst du, was er nach diesen Zeilen ergeben würde?
> 
> ```
> freiindex[i]=true;
> ...


_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:In die Zwischenablage kopieren


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]


----------



## VfL_Freak (11. Dez 2018)

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)

```
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: 

```
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 (11. Dez 2018)

Dein Betreuer (vermute ich mal) hat Dir richtigerweise geschrieben:


scratchy1 hat gesagt.:


> 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:


scratchy1 hat gesagt.:


> 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 (11. Dez 2018)

scratchy1 hat gesagt.:


> 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 (11. Dez 2018)

Hallo Temi,
ja diese Idee hatte ich ja auch, ich hatte

```
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?


----------



## mihe7 (11. Dez 2018)

scratchy1 hat gesagt.:


> Wie kann ich das ohne Schleife machen


if.. if.. if..


----------



## scratchy1 (11. Dez 2018)

hmm, meinst Du 
	
	
	
	





```
if (i==persons.length)
```
 ?
Und dann müsste ichs mit dem nächsten Befehl stoppen.
Falls nicht, muss ich mal noch weiter überlegen


----------



## temi (11. Dez 2018)

scratchy1 hat gesagt.:


> hmm, meinst Du
> 
> 
> 
> ...



Man kann auch auf kleiner oder größer vergleichen...


----------



## mihe7 (11. Dez 2018)

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


----------



## scratchy1 (12. Dez 2018)

Hallo Leute,
Danke für die Tipps,
Ok dann versuch ichs:

```
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 (12. Dez 2018)

Moin,


scratchy1 hat gesagt.:


> ```
> if( freiindex[i] = true )   // (A)
> {
> void addPerson(Person p)     // (B)
> ...


ein *letztes Mal* erkläre ich es Dir noch !!!  

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


----------



## temi (12. Dez 2018)

scratchy1 hat gesagt.:


> ```
> int i = 0;
> if (i<=persons.length){
> 
> ...



Und das ganze "Freiindex"-Gedönse ist völlig überflüssig, aber das hatten wir ja schon geklärt...


----------



## scratchy1 (12. Dez 2018)

VfL_Freak hat gesagt.:


> Moin,
> 
> ein *letztes Mal* erkläre ich es Dir noch !!!
> 
> ...





temi hat gesagt.:


> 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:

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


----------



## scratchy1 (13. Dez 2018)

Da es Dir mihe7 gefallen hat, ergänze ich es dann mal noch:

```
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 (13. Dez 2018)

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

Im übrigen ginge dies dann auch kürzer

```
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 (13. Dez 2018)

VfL_Freak hat gesagt.:


> ```
> // 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.


```
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?


----------



## mihe7 (13. Dez 2018)

scratchy1 hat gesagt.:


> Da es Dir mihe7 gefallen hat


Das war als Zustimmung für die richtige Variante gedacht.

Das hier


scratchy1 hat gesagt.:


> else if (i == persons.length) {
> persons_ = p;
> }
> _


_
sorgt nur für eine ArrayIndexOutOfBoundsException, denn die Array-Indizes von persons gehen von 0 bis (persons.length-1)._


----------



## scratchy1 (14. Dez 2018)

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:

```
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 (14. Dez 2018)

scratchy1 hat gesagt.:


> 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 (14. Dez 2018)

```
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 (14. Dez 2018)

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:

```
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:

```
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:

```
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

```
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:

```
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 (16. Dez 2018)

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 


Javinner hat gesagt.:


> 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
> ...


richtig umgesetzt habe und manches habe ich noch doppelt gemoppelt gelassen, damit ichs besser verstehe.
Mein momentaner Stand ist:

```
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 (16. Dez 2018)

scratchy1 hat gesagt.:


> 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".

```
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:

```
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):

```
newpersons = new Person[persons.length + persons.length];
```
Im nächsten Schritt speicherst Du die Referenz auf this.persons in newpersons. 

```
newpersons = this.persons;
```
Damit hast Du den ersten Schritt zunichte gemacht. Genauso gut könntest Du auch

```
void verdoppleKapazität() {
        Person[] newpersons;
        newpersons = persons;
        persons = newpersons;
    }
```
und damit

```
void verdoppleKapazität() {
    }
```
schreiben. Hätte den gleichen Effekt.


----------



## scratchy1 (17. Dez 2018)

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:

```
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 (17. Dez 2018)

Moin,


scratchy1 hat gesagt.:


> 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 (17. Dez 2018)

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


```
ArrayAdressBook1(int startarraylength) {
        if (startarraylength < 1) {
            startarraylength = 1;
        }
        this.persons = new Person[startarraylength];
    }
```
oder kürzer:

```
ArrayAdressBook1(int startarraylength) {
        this.persons = new Person[startarraylength < 1 ? 1 : startarraylength];
    }
```
oder:

```
ArrayAdressBook1(int startarraylength) {
        this.persons = new Person[Math.max(1, startarraylength)];
    }
```



scratchy1 hat gesagt.:


> 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 (18. Dez 2018)

Hallo Leute, danke für die Tipps, ich räum dann schonmal im Konstruktor auf:

```
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.


----------



## Javinner (18. Dez 2018)

Ich stelle fest, dass du die Ratschläge, die man dir gibt, nicht befolgst. Das führt zu nichts.


----------



## scratchy1 (18. Dez 2018)

Ok, was meinst Du genau?


----------



## temi (18. Dez 2018)

scratchy1 hat gesagt.:


> 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 (18. Dez 2018)

Hallo temi, geht es so, ich hab mir dies ausgedacht? 

```
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 (18. Dez 2018)

scratchy1 hat gesagt.:


> 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: 

```
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 (18. Dez 2018)

Da du anscheinend noch Probleme bei Grundlagen hast, experimentiere doch einfach mal etwas herum:

```
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));
    }
}
```


----------



## scratchy1 (18. Dez 2018)

Hallo temi,
ok mit Referenzen verschieben werd ich also nicht weiterkommen, dann versuch ichs mal mit einem Index


----------



## mihe7 (18. Dez 2018)

Wir kommen der Sache näher.


----------



## Javinner (19. Dez 2018)

@scratchy1 
Wenn du sehen willst, wie die Leute von Oracle es gelöst haben, dann empfehle ich dir den Blick auf die ArrayList (suche in deiner IDE nach ArrayList(java.util))
Die Probleme, die du jetzt hast, hatten viele vor dir auch. Da es bei dir an Grundlagen mangelt, tue dir selbst den Gefallen und schaue dir an, wie Leute, die was davon verstehen, die Probleme seiner Zeit für uns alle gelöst haben. Das befreit dich vom Lernen der Grundlagen in keinster Weise, sondern soll dich dabei unterstützen, das System zu verstehen. Ich hoffe, du merkst es selbst, dass das hier sehr zäh abläuft


----------



## mihe7 (19. Dez 2018)

scratchy1 hat gesagt.:


> 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().


Wenn Du das Adressbuch sinnvoll testen willst, dann musst Du Dir vor allem geeignete Testfälle überlegen. 

Zum Beispiel: 
1. ein neues Adressbuch hat 0 Einträge.
2. wenn Du einen Eintrag hinzufügst, hat es um einen Eintrag mehr
3. wenn Du einen Eintrag hinzufügst, ist der Eintrag hinterher auch im Adressbuch enthalten
usw.

Beim Aufstellen der Testfälle wirst Du feststellen, dass Du Dinge im Code noch gar nicht (bewusst) berücksichtigt hast. Zum Beispiel: was passiert, wenn es den hinzuzufügenden Eintrag bereits gibt? Wann sind zwei Einträge überhaupt gleich?Was soll passieren, wenn der Eintrag null ist?

Der Spaß lässt sich dann auch per Code testen.


----------



## scratchy1 (19. Dez 2018)

Hallo Leute,
Seit gestern hab ich noch einiges getan. @Javinner: ich wusste gar nicht, dass man nach schon gelösten Problemen suchen kann, das muss ich mir merken und versuchen.
@mihe7: Ok, aber bevor ich das mache, versuch ich das Adressbuch erstmal ordentlich zu machen, ich bin jetzt wie folgt weit:

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

        newpersons = new Person[persons.length + persons.length];
        for (int j = 1; j <= persons.length ;j++) {
            newpersons[j-1] = persons[j-1];
        }
        persons = newpersons;

    }
```


----------



## mihe7 (19. Dez 2018)

scratchy1 hat gesagt.:


> ch bin jetzt wie folgt weit:


Aha! Die Lösung ist nicht falsch aber gewöhne Dir besser gleich an, 0-basiert zu denken:

```
for (int j = 0; j < persons.length; j++) {
    newpersons[j] = persons[j];
}
```


----------



## scratchy1 (20. Dez 2018)

Hallo Leut, ok ich hab jetzt das Ganze ein bisschen verbessert und eine print()-Methode zum Testen mir ausgedacht(welche natürlich noch falsch bzw. unsinnig sein könnte, aber ich wollts ausprobieren)

```
public class ArrayAdressBook1 {
    private Person[] persons;

    private int nextFreeIndex;// personenschondrin

    ArrayAdressBook1(int initialCapacity) {

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

    }

    void addPerson(Person p) {
        if (nextFreeIndex >= persons.length) {
            increaseCapacity();
        }
        persons[nextFreeIndex] = p;
        nextFreeIndex = nextFreeIndex + 1;
    }

    private void increaseCapacity() {
        Person[] newpersons;

        newpersons = new Person[persons.length * 2];
        for (int j = 0; j < persons.length; j++) {
            newpersons[j] = persons[j];
        }
        persons = newpersons;

    }

    void print() {
        int capacity;
        capacity = persons.length - nextFreeIndex;
        System.out.println("Anzahl Einträge: " + nextFreeIndex);
        System.out.println("Eintragskapazität: " + capacity);
        for (int i = 0; i < persons.length; i = i + 1) {
            persons[i].print();
            System.out.println();
        }
    }
}
```
Hier nochmal die print()-Methode gesondert:

```
void print() {
        int capacity;
        capacity = persons.length - nextFreeIndex;
        System.out.println("Anzahl Einträge: " + nextFreeIndex);
        System.out.println("Eintragskapazität: " + capacity);
        for (int i = 0; i < persons.length; i = i + 1) {
            persons[i].print();
            System.out.println();
        }
    }
```


----------



## temi (20. Dez 2018)

scratchy1 hat gesagt.:


> welche natürlich noch falsch bzw. unsinnig sein könnte, aber ich wollts ausprobieren


Und? Funktioniert es wie gewünscht?


----------



## Javinner (20. Dez 2018)

scratchy1 hat gesagt.:


> eine print()-Methode zum Testen


Ich gehe davon aus, dass du:

den Inhalt des Arrays `persons`
die Anzahl der Einträge
die aktuelle Kapazität des Arrays
in der Konsole ausgeben willst.

Zu 1:
Wenn die Klasse Person die toString()-Methode passend für die Klasse implementiert, dann müsstest du nur noch durch das Array iterieren und den Inhalt ausgeben.

```
public class Person
{
    private final String firstname;
    private final String secondName;
    Person(String fName, String sName)
    {
          this.firstName = fName;
          this.secondName = sName;
    }

    public String getFirstName()
    {
        return this.firstName;
    }
  
    public String getSecondName()
    {
        return this.secondName;
    }

    public String toString()
    {
        return "Name: ".concat(getFirstName).concat(", ").concat(getSecondName());
    }
}

public class AddressBook
{
    private Person[] persons;
    ...
   
    public void print()
    {
        for(Person p : this.persons)
       {
            System.out.println(p); // Hier wird dann die toString()-Methode der Klasse Person aufgerufen
       }
    }
}
```

Zu 2:
Du hast ein Array, welches größer ist, als Personen drin. Also sind Stellen im Array, welche unbelegt sind, ergo musst du durch das Array iterieren und die besetzten Stellen zählen.

Zu 3:
Die Kapazität des Arrays ist dessen Länge. Bedenke dabei, dass ein Array bei Null anfängt

Also könnte die print()-Methode so aussehen..

```
public void print()
{
     int besetzteStellen = zaehleStellen();
     System.out.println(String.format(Locale.GERMAN,"Besetzte Stellen: %d, Kapazität: %d%n",besetzteStellen, this.persons.lenght));
     for(Person p : this.persons)
    {
         System.out.println(p); 
    }
}
```


----------



## mihe7 (20. Dez 2018)

Javinner hat gesagt.:


> Also sind Stellen im Array, welche unbelegt sind, ergo musst du durch das Array iterieren und die besetzten Stellen zählen.


Es gibt eine Ausnahme: wenn er dafür sorgt, dass das Array ohne Lücken ist, dann ist die Anzahl an Personen gleich nextFreeIndex.


----------



## Javinner (20. Dez 2018)

@mihe7  Ja wenn  Im Augenblick geht er sein eigenen Weg..


----------



## scratchy1 (21. Dez 2018)

Hallo Leute,
Danke für die Tipps. Ich hatte und habe immer noch ein paar Schwierigkeiten mit Eclipse, aber ich hab meinen Test etwas abgeändert, weil er nicht korrekt das tat, was ich wollte. Und ich geb auch mal die Klasse Person ein die ich geschrieben habe:

Also erst mal der Test, ich wollte einmal ausgeben, wieviele Einträge im Adressbuch sind und einmal, wie groß die aktuelle Kapazität ist:

```
void print() {

        System.out.println("Anzahl Einträge: " + nextFreeIndex);
        System.out.println("Eintragskapazität: " + persons.length);
        for (int i = 0; i < persons.length; i = i + 1) {
            persons[i].print();
            
        }
    }
```
Ich denke mal, hier sind keine Lücken (falls doch, wird das mir im Moment noch zu kompliziert, aber ich hab noch ein weiteres Vorhaben/Idee, dass/die ich nachher noch offenbaren werde).
So und jetzt die Klasse Person:

```
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.
    }
}
```
Ok ich hab gerad Probleme mit Eclipse, ich hab da vorher mal rumgespielt, und meine Konfiguration ist im Moment chaotisiert, ich werd vor dem Testen das in Ordnung bringen müssen, da hab ich jemand anderem heut eine mail rausgegeben, welches Problem ich da hab.
Ansonsten, folgendes hab ich jetzt vor:
Ich will eine Klasse AdressBookTest mit einer main-Methode schreiben. In dieser erzeuge ich ein ArrayAdressBook1 mit Anfangsgröße 3. Dann will ich einige Person-Objekte erzeugen und  sie mit der Methode addPerson() ins Adressbuch legen. Um zu überprüfen, ob das Einfügen und das automatische Verdoppeln der Kapazität funktioniert, will ich an geeigneten Stellen die Methode print() des Adressbuchs aufrufen.
Ich hoff, ich hab den Mund nicht zu voll genommen oder werde mich übernommen haben.


----------



## mihe7 (21. Dez 2018)

scratchy1 hat gesagt.:


> Ich denke mal, hier sind keine Lücken


Jein. Vom Prinzip her fügst Du immer nur hinten an, so dass das Adressbuch lückenlos gefüllt wird und ein Löschen hast Du noch nicht implementiert. 

Aber: Du fängst null nicht ab, daher ist es möglich, mittels addPerson(null) Lücken einzufügen. Die führen dann dazu, dass Deine print-Methode erstens nicht die richtige Anzahl an Personen (null ist keine Person) ausgibt und zweitens bei der Ausgabe der Personendaten abschmiert.



scratchy1 hat gesagt.:


> Ich hoff, ich hab den Mund nicht zu voll genommen oder werde mich übernommen haben.


Das denke ich mal nicht. Deine Beschreibung hört sich sehr gut überlegt an und dürfte genau so umsetzbar sein.


----------



## scratchy1 (22. Dez 2018)

Hi Leute, Hi mihe7,


mihe7 hat gesagt.:


> Aber: Du fängst null nicht ab, daher ist es möglich, mittels addPerson(null) Lücken einzufügen. Die führen dann dazu, dass Deine print-Methode erstens nicht die richtige Anzahl an Personen (null ist keine Person) ausgibt und zweitens bei der Ausgabe der Personendaten abschmiert.


Ach ja wieder das Problem . Da muss ich mir noch was fürs Abfangen überlegen.(Da brauch ich aber noch ein bisschen, um die Übersicht im Moment nicht zu verlieren.
Aber vorerst noch mein Rohversuch:

```
public class AddressBookTest {

    public static void main(String[] args) {
        // erzeugen ein ArrayAddressBook mit Anfangsgröße 3.
        ArrayAddressBook1[] addressbook = new ArrayAddressBook1[3];
        Person[] persons = new Person[3];
        // Person-Objekte erzeugen.
        Person[0] = new Person("Silversurfer", 19831007);
        Person[1] = new Person("Geilo", 19831007);
        Person[2] = new Person("Hulk", 19831007);
        // Person-Objekte ins Adressbuch reinzwirbeln.
        for (int i = 0; i <= 2; i++) {
            addressbook.addPerson();
        }
        // an geeigneter Stelle schauen, ob Verdopplung funktioniert.
        if (addressbook.length >= 4) {
            for (int i = 0; i <= addressbook.length; i++) {

                addressbook[i].print();
            }
        }
    }

}
```
Ich hab ein paar Fehlermeldungen, aber da hängt vieles damit zusammen, wo in Eclipse ich die ganzen Versuche abspeicher.


----------



## mihe7 (22. Dez 2018)

Ich kommentiere mal im Code:

```
public class AddressBookTest {

    public static void main(String[] args) {
        // hier erzeugst Du ein Array, das 3 ArrayAddressBook1-Objekte
        // aufnehmen kann
        // ArrayAddressBook1[] addressbook = new ArrayAddressBook1[3];
        // du willst:
        ArrayAddressBook1 addressbook = new ArrayAddressBook1(3);

        Person[] persons = new Person[3];
        // hier verwendest Du den Klassennamen, um auf 
        // auf ein Array zuzugreifen. Das funktioniert nicht
        //Person[0] = new Person("Silversurfer", 19831007);
        //Person[1] = new Person("Geilo", 19831007);
        //Person[2] = new Person("Hulk", 19831007);
        // du willst:
        persons[0] = new Person("Silversurfer", 19831007);
        persons[1] = new Person("Geilo", 19831007);
        persons[2] = new Person("Hulk", 19831007);

        for (int i = 0; i <= 2; i++) {
            // hier fehlt die Person, die hinzugefügt werden soll
            // addressbook.addPerson();
            // du willst:
            addressbook.addPerson(persons[i]);
        }
        // hier arbeitest Du mit der Länge des Arrays addressbook
        // das funktioniert nicht, weil dieses Array gar nicht verändert
        // wird. Vielmehr wird ein Array innerhalb des Adressbuchs
        // geändert
        // if (addressbook.length >= 4) {
        // du willst hier eine Methode des Adressbuchs benutzen
        // und zwar diejenige, die die Anzahl an Personen liefert.
        // Diese musst Du ggf. noch schreiben. Ich benutze mal
        // size():
        if (addressbook.size() >= 4) {
           // hier iterierst Du über alle Adressbücher, die im
           // adressbook-Array gespeichert sind. Da Du nur ein
           // Adressbuch brauchst und hast, ist das falsch
           // for (int i = 0; i <= addressbook.length; i++) {
           //     addressbook[i].print();
           // }
           // du willst:
           addressbook.print();
        }
    }
}
```


----------



## scratchy1 (22. Dez 2018)

mihe7 hat gesagt.:


> Ich kommentiere mal im Code:
> 
> ```
> public class AddressBookTest {
> ...


Ah vielen Dank mihe7, jetzt ist mir einiges klarer geworden.
1. ich erzeuge ein Adressbuch mit 3 Einträgen durch

```
ArrayAddressBook1 addressbook = new ArrayAddressBook1(3);
```
2. Man kann direkt die neu erzeugten Person-objekte ins persons Array reinschreiben.
3. Man muss dem Addressbuch schon sagen, welche Person-objekte er aufnehmen soll, das macht der nicht automatisch.
Ok, und bei size() würd ich gern irgendwie an das nextFreeIndex aus der Klasse ArrayAddressBook1 rankommen, wenn das geht.


----------



## mihe7 (22. Dez 2018)

1. ja, ein Adressbuch, das anfänglich eine Kapazität für 3 Einträge besitzt.
2. ja. Ein Array kannst Du Dir einfach wie ein langes Regal mit einer festen Anzahl an Fächern vorstellen, die beginnend mit 0 durchnummeriert sind. Die Anweisung `persons[0] = x;` legt x somit im Fach 0 des Regals "persons" ab.
3. ja, Du musst ganz allgemein immer die Parameter angeben, die die Methode erwartet



scratchy1 hat gesagt.:


> Ok, und bei size() würd ich gern irgendwie an das nextFreeIndex aus der Klasse ArrayAddressBook1 rankommen, wenn das geht.


Wenn Du weißt, dass adressbook vom Typ ArrayAddressBook1 ist und Dir den Aufruf adressbook.size() ansiehst, dann siehst Du sofort, dass die Methode size() in der Klasse ArrayAddressBook1 deklariert sein muss. Und die (EDIT: Methode) kann - ein lückenloses Adressbuch vorausgesetzt - einfach nextFreeIndex zurückgeben.


----------



## scratchy1 (23. Dez 2018)

Hi mihe7 &co:
So jetzt hab ich was gemacht und versuch auch noch die NullPointerException zu handeln:
Vielleicht kann man das mit dem Abfangen der Ausnahme . Vielleicht ginge es ungefähr so?:

```
public class AddressBookTest {

    public static void main(String[] args) {
        // erzeugen ein ArrayAddressBook mit Anfangsgröße 3.
        ArrayAddressBook1 addressbook = new ArrayAddressBook1(3);

        // Person-Objekte erzeugen.Ich will auf das Array zugreifen
        // und Person-Objekte ins Adressbuch reinzwirbeln.
        try {
            addressbook.addPerson(new Person("Silversurfer", 19831007));
            addressbook.addPerson(new Person("Geilo", 19831007));
            addressbook.addPerson(new Person("Hulk", 19831007));
        } catch (NumberFormatException e) {
        }
        // an geeigneter Stelle schauen, ob Verdopplung funktioniert.
        if (addressbook.size() >= 4) {

            addressbook.print();

        }
    }
}
```
Vielleicht könnte ich einen Index definieren in der catch-Klausel.
Gruß Scratchy


----------



## mihe7 (23. Dez 2018)

Das Hinzufügen erzeugt (bislang) keine Exception, sondern fügt einfach null in das Array ein. Insofern bringt es nichts, wenn Du beim Aufruf der Methode versuchst, eine Exception abzufangen.

Alles, was Du tun musst, ist in der Methode addPerson auf null zu prüfen und entsprechend zu reagieren.


----------



## scratchy1 (23. Dez 2018)

Hallo mihe7,
ok, ich überlege, wie das aussehen könnte, vielleicht:

```
void addPerson(Person p) {
        if (nextFreeIndex >= persons.length) {
            increaseCapacity();
        }
        persons[nextFreeIndex] = p;
        nextFreeIndex = nextFreeIndex + 1;
        if (p==null) {
            System.out.print("Null ist keine Person");
        }
}
```


----------



## mihe7 (23. Dez 2018)

Du musst die Prüfung schon machen, bevor Du die übergebene Person zum Adressbuch hinzufügst. Aktuell fügst Du hinzu und schaust hinterher nach: oh, das ist ja keine Person, das melde ich mal. 

Wie Du auf null reagierst, ist eine andere Frage. Du kannst z. B. einfach nichts tun oder eine Exception werfen (damit will ich Dich jetzt nicht überfordern). Weil kurz vor Weihnachten ist:


```
void addPerson(Person p) {
    if (p != null) {
        persons[nextFreeIndex] = p;
        nextFreeIndex++;
    }
}
```


----------



## scratchy1 (23. Dez 2018)

Hi mihe7, was bedeutet !=  ?  Ist das sowie ==?
Also der gleiche Vergleichsoperator? 
Und wenn ja , was macht die Methode wenn(p!=null) nicht gilt? 
Ach, oder bedeutet != dass p eben nicht null ist, also die Negation?


----------



## mihe7 (23. Dez 2018)

scratchy1 hat gesagt.:


> oder bedeutet != dass p eben nicht null ist, also die Negation?


Genau, == testet auf Gleichheit, != auf Ungleichheit.



scratchy1 hat gesagt.:


> was macht die Methode wenn(p!=null) nicht gilt?


Wenn (p != null) nicht gilt, also p == null gilt, dann macht die Methode einfach nichts.


----------



## scratchy1 (23. Dez 2018)

Ach super, danke.


----------



## scratchy1 (23. Dez 2018)

Hallo mihe7,


mihe7 hat gesagt.:


> Jein. Vom Prinzip her fügst Du immer nur hinten an, so dass das Adressbuch lückenlos gefüllt wird und ein Löschen hast Du noch nicht implementiert.
> 
> Aber: Du fängst null nicht ab, daher ist es möglich, mittels addPerson(null) Lücken einzufügen. Die führen dann dazu, dass Deine print-Methode erstens nicht die richtige Anzahl an Personen (null ist keine Person) ausgibt und zweitens bei der Ausgabe der Personendaten abschmiert.


Also ich wurde zwischendurch gefragt:
Wenn Sie das jetzt mal zu Ende umsetzen, werden Sie feststellen, dass in der Methode print() noch ein kleiner Fehler ist. Sie bekommen nämlich eine NullPointerException, und zwar z.B. wenn Sie nach dem Einfügen der zweiten oder vierten Person print() aufrufen. Wenn Sie hingegen nach der dritten Person print() aufrufen, gibt es keine NullPointerException. Bitte ausprobieren!

Eine NullPointerException bedeutet, dass Sie eine Methode auf der leeren Referenz aufrufen. Haben Sie eine Idee, warum sie in den o.g. Fällen auftritt (bei drei Personen aber nicht) und wie Sie das verhindern können?"

Ich weiss im Moment nicht, warum, er meinte:"Und das hat **nichts** damit zu tun, dass null statt einer Person eingefügt wird, sondern passiert bei der letzten Version im "normalen Betrieb". 

Probieren Sie es doch einfach mal aus. Und dann denken Sie nach, an welchen Stellen sich wohl in welchen Situationen null befindet, ob Sie das überhaupt verhindern wollen und wenn nein, wie Sie trotzdem die NullPointerException verhindern (verhindern, nicht abfangen!)."


----------



## mihe7 (23. Dez 2018)

Ich weiß jetzt nicht, um welchen Code es geht aber es liest sich so, als würdest Du in AddressBook#print über das ganze persons-Array iterieren. Das musst Du natürlich auf die Zahl der Einträge begrenzen, also statt

```
for (int i = 0; i < persons.length; i++)
```
musst Du

```
for (int i = 0; i < nextFreeIndex; i++)
```
schreiben.


----------



## Xyz1 (23. Dez 2018)

Und wie sieht jetzt alles zusammengefasst aus? Denn dann kann ichs verkomplettieren.  Aus Deinen postings stellt sich noch keine Frage heraus.


----------



## scratchy1 (24. Dez 2018)

Hallo Leute,
erstmal die Klasse ArrayAddressBook1:

```
public class ArrayAdressBook1 {
    private Person[] persons;

    private int nextFreeIndex;// personenschondrin

    ArrayAdressBook1(int initialCapacity) {

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

    }

    void addPerson(Person p) {
        if (nextFreeIndex >= persons.length) {
            increaseCapacity();
        }
        if (p!=null) {
        persons[nextFreeIndex] = p;
        nextFreeIndex = nextFreeIndex++;
      
          
        }
    }

    private void increaseCapacity() {
        Person[] newpersons;

        newpersons = new Person[persons.length * 2];
        for (int j = 0; j < persons.length; j++) {
            newpersons[j] = persons[j];
        }
        persons = newpersons;

    }

    void print() {

        System.out.println("Anzahl Einträge: " + nextFreeIndex);
        System.out.println("Eintragskapazität: " + persons.length);
        for (int i = 0; i < persons.length; i = i + 1) {
            persons[i].print();
          
        }
    }
}
```
Hier die Klasse AdressBookTest:

```
public class AddressBookTest {

    public static void main(String[] args) {
        // erzeugen ein ArrayAddressBook mit Anfangsgröße 3.
        ArrayAddressBook1 addressbook = new ArrayAddressBook1(3);

        // Person-Objekte erzeugen.Ich will auf das Array zugreifen
        // und Person-Objekte ins Adressbuch reinzwirbeln.
      
            addressbook.addPerson(new Person("Silversurfer", 19831007));
            addressbook.addPerson(new Person("Geilo", 19831007));
            addressbook.addPerson(new Person("Hulk", 19831007));
      
      
        // an geeigneter Stelle schauen, ob Verdopplung funktioniert.
      

            addressbook.print();

        }
    }
```
Und hier die Klasse Person:

```
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.
    }
}
```
Mein Meister/Mentor fragte mich nun, warum eine NullPointerException nur nach dem Aufruf von print() nach der 2. oder 4. Person, aber nicht nach der 3. Person auftaucht. Aber im Moment kann ich nichts ausprobieren:
Eine Fehleranzeige habe ich in der Klasse ArrayAddressBook1 print() is undefined for the type Person(in der Zeile 
	
	
	
	





```
persons[i].print();
```
 ganz unten) und eine weitere in der Klasse ArrayAddressBookTest: ArrayAddressBook1 cannot be resolved to a type (in Zeile  
	
	
	
	





```
ArrayAddressBook1 addressbook = new ArrayAddressBook1(3); )
```

Also ich hab gedacht, dass die Fehlermeldungen mir verständlich wären, wenn ich ArrayAddressBook1, Person und ArrayAddressBookTest nicht im gleichen package wären, aber sie sind alle in einem defaultpackage, der wiederum in einem source-Ordner drin ist, der selbst im Projekt AddressBookTest gespeichert ist.


----------



## scratchy1 (24. Dez 2018)

Achso mihe7, das mit dem nextFreeIndex hol ich noch nach.


----------



## temi (24. Dez 2018)

scratchy1 hat gesagt.:


> Mein Meister/Mentor fragte mich nun, warum eine NullPointerException nur nach dem Aufruf von print() nach der 2. oder 4. Person, aber nicht nach der 3. Person auftaucht.


Der Grund dafür steht im Beitrag #76.
Denk mal darüber nach, wie dein Array aussieht, wenn es eine Länge von drei hat und du zwei Personen eingefügt hast!
Welcher Wert ist dann an der letzten Stelle?
Was passiert, wenn du auf diesen Wert (in der print()-Methode) zugreifen willst?
Welcher Wert steht an dieser Stelle, nachdem du eine dritte Person angefügt hast?
Was passiert mit dem Array, wenn du eine vierte Person anfügst?
Welcher Wert steht dann an der fünften Stelle?


----------



## scratchy1 (24. Dez 2018)

Hi temi,
Beim Einfügen von 2 Personen ist das Array mit persons[0] und persons[1] gefüllt, an der letzten Stelle steht dann noch kein Wert, oder?
Wenn ich nun in print() auf den letzten Wert zugreifen will,hmm dann geht das nicht, weil da keiner ist, aber könnte er dann nicht einfach d einfach persons[0] und persons[1] ausdrucken, also Silversurfer und Geilo?, vielleicht nicht. Wenn ich eine 3. Person anfüge ,habe ich eine Lücke an 3. Stelle, kann das sein?
Ach und das hiesse, dass die 3. Person auch nicht eingefügt werden könnte.


----------



## temi (24. Dez 2018)

scratchy1 hat gesagt.:


> Beim Einfügen von 2 Personen ist das Array mit persons[0] und persons[1] gefüllt, an der letzten Stelle steht dann noch kein Wert, oder?
> Wenn ich nun in print() auf den letzten Wert zugreifen will,


Dann hast du eine Null-Pointer-Exception


scratchy1 hat gesagt.:


> aber könnte er dann nicht einfach


Wer ist denn "er"?


scratchy1 hat gesagt.:


> Wenn ich eine 3. Person anfüge ,habe ich eine Lücke an 3. Stelle, kann das sein?


Nein. Die ersten angefügte Person ist an der ersten Stelle, die Zweite an der Zweiten und die Dritte...


----------



## scratchy1 (25. Dez 2018)

Frohe Weihnachten mihe7 und alle anderen 
Ach dann ist, wenn ich auf dem Adressbuch print() aufrufe und dort über *alle* Slots iteriere (also auch die nicht befüllten), dann steht in den "hinteren" ja u.U. noch die leere Referenz. Und das ist das Böse an der Sache.


----------



## Blender3D (25. Dez 2018)

mihe7 hat gesagt.:


> Jaaaa, auf dem 64er mit Speichern auf der 5,25"-Floppy und Locher-Kapazitätsverdopplung - ich glaub, ich muss das Teil mal wieder auspacken


Das war auch meine Zeit.


----------



## mihe7 (25. Dez 2018)

scratchy1 hat gesagt.:


> dort über *alle* Slots iteriere (also auch die nicht befüllten), dann steht in den "hinteren" ja u.U. noch die leere Referenz. Und das ist das Böse an der Sache.


Genau so ist es. Schöne Feiertage auch.


----------



## scratchy1 (25. Dez 2018)

Vielen Dank. Könnt Ihr mir auch empfehlen, wie ich einen Screenshot machen könnte in Eclipse, ich hab gesucht, aber in Eclipse selbst scheint es das nicht zu geben. Ich möchte das machen, um meinen Package-Explorer zu screenshoten und dann meinem Sensei schicken.


----------



## mihe7 (25. Dez 2018)

Unter Windows: Screenshot des aktuellen Fensters mit Alt+Print in die Zwischenablage kopieren. Danach das Bild irgendwo einfügen. Oder das "Snipping Tool" verwenden.


----------



## scratchy1 (26. Dez 2018)

Vielen Dank, es hat geklappt. Ich überlege jetzt als nextes, wie ich eine Instanz der Subklasse Student der Klasse Person auch testen kann. 

```
public class Student extends Person {
int matriculationNr;
int semester;
Student(String name, int birthday, int matriculationNr, int semester) {
super(name, birthday);
this.matriculationNr = matriculationNr;
this.semester = semester;
}
void print() {
super.print();
System.out.println("Matrikelnr: " + matriculationNr);
System.out.println("Semesterzahl: " + semester);
}
int getMatriculationNr() {
return matriculationNr;
}
}
```


----------



## scratchy1 (26. Dez 2018)

Der Test sieht nun so aus

```
public class AddressBookTest {

    public static void main(String[] args) {
        // erzeugen ein ArrayAddressBook mit Anfangsgröße 4.
        ArrayAdressBook1 addressbook = new ArrayAdressBook1(4);

        // Person-Objekte erzeugen.
        //  Person-Objekte ins Adressbuch reinzwirbeln.

        addressbook.addPerson(new Person("Silversurfer", 19831007));
        addressbook.addPerson(new Person("Geilo", 19831007));
        addressbook.addPerson(new Person("Hulk", 19831007));
        addressbook.addPerson(new Student("Planck", 18580423, 3454545, 47));

        // an geeigneter Stelle schauen, ob Verdopplung funktioniert.

        addressbook.print();

    }
}
```


----------



## scratchy1 (26. Dez 2018)

Wenn ich ursprünglich teste, erhalte ich
Anzahl Einträge: 0
Eintragskapazität: 3
Mit dem einen Studenten dazu
Anzahl Einträge: 0
Eintragskapazität: 4


----------



## mihe7 (26. Dez 2018)

Warum ist die Anzahl der Einträge 0? Der Grund liegt in der falschen Zeile: `nextFreeIndex = nextFreeIndex++;` 

Was macht der Postinkrement-Operator "++"? Er erhöht zwar nextFreeIndex, liefert aber den Wert vor der Erhöhung zurück. 

Anfangs gilt nextFreeIndex == 0. Wird die o.g. Zeile ausgeführt, wird zuerst die rechte Seite ausgewertet, d. h. nextFreeIndex++ erhöht nextFreeIndex um 1, gibt aber 0 zurück. Die 0 wird anschließend nextFreeIndex zugewiesen. Ergebnis: nextFreeIndex bleibt 0.

Entweder schreibst Du nur `nextFreeIndex++;` oder `nextFreeIndex = nextFreeIndex + 1;`. Es gibt weitere Schreibweisen, die zum richtigen Ergebnis führen, die sind in der Form aber eher ungewöhnlich, daher lasse ich sie hier mal weg.


----------



## scratchy1 (26. Dez 2018)

Ah ja vielen Dank, ich frag mich immer wie man sowas so schnell merken kann  , super, jetzt kommt
Anzahl Einträge: 4
Eintragskapazität: 6
Name: Silversurfer
Geburtsdatum: 19831007
Name: Geilo
Geburtsdatum: 19831007
Name: Hulk
Geburtsdatum: 19831007
Name: Planck
Geburtsdatum: 18580423
Matrikelnr: 3454545
Semesterzahl: 47


----------



## temi (27. Dez 2018)

@scratchy1: Offenbar verwendest du Eclipse als IDE. Du solltest dich unbedingt mal mit den dort vorhandenen Möglichkeiten einen Code zu debuggen auseinander setzen. Solche Fehler musst du durch systematisches Vorgehen und entsprechende Breakpoints auch selbst finden können.

Da ich Eclipse nicht verwende, kann dich leider keine Tipps geben, aber es findet sich hier im Forum bestimmt jemand, der das kann.


----------



## Xyz1 (27. Dez 2018)

Man ist das ein laaanges Thema... Ich dachte Planck sei schon verstorben?

@scratchy1 ist das Thema denn jetzt gelöst?


----------



## mihe7 (27. Dez 2018)

DerWissende hat gesagt.:


> Man ist das ein laaanges Thema...


Das ist ein neuer Ansatz: learning (programming) by posting


----------



## scratchy1 (27. Dez 2018)

Hallo Leute, 
Vielen Dank für Eure Hilfe, ich hab viel gelernt, das ich aber immer noch verarbeiten und merken muss.
Es ist eigentlich fertig, weil es funktioniert. Ein paar Sachen kann man in weniger Zeilen schreiben (das mache ich gerade). Es ist nicht einfach und ich bin Anfänger  . Als nächstes werde ich mir ein objektorientiertes Modell für einen intelligenten Kühlschrank ausdenken, indem ich die Gegenstände seiner Welt angebe und die Methoden,
die der Kühlschrank und diese Gegenstände besitzen müssen, um zu kommunizieren und ihre Aufgaben zu erledigen. 
Ich muss noch sehr viel üben. Im Moment habe ich 2 Bücher und das Internet und immer wenn ich was ausprobiere, will ich nicht in die Musterlösung schauen aus den Büchern. Da stehen oft auch sowieso nicht viele Kommentare, manchmal gar keine. Aber ich mach mir auch keinen Zeitdruck, ich mache alles Schritt für Schritt, und wenn ich mich abmühen muss oder irgendwo feststecke, dann bleib ich einfach solange dran wie es sein muss. Am Besten wäre natürlich, wenn ich zu jemanden (Firma/Meister/Lehrer/Ausbilder) persönlich gehen könnte, denn im direkten Dialog oder in der Gruppe , kommt man sehr oft viel schneller und besser ans Ziel.


----------



## scratchy1 (28. Dez 2018)

Hallo Leute ich wollte die eine for-Schleife durch eine Methode ersetzen, die ich in
https://docs.oracle.com/javase/8/do...java.lang.Object-int-java.lang.Object-int-int

gefunden habe: Es geht um die Methode arraycopy(), die ich statt der for-Schleife in der Verdopplungsmethode einsetzen möchte.
Der Aufruf müsste klappen, ich weiss allerdings nicht, ob und wenn ja, was in die Methode gehört,
das müsste ich mir noch überlegen.

```
private void increaseCapacity() {
        Person[] newpersons;

        newpersons = new Person[persons.length * 2];
        //for (int j = 0; j < persons.length; j++) {
            //newpersons[j] = persons[j];
        //}stattdessen nun:
        arraycopy(newpersons,0,persons,0,persons.length);
      
        persons = newpersons;

    }
    static void arraycopy(Object src, int srcPos, Object dest, int   destPos, int length) {
      
    }
```


----------



## mihe7 (28. Dez 2018)

Die Methode existiert doch bereits, warum willst Du sie nochmal schreiben?

Die Quelle ist persons, das Ziel ist newpersons, Quell- und Zielposition ist jeweils 0 und die Länge ist durch persons.length bestimmt. Also:
`System.arraycopy(persons, 0, newpersons, 0, persons.length);`
Das ist alles.


----------



## scratchy1 (28. Dez 2018)

Vielen Dank, mihe7,
ich hatte zuvor 
	
	
	
	





```
arraycopy(persons, 0, newpersons, 0, persons.length);
```
ausprobiert, ohne die Methode nochmal zu schreiben, denn intuitiv weiss ich, dass die Methode schon existierte.
Also dann interpretiere ich das so, dass man eine schon vorhandene Methode mit System.methode() aufrufen soll.
Gruß,
Scratchy


----------



## mihe7 (28. Dez 2018)

scratchy1 hat gesagt.:


> Also dann interpretiere ich das so, dass man eine schon vorhandene Methode mit System.methode() aufrufen soll.


Nein. Die Methode ist in Klasse System definiert (daher kommt das System) und als static deklariert. Letzteres bedeutet, dass man die Methode verwenden kann, ohne vorher ein Objekt erstellen zu müssen. 

Wenn Du Dir https://docs.oracle.com/javase/8/docs/api/java/lang/Math.html ansiehst, gibt es z. B. static double abs(double); daher kannst Du 
double x = Math.abs(-5.0) schreiben.


----------



## scratchy1 (30. Dez 2018)

Vielen Dank.
Gruß,
Scratchy


----------

