Statiske metoder

1. Statiske metoder

I tillegg til statiske variabler kan klasser også ha statiske metoder.

Vanlige metoder er bundet til objekter (forekomster) av en klasse og kan referere til vanlige (ikke-statiske) variabler i klassen (så vel som statiske variabler og metoder ). Statiske metoder er bundet til klassens statiske objekt og kan bare få tilgang til de statiske variablene og/eller andre statiske metoder i klassen.

For å kalle en vanlig (ikke-statisk) metode på en klasse, må du først opprette et objekt av klassen og deretter kalle metoden på objektet. Du kan ikke kalle en vanlig metode på klassen i stedet for et objekt.

Eksempel:

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 for å kalle en statisk metode, er det nok at klassens statiske objekt ganske enkelt eksisterer (og det eksisterer alltid etter at klassen er lastet inn i minnet). Dette er grunnen til at main()-metoden er statisk. Den er bundet til klassens statiske objekt, så du trenger ikke lage noen objekter for å kalle den.

For å erklære en metode statisk, må du skrive det statiske nøkkelordet før metodeoverskriften. Det generelle utseendet til denne konstruksjonen er som følger:

static Type name(parameters)
{
   method code
}

Eksempler:

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

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

For å kalle en statisk metode fra en annen klasse, må du spesifisere klassenavnet før navnet på den statiske metoden. Det generelle utseendet til denne konstruksjonen er som følger:

Type name = ClassName.methodName(arguments)

Eksempler:

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. Statiske vs vanlige (ikke-statiske) metoder

Hva er forskjellen mellom statiske metoder og vanlige?

En vanlig metode er bundet til et vanlig objekt (en forekomst av en klasse), mens en statisk metode ikke er det. En vanlig metode kan få tilgang til variabler i sin instans, men en statisk metode kan ikke: den har rett og slett ikke en tilknyttet instans.

Forskjellene mellom de to typene metoder er uttrykt i følgende tabell:

Hvorfor trengs slike metoder hvis de er så sterkt begrenset? Svaret er at denne tilnærmingen også har sine fordeler.

For det første trenger du ikke sende noen objektreferanse for å få tilgang til statiske metoder og variabler.

For det andre, noen ganger trenger du at det bare er en enkelt forekomst av en variabel. For eksempel System.out( System-klassens statiske ut-variabel ).

Og for det tredje, noen ganger må du kalle en metode før det i det hele tatt er mulig å lage objekter. For eksempel kaller Java-maskinen main()-metoden for å starte kjøringen av programmet selv før en forekomst av klassen er opprettet.

Bundet til en forekomst av klassen

Når en vanlig metode kalles, sendes et argument - objektet som metoden kalles på - implisitt til den. Denne parameteren kalles this. Denne implisitte parameteren (en referanse til objektet som metoden kalles på) skiller vanlige metoder fra statiske.

Statiske metoder har ikke denne implisitte parameteren, så du kan ikke bruke nøkkelordet thisi statiske metoder, og du kan ikke kalle en ikke-statisk metode i en statisk metode. Det er rett og slett ingen steder å få en referanse til en forekomst av en klasse.

Kan kalle vanlige metoder i klassen

En vanlig metode har alltid den implisitte thisparameteren, så du har alltid en referanse til objektet som metoden kalles på. Hver gang du kaller en ordinær metode i en annen ordinær metode, thisbrukes den implisitte parameteren til å gjøre det kallet. Eksempel

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 er derfor du ikke kan kalle en vanlig metode fra en statisk. Det er rett og slett ingen implisitt variabel navngitt thisi en statisk metode.

Eller forestill deg en annen situasjon: ikke et eneste objekt i klassen vår har ennå blitt opprettet i programmet vårt. Kan vi kalle en statisk metode for klassen vår? Ja. Og kan denne statiske metoden kalle en vanlig (ikke-statisk) metode?

Vel, hvilket objekt skulle vi kalle det på? Tross alt, ikke en eneste forekomst av klassen vår eksisterer ennå!

Kan kalle statiske metoder for klassen

Statiske metoder kan kalles fra hvor som helst - fra hvilket som helst sted i programmet. Dette betyr at de kan kalles fra både statiske metoder og vanlige. Det er ingen begrensninger her.

Kan få tilgang til vanlige variabler i klassen

Du kan få tilgang til vanlige variabler for en klasse fra en vanlig metode, siden den enkelt kan få en referanse til en forekomst av klassen via den implisitte thisparameteren.

En statisk metode vet ikke hvilken forekomst av klassen den skal bruke for å få verdier av vanlige variabler. Og mer generelt kan vi lett ha en situasjon der en statisk metode kalles, men ikke en eneste forekomst av klassen er opprettet i programmet ennå.

Som et resultat kan ikke statiske metoder få tilgang til vanlige variabler i en klasse.

Anta at en statisk metode kaller en vanlig metode. Hvilket objekt skal den vanlige metoden kalles på?

Ingen vet! Det er derfor du ikke kan kalle en vanlig metode fra en statisk uten å sende inn en referanse til et objekt!

Kan få tilgang til statiske variabler i klassen

Situasjonen med kall til statiske variabler er den samme som med kall til statiske metoder. Statiske variabler kan nås fra hvor som helst i programmet. Det betyr at du kan få tilgang til dem fra statiske og vanlige metoder.

Kan kalles på et objekt

Både statiske og ordinære metoder kan kalles på et objekt. Et vanlig metodekall er mulig - det er faktisk den eneste måten å kalle en vanlig metode. En statisk metode kan også kalles på et objekt: i dette tilfellet bestemmer kompilatoren selv typen av variabelen og kaller den statiske metoden basert på typen:

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 kalles på klassen

Du kan bare kalle en statisk metode på en klasse. For å kalle en vanlig metode trenger du en referanse til en forekomst av klassen. Derfor kan du ikke kalle en vanlig metode ved å bruke denne konstruksjonen:ClassName.methodName(arguments)