[Explained] Hur man anropar en metod i Java

Innehållsförteckning

I Java är en metod en återanvändbar kodsekvens som aktiveras när den behövs.

Metoder benämns ofta som funktioner, och dessa termer används ofta synonymt.

Betydelsen av att använda metoder eller funktioner

Programutvecklare hanterar komplexa problem genom att dela upp dem i mindre, mer hanterbara delar. Denna strategi leder till modulär programmering. Genom detta tillvägagångssätt delas koden upp i delar som kan flyttas runt och köras oberoende för att lösa ett större problem.

Metoder är praktiska eftersom de kan användas på flera ställen i ett program. Antag att du vill skapa en funktion för att eliminera överflödiga blanksteg i en textsträng. Är det effektivt att skriva samma kod varje gång den behövs i applikationen?

Eller är det bättre att skapa en metod en gång och återanvända den med olika indata? Det senare alternativet är utan tvekan mer effektivt och praktiskt.

Med hjälp av åtkomstmodifierare i Java kan du även kontrollera vilka metoder som får användas i hela programmet och vilka som inte får det. Detta gör också din kod mer lättläst, välorganiserad och strukturerad.

Olika typer av metoder i Java

I Java skiljer vi mellan två typer av metoder: användardefinierade och fördefinierade metoder. Som namnet antyder, skapas användardefinierade metoder av utvecklaren. Ett exempel på en sådan metod kan vara:

public int sum(int a, int b) {
    return a + b;
}

Fördefinierade metoder eller inbyggda metoder är en del av programmeringsspråket Java. Ett exempel på en inbyggd metod är:

String text = "Hello World";
text.toLowerCase();

Här är `toLowerCase` en inbyggd Java-metod som kan användas var som helst i din kod.

Struktur för en metod i Java

Låt oss granska den typiska strukturen för en metod i Java:

[access_modifier] [return_type] method_name(...parameters) {
    // method body
}

Dessa komponenter i en metod måste anges i en bestämd ordning. Metoden får till exempel inte definieras före returtypen. Låt oss titta närmare på varje komponent och hur de interagerar.

#1. Åtkomstmodifierare

I Java är åtkomstmodifierare nyckelord som anger synligheten för en metod, klass, gränssnitt, variabel och så vidare. Tekniskt sett finns det fyra huvudsakliga åtkomstmodifierare i Java:

`public`: tillgänglig från alla klasser
`private`: endast tillgänglig inom den klass den tillhör
`default` (ingen modifierare): tillgänglig inom samma paket
`protected`: tillgänglig inom samma paket och från subklasser i andra paket

public int sum(int a, int b) {
    return a + b;
}

I detta exempel har metoden `sum` åtkomstmodifieraren `public`, vilket gör den tillgänglig överallt.

#2. Returtyp

Returtypen för en funktion anger vilken datatyp funktionen ska returnera. Om du inte vill att funktionen ska returnera något, använd typen `void`. Nyckelordet `return` får inte användas när returtypen är `void`. Att ange en returtyp är obligatoriskt när man definierar en funktion.

public void log(String text) {
    System.out.println(text);
}

Denna metod returnerar ingenting; den skriver bara ut text till konsolen. Därför har den returtypen `void`.

#3. Metodnamn

Metodnamnet identifierar en metod inom en klass och används för att anropa metoden via ett objekt.

class Print {
    void log(String text) {
        System.out.println(text);
    }
}

Print p = new Print();
p.log("hello world"); // skriver ut "hello world"

#4. Parametrar

Du kan skicka argument till metoder, baserat på de parametrar som definieras i metoden. Om till exempel två parametrar definieras i en metod, kan du bara skicka två argument med motsvarande datatyper. Dessutom måste du skicka argumenten i den ordning de definieras.

class Calc {
    int sum(int a, int b) {
        return a + b;
     }
}

Calc cal = new Calc();
cal.sum(3, 7); // returnerar 10

#5. Kropp

Metodkroppen innehåller den programmeringslogik som används för att generera ett specifikt resultat. Den utför den uppgift som metoden är avsedd för. Metodkroppen omsluts av klammerparenteser och benämns ofta som ett kodblock.

class Calc {
    int sum(int a, int b) {
        return a + b;
     }
}

Här är `return`-satsen inuti klammerparenteserna kropp av metoden `sum`.

Anropa metoder i Java

Att anropa metoder i Java är enkelt. Du kan anropa en metod genom dess namn via en instans av den klass den finns i.

Statiska metoder kan anropas utan att skapa en instans av klassen. Icke-statiska metoder måste anropas via en instans av en klass, det vill säga ett objekt.

För statiska metoder ser anropet ut så här:

class Math {
    public static int sum(int a, int b) {
        return a + b;
    }
}

public class Main {
    public static void main(String[] args) {
        int add = Math.sum(5, 2);
        System.out.println(add);
    }
}

I koden ovan är metoden `sum` i klassen `Math` en statisk metod. Därför behöver du inte skapa ett objekt (instans) av `Math`-klassen, utan kan anropa metoden direkt från klassen.

För icke-statiska metoder ser anropet ut så här:

class Math {
    public int sum(int a, int b) {
        return a + b;
    }
}

public class Main {
    public static void main(String[] args) {
        int add = new Math().sum(5, 2);
        System.out.println(add);
    }
}

Här skapas ett nytt objekt från `Math`-klassen, och metoden `sum` anropas via det objektet. Detta beror på att icke-statiska metoder inte instansieras förrän klassen instansieras.

Det är så du kan anropa en metod i Java.

Avslutande tankar

Metoder är inte bara viktiga i Java, utan i alla programmeringsspråk. De är ett utmärkt sätt att strukturera din kod och återanvända kod på olika platser. Metoder är grundläggande byggstenar i modulär och komponentbaserad arkitektur.

Om du är intresserad av Java, kan du lära dig mer om felhantering i Java.