Methoden in Java

1. Inleiding

In Java definiëren we methoden waar we de bedrijfslogica van een applicatie definiëren. Ze definiëren de interacties tussen de gegevens in een object.

In deze tutorial we zullen de syntaxis van Java-methoden doornemen, de definitie van de methodehandtekening en hoe methoden kunnen worden aangeroepen en overbelast.

2. Syntaxis van methode

Ten eerste bestaat een methode uit zes delen:

  • Toegangsmodificator: optioneel kunnen we specificeren vanaf welke code men toegang heeft tot de methode
  • Retourtype: het type waarde dat door de methode wordt geretourneerd, indien aanwezig
  • Methode-identificatie: de naam die we aan de methode geven
  • Parameter lijst: een optionele door komma's gescheiden lijst met invoer voor de methode
  • Uitzonderingslijst: een optionele lijst met uitzonderingen die de methode kan veroorzaken
  • Lichaam: definitie van de logica (kan leeg zijn)

Laten we een voorbeeld bekijken:

Laten we elk van deze zes delen van een Java-methode eens nader bekijken.

2.1. Toegang tot Modifier

Met de toegangsmodificator kunnen we specificeren welke objecten toegang kunnen hebben tot de methode. Er zijn vier mogelijke toegangsmodificatoren: openbaar, beschermd, privé, en standaard (ook wel pakket-privé).

Een methode kan ook de statisch trefwoord voor of na de toegangsmodificator. Dit betekent dat de methode tot de klasse behoort en niet tot de instanties, en daarom kunnen we de methode aanroepen zonder een instantie van de klasse te maken. Methoden zonder de statisch sleutelwoorden staan ​​bekend als instantiemethoden en mogen alleen worden aangeroepen op een instantie van de klasse.

Wat betreft de prestaties: een statische methode wordt slechts één keer in het geheugen geladen - tijdens het laden van de klasse - en is dus geheugenefficiënter.

2.2. Retourtype

Methoden kunnen gegevens retourneren naar de code waarvandaan ze zijn aangeroepen. Een methode kan een primitieve waarde of een objectreferentie retourneren, of het kan niets retourneren als we de leegte trefwoord als het retourtype.

Laten we eens kijken naar een voorbeeld van een leegte methode:

public void printFullName (String firstName, String lastName) {System.out.println (firstName + "" + lastName); }

Als we een retourtype aangeven, moeten we een terugkeer verklaring in de hoofdtekst van de methode. Zodra het terugkeer statement is uitgevoerd, wordt de uitvoering van de body van de methode voltooid en als er meer statements zijn, worden deze niet verwerkt.

Aan de andere kant is een leegte methode retourneert geen enkele waarde en heeft dus geen terugkeer uitspraak.

2.3. Methode-identificatie

De methode-ID is de naam die we aan een methodespecificatie toekennen. Het is een goede gewoonte om een ​​informatieve en beschrijvende naam te gebruiken. Het is vermeldenswaard dat een methode-ID maximaal 65536 tekens kan bevatten (een lange naam echter).

2.4. Parameterlijst

Wij kunnen specificeer invoerwaarden voor een methode in de parameterlijst, die tussen haakjes staat. Een methode kan overal 0 tot 255 parameters hebben, die worden gescheiden door komma's. Een parameter kan een object, een primitief of een opsomming zijn. We kunnen Java-annotaties gebruiken op het parameterniveau van de methode (bijvoorbeeld de Spring-annotatie @RequestParam).

2.5. Uitzonderingenlijst

We kunnen specificeren welke uitzonderingen door een methode worden gegenereerd door de gooit clausule. In het geval van een aangevinkte uitzondering, moeten we ofwel de code tussen een proberen te vangen clausule of we moeten een gooit clausule in de methodehandtekening.

Laten we dus eens kijken naar een meer complexe variant van onze vorige methode, die een gecontroleerde uitzondering genereert:

public void writeName (String name) gooit IOException {PrintWriter out = new PrintWriter (new FileWriter ("OutFile.txt")); out.println ("Naam:" + naam); out.close (); }

2.6. Method Body

Het laatste deel van een Java-methode is de body van de methode, die de logica bevat die we willen uitvoeren. In de body van de methode kunnen we zoveel regels code schrijven als we willen - of helemaal geen in het geval van statisch methoden. Als onze methode een retourtype declareert, moet de hoofdtekst van de methode een retourinstructie bevatten.

3. Methode Handtekening

Volgens de definitie bestaat een handtekening van een methode uit slechts twee componenten: de naam van de methode en de parameterlijst.

Laten we dus een eenvoudige methode schrijven:

public String getName (String firstName, String lastName) {return firstName + "" + middleName + "" + lastName; }

De handtekening van deze methode is getName (String firstName, String lastName).

De methode-id kan elke id zijn. Als we echter algemene Java-coderingsconventies volgen, moet de methode-ID een werkwoord in kleine letters zijn dat kan worden gevolgd door bijvoeglijke naamwoorden en / of zelfstandige naamwoorden.

4. Een methode aanroepen

Laten we nu eens kijken hoe je een methode in Java aanroept. Laten we, in navolging van het vorige voorbeeld, aannemen dat die methoden zijn ingesloten in een Java-klasse met de naam PersonName:

public class PersonName {public String getName (String firstName, String lastName) {return firstName + "" + middleName + "" + lastName; }}

Sinds onze getName methode is een instantiemethode en niet een statisch methode, om de methode aan te roepen getName, we moeten maak een instantie van de klassePersonName:

PersonName personName = nieuwe PersonName (); String fullName = personName.getName ("Alan", "Turing");

Zoals we kunnen zien, gebruiken we het gemaakte object om de getName methode.

Laten we tot slot eens kijken hoe je een statisch methode. In het geval van een statische methode hebben we geen klasse-instantie nodig om de aanroep te doen. In plaats daarvan roepen we de methode aan met de naam voorafgegaan door de klassenaam.

Laten we demonstreren met behulp van een variant van het vorige voorbeeld:

public class PersonName {public static String getName (String firstName, String lastName) {return firstName + "" + middleName + "" + lastName; }}

In dit geval is de methodeaanroep:

String fullName = PersonName.getName ("Alan", "Turing");

5. Methode overbelasting

Java stelt ons in staat om twee of meer methoden met dezelfde identifier maar verschillende parameterlijst - verschillende methodehandtekeningen. In dit geval zeggen we dat de methode is overbelast. Laten we met een voorbeeld gaan:

public String getName (String firstName, String lastName) {return getName (firstName, "", lastName); } public String getName (String firstName, String middleName, String lastName) {if (! middleName.isEqualsTo ("")) {return firstName + "" + lastName; } retourneer voornaam + "" + tweede naam + "" + achternaam; }

Overbelasting van de methode is handig voor gevallen zoals die in het voorbeeld, waar we een methode kunnen hebben die een vereenvoudigde versie van dezelfde functionaliteit implementeert.

Ten slotte is het een goede ontwerpgewoonte om ervoor te zorgen dat overbelaste methoden zich op dezelfde manier gedragen. Anders zal de code verwarrend zijn als een methode met dezelfde identifier zich op een andere manier gedraagt.

6. Conclusie

In deze zelfstudie hebben we de delen van de Java-syntaxis onderzocht die betrokken zijn bij het specificeren van een methode in Java.

We hebben in het bijzonder de toegangsmodificator, het retourtype, de methode-ID, de parameterlijst, de uitzonderingenlijst en de hoofdtekst van de methode doorgenomen. Toen zagen we de definitie van de methodehandtekening, hoe je een methode aanroept en hoe je een methode overbelast.

Zoals gewoonlijk is de code die hier te zien is, beschikbaar op GitHub.