Neem even de tijd om een object te bestuderen. Alle Java-klassen zijn een
subklasse van Object en dus nemen alle Java-klassen de methoden
clone (), equals (), finalize (), hashCode (), enzovoort over.
bevat() staat niet in die lijst met objectmethoden. bevat() komt
van een andere plaats - een interface genaamd Collection . Een interface definieert een
contract voor een bepaalde klasse (en alle klassen zijn
uiteindelijk Objecten), waarbij dat contract een lijst is van
methoden die moeten worden geïmplementeerd. Verzameling definieert
een bevat() -methode en alles dat een verzamelinginterface
implementeert, inclusief Lijst - uitvoering van klasse, moet een bevat()
methode bevatten.
Wanneer u een lijst opgeeft voor uw methode searchList (), geeft
u deze door een parameter Object. Dat betekent dat binnen
searchList() de enige methoden die kunnen worden aangeroepen, de
methoden zijn die voor Object zijn gedefinieerd, zelfs als de lijst
in uw aanroep naar searchList() echt een lijst van een soort is. In
zekere zin heeft uw parameterlijst de lijst-i-heid van de
lijstparameter "weggecrubd".
Wat u moet doen, zoals al vermeld, is uw parameter wijzigen in
Verzameling of Lijst. Op die manier weet de Java-compiler binnen de
methode searchList() dat de parameter 'list' in werkelijkheid een
List is en dus echt een methode contains() heeft.
Merk op dat List ook een interface is, en het bevat de
Collection-interface door het uit te breiden. Dus elke klasse die
de lijstinterface implementeert, moet de methoden in de verzameling
bieden, evenals de aanvullende lijstmethoden. Moet u lijst of
verzameling gebruiken? Mijn mening is om de minst dwingende keuze
te gebruiken. Het lijkt erop dat je searchList() alleen contains()
gebruikt, dus echt, het zal werken op alles dat Collection
implementeert, inclusief bijvoorbeeld Instellen .
Dus ik zou je methode een andere naam geven door te verwijzen
naar waar je naar kijkt (binnen een lijst) naar wat je zoekt (de
volgende regel).
public void searchForNextLine(Scanner scan, Collection lines){
System.out.println("Search for element:\t");
String p = scan.nextLine();
if (lines.contains(p))
System.out.println(p + " is in the collection of lines");
else
System.out.println(p + " is not in the collection of lines.");
}
Laten we nu aannemen dat u uw lijst heeft geïmplementeerd met
een ArrayList . Later verander je van gedachten, en
besluit je dat een TreeSet is beter. Deze searchForNextLine()
-methode zal blijven werken, omdat zowel TreeSet als ArrayList
implementaties van Collection zijn. Beter nog, als u besluit om uw
eigen lijstklasse te rollen (en zeker weet dat u een echte lijst
wilt, en niet een andere soort verzameling), dan moet u, zolang u
de lijstinterface implementeert, een bevat() methode (omdat je ook
de Collection-interface implementeert als onderdeel van de
implementatie van de List-interface), en je het object van je
nieuwe klasse kunt doorgeven aan searchForNextLine (), ervan
overtuigd dat het prima werkt zonder enige wijzigingen .
public class MyListClass implements List {
//all the methods required to implement a List interface
}