Skapa en metod i Java

I Java använder man metoder för att utföra en sekvens av operationer. Metoder kan få inparametrar och returnera värden. Genom att skapa en metod i Java, kan man återanvända kod flera gånger i samma program.

Vad är en metod i Java?

Ofta när man programmerar, vill man att samma kod ska utföras flera gånger fast vid olika ställen i programmet. Med en metod, kan vi specificera ett block av operationer metoden utför när den blir kallad på. Detta blir en stor fördel, eftersom du inte behöver skriva samma kod flera gånger om.

I Java använder man metoder för att utföra en sekvens av operationer.

Du kan se en metod som en “svart låda”. Man skickar in ett värde, och får ut ett annat. Vad som händer inne i lådan är egentligen inte det viktiga, det viktiga är att du vet vad du får tillbaka från metoden.

Metoder sammanfattat:

Är en sekvens av operationer som metoden utför när den blir anropad på.
Metoder kan få inparametrar, det vill säga värden som skickas in i metoden.
Det är möjligt att returnera ett värde från metoden.
En metod är oberoende av övrig kod i programmet.
En metod kan kalla (anropa) på andra metoder.
I vissa programmeringsspråk kallar man metoder för funktioner, dock är metod det korrekta i Java.

Hur skapar man metoder i Java?

När man skapar en metod behöver man ange eventuella inparametrar, samt om metoden ska returnera några värden. Vi kan designa vår metod på flera olika sätt:

Det vill säga, vi behöver ange två saker när vi skapar metoden:

Antal inparametrar
Vad metoden ska returnera

Vi kommer även behöva ange vilken datatyp vi returnerar, samt datatyp på eventuella inparametrar.

Syntax för Metoder i Java

Vi ska nu visa hur vi kan skapa olika typer av metoder i Java. Notera att de uppgifter för metodens “huvud” finns längre ned med utförligare förklaringar. Eftersom metoder i Java kan deklareras på flertalet olika sätt så visar vi ett exempel på en metod och beskriver sedan de olika delarna, så kan du lära dig hur dom hänger ihop och sedan skapa dina egna metoder.

public static int namn(int a, String b) {

    // Här skrivs det som ska hända i metoden

    return a;  // Metoden avslutas med return 
}

Inparametrar till metoder i Java

public static – är den så kallade modifieraren, som avgör synligheten för metoden.
int – specificerar vilken datatyp som metoden ska skicka tillbaka (returnera). Om ingen datatyp ska returnera anger man det reserverade ordet void. I detta fallet returnerar vi en int, men vi skulle lika gärna kunna returnera en annan datatyp, så som double, string eller float.
namn – är namnet på metoden. Alla metoder måste ha ett namn och praxis är att namnet alltid skrivs med liten bokstav.
(int a, String b) – innanför parenteserna anger man vad man vill skicka in i metoden. I detta fall skickar vi in en int som vi har gett namnet a, samt en String som vi gett namnet b. Det går att skicka in hur många värden som helst i en metod, det är bara att fylla på inom parentesen med ett kommatecken “,” mellan varje inparameter. Om man lämnar parentesen tom, skickar man inte in något värde till metoden.

Hur använder man return för metoder i Java?

return — Alla metoder (förutom de som specificeras med void), måste returnera ett värde. Det är return som anger vad vi skickar ut ur metoden. I detta fall skickar man ut värdet a. Det som vi vill returnera, måste vara detsamma som den datatyp som är specificerad när vi skapade metoden, i detta fall en int. Det skulle alltså inte gå att returnera värdet b, eftersom b är av datatypen String och vi har angett att det är en int som metoden ska returnera. En metod slutar alltid direkt efter att return har blivit körts. Det är alltså alltid det sista som händer i en metod.
void — Nyckelordet void t låter oss skapa metoder som inte returnerar ett värde. När vi inte vill att vår metod ska returnera något så specificera vi det i metodens “huvud”.
Vi kommer nedan så exempel på både metoder som returnerar ett värde och metoder som inte returnerar något (void).

Skillnad mellan en Static och Non-static metod i Java

Vad menas egentligen med Static (statisk) och Non-static (icke-statisk) metod i Java? Jo, här är några skillnader mellan dem

En av de stora skillnaderna mellan Static och Non-static metod är att en Static metod tillhör en klass medan en Non-static metod tillhör instansen. Detta betyder att du kan anropa en static metod utan att skapa någon instans av klassen. Det låter säkert otydligt nu och vi kommer se mer om klasser och instanser av klasser längre fram.
En tumregel som kan fråga sig “är det vettigt att anropa den här metoden, även om inget objekt har instantiserats ännu?” I så fall bör det definitivt vara en Static method.
Vidare, en till viktig skillnad mellan den Static och Non-static metoder är att du inte kan använda en Non-static metodvariabel i en Static metod, du kan inte ens anropa en Non-static metod från den en Static metoden. Däremot, motsatsen är funkar, till exempel. du kan anropa en Static metod från en Non-static metod i Java.
Avslutningsvis, Static konceptet upplevs i princip alltid med viss otydlighet av Java-programmerare, särskilt i början av nybörjare. Men var inte orolig det kommer bli tydligare ju mer vi lär oss om klasser och objekt

Det känns säkerligen rätt otydligt vad skillnaderna mellan Static och Non-static är, det kommer bli tydligare i kapitel 7 när vi lär oss om klasser och objekt. Vi kommer i våra exempel bara att använda Static metoder.

Vanliga misstag när man skapar metoder i Java

Enklare deklarationsfel, det händer inom programmering generellt att man är lite slarvig när man kodar
Inte är uppmärksam på antalet inparametrar och vilken datatyp man ska använda
Använder otydliga namn på sina metoder. Kom ihåg, vanligtvis i större projekt jobbar man flera olika personer på ett program med flertalet olika metoder. Då är det bra att ha tydliga namn på vad metoden utför. Det är även ett bra tips för egen del, det är lätt att tänka att man kommer att komma ihåg vad alla metoder gör, men det är lätt att glömma. Istället för att lägga tid på att undersöka det, lägg gärna några extra sekund på att skriva tydliga namn vad metoder faktiskt utför.
Specificerar fel huruvida metoden ska returnera något eller ej
Anropa Non-static metoder från ett Static sammanhang. Händer vanligtvis när man försöker använda main metoden (som är static) för att komma åt non-static metoder.

Exempel: Hur man skapar en metod i Java

Vi ska testa skapa ett program som anropar en metod tre gånger. Det enda metoden gör är att skriva ut en text.

Betrakta följande kod:

public class Metoder {

    // Skapar en metod som heter my_method
    public static void my_method(){
        System.out.println("Detta är min första metod"); 
    }

    public static void main(String[] args) {
        my_method();  // Anropa metoden
        my_method();  // Anropa metoden
        my_method();  // Anropa metoden
    }
}

Vi har skapat en metod som heter my_method(). Det är rad 3-6 som är själva metoden. Det metoden gör är att skriva ut en textrad “Detta är min första metod!“. När programmet körs, kallar vi på metoden tre gånger. Alltså kommer vi få utskriften tre gånger:

Detta är min första metod!
Detta är min första metod!
Detta är min första metod!

TESTA SJÄLV ONLINE

Exempel 2: Skapa metod i Java

Vi tar ett till exempel där vi skapar tre metoder som ska hjälpa oss med enklare matematiska beräkningar så som Addera två tal, Multiplicera två tal, och Dividera två tal.

Varje metod kommer ta två int variabler som inputparameter
Varje metod kommer returnera en double
Notera metoden för division att vi behöver göra en typkonvertering innan vi genomför själva beräkningen. Gör vi inte det så kommer vi tappa en del av resultatet eftersom vi arbetar med int variabler

public class Metoder {

    // Metod som adderar två tal
    public static double addTwoNumbers (int a, int b){
        return (a + b);
    }

    // Metod som multiplicerar två tal     
    public static double multiplyTwoNumbers (int a, int b){
        return (a * b);
    }

    // Metod som dividerar två tal
    public static double divideTwoNumbers (int a, int b){
        double num1 = (double)a;
        double num2 = (double)b;
        return (num1/num2);
    }

    public static void main(String[] args) {
        int inputA = 10;
        int inputB = 4;

        System.out.println(addTwoNumbers(inputA,inputB));
        System.out.println(multiplyTwoNumbers(inputA,inputB));
        System.out.println(divideTwoNumbers(inputA,inputB));
    }
}

Vidare, resultatet för de tre metoderna blir

14.0
40.0
2.5

Avslutningsvis, typkonverteringen som vi gör i metoden som dividerar två tal kan vi göra direkt i return satsen också. Vi valde att göra den separat för att det ska bli enklare att följa med. Väljer vi att göra den direkt i return satsen skulle den metoden se ut så här

// Metod som dividerar två tal
public static double divideTwoNumbers (int a, int b){
    return ((double)a/(double)b);
}

Föregående sida

Nästa sida