Java >> Java tutorial >  >> Java

Metoder i Java med eksempler

Ved hjælp af eksempler vil vi lære om Java-metoder, definere dem og bruge dem i Java-programmer i denne artikel. En metode er et stykke kode, der opnår et bestemt mål. Generelt er en metode en samling af udsagn eller udsagn organiseret sammen for at udføre en bestemt opgave eller handling. Det er en teknik til at gøre kode mere genbrugelig. Vi opretter en metode én gang og bruger den derefter gentagne gange.

Vi behøver ikke at skrive kode igen og igen. Det giver også mulighed for nem kodeændring og læsbarhed ved blot at tilføje eller fjerne kodestykker. Kun når vi kalder eller påberåber metoden, udføres den. Main()-metoden er den mest betydningsfulde metode i Java.

Antag, at du skal lave et program for at tegne en cirkel og farvelægge den. For at overvinde denne vanskelighed kan du udtænke to tilgange:

  • en metode til at tegne en cirkel
  • en metode til at farve cirklen

Værdier eller argumenter kan indsættes i metoder, og de vil kun blive udført, når metoden kaldes. Funktioner er et andet navn for dem. Følgende er den mest almindelige brug af metoder i Java:

  • Det giver mulighed for genbrug af kode (definer én gang og brug flere gange)
  • Et omfattende program kan opdeles i mindre kodedele.
  • Det forbedrer kodens læsbarhed.

Metoder i Java

Ved at nedbryde et komplekst problem i mindre stykker kan du skabe et program, der er lettere at forstå og genbruge. Der er to slags metoder i Java:statisk og dynamisk.

Brugerdefinerede metoder: Vi kan udvikle vores metode ud fra vores behov.

Standard biblioteksmetoder: Dette er Javas indbyggede metoder, der kan bruges.

Deklaration af metoden

Metodeegenskaber såsom synlighed, returtype, navn og parametre er alle angivet i metodedeklarationen. Som det ses i det følgende diagram, består det af seks komponenter kendt som metodeoverskrifter.

(Access Specifier)  (Return Type) (Method Name) (Parameter List) --> Method Header

{
 // Method Body
}

For eksempel:

public int sumValues(int x, int y){
// method body
}

Hvor sumValues(int x, int y) er metodesignaturen

Metodesignatur: En metodesignatur er en streng, der identificerer en metode. Det er inkluderet i metodedeklarationen. Den indeholder metodenavnet samt en liste over parametre.

Adgangsspecifikation: Metodens adgangsspecifikation, også kendt som en modifikator, bestemmer metodens adgangstype. Det angiver metodens synlighed. Der er fire forskellige typer af adgangsspecifikationer i Java:

  • Offentlig: Når vi bruger den offentlige specificator i vores applikation, kan alle klasser få adgang til metoden.
  • Privat: Metoden er kun tilgængelig i de klasser, der er erklæret, når du bruger en privat adgangsspecifikation.
  • Beskyttet: Metoden er tilgængelig inden for den samme pakke eller underklasser i en anden pakke, når du bruger den beskyttede adgangsspecifikation.
  • Standard: Når der ikke er angivet nogen adgangsspecifikation i metodeerklæringen, bruger Java standardadgangsspecifikationen. Det kan kun ses fra den samme pakke.

Returtype: En metodes returtype er den datatype, den returnerer. Det kan for eksempel være en primitiv datatype, et objekt, en samling eller undgå. Nøgleordet void bruges, når en metode ikke returnerer noget.

Metodenavn: Navnet på en metode er defineret af dens metodenavn, som er et unikt navn.

Det skal passe til metodens funktionalitet. Hvis vi laver en metode til at trække to tal fra, skal metodens navn være subtraktion(). Navnet på en metode bruges til at kalde den.

Parameterliste: Parameterlisten er en samling af parametre adskilt af et komma og indpakket i parentes. Den specificerer datatypen samt navnet på variablen. Lad parentesen være tom, hvis metoden ikke har nogen parametre.

Metodetekst: Metodedeklarationen indeholder et afsnit kaldet metodelegemet. Den indeholder alle de handlinger, der skal udføres. Ydermere er den beskyttet af et par krøllede seler.

Valg af et metodenavn

Når du navngiver en metode, skal du huske på, at det skal være et verbum og begynde med et lille bogstav. Hvis der er mere end to ord i metodenavnet, skal det første være et verbum efterfulgt af et adjektiv eller substantiv. Bortset fra det første ord skal begyndelsesbogstavet i hvert ord i metodenavnet med flere ord være med stort bogstav. Overvej følgende scenarie:

  • sum(), area() er to enkeltordsmetoder
  • areaOfCircle(), stringComparision() er to flerordsmetoder

Det er også tænkeligt, at en metode har samme navn som en anden metode i samme klasse; dette kaldes metodeoverbelastning.

Brugerdefinerede metoder

Lad os starte med at se på brugerdefinerede metoder. For at erklære en metode skal du bruge følgende syntaks:

returnType methodName() {
  // method body
}

Som et eksempel,

int sumValues() {
// code
}

Metoden ovenfor hedder sumValues(), hvis returtype er en int. Syntaksen for at erklære en metode er som følger. Den komplette syntaks til at erklære en metode er på den anden side

modifier static returnType nameOfMethod (parameter1, parameter2, ...) {
  // method body
}

Her,

modifikator – Den specificerer metodens adgangstyper, såsom offentlig, privat osv. Besøg Java Access Specifier for yderligere information.

statisk -Den kan tilgås uden at oprette objekter, hvis vi bruger det statiske nøgleord.

Metoden sqrt() i standard Math-klassen er for eksempel statisk. Som et resultat kan vi kalde Math.sqrt() uden først at etablere en Math-klasseinstans. Værdierne parameter1/parameter2 leveres til en metode. En metode kan tage et vilkårligt antal argumenter.

Metodekald i Java

Vi har erklæret en metode kaldet sumValues() i det forrige eksempel. For at bruge metoden skal vi først kalde den. SumValues()-metoden kan kaldes på følgende måde.

// calls the method
sumValues();

Example: Using Methods in Java

class Codeunderscored {

  // create a method
  public int sumValues(int num_1, int num_2) {
    int sumVal = num_1 + num_2;
    // return the results
    return sumVal;
  }

  public static void main(String[] args) {
    
    int num1 = 67;
    int num2 = 33;

    // create an object of  Codeunderscored
    Codeunderscored code = new Codeunderscored();

    // calling method
    int resultVal = code.sumValues (num1, num2);
    System.out.println("The resultant sum  value is: " + resultVal);
  }
}

Vi definerede en metode kaldet sumValues() i det foregående eksempel. Parametrene num_1 og num_2 bruges i metoden. Bemærk linjen,

int resultVal = code.sumValues (num1, num2);

Proceduren blev påberåbt ved at give to argumenter, num_1 og num_2. Vi har placeret værdien i resultatvariablen, fordi metoden returnerer en værdi. Det er værd at bemærke, at metoden ikke er statisk. Som et resultat bruger vi klassens objekt til at påkalde metoden.

Søgeordet ugyldigt

Vi kan bruge nøgleordet void til at skabe metoder, der ikke returnerer en værdi. I det følgende eksempel ser vi på en void-metode kaldet demoVoid. Det er en void-metode, hvilket betyder, at den intet returnerer. En erklæring skal bruges til at kalde en void-metode, såsom demoVoid(98);. Som illustreret i det følgende eksempel er det en Java-sætning, der afsluttes med et semikolon.

public class Codeunderscored {

   public static void main(String[] args) {
      demoVoid(98);
   }

   public static void demoVoid(double points) {
      if (points >= 100) {
         System.out.println("Grade:A");
      }else if (points >= 80) {
         System.out.println("Grade:B");
      }else {
         System.out.println("Grade:C");
      }
   }
}

Brug af værdier til at videregive parametre

Argumenter skal fremføres under arbejdet med opkaldsproceduren. Disse bør være opført i metodespecifikationen i samme rækkefølge som deres tilsvarende parametre. Generelt kan parametre gives på to måder:en værdi eller en reference.

At kalde en metode med en parameter er kendt som at overføre parametre efter værdi. Argumentværdien leveres til parameteren på denne måde. Programmet nedenfor viser, hvordan man sender en parameter efter værdi. Selv efter brug af proceduren forbliver argumenternes værdier uændrede.

public class Codeunderscored {

   public static void main(String[] args) {
      int x = 20;
      int y = 62;
      System.out.println("Items initial order, x = " + x + " and y = " + y);

      // Invoking the swap method
      swapValues(x, y);
      System.out.println("\n**Order if items, before and after swapping values **:");
      System.out.println("Items after swapping, x = " + x + " and y is " + y);
   }

   public static void swapValues(int a, int b) {
      System.out.println("Items prior to swapping(Inside), x = " + x + " y = " + y);
      
      // Swap n1 with n2
      int temp = x;
      x = y;
      y = temp;
      System.out.println("Items post swapping(Inside), x = " + x + " y = " + y);
   }
}

Overbelastning af metoder

Metodeoverbelastning opstår, når en klasse indeholder to eller flere metoder med samme navn, men forskellige parametre. Det er ikke det samme som at tilsidesætte. Når en metode tilsidesættes, har den samme navn, type, antal parametre osv.

Overvej eksemplet med at finde de mindste heltal. Lad os sige, at vi leder efter det mindste antal dobbelttyper. For derefter at bygge to eller flere metoder med samme navn, men forskellige parametre, vil begrebet overbelastning blive introduceret.

Følgende eksempel tydeliggør situationen:

public class Codeunderscored {

   public static void main(String[] args) {
      int x = 23;
      int y = 38;
      double numOne = 17.3;
      double numTwo = 29.4;

      int resultOne = smallestValue(x, y);
      
      // invoking function name with different parameters
      double resultTwo = smallestValue(numOne, numTwo);

      System.out.println("The Minimum number is: = " + resultOne);
      System.out.println("The Minimum number is: = " + resultTwo);
   }

   // for integer
   public static int smallestValue(int numOne, int  numTwo) {
      int smallestVal;
      if ( numOne > numTwo)
         smallestVal = numTwo;
      else
         smallestVal = numOne;

      return smallestVal;
   }
   
   // for double
   public static double smallestValue(double numOne, double numTwo) {
     double smallestVal;
      if ( numOne > numTwo)
         smallestVal = numTwo;
      else
         smallestVal = numOne;

      return smallestVal;
   }
}

Overbelastningsmetoder forbedrer et programs læsbarhed. Her præsenteres to metoder med samme navn, men forskellige parametre. Resultatet er det laveste tal fra heltal- og dobbeltarterne.

Brug af argumenter på kommandolinjen

Når du udfører et program, vil du måske tilføje nogle oplysninger til det. Det udføres ved at kalde main() med kommandolinjeargumenter.

Når et program køres, er et kommandolinjeargument information, der vises efter programmets navn på kommandolinjen. Det er nemt at hente kommandolinjeparametre fra et Java-program. De gemmes i String-arrayet, der leveres til main() som strenge. Det følgende program viser alle de kommandolinjeargumenter, som det kaldes på.

public class Codeunderscored {

   public static void main(String args[]) {
      for(int i = 0; i<args.length; i++) {
         System.out.println("args[" + i + "]: " +  args[i]);
      }
   }
}

'Dette' søgeord

Et Java nøgleord bruges til at referere til den aktuelle klasses objekt i en instansmetode eller konstruktør. Du kan bruge dette til at henvise til klassemedlemmer som konstruktører, variabler og metoder. Det er værd at bemærke, at søgeordet dette kun bruges inden for instansmetoder og konstruktører.

Generelt refererer dette udtryk til:

  • I en konstruktør eller en metode skal du skelne instansvariabler fra lokale variabler, hvis deres navne er de samme.
class Employee {
   int age;   
   Employee(int age) {
      this.age = age;	
   }
}
  • I en klasse skal du kalde en slags konstruktør (parametriseret konstruktør eller standardkonstruktør) fra en anden. Eksplicit konstruktørinvokation kaldes det.
class Employee {
   int age
   Employee() {
      this(20);
   }
   
   Employee(int age) {
      this.age = age;	
   }
}

Dette nøgleord bruges til at få adgang til klassemedlemmerne i følgende eksempel. Kopier og indsæt programmet nedenfor i en fil kaldet thisKeyword.java.

public class Codeunderscored {
   // Instance variable num
   int num = 10;
	
   Codeunderscored() {
      System.out.println("This is a program that uses the keyword this as an example. ");	
   }

   Codeunderscored(int num) {
      // Using the default constructor as a starting point
      this();
      
      // num is assigned to the instance variable num by assigning the local variable num to the instance variable num.
      this.num = num;	   
   }
   
   public void greet() {
      System.out.println("Hello and welcome to Codeunderscored.com. ");
   }
      
   public void print() {
      // declaration of the num Local variable
      int num = 20;
      
      // The local variable is printed.
      System.out.println("num is the value of a local variable. : "+num);
      
      // The instance variable is printed.
      System.out.println("num is the value of the instance variable.  : "+this.num);
      
      // Invoking a class's greet method
      this.greet();     
   }
   
   public static void main(String[] args) {
      // Creating an instance of the class
      Codeunderscored code = new Codeunderscored();
      
      // The print technique is used to print a document.
      code.print();
	  
      // Through a parameterized constructor, a new value is passed to the num variable.
      Codeunderscored codeU = new Codeunderscored(30);
      
      // Using the print technique once more
      codeU.print();
   }
}

Argumenter med variabler (var-args)

Du kan give et variabelt antal parametre af samme type til en metode i JDK 1.5. Metodens parameter er deklareret som følger:

typeName... parameterName

Du angiver typen efterfulgt af en ellipse i metodedefinitionen (…). I en metode kan kun én parameter med variabel længde angives, og det skal være den sidste parameter. Alle almindelige parametre skal gå forud.

public class VarargsCode {

   public static void main(String args[]) {
      // Calling of a method with variable args  
      
      showMax(54, 23, 23, 22, 76.5);
      showMax(new double[]{21, 22, 23});
   }

   public static void showMax( double... numbers) {
      if (numbers.length == 0) {
         System.out.println("No argument passed");
         return;
      }

      double result = numbers[0];

      for (int i = 1; i <  numbers.length; i++)
      if (numbers[i] >  result)
      result = numbers[i];
      System.out.println("The max value is " + result);
   }
}

Returtype for en Java-metode

Funktionskaldet får muligvis ikke en værdi fra en Java-metode. Returerklæringen bruges til at returnere enhver værdi. Som et eksempel,

int sumValues() {
...
return sumVal;
}

Variablen sumVal returneres i dette tilfælde. Fordi funktionens returtype er int, skal typen af ​​sumVal-variablen være int. Ellers vil der blive genereret en fejl.

// Example : Return Type of a Method

class Codeunderscored {

// creation of a static method
  public static int squareValues(int numVal) {

    // return statement
    return numVal * numVal;
  }

  public static void main(String[] args) {
    int result;

    // call the method
    // store returned value to result
    resultVal = squareValues(13);

    System.out.println("The Squared value of 13 is: " + resultVal);
  }

}

I det foregående program konstruerede vi en squareValues()-metode. Metoden accepterer et heltal som input og returnerer tallets kvadrat. Metodens returtype er angivet som int her.

Som følge heraf skal metoden altid returnere et positivt tal. Bemærk, at vi bruger void-søgeordet som metodens returtype, hvis metoden ikke returnerer nogen værdi.

Som et eksempel,

public void squareValues(int i) {
  int resultVal = i * i;
  System.out.println("The Square of the given number is: " + resultVal);
}

Java-metodeparametre

En metodeparameter er en værdi, som metoden accepterer. En metode kan, som tidligere nævnt, have et hvilket som helst antal parametre. Som et eksempel,

// method with two parameters
int sumValues(int x, int y) {
  // code
}

// method with no parameter
int sumValues(){
  // code
}

Når vi kalder en parametermetode, skal vi angive værdierne for disse parametre. Som et eksempel,

// call to a method with two parameters
sumValues(29, 21);

// call to a method with no parameters
sumValues()

Eksempel:Metodeparametre

class Codeunderscored {

  // method with no parameter
  public void methodWithNoParameters() {
    System.out.println("Method without parameter");
  }

  // method with single parameter
  public void methodWithParameters(int a) {
    System.out.println("Method with a single parameter: " + a);
  }

  public static void main(String[] args) {
    
    // create an object of  Codeunderscored
    Codeunderscored code = new Codeunderscored();

    // call to a  method with no parameter
    code.methodWithNoParameters ();
    
    // call to a method with the single parameter
    code.methodWithParameters (21);
  }
}

Metodens parameter er int i dette tilfælde. Som et resultat vil compileren give en fejl, hvis vi sender en anden datatype end int. Fordi Java er et stramt skrevet sprog, er dette tilfældet. Den faktiske parameter er det 32. argument, der leveres til metoden methodWithParameters() under metodekaldet.

Et formelt argument er parameteren num, som metodespecifikationen accepterer. Typen af ​​formelle argumenter skal specificeres. Desuden bør typerne af faktiske og formelle argumenter altid være de samme.

Statisk metode

En statisk metode har det statiske nøgleord. Med andre ord er en statisk metode en metode, der tilhører en klasse snarere end en forekomst af den klasse. Vi kan også konstruere en statisk metode ved at sætte ordet statisk foran metodenavnet.

Den grundlæggende fordel ved en statisk metode er, at den kan kaldes uden at kræve oprettelse af et objekt. Det kan ændre værdien af ​​statiske datamedlemmer og få adgang til dem. Det bruges til at skabe en instansmetode. Klassenavnet bruges til at kalde det. Main()-funktionen er det bedste eksempel på en statisk metode.

public class Codeunderscored  
{  
public static void main(String[] args)   
{  
displayStatically();  
}  
static void displayStatically()   
{  
System.out.println("Codeunderscored example of static method.");  
}  
}  

Forekomstmetode i Java

En klassemetode omtales som en instansmetode. Det er en klassedefineret ikke-statisk metode. Det er vigtigt at konstruere et objekt af klassen, før du kalder eller påkalder instansmetoden. Lad os se på en instansmetode i aktion.

public class CodeunderscoredInstanceMethod
{  
public static void main(String [] args)  
{  
//Creating an object of the class  
CodeunderscoredInstanceMethod code = new CodeunderscoredInstanceMethod();  
//invoking instance method   
System.out.println("The  numbers' sum is: "+code .sumValues(39, 51));  
}  
int s;  
//user-defined method because we have not used static keyword  
public int sumValues(int x, int y)  
{  
resultVal = x+y;  
//returning the sum  
return resultVal;  
}  
}  

Forekomstmetoder er opdelt i to kategorier:

  • Mutatormetode
  • Adgangsmetode

Adgangsmetode

Accessormetoden er den eller de metoder, der læser instansvariablen/-erne. Fordi metoden er forankret med udtrykket opnå, kan vi genkende den. Getters er et andet navn for det. Det returnerer det private felts værdi. Det bruges til at få det private felts værdi.

public int getAge()    
{    
return age;    
}   

Mutatormetode

Metoden/metoderne læser og ændrer instansvariablernes værdier. Fordi metoden gik forud for termsættet, kan vi genkende det. Settere eller modifikatorer er andre navne for det. Selvom det ikke giver dig noget, accepterer det en feltafhængig parameter af samme datatype. Det bruges til at indstille værdien for det private felt.

public void setAge(int age)   
{  
this.age = age;  
}  

Eksempel:Forekomstmetoder – Accessor &Mutator

public class Employee   
{  
private int empID;  
private String name;  
public int getEmpID()    //accessor method  
{  
return empID;  
}  
public void setEmpID(int empID) //mutator method  
{  
this.empID = empID;  
}  
public String getName()   
{  
return name;  
}  
public void setName(String name)   
{  
this.name = name;  
}  
public void display()  
{  
System.out.println(" Your Employee NO is.: "+empID);  
System.out.println("Employee name: "+name);  
}  
}  

Metoder til et standardbibliotek

Standard biblioteksmetoderne er Java indbyggede metoder, der kan bruges med det samme. Disse standardbiblioteker er inkluderet i en Java-arkivfil (*.jar) med JVM og JRE og Java Class Library (JCL).

Eksempler omfatter,

  • print() er en java.io-metode.
  • I PrintSteam viser print(“…”)-metoden en streng omgivet af anførselstegn.
  • sqrt() er en matematisk klassemetode. Det returnerer et tals kvadratrod.

Her er et eksempel, der virker:

// Example: Method from the Java Standard Library

public class Codeunderscored {

  public static void main(String[] args) {
    
    // the sqrt() method in action
    System.out.print("The Square root of 9 is: " + Math.sqrt(9));
  }
}

Abstrakt metode

En abstrakt metode har ikke et metodelegeme. Med andre ord har en abstrakt metode ikke en implementering. Den erklærer sig selv i den abstrakte klasse til enhver tid. Hvis en klasse har en abstrakt metode, skal den selv være abstrakt. Nøgleordet abstrakt bruges til at definere en abstrakt procedure.

Syntaksen er som følger:

abstract void method_name();  
abstract class CodeTest //abstract class  
{  
//abstract method declaration  
abstract void display();  
}  
public class MyCode extends CodeTest  
{  
//method impelmentation  
void display()  
{  
System.out.println("Abstract method?");  
}  
public static void main(String args[])  
{  
//creating object of abstract class  
CodeTest code = new MyCode();  

//invoking abstract method  
code.display();  
}  
}  

Fabriksmetode

Det er en metode, der returnerer et objekt til den klasse, hvor det blev oprettet. Fabriksmetoder er alle statiske metoder. Et eksempel på et tilfælde er som følger:

NumberFormat obj = NumberFormat.getNumberInstance().

Fuldfør( )-metoden

Det er muligt at definere en metode, der vil blive kaldt umiddelbart før affaldssamleren ødelægger en genstand. Denne funktion kaldes finalize(), der sikrer, at et objekt afsluttes korrekt. Finalize(), for eksempel, kan bruges til at sikre, at en åben fil, der opbevares af det pågældende objekt, lukkes.

Du skal blot definere finalize()-metoden for at tilføje en finalizer til en klasse. Når Java runtime genbruger et objekt af denne klasse, kalder det denne metode. I finalize()-metoden skal du angive de handlinger, der skal udføres, før et objekt ødelægges i finalize()-metoden.

Dette er den generelle form for finalize()-metoden:

protected void finalize( ) {
   // finalization code here
}

Nøgleordet protected er en specificator, der forhindrer kode, der er erklæret uden for klassen, i at få adgang til finalize(). Det betyder, at du ikke har nogen måde at vide, hvornår eller om finalize() vil blive kaldt. For eksempel, hvis din applikation stopper før skraldindsamling, vil finalize() ikke blive kaldt.

Hvad er fordelene ved at bruge metoder?

Den væsentligste fordel er, at koden kan genbruges. En metode kan skrives én gang og derefter bruges flere gange. Vi behøver ikke at genskabe koden fra bunden hver gang. Tænk på det på denne måde:"skriv én gang, genbrug mange gange."

Eksempel 5:Java-metode til genbrug af kode

public class Codeunderscored {

  // definition of the method
  private static int calculateSquare(int x){
    return x * x;
  }

  public static void main(String[] args) {
    for (int i = 5; i <= 10; i++) {

      //calling the method
      int resultVal = calculateSquare(i);
      System.out.println("The Square of " + i + " is: " + resultVal);
    }
  }
}

Vi udviklede calculateSquare()-metoden i det forrige program til at beregne kvadratet af et tal. Fremgangsmåden bruges til at finde kvadratet af tal mellem fem og 10 i dette tilfælde. Som følge heraf anvendes den samme procedure gentagne gange.

  • Metoder gør koden mere læsbar og fejlfindbar.

Koden til at beregne kvadratet i en blok opbevares i calculateSquare() metoden. Som et resultat er det nemmere at læse.

Eksempel:Opkald til en metode flere gange

public class Codeunderscored {
  static void showCode() {
    System.out.println("I am excited about CodeUnderscored!");
  }

  public static void main(String[] args) {
    showCode();
    showCode();
    showCode();
    showCode();
  }
}

//  I am excited about CodeUnderscored!
//  I am excited about CodeUnderscored!
//  I am excited about CodeUnderscored!
//  I am excited about CodeUnderscored!

Eksempel:Brugerdefineret metode

import java.util.Scanner;  
public class Codeunderscored  
{  
public static void main (String args[])  
{  
//creating Scanner class object     
Scanner scan=new Scanner(System.in);  
System.out.print("Enter the number: ");  
//reading value from user  
int num=scan.nextInt();  
//method calling  
findEvenOdd(num);  
}  
//user defined method  
public static void findEvenOdd(int num)  
{  
//method body  
if(num%2==0)   
System.out.println(num+" is even");   
else   
System.out.println(num+" is odd");  
}  
}  

Konklusion

Generelt er en metode en måde at opnå et mål på. I Java er en metode en samling instruktioner, der opnår et bestemt mål. Det sikrer, at koden kan genbruges. Derudover kan metoder også bruges til at ændre kode hurtigt.

En metode er en sektion af kode, der kun udføres, når den påkaldes. Det har parametre, som er data, der kan overføres til en metode. Metoder, ofte kendt som funktioner, udfører specifikke opgaver. Yderligere inkluderer nogle af fordelene ved at bruge metoder genbrug af kode, oprettelse af den én gang og brug af den flere gange.

Inden for en klasse skal en metode erklæres. Det er defineret af metodens navn, efterfulgt af parentes(). Selvom Java har flere foruddefinerede måder, såsom System.out.println(), kan du også skrive din egen til at håndtere specifikke opgaver.


Java tag