Metoddeklaration

Hej! Du har redan känt till att skapa dina egna klasser med fält och metoder. Nu ska vi uppehålla oss vid metoder. Naturligtvis har vi redan gjort det här mer än en gång på våra lektioner, men vi har huvudsakligen tagit upp allmänheter. Idag ska vi dissekera metoder och studera vad de är gjorda av, de olika sätten att skapa dem och hur man hanterar det hela. :) Nu går vi!

Metoddeklaration

All kod som definierar en metod kallas en metoddeklaration . Den allmänna formen för en metoddeklaration kan beskrivas på följande sätt:

access modifier, return type, method name (parameter list) {
    // method body
}

Som exempel, ta en titt på deklarationerna för klassens olika metoder Dog.

public class Dog {

   String name;

   public Dog(String name) {
       this.name = name;
   }

   public static void main(String[] args) {
       Dog max = new Dog("Max");
       max.woof();

   }

   public void woof() {
       System.out.println("A dog named " + name + " says \"Woof, woof!\"");
   }

   public void run(int distanceInFeet) {
       System.out.println("A dog named " + name + " ran " + distanceInFeet + " feet!");
   }

   public String getName() {
       return name;
   }
}

1. Åtkomstmodifierare

Åtkomstmodifieraren indikeras alltid först. Alla Dogklassens metoder är markerade med den offentliga modifieraren. Det betyder att vi kan ringa dem från vilken annan klass som helst:

public class Main {

   public static void main(String[] args) {

       Dog butch = new Dog("Butch");
       butch.run(100);
   }

}

Som du kan se Dogär klassens metoder lättillgängliga i Mainklassen. Detta är möjligt på grund av den offentliga modifieraren. I Java finns det andra modifierare. De tillåter inte alla att metoder används i andra klasser. Vi kommer att prata om dem i andra lektioner. Det viktigaste att komma ihåg är vad modifieraren är ansvarig för: om en metod är tillgänglig i andra klasser :)

2. statiskt nyckelord

En av Dogmetoderna, main(), är markerad med nyckelordet static . Det är också en del av metoddeklarationen, och vi vet redan dess innebörd. Vi nämnde det inte i metoddeklarationsmallen som gavs i början av lektionen, eftersom det är valfritt. Om det är specificerat måste det komma efter åtkomstmodifieraren. Kommer du ihåg att vi på de senaste lektionerna pratade om statiska (klass)variabler? När det tillämpas på metoder har detta nyckelord ungefär samma betydelse. Om en metod är statisk kan den användas utan en referens till ett specifikt objekt i klassen. Och faktiskt, du behöver inte ett Dogobjekt för att köra den statiska main()metoden iDogklass. Det går bra utan en. Om denna metod inte var statisk, skulle vi först behöva skapa ett objekt för att kunna köra det.

3. Returvärde

Om vår metod skulle returnera något, så anger vi typen av returvärde. Detta framgår av exemplet med getName()getter:

public String getName() {
   return name;
}

Det returnerar ett Stringobjekt. Om en metod inte returnerar något, används nyckelordet voidwoof() istället, som i metoden:

public void woof() {
   System.out.println("A dog named " + name + " says \"Woof, woof!\"");
}

Metoder med samma namn

Det finns situationer då vi vill ha flera olika sätt att kalla en metod. Varför inte skapa vår egen artificiella intelligens? Amazon har Alexa, Apple har Siri, så varför skulle vi inte ha en? :) I filmen Iron Man skapar Tony Stark sin egen otroliga artificiella intelligens, Jarvis. Låt oss hylla den fantastiska karaktären och namnge vår AI till hans ära. :) Det första vi behöver göra är att lära Jarvis säga hej till folk som kommer in i rummet (det skulle vara konstigt om ett så fantastiskt intellekt visade sig vara oartigt).

public class Jarvis {

   public void sayHi(String name) {
       System.out.println("Good evening, " + name + ". How are you?");
   }

   public static void main(String[] args) {
       Jarvis jarvis = new Jarvis();
       jarvis.sayHi("Tony Stark");
   }
}

Konsolutgång: God kväll, Tony Stark. Hur mår du? Mycket bra! Jarvis kan nu välkomna gäster. Naturligtvis, oftare än det kommer att vara hans mästare, Tony Stark. Men tänk om han inte kommer ensam! Men vår sayHi()metod accepterar bara ett argument. Så den kan bara hälsa på en person som kommer in i rummet och ignorerar den andra. Inte särskilt artig, håller med? :/ I det här fallet kan vi lösa problemet genom att helt enkelt skriva 2 metoder med samma namn, men olika parametrar:

public class Jarvis {

   public void sayHi(String firstGuest) {
       System.out.println("Good evening, " + firstGuest + ". How are you?");
   }

   public void sayHi(String firstGuest, String secondGuest) {
       System.out.println("Good evening, " + firstGuest + " and " + secondGuest + ". How are you?");
   }

}

Detta kallas metodöverbelastning . Metodöverbelastning gör att vårt program blir mer flexibelt och rymmer olika sätt att arbeta. Låt oss se över hur det fungerar:

public class Jarvis {

   public void sayHi(String firstGuest) {
       System.out.println("Good evening, " + firstGuest + ". How are you?");
   }

   public void sayHi(String firstGuest, String secondGuest) {
       System.out.println("Good evening, " + firstGuest + " and " + secondGuest + ". How are you?");
   }

   public static void main(String[] args) {
       Jarvis jarvis = new Jarvis();
       jarvis.sayHi("Tony Stark");
       jarvis.sayHi("Tony Stark", "Captain America");
   }
}

Konsolutgång: God kväll, Tony Stark. Hur mår du? God kväll, Tony Stark och Captain America. Hur mår du? Utmärkt, båda versionerna fungerade. :) Men vi löste inte problemet! Tänk om det är tre gäster? Vi skulle naturligtvis kunna överbelasta sayHi()metoden igen, så att den accepterar tre gästnamn. Men det kan finnas 4 eller 5. Hela vägen till oändligheten. Finns det inte ett bättre sätt att lära Jarvis att hantera hur många namn som helst, utan att överbelasta metoden sayHi()en miljon gånger()? :/ Självklart finns det! Om det inte fanns, tror du att Java skulle vara det populäraste programmeringsspråket i världen? ;)

public class Jarvis {

   public void sayHi(String...names) {

       for (String name: names) {
           System.out.println("Good evening, " + name + ". How are you?");
       }
   }

   public static void main(String[] args) {
       Jarvis jarvis = new Jarvis();
       jarvis.sayHi("Tony Stark");
       System.out.println();
       jarvis.sayHi("Tony Stark", "Captain America");
   }
}

När ( String... names ) används som en parameter, indikerar det att en samling strängar kommer att skickas till metoden. Vi behöver inte ange i förväg hur många det kommer att bli, så nu är vår metod mycket mer flexibel:

public class Jarvis {

   public void sayHi(String...names) {

       for (String name: names) {
           System.out.println("Good evening, " + name + ". How are you?");
       }
   }

   public static void main(String[] args) {
       Jarvis jarvis = new Jarvis();
       jarvis.sayHi("Tony Stark", "Captain America", "Black Widow", "Hulk");
   }
}

Konsolutgång: God kväll, Tony Stark. Hur mår du? God kväll, Captain America. Hur mår du? God kväll, Black Widow. Hur mår du? God kväll, Hulk. Hur mår du? Inuti metoden itererar vi över alla argument och visar fraser formaterade med namn. Här använder vi en förenklad for-eachslinga (som du sett tidigare). Det är perfekt här, för notationen ( String... names ) betyder faktiskt att kompilatorn lägger alla de godkända argumenten i en array. Som ett resultat kan vi arbeta med variabelnamnsom vi skulle arbeta med en array, inklusive genom att iterera genom den i en loop. Dessutom kommer det att fungera med valfritt antal passerade strängar! Två, tio, till och med tusen — metoden kommer att fungera korrekt med hur många gäster som helst. Mycket bekvämare än att överbelasta metoden för alla möjligheter, tycker du inte? :) Här är ett annat exempel på metodöverbelastning. Låt oss ge Jarvis en printInfoFromDatabase()metod. Det kommer att visa information om en person från en databas. Om databasen indikerar att en person är en superhjälte eller superskurk, visar vi den informationen:

public class Jarvis {

   public void printInfoFromDatabase (String bio) {

       System.out.println(bio);
   }

   public void printInfoFromDatabase(String bio, boolean isEvil, String nickname) {

       System.out.println(bio);
       if (!isEvil) {
           System.out.println("Also known as the superhero " + nickname);
       } else {
           System.out.println("Also known as the supervillain " + nickname);
       }
   }

   public static void main(String[] args) {
       Jarvis jarvis = new Jarvis();
       jarvis.printInfoFromDatabase("Laura Palmer. Date of birth: July 22, 1972. Twin Peaks, Washington");
       System.out.println();
       jarvis.printInfoFromDatabase("Max Eisenhardt. Height: 15.6 ft. Weight: 189 lbs. ", true, "Magneto");
   }
}

Output: Laura Palmer. Födelsedatum: 22 juli 1972. Twin Peaks, Washington Max Eisenhardt. Höjd: 15,6 fot. Vikt: 189 lbs. Även känd som superskurken Magneto Så, vår metods beteende beror på vilken data vi skickar till den. Här är en annan viktig punkt: ordningen på argumenten spelar roll! Låt oss säga att vår metod tar en sträng och ett nummer:

public class Person {

   public static void sayYourAge(String greeting, int age) {
       System.out.println(greeting + " " + age);
   }

   public static void main(String[] args) {

       sayYourAge("My age is ", 33);
       sayYourAge(33, "My age is "); // Error!
   }
}

Om Personklassens sayYourAge()metod tar en sträng och ett tal som indata, så är detta ordningen som dessa argument måste skickas till metoden! Om vi ​​skickar dem i en annan ordning kommer kompilatorn att generera ett fel och personen kommer inte att kunna säga sin ålder. Förresten, konstruktörer, som vi behandlade i förra lektionen, är också metoder! Du kan också överbelasta dem (dvs skapa flera konstruktörer med olika uppsättningar av parametrar) och ordningen på skickade argument är fundamentalt viktig för dem också. De är riktiga metoder! :)

Hur man anropar metoder med liknande parametrar

Som ni vet nullär det ett nyckelord i Java. Det är mycket viktigt att förstå att det nullvarken är ett objekt eller en datatyp . Föreställ dig att vi har en Personklass och en introduce()metod, som tillkännager personens namn och ålder. Dessutom kan åldern passeras som text eller ett nummer.

public class Person {

   public void introduce(String name, String age) {
       System.out.println("My name is " + name + ". My age is " + age);
   }

   public void introduce(String name, Integer age) {
       System.out.println("My name is " + name + ". My age is " + age);
   }

   public static void main(String[] args) {

       Person alex = new Person();
       alex.introduce ("Alex", "twenty-one");

       Person mary = new Person();
       mary.introduce("Mary", 32);
   }
}

Vi är redan bekanta med överbelastning, så vi vet att båda metoderna fungerar som de ska: Jag heter Alex. Jag är tjugoett år Jag heter Mary. Min ålder är 32 Men vad händer om vi passerar nullsom den andra parametern istället för en sträng eller ett nummer?

public static void main(String[] args) {

   Person victor = new Person();
   victor.introduce("Victor", null);// Ambiguous method call!
}

Vi kommer att få ett kompileringsfel! Vad orsakar detta och exakt vad är "tvetydigheten"? Faktum är att det hela är väldigt enkelt. Problemet är att vi har två versioner av metoden: en med a Stringsom andra argument och en med en Integersom andra argument. Men a Stringoch an Integerkan båda vara null! Eftersom de är referenstyper, nullär standardvärdet för dem båda. Det är därför kompilatorn i den här situationen inte kan ta reda på vilken version av metoden den ska anropa. Lösningen på detta problem är ganska enkel. Nullkan uttryckligen konverteras till en specifik referenstyp. När du anropar en metod kan du alltså inom parentes ange vilken datatyp du vill ha för det andra argumentet! Kompilatorn kommer att förstå ditt "tips" och anropar den korrekta metoden:

public class Person {

   public void introduce(String name, String age) {
       System.out.println("Method with two strings!");
       System.out.println("My name is " + name + ". My age is " + age);
   }

   public void introduce(String name, Integer age) {
       System.out.println("Method with a string and a number!");
       System.out.println("My name is " + name + ". My age is " + age);
   }

   public static void main(String[] args) {

       Person victor = new Person();
       victor.introduce("Victor", (String) null);
   }
}

Output: Metod med två strängar! Jag heter Victor. Min ålder är null. Observera att om nummerparametern var en primitiv int, snarare än en instans av referenstypen Heltal, skulle det inte ha varit ett sådant fel.

public class Person {

   public void introduce(String name, String age) {
       System.out.println("Method with two strings!");
       System.out.println("My name is " + name + ". My age is " + age);
   }

   public void introduce(String name, int age) {
       System.out.println("Method with a string and a number!!");
       System.out.println("My name is " + name + ". My age is " + age);
   }

   public static void main(String[] args) {

       Person victor = new Person();
       victor.introduce("Victor", null);
   }
}

Kan du gissa varför? Om du gissade varför, bra jobbat! :) För primitiver kan inte vara null. Nu har kompilatorn bara ett val, dvs att anropa introduce()metoden med två strängar. Detta är versionen av metoden som kommer att köras varje gång metoden anropas.