Statiska metoder

1. Statiska metoder

Förutom statiska variabler kan klasser även ha statiska metoder.

Vanliga metoder är bundna till objekt (instanser) av en klass och kan referera till vanliga (icke-statiska) variabler i klassen (liksom statiska variabler och metoder ). Statiska metoder är bundna till klassens statiska objekt och kan endast komma åt klassens statiska variabler och/eller andra statiska metoder.

För att anropa en vanlig (icke-statisk) metod på en klass måste du först skapa ett objekt av klassen och sedan anropa metoden på objektet. Du kan inte anropa en vanlig metod på klassen snarare än ett objekt.

Exempel:

public class DataInfo
{
   public int getValue()
   {
      return 100;
   }
}

public class Solution
{
   public static void main(String[] args)
   {
      System.out.println(DataInfo.getValue()); // This will generate an error!
   }
}

Men för att anropa en statisk metod räcker det att klassens statiska objekt helt enkelt existerar (och det finns alltid efter att klassen har laddats in i minnet). Det är därför main()-metoden är statisk. Det är bundet till klassens statiska objekt, så du behöver inte skapa några objekt för att anropa det.

För att deklarera en metod statisk måste du skriva det statiska nyckelordet före metodhuvudet. Det allmänna utseendet för denna konstruktion är som följer:

static Type name(parameters)
{
   method code
}

Exempel:

public class Solution
{
   public static void main(String args[])
   {
      test();
   }

   public static void test()
   {
      int d = 2/0;
   }
}

För att anropa en statisk metod från en annan klass måste du ange klassnamnet före namnet på den statiska metoden. Det allmänna utseendet för denna konstruktion är som följer:

Type name = ClassName.methodName(arguments)

Exempel:

int x = Math.min(a, b);

int min(int a, int b)

Thread.sleep(200);

void sleep(long ms)

Path path = Path.of("c:\\readme.txt");

Path of(String str)

2. Statiska kontra vanliga (icke-statiska) metoder

Vad är skillnaden mellan statiska metoder och vanliga?

En vanlig metod är bunden till ett vanligt objekt (en instans av en klass), medan en statisk metod inte är det. En vanlig metod kan komma åt variabler i sin instans, men en statisk metod kan inte: den har helt enkelt inte en associerad instans.

Skillnaderna mellan de två typerna av metoder uttrycks i följande tabell:

Varför behövs sådana metoder om de är så kraftigt begränsade? Svaret är att detta tillvägagångssätt också har sina fördelar.

För det första behöver du inte skicka någon objektreferens för att komma åt statiska metoder och variabler.

För det andra, ibland behöver du bara finnas en enda instans av en variabel. Till exempel System.out( Systemklassens statiska utvariabel ) .

Och för det tredje, ibland behöver du anropa en metod innan det ens är möjligt att skapa objekt. Till exempel anropar Java-maskinen main()-metoden för att starta exekveringen av programmet redan innan en instans av klassen skapas.

Bundet till en instans av klassen

När en vanlig metod anropas skickas ett argument - objektet som metoden anropas på - implicit till den. Denna parameter kallas this. Denna implicita parameter (en referens till objektet som metoden kallas) skiljer vanliga metoder från statiska.

Statiska metoder har inte denna implicita parameter, så du kan inte använda nyckelordet thisi statiska metoder, och du kan inte anropa en icke-statisk metod i en statisk metod. Det finns helt enkelt ingenstans att få en referens till en instans av en klass.

Kan anropa vanliga metoder i klassen

En vanlig metod har alltid den implicita thisparametern, så du har alltid en referens till objektet som metoden anropas på. När du anropar en vanlig metod inom en annan vanlig metod, thisanvänds den implicita parametern för att göra det anropet. Exempel

int min(int a, int b)
{
   return a < b ? a : b;
}

int min(int a, int b, int c)
{
   int t = min(a, b);
   return min(t, c);
}

int min(int a, int b)
{
   return a < b ? a : b;
}

int min(int a, int b, int c)
{
   int t = this.min(a, b);
   return this.min(t, c);
}

Det är därför man inte kan kalla en vanlig metod från en statisk. Det finns helt enkelt ingen implicit variabel namngiven thisinuti en statisk metod.

Eller föreställ dig en annan situation: inte ett enda objekt i vår klass har ännu skapats i vårt program. Kan vi kalla en statisk metod för vår klass? Ja. Och kan denna statiska metod kalla en vanlig (icke-statisk) metod?

Nåväl, vilket objekt skulle vi kalla det för? Det finns trots allt inte en enda instans av vår klass ännu!

Kan anropa statiska metoder för klassen

Statiska metoder kan anropas var som helst - från vilken plats som helst i programmet. Det betyder att de kan anropas från både statiska metoder och vanliga. Det finns inga begränsningar här.

Kan komma åt vanliga variabler i klassen

Du kan komma åt vanliga variabler för en klass från en vanlig metod, eftersom den enkelt kan få en referens till en instans av klassen via den implicita thisparametern.

En statisk metod vet inte vilken instans av klassen den ska använda för att få värden på vanliga variabler. Och mer generellt kan vi lätt ha en situation där en statisk metod anropas men inte en enda instans av klassen ännu har skapats i programmet.

Som ett resultat kan statiska metoder inte komma åt vanliga variabler i en klass.

Antag att en statisk metod anropar en vanlig metod. Vilket objekt ska den vanliga metoden kallas?

Ingen vet! Det är därför du inte kan anropa en vanlig metod från en statisk utan att skicka in en referens till ett objekt!

Kan komma åt statiska variabler för klassen

Situationen med anrop till statiska variabler är densamma som med anrop till statiska metoder. Statiska variabler kan nås från var som helst i programmet. Det betyder att du kan komma åt dem från statiska och vanliga metoder.

Kan anropas på ett objekt

Både statiska och vanliga metoder kan anropas på ett objekt. Ett vanligt metodanrop är möjligt - det är faktiskt det enda sättet att anropa en vanlig metod. En statisk metod kan också anropas på ett objekt: i det här fallet bestämmer kompilatorn själv typen av variabel och anropar den statiska metoden baserat på dess typ:

Thread th = Thread.current();
th.sleep(1000);

Thread th = Thread.current();
Thread.sleep(1000);

Integer i = 1;
int x = i.parseInt("12");

Integer i = 1;
int x = Integer.parseInt("12");

"".valueOf(12);

String.valueOf(12);

Kan ringas på klassen

Du kan bara anropa en statisk metod på en klass. För att anropa en vanlig metod behöver du en referens till en instans av klassen. Därför kan du inte anropa en vanlig metod med denna konstruktion:ClassName.methodName(arguments)