Wenn Du das Adressbuch sinnvoll testen willst, dann musst Du Dir vor allem geeignete Testfälle überlegen.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().
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;
}
Aha! Die Lösung ist nicht falsch aber gewöhne Dir besser gleich an, 0-basiert zu denken:ch bin jetzt wie folgt weit:
for (int j = 0; j < persons.length; j++) {
newpersons[j] = persons[j];
}
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();
}
}
}
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();
}
}
Und? Funktioniert es wie gewünscht?welche natürlich noch falsch bzw. unsinnig sein könnte, aber ich wollts ausprobieren
Ich gehe davon aus, dass du:eine print()-Methode zum Testen
persons
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
}
}
}
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);
}
}
Es gibt eine Ausnahme: wenn er dafür sorgt, dass das Array ohne Lücken ist, dann ist die Anzahl an Personen gleich nextFreeIndex.Also sind Stellen im Array, welche unbelegt sind, ergo musst du durch das Array iterieren und die besetzten Stellen zählen.
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();
}
}
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.
}
}
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.Ich denke mal, hier sind keine Lücken
Das denke ich mal nicht. Deine Beschreibung hört sich sehr gut überlegt an und dürfte genau so umsetzbar sein.Ich hoff, ich hab den Mund nicht zu voll genommen oder werde mich übernommen haben.
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: 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.
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();
}
}
}
}
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();
}
}
}
Ah vielen Dank mihe7, jetzt ist mir einiges klarer geworden.Ich kommentiere mal im Code:
Java: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(); } } }
ArrayAddressBook1 addressbook = new ArrayAddressBook1(3);
persons[0] = x;
legt x somit im Fach 0 des Regals "persons" ab.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.Ok, und bei size() würd ich gern irgendwie an das nextFreeIndex aus der Klasse ArrayAddressBook1 rankommen, wenn das geht.
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();
}
}
}
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");
}
}
void addPerson(Person p) {
if (p != null) {
persons[nextFreeIndex] = p;
nextFreeIndex++;
}
}
Genau, == testet auf Gleichheit, != auf Ungleichheit.oder bedeutet != dass p eben nicht null ist, also die Negation?
Wenn (p != null) nicht gilt, also p == null gilt, dann macht die Methode einfach nichts.was macht die Methode wenn(p!=null) nicht gilt?
Also ich wurde zwischendurch gefragt: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.
for (int i = 0; i < persons.length; i++)
for (int i = 0; i < nextFreeIndex; i++)
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();
}
}
}
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();
}
}
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.
}
}
persons[i].print();
ArrayAddressBook1 addressbook = new ArrayAddressBook1(3); )
Der Grund dafür steht im Beitrag #76.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.
Dann hast du eine Null-Pointer-ExceptionBeim 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,
Wer ist denn "er"?aber könnte er dann nicht einfach
Nein. Die ersten angefügte Person ist an der ersten Stelle, die Zweite an der Zweiten und die Dritte...Wenn ich eine 3. Person anfüge ,habe ich eine Lücke an 3. Stelle, kann das sein?
Das war auch meine Zeit.Jaaaa, auf dem 64er mit Speichern auf der 5,25"-Floppy und Locher-Kapazitätsverdopplung - ich glaub, ich muss das Teil mal wieder auspacken
Genau so ist es. Schöne Feiertage auch.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.
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;
}
}
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();
}
}
nextFreeIndex = nextFreeIndex++;
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.Das ist ein neuer Ansatz: learning (programming) by postingMan ist das ein laaanges Thema...
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) {
}
System.arraycopy(persons, 0, newpersons, 0, persons.length);
arraycopy(persons, 0, newpersons, 0, persons.length);
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.Also dann interpretiere ich das so, dass man eine schon vorhandene Methode mit System.methode() aufrufen soll.