Skapa och anropa en metod i Java

Den här artikeln kommer visa hur man kan anropa en metod i Java (engelska: call a method), med andra ord, hur man använder en metod. Vi kommer se exempel på hur man genom att skapa flera små metoder, sedan kan använda dem för att tillsammans utgöra ett större program.

Hur anropar man en metod i Java?

När man vill använda en skapad metod så säger man att man anropar man den metoden. För att anropa metoden så anger man metodens namn och eventuella inparametrar. När en parameter skickas till metoden kallas den för ett argument.

För att anropa en metod i Java skriver vi:

• Först metodens namn.
• Följt av argumenten in till metoden inom parantes. Kräver metoden flera argument så separerar vi dom med ett kommatecken (input1, input2, input3, osv).
• Vi avslutar sedan med ett semikolon.

Syntax: Anropa en metod i Java

Om vi skriver in punkterna i listan ovan i kodeditorn så får vi

metodensNamn (input parametrar);

Argument till en metod i Java

När vi skickar en parameter till en metod kallas den för ett argument. Observera att när du arbetar med flera parametrar måste metodanropet ha samma antal argument som det finns parametrar och argumenten måste skickas i samma ordning. Med andra ord, om du har metoden nedan

public static void exMethod (int a, String b, double c){

}

Så ska alla argument in till metoden finnas och vara i ordningen int, string och double. Relaterat till det, om metoden inte har några inparametrar så kan vi självklart inte ange några.

Genom att skapa flera små metoder i Java, kan dessa användas för att skapa stora program. 

Tilldela värden från det en metod returnerar till en variabel

Om metoden returnerar ett värde, kan man tilldela detta till en variabel av samma datatyp. Om vi har en metod som returnerar något och vill spara ned det i en variabel så skriver vi enkelt

datatyp variabelNamn = metodensNamn (input parametrar);

Viktigt att vara uppmärksam på vad metoden returnerar för datatyp. Kom ihåg, vill vi spara ned värden i en annan datatyp än vad som returneras från metoden så löser vi det med hjälp av typkonvertering.

Exempel: Anropa metoder i Java

Nu har vi sett hur man skapar och anropar metoder i Java, men låt oss nu ta ett par exempel för att använda det vi har gått igenom.

Exempel 1: Anropa en metod i Java

Låt oss börja med ett enklare exempel. Nedan har vi skapat en metod som heter min_metod. Vi har angett att metoden ska returnera en int och ha två inparametrar, num1 och num2, av typen int. Det metoden gör är att utföra en multiplikation mellan num1 och num2 och sedan returnera värdet

public static int min_metod(int num1, int num2){ 
    return num1 * num2; 
}

Om vi illustrerar metoden får vi,

Vi kan nu anropa metoden med dess metodnamn:

int a = min_metod(5, 4);

• I detta fall skapar vi en variabel av typen int som heter a. Variabeln a kommer tilldelas värdet som returneras från metoden.
• Våra inparametrar till metoden är värdet 5 och 4 där variabeln num1 kommer få värdet 5 och variabeln num2 kommer bli 4. Inparametrarna till metoden blir tilldelade i samma ordning som man specificerar dem när man skapar metoden.
• Metoden returnerar multiplikationen mellan num1 och num2. Skriver vi ut värdet på a kommer vi alltså få utskriften 20.

Låt oss testa några fler fall

int a = min_metod(5, 4);
int b = min_metod(3, 2); 
int c = min_metod(1, 8);

Skriver vi ut variablerna får vi

System.out.println(a); 
System.out.println(b); 
System.out.println(c);

Vilket resulterar i

20
6
8

Vill du testa koden ovan själv, klicka på knappen nedan för att testa den online.

Exempel 2: Skapa och Anropa flera metoder i Java

Vi ska nu testa skapa flera olika metoder i Java och sedan anropa dessa. Vi ska programmera en räknare som håller reda på hur många personer det är inne i en butik. I exemplet använder vi klassen scanner för att ta in information av användaren.

Vi börjar med en väldigt enkel metod, det enda den ska göra är att lägga till en person

//Öka variabeln nmbrOfPeople med ett
public static void increaseValue(){     
    nmbrOfPeople++;                     
}

Vidare, på motsvarande sätt skapar vi en metod som ska ta bort en person

//Metoden minskar variabeln nmbrOfPeople med ett
public static void decreaseValue(){     
    nmbrOfPeople--;                    
}

Sedan vill vi även ha metod som returnerar värdet på nmbrOfPeople

//Metoden returnerar värdet på nmbrOfPeople
public static int getNmbrOfPeople(){     
    return nmbrOfPeople;               
}

Vidare, vi skriver även en metod som ger uppmaningar till användaren. Skriver användaren “ÖKA” så ska antal personer i butiken öka. På motsvarande sätt, om användaren skriver “SÄNK” så ska programmet sänka antal personer i butiken med ett.

// Denna metod returnerar det användaren skriver in. 
// I detta fall returneras en String
public static String getInputsFromScanner() {  
    
    //Deklarerar en variabel som heter name
    String name;  
    //Skriver ut en uppmaning till användaren
    System.out.println("Skriva ÖKA om du vill öka antal " +   
            "personer, skriv SÄNK om du vill minska antal personer");

    //Scanner tar in värdet från användaren
    Scanner input = new Scanner(System.in);
    
    //Värdet sparas i variabeln name
    name = input.nextLine();  
    
    //Metoden returnerar variabeln name
    return name;     
}

Vi kombinerar nu alla metoderna för att skapa hela programmet:

//Importerar klassen scanner
import java.util.Scanner;                   

public class Counter {  
    //Skapar variabeln nmbrOfPeople                 
    public static int nmbrOfPeople = 0;     

    //Metod för att öka variabeln nmbrOfPeople med ett
    public static void increaseValue(){     
        nmbrOfPeople++;                    
    }

    //Metod för att minska variabeln nmbrOfPeople med ett
    public static void decreaseValue(){     
        nmbrOfPeople--;                     
    }

    //Metod för att returnera värdet på nmbrOfPeople
    public static int getNmbrOfPeople(){    
        return nmbrOfPeople;                
    }

    public static String getInputsFromScanner() {  
        String name;                                              
        System.out.println("Skriva ÖKA om du vill öka antal " +  
                "personer, skriv SÄNK om du vill minska antal personer" +
               ", eller skriv QUIT om du vill avsluta");

        Scanner input = new Scanner(System.in);                   
        name = input.nextLine();                                  
        return name;                                              
    }

    public static void main(String args[]) {

       //Boolean variabel för att styra loopen 
       boolean runProg = true; 

       //Loopen körs medan runProg är true
       while(runProg) {                            
           
           //Metoden getInputsFromScanner returnerar värdet på 
           //det användaren skriver in och sparar detta i str
           String str = getInputsFromScanner(); 

           //Om användaren skrev "ÖKA" så ska metoden increaseValue köras
           if (str.equals("ÖKA")) {             
                increaseValue();
           }

           //Om användaren skrev "SÄNK" så ska metoden decreaseValue köras
           else if (str.equals("SÄNK")){        
               decreaseValue();
           }

           //Om användaren angav "QUIT" så ska loopen avslutas
           else if(str.equals("QUIT")){
                System.out.println("Programmet avslutas");
                runProg = false;
            }

           //Om användaren angav felaktig input
           else{
                System.out.println("Felaktig input, försök igen");
            }

           //Slutligen skriver vi ut antal personer i butiken
           System.out.println("Antal personer är nu: " + getNmbrOfPeople());   
       }
    }
}

Vidare, exemplet ovan kommer då att se ut såhär:

Avslutningsvis, vi har alltså använt oss av flera olika metoder för att skapa ett fullt program. Små byggstenar skapar tillsammans stora program! Gör därför dina metoder så generella och användbara som möjligt så att du kan återanvända dem så många gånger som möjligt. Det är så vi skapar effektiv kod!

Exempel 3: Räkna ut volymen på en kon och en pyramid

Det här blir ett lite längre exempel som vi kommer ta steg för steg. Vi ska nu skapa ett räkneexempel med metoder, där vi kan se hur vi kan återanvända metoder för flera användningsområden. Vi ska med hjälp av metoder skriva ett program som räknar ut volymen på en kon och en pyramid. Programmet ska sedan avgöra vilken av konen eller pyramiden som har störst volym. Vi kommer använda JOptionPane för att skapa dialogrutor som ska interagera med användaren och ta in uppgifter och sedan presentera resultatet av beräkningarna.

Innan vi börjar, vi rekommenderar att du följer händelseförloppet i koden i lugn takt och ta tid på dig för att verkligen följa med på vad som händer.

Räkna ut volymen på en kon

Räkna ut volymen på en pyramid

Skapa en metod i Java som beräknar arean av en cirkel

Vi börjar med att skapa en metod, areaCircle, som räknar ut arean på en cirkel, alltså basytan på konen. Metoden tar in en double som parameter och ska även returnera en double.

public static double areaCircle(double radius) { 

    // Beräknar arean av en cirkel
    double area = radius*radius*Math.PI;      
    return area;                              
}

Skapa en metod i Java som beräknar basarean av en pyramid

På liknande sätt skapar vi en metod, areaPyramid, som beräknar basarean för pyramiden. Notera att areaPyramid tar in två parametrar av typen double, samt att även denna metod returnerar en double

public static double areaPyramid(double length, double width ) { 

    // Beräknar arean och sparar värdet i areaTriangle
    double areaTriangle = length*width;                          
    return areaTriangle;                                        
}

Skapa en metod som beräknar volymen av en pyramid och en kon

Eftersom formeln för att räkna ut volymen är densamma för både konen och pyramiden, innebär det att vi kan använda samma metod i båda fallen. Vi skapar en metod som heter volume som även den tar in två värden, area och height, och returnerar sedan en variabel av datatyp double.

public static double volume(double area, double height) {  

    // Beräknar volymen
    double volume = area * height; 
    return volume;   
}

Skapa en metod i Java som avgör vilken volym som är störst

Vidare, nu ska vi jämföra vilken av volymerna som är störst och vi skapar då en passande metod som hjälper oss med detta, largestVolume. Notera att denna metod returnerar en String

public static String largestVolume(double volumeCone, double volumePyramid){

    // Kollar om konens volym är större än pyramidens  
    if(volumeCone > volumePyramid){  
        return "Konen har störst volym!";
    }

    // Kollar om konens volym är mindre än pyramidens   
    else if(volumeCone < volumePyramid){
        return "Pyramiden har störst volym";
    }

    // Om varken konen är större eller mindre än pyramiden 
    //måste volymerna vara lika stora!   
    else{ 
        return "Volymerna är lika stora!";  
    }
}

Ta emot input till programmet med JOptionPane

Sedan skapar vi en metod som tar in längden och höjden på pyramiden och konen med hjälp av klassen JOptionPane. Metoden heter getInputsFromJOptionPane och ska inte returnera något värde (void) och metoden ska heller inte få in något värde.

public static void getInputsFromJOptionPane() {        

     // Sparar undan det värdet som användaren skriver in i ett dialogfönster. 
    // Double.parseDouble finns för att värdet som skrivs in ska vara en double               
    double radiusCone = Double.parseDouble(JOptionPane.showInputDialog(null, "Skriv in radien på konen"));   
    double heightCone = Double.parseDouble(JOptionPane.showInputDialog(null, "Skriv in höjden på konen"));
    double lengthPyramid = Double.parseDouble(JOptionPane.showInputDialog(null, "Skriv in längden på pyramidens bas"));
    double widthPyramid = Double.parseDouble(JOptionPane.showInputDialog(null, "Skriv in bredden på pyramidens bas"));
    double heightPyramid = Double.parseDouble(JOptionPane.showInputDialog(null, "Skriv in höjden på pyramiden"));

    // Använder metoden areaCircle för att beräkna arean. Skickar in värdet på radiusCone. 
    // Värdet som kommer ut ur metoden sparas i areaOfCone 
    double areaOfCone = areaCircle(radiusCone);                       

    // Använder metoden volume för att beräkna volymen av konen. Skickar in värdet på areaOfCone och heightCone.    
    // Värdet som kommer ut ur metoden sparas i volumeCone 
    double volumeCone = volume(areaOfCone, heightCone);               

    // Använder metoden areaPyramid för att beräkna arean. Skickar in värdet på lengthPyramid och widthPyramid.    
    // Värdet som kommer ut ur metoden sparas i areaOfPyramid 
    double areaOfPyramid = areaPyramid(lengthPyramid, widthPyramid);  

    // Använder metoden volume för att beräkna volymen av pyramiden. Skickar in värdet på areaOfPyramid och heightPyramid.
    double volumePyramid = volume(areaOfPyramid, heightPyramid);      

    // Kollar vilken volym som är störst med hjälp av metoden largestVolyme. 
    String largestVolume = largestVolume(volumeCone, volumePyramid);  

     // Skriver ut det största värdet i en dialogruta
    JOptionPane.showMessageDialog(null, largestVolume);
}

Hela koden för att räkna ut volymen på en kon och en pyramid

Avslutningsvis, om vi sammanfogar koden från alla tidigare steg med förklarande kommentarer så får vi.

 //Importerar klassen JOptionPane
import javax.swing.JOptionPane;

public class Volume {
    public static void main(String args[]) {

         //Det är här koden startar. Metoden getInputsFromJOptionPane utförs först
        getInputsFromJOptionPane();
    }

    public static double areaCircle(double radius) { 

        // Beräknar arean av en cirkel
        double area = radius*radius*Math.PI;      
        return area;                              
    }

    public static double areaPyramid(double length, double width ) { 

        // Beräknar arean och sparar värdet i areaTriangle
        double areaTriangle = length*width;                          
        return areaTriangle;                                        
    }
    public static double volume(double area, double height) {  

        // Beräknar volymen
        double volume = area * height; 
        return volume;   
    }

    public static String largestVolume(double volumeCone, double volumePyramid){

        // Kollar om konens volym är större än pyramidens  
        if(volumeCone > volumePyramid){  
            return "Konen har störst volym!";
        }

        // Kollar om konens volym är mindre än pyramidens   
        else if(volumeCone < volumePyramid){
            return "Pyramiden har störst volym";
        }

        // Om varken konen är större eller mindre än pyramiden 
        //måste volymerna vara lika stora!   
        else{ 
            return "Volymerna är lika stora!";  
        }
    }

    public static void getInputsFromJOptionPane() {        

         // Sparar undan det värdet som användaren skriver in i ett dialogfönster. 
        // Double.parseDouble finns för att värdet som skrivs in ska vara en double 
        double radiusCone = Double.parseDouble(JOptionPane.showInputDialog(null, "Skriv in radien på konen"));   
        double heightCone = Double.parseDouble(JOptionPane.showInputDialog(null, "Skriv in höjden på konen"));
        double lengthPyramid = Double.parseDouble(JOptionPane.showInputDialog(null, "Skriv in längden på pyramidens bas"));
        double widthPyramid = Double.parseDouble(JOptionPane.showInputDialog(null, "Skriv in bredden på pyramidens bas"));
        double heightPyramid = Double.parseDouble(JOptionPane.showInputDialog(null, "Skriv in höjden på pyramiden"));

        // Använder metoden areaCircle för att beräkna arean. Skickar in värdet på radiusCone. 
        // Värdet som kommer ut ur metoden sparas i areaOfCone 
        double areaOfCone = areaCircle(radiusCone);   
                    
        // Använder metoden volume för att beräkna volymen av konen. Skickar in värdet på areaOfCone och heightCone
        // Värdet som kommer ut ur metoden sparas i volumeCone 
        double volumeCone = volume(areaOfCone, heightCone);               

        // Använder metoden areaPyramid för att beräkna arean. Skickar in värdet på lengthPyramid och widthPyramid
        // Värdet som kommer ut ur metoden sparas i areaOfPyramid 
        double areaOfPyramid = areaPyramid(lengthPyramid, widthPyramid);  

        // Använder metoden volume för att beräkna volymen av pyramiden. Skickar in värdet på areaOfPyramid och heightPyramid.
        double volumePyramid = volume(areaOfPyramid, heightPyramid); 

        // Kollar vilken volym som är störst med hjälp av metoden largestVolyme. 
        String largestVolume = largestVolume(volumeCone, volumePyramid);  

         // Skriver ut det största värdet i en dialogruta
        JOptionPane.showMessageDialog(null, largestVolume);
    }
}

Vanliga misstag när man anropar metoder i Java

Följande är några enklare misstag som vi uppmärksammat

• Man är inte uppmärksam på inparametrarna till metoden. Till exempel, vilken datatyp som metoden kräver, vilken ordning metoden använder dem, med mera.
• Viktigt att vara uppmärksam på vad metoden returnerar för datatyp. Vill vi spara ned värden i en annan datatyp än vad som returneras från metoden så löser vi det med hjälp av typkonvertering.
• 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.

Sammanfattning: Anropa metoder i Java

När man vill använda en tidigare skapad metod så säger man att man anropar man den metoden. För att anropa metoden så anger man metodens namn följt av eventuella inparametrar inom parantes. När en parameter skickas till metoden kallas den för ett argument och när du arbetar med flera argument måste metodanropet ha samma antal argument som det finns parametrar och argumenten måste skickas i samma ordning. Avslutningsvis, om den anropade metoden returnerar ett värde, kan man tilldela detta till en variabel av samma datatyp.

Vanliga frågor och svar: Anropa en metod i Java