1. Passerende argumenter
Og nu begynder det sjove. Du kender sikkert allerede fra metoder som System.out.println()
den, at vi kan overføre argumenter til metoder. Når vi er inde i metoden, omtaler vi dem som parametre. Faktisk forbedrer parametre i høj grad de fordele, vi får ved at skabe og bruge metoder.
Hvordan erklærer vi en metode med parametre? Det er faktisk ret simpelt:
public static void name(parameters)
{
method body
}
Hvor name
er det unikke navn på metoden og method body
repræsenterer de kommandoer, der udgør metoden. Og parameters
er en pladsholder for metodeparametrene, adskilt af kommaer. Lad os beskrive denne skabelon mere detaljeret:
public static void name(Type1 name1, Type2 name2, Type3 name3)
{
method body
}
Eksempler:
Kode | Forklaring |
---|---|
|
Metoden print er deklareret med en parameter:String str |
|
Metoden print er deklareret med to parametre:String str int count |
|
Metoden write er deklareret med to parametre:int x int y |
Hvis vi ikke ønsker at metoden skal have parametre, så lader vi bare parenteserne stå tomme.
Parametre er specielle variable inden for en metode. Med deres hjælp kan du videregive forskellige værdier til metoden, når den kaldes.
Lad os for eksempel skrive en metode, der viser en tekststreng et givet antal gange.
Du ved allerede, hvordan man skriver kode for at vise en streng på skærmen flere gange. Men hvilken streng skal du printe? Og hvor mange gange? Det er det, vi skal bruge parametrene til.
Koden, der gør dette, vil se sådan ud:
Kode | Forklaring |
---|---|
|
Vi erklærede printLines metoden med følgende parametre: String text , int count Metoden viser strengtider text count Vi kalder printLines metoden med forskellige parametre |
Hver gang en metode kaldes, tildeles dens parametre de beståede værdier, og først derefter begynder vi at udføre kommandoerne inde i metoden.
2. Argumenter
Jeg vil gerne henlede din opmærksomhed lidt mere på at kalde en metode med parametre.
De værdier, der sendes til metoden, kaldes normalt argumenter, når de overføres til metoden.
Lad os se på et andet eksempel:
Kode | Forklaring |
---|---|
|
Vi erklærede printLines metoden med følgende parametre: String text , int count Metoden viser strengtider. text count Vi kalder printLines metoden med følgende argumenter:text = "Hi"; count = 10; text = "Bye"; count = 20; |
Da printLines
metoden blev kaldt for første gang, blev dens parametre tildelt følgende værdier: String text = "Hi", int count = 10
.
Da printLines
metoden blev kaldt anden gang, blev dens parametre tildelt forskellige værdier: String text = "Bye", int count = 20
.
Parametre er hverken mere eller mindre end variabler, der tildeles bestemte værdier, når en metode kaldes. Værdierne "Hi"
, "Bye"
, 10
og 20
kaldes i sig selv argumenter."
3. Modstridende variabelnavne, når en metode kaldes
Variabler kan bruges som metodeargumenter. Dette er enkelt og forståeligt, men det kan potentielt give nogle vanskeligheder. Lad os gå tilbage til det samme eksempel, men denne gang flytter vi argumenterne til separate variable:
Kode | Forklaring |
---|---|
|
Vi erklærede printLines metoden med følgende parametre: String text , int count Metoden viser strengtider. text count Vi kalder printLines metoden med følgende argumenter:text = str; count = n; |
Så langt, så godt: Vi har en str
variabel. Dens værdi tildeles parameteren, text
når metoden kaldes. Vi har en n
variabel. Dens værdi tildeles parameteren, count
når metoden kaldes." Indtil videre er alt klart.
Lad os nu omdøbe vores variable i main
metoden:
Kode | Forklaring |
---|---|
|
Vi erklærede printLines metoden med følgende parametre: String text , int count Metoden viser strengtider. text count Vi kalder printLines metoden med følgende argumenter:text = text; count = count; |
Vær opmærksom på to ting
For det første: vi har variabler med samme navn i forskellige metoder. Disse er forskellige variabler (vi afbilder dem bevidst ved hjælp af forskellige farver). Alt fungerer på samme måde som i det foregående eksempel, hvor variablerne i main
metoden blev navngivet str
og n
.
For det andet: Der sker ikke noget magisk, når metoden kaldes. Parametrene tildeles simpelthen argumentværdierne. Uanset om det er tal, strenge, variable eller udtryk.
Efter at vi har omdøbt variablerne i hovedmetoden, er intet ændret. De var forskellige variabler i forskellige metoder tidligere, og så forbliver de. Der er ingen magisk forbindelse mellem variablerne text
og text
.
4. Videregivelse af referencer til metoder
Jeg håber, at du forstod alt fra den forrige lektion, for nu skal vi gense forbigående argumenter til metoder, kun vi dykker dybere.
Som du allerede ved, lagrer nogle Java-variabler ikke selve værdierne, men i stedet en reference, altså adressen på den hukommelsesblok, hvor værdierne er placeret. Sådan fungerer strengvariabler og matrixvariabler.
Når du tildeler en anden matrixvariabel til en matrixvariabel, hvad sker der så? Det er rigtigt. De to variabler begynder at henvise til det samme rum i hukommelsen:
Og hvad sker der, hvis en af disse variable er en metodeparameter?
Kode | Forklaring |
---|---|
|
Metoden printArraySum beregner summen af tallene i det beståede array og viser det på skærmen |
Præcis det samme sker: data
parameteren vil indeholde en reference til det samme hukommelsesområde som variablen months
. Når metoden kaldes, opstår en simpel tildeling :.data = months
Og da begge variabler refererer til det samme hukommelsesområde, der lagrer et heltal, så printArraySum
kan metoden ikke kun læse værdier fra arrayet, men også ændre dem!
For eksempel kan vi skrive vores egen metode, der udfylder et todimensionelt array med samme værdi. Sådan kan det se ud:
Kode | Forklaring |
---|---|
|
Metoden fill itererer over hver celle i det beståede todimensionelle array og tildeler value dem. Vi skaber et todimensionelt array. Vi fylder hele arrayet med nummeret 8 . |
5. Metoder med samme navn
Lad os nu vende tilbage til metodenavnene igen.
Java-standarder kræver, at alle metoder i samme klasse har unikke navne. Det er med andre ord umuligt at erklære to identisk navngivne metoder i samme klasse.
Når metoder sammenlignes for ensartethed, tages der ikke kun hensyn til navnene, men også parametrenes typer ! Bemærk, at navnene på parametrene ikke tages i betragtning . Eksempler:
Kode | Forklaring |
---|---|
|
Disse tre metoder er forskellige metoder. De kan deklareres i samme klasse. |
|
Hver af disse fem metoder betragtes som forskellige . De kan deklareres i samme klasse. |
|
Disse to metoder betragtes som de samme , hvilket betyder, at de ikke kan erklæres i samme klasse. |
Hvorfor betragtes nogle metoder som ens , mens andre er forskellige ? Og hvorfor tages der ikke højde for parameternavne, når en metodes unikhed skal bestemmes?
Hvorfor er unikhed overhovedet nødvendigt? Sagen er, at når compileren kompilerer et program, skal den vide præcis, hvilken metode du har tænkt dig at kalde et givet sted.
For eksempel, hvis du skriver , er compileren smart og vil nemt konkludere, at du har tænkt dig at kalde metoden her med en parameter.System.out.println("Hi")
println()
String
Men hvis du skriver , vil compileren se et kald til metoden med en parameter.System.out.println(1.0)
println()
double
Når en metode kaldes, sikrer compileren, at typerne af argumenterne matcher parametrenes typer. Den lægger ikke vægt på navnet på argumenterne. I Java hjælper parameternavne ikke compileren med at bestemme, hvilken metode der skal kaldes. Og det er derfor, de ikke tages i betragtning, når man skal bestemme en metodes unikke karakter.
Navnet på en metode og typen af dens parametre kaldes metodesignaturen . For eksempel,sum(int, int)
Hver klasse skal have metoder med unikke signaturer i stedet for metoder med unikke navne.
GO TO FULL VERSION