Een fragment uit een lezing met een mentor als onderdeel van de Codegym University-cursus. Schrijf je in voor de volledige cursus.
"Gegroet, Amigo! Ik hoor dat je de methodes al goed onder de knie hebt?"
"Hallo, Rishi. Ja, ik heb me al een weg gebaand door de truc van die leraar. Ik zou zeggen dat het niet zo erg was, maar je zult me vertellen: 'Nee, nee! Je hebt niets bedacht. '"
"Je hebt duidelijk te veel tijd besteed aan het kletsen met bepaalde leraren, waarschijnlijk met Diego. Hoe dan ook... ik hoop nog steeds dat je methoden goed genoeg begrijpt. Tenslotte ga ik je vandaag wat magische woorden leren die helpen bij het afbakenen van methoden. 'invloedssferen'.
"Klinkt intrigerend."
"In feite is het allemaal eenvoudig. Voor elke methode kunnen programmeurs zogenaamde toegangsmodifiers specificeren. Deze bevatten de volgende trefwoorden: public
, protected
, private
.
"Met deze toegangsmodifiers kun je de toegang van andere klassen tot een methode beperken.
"Als u bijvoorbeeld het private
sleutelwoord vóór een methodedeclaratie schrijft, kan de methode alleen worden aangeroepen vanuit dezelfde klasse waarin deze is gedeclareerd. Het public
sleutelwoord geeft toegang tot de gemarkeerde methode vanaf elke methode van elke klasse.
Er zijn in totaal 3 van dergelijke modifiers , maar er zijn 4 soorten toegang tot een methode. Dit komt omdat de afwezigheid van een toegangsmodificator ook iets betekent. Hier is een volledige tabel:
Toegang vanaf... | ||||
---|---|---|---|---|
Modificaties | Elke klasse | Kind klasse | Zijn pakket | Zijn klasse |
public |
Ja | Ja | Ja | Ja |
protected |
Nee | Ja | Ja | Ja |
geen modificatie | Nee | Nee | Ja | Ja |
private |
Nee | Nee | Nee | Ja |
"En hier is een volledige uitleg van de toegangsmodificatoren:
1. public
modificator
Een methode (of variabele of klasse) gemarkeerd met de modifier is overal in het programmapublic
toegankelijk . Dit is de hoogste graad van openheid — er zijn geen beperkingen.
2. private
modificator
Een methode (of variabele of klasse) gemarkeerd met de private
modifier is alleen toegankelijk vanuit dezelfde klasse waarin deze is gedeclareerd . Voor alle andere klassen is de gemarkeerde methode (of variabele) onzichtbaar. Het is alsof het niet bestaat. Dit is het hoogste niveau van beperking - alleen zijn eigen klasse.
3. Geen modifier (standaard modifier)
Als een methode (of variabele) niet is gemarkeerd met een modifier, wordt deze geacht de 'standaardmodifier' te hebben. Variabelen of methoden met die modifier (dwz helemaal geen) zijn zichtbaar voor alle klassen in het pakket waarin ze zijn gedeclareerd . En alleen voor hen. Deze modifier wordt soms ook wel genoemd package-private
, wat aangeeft dat toegang tot variabelen en methoden openstaat voor het hele pakket waarin hun klasse zich bevindt.
4. protected
modificator
Als een methode is gemarkeerd met de protected
modifier, dan kan deze worden benaderd vanuit dezelfde klasse, hetzelfde pakket en afstammelingen (klassen die de klasse overerven waarin de methode is gedeclareerd). We zullen dit onderwerp in meer detail analyseren in de Java Core-zoektocht."
"Interessant, maar ik weet niet zeker of ik deze modifiers meteen op de goede plek kan zetten.
"Je komt er geleidelijk aan. Je hoeft je van tevoren geen zorgen te maken. Totdat je het einde van de Java Syntax-zoektocht hebt bereikt, kun je de modifier gebruiken public
voor al je methoden (evenals klassen en instantievariabelen). Je hebt de andere modifiers wanneer we OOP actief gaan leren."
"Kunt u in meer detail uitleggen waarom toegangsmodificatoren nodig zijn?"
"Ze worden noodzakelijk voor grote projecten die door tientallen en honderden programmeurs tegelijkertijd worden geschreven.
"Soms zijn er situaties waarin een programmeur een te grote methode in delen wil splitsen en een deel van de code wil verplaatsen naar helpermethoden. Maar tegelijkertijd wil hij of zij niet dat andere programmeurs deze helpermethoden aanroepen, omdat de corresponderende code werkt mogelijk niet correct."
"Dus bedachten ze deze toegangsmodificatoren. Als je een helpermethode markeert met het woord private , dan kan geen andere code dan je klas je helpermethode zien."
"Ik denk dat ik het begrijp."
static
trefwoord
"Er is nog een interessant sleutelwoord. Het is static
. Het is niet verwonderlijk dat het methoden statisch maakt."
"Wat betekent dat?"
"Ik zal je er later meer over vertellen. Maak je geen zorgen. Probeer nu een paar feiten over statische methoden te onthouden.
Feit 1. Een statische methode is aan geen enkel object gekoppeld, maar behoort in plaats daarvan tot de klasse waarin deze is gedeclareerd. Om een statische methode aan te roepen, moet u schrijven:
ClassName.MethodName()
Voorbeelden van statische methoden:
Naam van de klasse | Naam van de statische methode | |
---|---|---|
Thread.sleep() |
Thread |
sleep() |
Math.abs() |
Math |
abs() |
Arrays.sort() |
Arrays |
sort() |
De klassenaam voor de naam van een statische methode kan worden weggelaten als u de statische methode vanuit zijn klasse aanroept. Dit is de reden waarom u niet hoeft te schrijven Solution
voor de namen van elk van de statische methoden die worden aangeroepen.
Feit 2. Een statische methode heeft geen toegang tot de niet-statische methoden van zijn eigen klasse. Een statische methode heeft alleen toegang tot statische methoden. Als resultaat declareren we alle methoden die we willen aanroepen vanuit de main
methode statisch."
"Waarom is dat?"
"Je zult deze vraag zelf beantwoorden als je begint met het leren van OOP en begrijpt hoe statische methoden werken. Vertrouw me tot die tijd maar.
throws
trefwoord
"Er is nog een trefwoord dat je waarschijnlijk hebt gezien in een methodedeclaratie - het throws
trefwoord. In tegenstelling tot toegangsmodificaties en het trefwoord, wordt dit trefwoord na de methodeparameters static
geplaatst :
public static Type name(parameters) throws Exception
{
method body
}
"En wat betekent dat?"
"Nogmaals moet ik je zeggen dat je later het ware doel ervan zult leren, wanneer we uitzonderingen bestuderen (in niveau 15).
Maar om er oppervlakkig op in te gaan, kunnen we zeggen dat een methode gemarkeerd met het throws
trefwoord fouten (uitzonderingen) kan genereren, waarmee wordt bedoeld instanties van de Exception
klasse (en klassen die deze overerven). Als er verschillende soorten fouten kunnen optreden in een klasse, dan moet je ze allemaal opsommen, gescheiden door komma's."
"Klinkt mysterieus en onbegrijpelijk! Ik zal moeten wachten op niveau 14."
belangrijkste methode
"Laten we nu de hoofdmethode eens nader bekijken. U begrijpt al dat de regel waar een methode wordt gedeclareerd, die alle modifiers bevat, van invloed is op hoe deze methode wordt aangeroepen vanuit andere klassen en methoden. Bovendien heeft het invloed op het type resultaat zal de methode terugkeren en aangeven welke fouten mogelijk zijn terwijl deze wordt uitgevoerd.
"Zo'n regel wordt een methodedeclaratie genoemd en heeft de volgende algemene indeling:
access modifier static Type name(parameters) throws exceptions
Waar access modifiers
wordt vervangen door public
, protected
, private
, of helemaal niets;
als de methode statisch is, static
verschijnt het trefwoord (het is afwezig voor niet-statische methoden)
Type
is het type van de geretourneerde waarde ( void
als er geen resultaat is)
"Nu heb je een veel beter begrip van wat al deze woorden betekenen in de verklaring van de main
methode:
public static void main(String[] args) throws Exception
main
De methode declareren
"Nou, nu realiseer ik me dat toegang tot de main()
methode mogelijk is vanuit elke klasse, zoals aangegeven door het public
trefwoord. De methode is statisch, dus het kan expliciet worden aangeroepen als Solution.main()
."
"Welk resultaat geeft de main()
methode terug?"
"Helemaal geen! Het resultaattype is void
. Het is een soort leeg type, een tijdelijke aanduiding."
"Wat main()
staat er tussen haakjes?"
"Hmm... Het blijkt dat de main
methode argumenten nodig heeft (!). Ze worden doorgegeven als een reeks strings."
"Dat klopt. En de parameternaam args
suggereert 'argumenten' voor onze geest. Wanneer het programma start, kun je het argumenten doorgeven - een reeks strings. Ze zullen in de args
array in de main()
methode worden opgenomen."
"Ho! Ik vroeg me dit af toen ik het de eerste keer zag, maar toen raakte ik eraan gewend en begon ik zonder na te denken de parameterlijst te schrijven."
"We zijn er allemaal geweest. Ten slotte kunnen onverwerkte fouten zoals Exception
(of zijn afstammelingen) in de main()
methode voorkomen. We weten dit dankzij het throws Exception
deel van de aangifte."
"Dank je, Rishi. Ik begreep niet alles, maar dit was interessant."
'Graag gedaan. Geleidelijk zul je al deze subtiele punten gaan begrijpen, dat weet ik zeker.'
GO TO FULL VERSION