# Telefonliste programmieren



## Semox (9. Dez 2009)

Hallo zusammen

Ich habe ein paar spezielle Fragen und bitte um Euren Rat. Zuerst folgt die Aufgabenstellung:
_
Erstellen Sie eine Klasse TelefonEintrag, mit der Sie den Namen und die Telefonnummer einer Person erfassen können.
Entwickeln Sie eine weitere Klasse Telefonliste, die Objekte der Klasse TelefonEintrag verwaltet. 
... 
Wählen Sie als Datenstruktur zur Verwaltung der Einträge [in der Klasse TelefonListe] eine ArrayList<TelefonEintrag>. 
_

Meine Frage: Ich habe eine Liste und mal angenommen da steckt nun ein Objekt darin, daß ich entfernen will. Dann gehe ich so vor, daß ich die Liste aufrufe und einen remove(ein Objekt) Befehl gebe. Dazu wollte ich eine Methode schreiben, die das entsprechende Objekt aufruft und dem gc übergibt.

Leider verstehe ich die Logik nicht, daß zu machen. Ich muß doch nicht erst ein Objekt, was es ja schon gibt nicht nocheinmal machen, um es zu zerstören, oder? Anders gefragt - wie kann ich das entsprechende Objekt aus der liste ansprechen, um es zu zerstören? Braucht man dazu einen Suchalgo, oder geht Java selbst die Liste durch, bis es das entsprechende Objekt gefunden hat, um es zu killen?

Danke für Eure Zeit.

Okay - Das ist dann die Datei TelefonEintrag.java, :


```
public class TelefonEintrag{

	private String telNumber;
	private String name;

	public TelefonEintrag( String n, String t){
		name = n;
		telNumber = t;
	}


	public String getTelNumber(){
		return telNumber;
	}

	public String getName(){
			return name;
	}

	public void aendern(String n, String t){
		name = n;
		telNumber = t;
	}

	public String toString(){
		return "Name :" + name + " Tel: " + telNumber;
	}

	
} // end class
```

Diese wird benötigt von folgender Klasse:


```
import java.util.ArrayList;

public class Telefonliste {

	private ArrayList<TelefonEintrag> liste;

	public Telefonliste() {
		liste = new ArrayList<TelefonEintrag>();
	}

	// 2 Methoden um einen Antrag einzulegen
	// Die Methode anlegen wird ueberladen

	public void anlegen(TelefonEintrag t) {
		liste.add(t);
	}

	public void anlegen(String nummer, String namen) {
		TelefonEintrag t = new TelefonEintrag(nummer, namen);
		liste.add(t);
	}

	public void loeschen(String nummer, String namen) {
		TelefonEintrag t;
		liste.remove(t);
	}
	

}
```

Viele Grüße,
Semo


----------



## Gonzo17 (9. Dez 2009)

Ne, also das stimmt schon, dass du nicht ein neues Objekt erzeugen musst. Du musst vielmehr erstmal dieses bestimmte Objekt mit der Nummer und dem Namen finden und danach löschen. Dazu würde ich zuerst ne Methode "findTelefonEintrag" (oder wie auch immer du die nennen möchtest) schreiben, die dann eben in der Liste nach einem Eintrag mit bestimmter Nummer und bestimmten Namen sucht. Und in dieser Methode würd ich das ganz banal machen, einfach ne for-Schleife und damit jeden Eintrag der Liste mit dem vergleichen, was man sucht. Wenn ers gefunden hat, dann mit return zurückgeben, wenn er nix gefunden hat, dann nach der for-Schleife null zurückgeben. Je nachdem was du tun willst, wenn der Eintrag nicht gefunden wurde in der Liste, kannst du entweder immer remove aufrufen oder optional eine Abfrage vorher machen, die dir dann sagt, dass der Eintrag nicht in der Liste existiert.


----------



## Semox (9. Dez 2009)

Hallo Gonzo17

[Spaß mode]
Kannst Du das bitte mal ausprogrammieren?!
[/Spaß mode]

Vielen Dank für den guten Hinweis. Freue mich sehr, daß man hier (java-forum) schnell eine Antwort bekommen kann und nicht auf die kraß trägen Antwortzeiten der Kommilitonen warten muß, bevor man weitermachen kann. Im OnlineStudium ist das alles echt nervig, wenn man teilweise 3 Tage auf eine simple Frage warten muß und damit die Hausaufgaben nicht rechtzeitig fertig bekommt.

Und bitte: nicht ausprogrammieren... das mach ich schön selbst!

Danke,
Semo


----------



## Gonzo17 (9. Dez 2009)

Keine Ursache  Wenn du ne Lösung hast, dann kannste die ja mal zeigen, dann wird man dir bestimmt auch noch helfen das ggfs. zu optimieren.


----------



## Semox (9. Dez 2009)

Ich habe mal die folgende Methode loeschen(String, String) geschrieben. Wäre das korrekt? (Ich weiß nämlich noch nicht, wie ich die Methode später mal in  einem Programm verwenden kann. Wollte zuerst einmal die Logik bauen und mir später einen Kopf machen, wie man das überhaupt benutzt.) 

[Java]
public void loeschen(String nummer, String namen) {
		for(TelefonEintrag t:liste){ 
		     if(((TelefonEintrag) t).equals(namen) || ((TelefonEintrag) t).equals(nummer)){ 
		             liste.remove(t);
		     } 	else {
		    	 System.out.println("No such Name or Number known. ");
		     }	
	}
[/code]

Gruß,
Semo


----------



## eRaaaa (9. Dez 2009)

also den cast brauchst du nicht ! 
((TelefonEintrag) t).equals(namen)
aber was du brauchst, ist noch den namen von t. so ergibit das ja keinen sinn, du meinst sicherlich

t.getName().equals(namen) ...same bei nummer.

was auch nicht geht ist, beim durchiterieren mit der foreach schleife, dann elemente zu löschen!.

du könntest dir das objekt merken, und nach dem iterieren löschen beispielsweise!


----------



## Semox (9. Dez 2009)

eRaaaa hat gesagt.:


> was auch nicht geht ist, beim durchiterieren mit der foreach schleife, dann elemente zu löschen!.



Danke Dir. Den Cast hat Eclipse vorgeschlagen. Warum, das kann ich noch nicht verstehen. Warum kann man innerhalb einer Schleife kein remove() durchführen. Weißt Du das zufällig?

Grüße,
Semo


----------



## eRaaaa (9. Dez 2009)

also mit einer normalen schleife solltest du keine probleme haben, aber bei der for-each, oder generell beim iterator, schon. denn wenn du ein element löschst , veränderst du ja die liste, das passt dem iterator gar nicht


----------



## Semox (9. Dez 2009)

Ok. Solche Möglichkeiten sind wahrscheinlich hochinteressant, wenn man Listen mittels paralleler Threads bearbeitet, korrekt? Ist das die Sache mit Vector oder nicht Vector? Naja... lern' ich später noch...

Ich habe versucht das mal sinnvoll umzusetzen. Demnach ergibt sich folgende Änderung in der Methode.


a) wenn Nummer oder Name des Elements gefunden, hole den Index und speichere in Klassenvariable index. Wenn index nicht alle, so führe remove des Index bla aus.
b) wenn Nummer oder Name nicht gefunden, steige aus der foreach-Schleife aus. (Weil index nüscht enthält, endet die Methode ohne Ausführen des remove)​
Aktuell sieht die Methode so aus:
[Java]
	public void loeschen(String nummer, String namen) {
		for (TelefonEintrag t : liste) {
			if (t.getName().equals(namen) || t.getName().equals(nummer)) {
				liste.get(index);
			} else {
				System.out.println("No such Name or Number known. ");
				break;
			}

		}
                if (index != -1 ) liste.remove(index);
	}
[/Java]

EDIT: Das letzte if war fälschlicherweise noch in der Schleife.

Gruß,
Semo


----------



## eRaaaa (9. Dez 2009)

ähm
bei der 2. prüfung in deiner if, musst du getTelNumber() aufrufen !!!  nicht nochmal getName()

und von wo kommt den index? und wieso zählste das auch nirgends hoch oder so? ist ja dann immer der gleiche wert den du prüfst? also ich meinte das eig. eher so:


```
TelefonEintrag te = null;
 for (TelefonEintrag t : liste) {
            if (t.getName().equals(namen) || t.getTelNumber().equals(nummer)) {
                te = t;
                break;
            }
        }
//jetzt kannst du löschen:
if(te!=null)
liste.remove(te);
```


----------



## Semox (9. Dez 2009)

eRaaaa hat gesagt.:


> ```
> TelefonEintrag te = null;
> ```



Oh mann... ich habe Java noch nicht wirklich begriffen. Frustrierend... 

Danke für das Snippet. Warum wird te = null gesetzt? Ist das vgl. so etwas wie eine lokale Variable?

Grüße,
Semo


----------



## eRaaaa (9. Dez 2009)

es ist eine lokale variable, ja


----------



## Semox (9. Dez 2009)

Wird damit nach te also der Index des Objekts t geschrieben, der wiederum von der der remove Methode benutzt wird? Oder wird der Name des Objekts nach te geschrieben und Java weiß nun welcher Index dahinter steht um das Objekt zu entfernen?

Wenn dem so ist, spricht Java innerhalb einer ArrayList die Objekte anhand Ihrer Indizees an oder anhand des Namens?

Grüße,
Semo


----------



## eRaaaa (9. Dez 2009)

wenn die bedingung zutrifft, wird in der variable te, das objekt t (also TelefonEintrag) referenziert !
das remove in deinem fall, löscht also anhand des objektes. 
das interface definiert aber 2 remove methoden, einmal via objekt, einmal via index.

deswegne sagte ich ja auch, könntest du auch die normal schleife benutzen !!!

```
for (int i = 0; i < liste.size(); i++) {
	    if (liste.get(i).getName().equals(namen) || liste.get(i).getTelNumber().equals(nummer)) {
		liste.remove(i);
	    }
	}
```


----------



## Semox (10. Dez 2009)

Hallo eRaaaa

Jetzt habe ich es verstanden. Danke Euch für die Erklärungen.

Beste Grüße,
Semo


----------



## Vayu (10. Dez 2009)

ich würde generell nicht innerhalb einer Schleife etwas herauslöschen


```
for (int i = 0; i < liste.size(); i++) {
        if (liste.get(i).getName().equals(namen) || liste.get(i).getTelNumber().equals(nummer)) {
        liste.remove(i);
        }
    }
```

hierbei wirst du ein Element überspringen

Wenn dann mach es so


```
for (int i = 0; i < liste.size(); i++) {
        if (liste.get(i).getName().equals(namen) || liste.get(i).getTelNumber().equals(nummer)) {
        liste.remove(i);
        i--;
        }
    }
```

Aber die Methode mit merken und hinterher rauslöschen würde ich bevorzugen


----------



## eRaaaa (10. Dez 2009)

Vayu hat gesagt.:


> ich würde generell nicht innerhalb einer Schleife etwas herauslöschen
> 
> 
> ```
> ...



stimmt, da hast du recht, ich bin aber davon ausgegangen , dass dort dann eh aus der schleife gesprungen wird?! ;/


----------



## Vayu (10. Dez 2009)

ging mir ja generell um die schleifenproblematik. klar bei einem simplen remove nur eines objekts macht ein weiterlaufen keinen Sinn, aber gibt ja noch andere anwendungsfälle


----------



## Semox (10. Dez 2009)

Vayu hat gesagt.:


> ```
> for (int i = 0; i < liste.size(); i++) {
> if (liste.get(i).getName().equals(namen) || liste.get(i).getTelNumber().equals(nummer)) {
> liste.remove(i);
> ...



Hallo Vayu

Warum wird der Index heruntergezählt, wenn er beim nächsten Schleifendurchlauf wieder inkrementiert wird? Erzeugt man damit nicht einen Infinite Loop?

Grüße,
Semo


----------



## Landei (10. Dez 2009)

Vayu hat gesagt.:


> Wenn dann mach es so
> 
> ```
> for (int i = 0; i < liste.size(); i++) {
> ...



Beim Removen gehe ich Listen immer rückwärts durch, da muss man die Indizes nicht anpassen:

```
for (int i = liste.size()-1; i >= 0; i--) {
    if (liste.get(i).getName().equals(namen) || liste.get(i).getTelNumber().equals(nummer)) {
        liste.remove(i);
    }
}
```


----------



## Vayu (10. Dez 2009)

Semox hat gesagt.:


> Hallo Vayu
> 
> Warum wird der Index heruntergezählt, wenn er beim nächsten Schleifendurchlauf wieder inkrementiert wird? Erzeugt man damit nicht einen Infinite Loop?
> 
> ...



wenn du ein element entfernst aus der liste rutscht das darauffolgende im index eins runter. sprich im nächsten schleifendurchlauf würdest du das element überspringen. Also zählst du nach dem entfernen eines Objekts den index um ein dekrementieren.

ODER wie Landei schrieb, geh die Liste rückwärts durch


----------



## Semox (10. Dez 2009)

@Vayu - Okay. Hab's kapiert.

Folgeaufgabe für mich:

Jetzt versuche ich nun die 
	
	
	
	





```
aendern(String, String)
```
 Methode zu erzeugen. Im Gegensatz zur 
	
	
	
	





```
loeschen(String, String)
```
-Methode gibt es in der Klasse TelefonEintrag.java (Seite 1) zwei Parameter, die ich übergeben muß - 
	
	
	
	





```
String n
```
 und 
	
	
	
	





```
String t
```
. 

Da diese aber den Modifizierer 
	
	
	
	





```
private
```
tragen, kann ich _nicht _unmittelbar in der Telefonliste.java darauf zugreifen, um diese zu verändern. 

Die Frage: Wie muß ich vorgehen, um die aendern Methode in der Telefonliste.java nutzen möchte? Bin mir nicht sicher, wie sich das ergänzen sollte.

Habe daher folgendes überlegt. Ich lasse ein bestimmtes Objekt auffinden und würde dann den Inhalt des Objekts mit neuem Namen und ggf. neuer Nummer in der Liste speichern. Kann man das machen, oder würde der Versuch daran scheitern, daß man nur irgend so etwas wie eine Referenz umbennenen würde, daß Objekt selbst jedoch nicht umbenennen kann?


Wenn ich in der Telefonliste.java folgendes Aufrufe und übergebe,


```
TelefonEintrag.aendern(namen, nummer);
```

dann möchte mir Eclipse anraten, die 
	
	
	
	





```
aendern
```
-Methode in eine 
	
	
	
	





```
static
```
 umzuwandeln, inklusive der Variablen 
	
	
	
	





```
telNumber
```
 und 
	
	
	
	





```
name
```
.

Ist das der falsche Weg? Mache ich einen Denkfehler?

Grüße,
Semo


----------



## Semox (14. Dez 2009)

Hallo,

Habe nun eine neue Methode auf Basis der alten loeschen() geschrieben. Ich denke, das sollte so funktionieren.

[Java]
public void aendern(String nummer, String namen, String name_neu,
			String nummer_neu) {
		int index = 0;
		TelefonEintrag t_new = new TelefonEintrag(nummer_neu, name_neu);
		TelefonEintrag te = null;
		for (TelefonEintrag t : liste) {
			if (t.getName().equals(namen) || t.getName().equals(nummer)) {
				te = t;
				break;
			}
		}
		if (te != null)
			liste.get(index);
		liste.set(index, t_new);
	}
[/Java]

Nun hänge ich an der vorletzten Sache: Schreiben Sie eine Methode, um Namen-Nummer oder Nummer-Namen zu finden.

Meine Idee: Ich benutze Methoden aus der TelefonEintrag.java in der Telefonliste.java. 

Hier die entsprechenden Methoden (Ausschnitt ist vollständig im Threaderöffnungspost zu finden):

[Java]
public String getTelNumber(){
		return telNumber;
	}

	public String getName(){
			return name;
	}
(...)
public String toString(){
		return "Name :" + name + " Tel: " + telNumber;
	}
[/Java]

Ich weiß nicht so recht, wie man da beginnen sollte... Da die o.g. Methoden ja void sind, weiß ich nicht, wie ich da die Werte z.B. aus einer Konsole übergeben sollte. Ich bitte um Euren Rat.

Vielen Dank,
Semo


----------



## Vayu (15. Dez 2009)

du übergibst keine Werte aus der Konsole in die Objekte.
Du gibst in der Konsole den Namen oder die Nummer ein und möchtest den passenden Eintrag finden, korrekt?

Dann gehst du deine Liste gespeicherter telefoneinträge durch und vergleichst getName() und getNummer() mit dem über die Konsole eingegebenen Wert. sofern ein Wert übereinstimmt hast du einen Treffer.


----------



## Semox (15. Dez 2009)

Hallo

Was denkst Du darüber?

[Java]
public void findeEintrag(String nummer, String namen) {
		TelefonEintrag te = null;
		for (TelefonEintrag t : liste) {
			if (t.getName().equals(namen) || t.getName().equals(nummer)) {
				te = t;
				break;
			}
		}
		//wuerde das das Ganze Listenobjekt zurueckgeben?
                if (te != null) System.out.println(te.toString());
	}
}
[/Java]

Was ich mich frage ist, weiß dann der Compiler, daß er eine Methode aus der TelefonEintrag Klasse verwendet, oder nutzt er die toString-Methode aus der Java-API?

Grüße,
Semo


----------



## Meldanor (15. Dez 2009)

Wenn inder Klasse TelefonEintrag eine Methode mit
public String toString()
existiert, dann nimmt er diese, weil du überschreibst diese Funktion der Mutterklasse Objekt, wovon alle Klasse automatisch erben.
WEnn du das nicht hast oder
public void toString()
oder
private String toString()
dann überschreibst du nicht die Methode toString von Objekt , sondern machst eine eigene auf.


----------



## Semox (15. Dez 2009)

Meldanor hat gesagt.:


> Wenn inder Klasse TelefonEintrag eine Methode mit
> public String toString()
> existiert, dann nimmt er diese, weil du überschreibst diese Funktion der Mutterklasse Objekt, wovon alle Klasse automatisch erben.
> WEnn du das nicht hast oder
> ...



Hallo Meldanor

Danke für den Hinweis. Ich habe mal versucht das umzusetzen. Ist das dann in etwa korrekt?



[Java]
	public String findeEintrag(String nummer, String namen) {
		TelefonEintrag te = null;
		for (TelefonEintrag t : liste) {
			if (t.getName().equals(namen) || t.getName().equals(nummer)) {
				te = t;
				break;
			}
		}
		return te.toString();
	}
[/Java]

Viele Grüße,
Semo


----------



## Meldanor (15. Dez 2009)

Ich sehe gerade, dass du bereits die toString Methode in deiner klasse TelefonEintrag überschrieben hast.

Zu deinem Quellcode:
Anstatt die forschleife per break zu verlassen, würde ich bei der if Anweisung einfach schon re.toString returnen. Dann wird die schleife verlassen, die methode dort "verlassen" und der Telefonbuch eintrag zurückgegeben.
Sollte dieses return jedoch nicht erreicht werden, sprich, es gibt keinen ähnlichen Telefonbucheintrag, solltest du null zurückgegeben, so dass du im anderen Teil des Programm siehst:
Aha, es gibt keinen ähnlichen , also muss ich das jetzt einfügen.


----------



## Semox (15. Dez 2009)

Meldanor hat gesagt.:


> Anstatt die forschleife per break zu verlassen, würde ich bei der if Anweisung einfach schon re.toString returnen. Dann wird die schleife verlassen, die methode dort "verlassen" und der Telefonbuch eintrag zurückgegeben.
> Sollte dieses return jedoch nicht erreicht werden, sprich, es gibt keinen ähnlichen Telefonbucheintrag, solltest du null zurückgegeben, so dass du im anderen Teil des Programm siehst:
> Aha, es gibt keinen ähnlichen , also muss ich das jetzt einfügen.



Hmmm... Ich habe das nochmal geändert, so daß man jetzt was zurückbekommt, statt einen Abbruch zu erzwingen...

Zudem habe ich dann den Inhalt aus der Liste t in ein Objekt kopiert, damit ich später mal etwas an das return Statement liefern kann...

[Java]
	public String findeEintrag(String nummer, String namen) {
		TelefonEintrag te = null;
		Object content = null;
		for (TelefonEintrag t : liste) {
			if (t.getName().equals(namen) || t.getName().equals(nummer)) {
				te = t;
				content = te.toString();
			} else {
				System.out.println("Nicht vorhanden.");
				content = null;
			}
		}
		return (String) content;
	}
[/Java]

Gruß,
Semo


----------



## Meldanor (15. Dez 2009)

Mmm...scheinbar hab ich mich nicht so ausgedrückt, sry ^^

Ich meinte es so:


```
public String findeEintrag(String nummer, String namen) {
        for (TelefonEintrag t : liste) {
            if (t.getName().equals(namen) || t.getName().equals(nummer)) {
                return t.toString()
            }
        }
        return null;
    }
```


----------



## Semox (15. Dez 2009)

Hallo Meldanor

Cool. So wie Du hatte ich es auch, aber dann hat sich Eclipse beschwert über das missing return. Denn ich hatte nur eines in der Condition, statt am Ende der Methode. Habe mich davon fehlleiten lassen und dann angefangen Methoden und anderes static zu deklarieren... :autsch:

Vielen Dank für den Rat!

Beste Grüße
Semo


----------



## Meldanor (15. Dez 2009)

Jede Methode, die kein void hat als Rückgabewert , muss nen return beinhalten und zwar an alle Stellen der Methode

```
public boolean isTrue(){
if (true)
return true;
}
```
das würde nicht gehen, da , wenn true nicht true ist, er nie was zurückgeben würde
ergo

```
public boolean isTrue(){
if (true)
return true;
else
return false;
}
```


----------



## Vayu (15. Dez 2009)

was du noch ändern solltest ist das hier


```
if (t.getName().equals(namen) || t.getName().equals(nummer)) {
                return t.toString()
            }
```



```
if (t.getName().equals(namen) || t.getNummer().equals(nummer)) {
                return t.toString()
            }
```

sonst vergleichst du nämlich die telefonnummer mit dem namen des eintrags, das kann nie matchen


----------



## Semox (15. Dez 2009)

Hallo Vayu

Ich nehme an es sollte wohl besser so sein? 


```
if (t.getName().equals(namen) || t.getTelNumber().equals(nummer)) {
                return t.toString();
            }
```

Grüße,
Semo


----------



## Semox (15. Dez 2009)

Ich schreibe nun an der Testklasse des Programms und habe mich eines syntaktischen Verbrechens schuldig gemacht:

_Cannot make a static reference to the non-static method allesAusgeben() from the type Telefonliste	TelefonEintrag_Testklasse.java_

Ich habe eine Menü-Methode geschrieben, die eine Funktion in einer anderen Klasse aufrufen soll. Warum möchte Java, daß ich jetzt alles ändere, damit auch eine static-Methode funktioniert?

_EDIT: Ok... Habe nochmal in Forum was gefunden... http://www.java-forum.org/stichwort...ic-method-cant-referenced-static-context.html

Hilft mir in dem Fall ein bißchen weiter... Doch ich will ja nicht gleich ein Objekt erstellen und damit arbeiten. Sondern ein bereits vorhandenes Objekt abrufen... Huhn-Ei Problem... :rtfm:

Sollte ich vielleicht einen Konstruktor machen und den mit null initialisieren?_


```
private void menue() throws IOException {

		while (run) {

			System.out
					.println("Bitte waehlen Sie aus folgenden Moeglichkeiten: ");

			System.out.println("1 - Neuen Eintrag anlegen");
			System.out.println("2 - Eintrag loeschen");
			System.out.println("3 - Eintrag aendern");
			System.out.println("4 - Liste ausgeben");
			System.out.println("5 - Eintrag finden");
			System.out.println("6 - Programm beenden");
			System.out.println("Bitte geben Sie eine Wahl ein (1-6): ");

			str = br.readLine();
			sel = Integer.valueOf(str).intValue();

			switch (sel) {
			case 1: {
				System.out.println("Bitte tragen Sie den Namen ein: ");
				namen = br.readLine();
				System.out.println("Wie lautet die Telefonnummer: ");
				nummer = br.readLine();
				Telefonliste.anlegen(nummer, namen); 
//hier weigert sich der Compiler... warum 
//brauche ich da eine static Methode??
			}
//noch ein paar cases, dann eine default
}
```

lg,
Semo


----------



## Meldanor (17. Dez 2009)

KLASSE.FUNKTION bedeutet, dass du auf die static Funktionen zurückgreifst.
Static bedeutet hier, dass sie Instanzunabhängig genutzt werden können, sprich, du musst kein Objekt davon erzeugen.
Erst mit Erzeugung eines Objekts existiert es ja. Wenn es existiert, kannst du auch die Methoden nutzen.
Wenn es allerdings nicht existiert, dann hast du auch keine Methoden zur Verfügung.
Sind jedoch einige Methoden Static deklariert, dann kannst du sie auch nutzen, ohne dass ein Objekt exisitiert.

Lösung:
Entweder du erzeugst ein Objekt der Klasse Telefonliste und greifst auf die Methode zu oder aber du machst eine Funktion in Telefonliste, die static deklariert ist.


----------



## Semox (17. Dez 2009)

Hi Meldanor

Manchmal muß man eben auch was machen, vor dem man Sorge hatte, daß es schief geht... Ich habe einfach das gesamte Menu aus der Testklasse in die Telefonliste.java eingebaut. So konnte ich problemlos alles parametrisieren, wie die Methoden es erwarteten... :toll:

Nun hänge ich am Merkwürdigsten:

Wie kann ich das Programm nun in der main() ausführen lassen? 

Grüße,
Semo


----------

