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
}