# Hvordan bruke Java-metoden main():

Metoden `main()` finnes i begynnelsen og slutten av hvert program i Java. Bare setninger som ligger innenfor dens omfang tas i betraktning under utførelsen. Derfor er det så viktig å være oppmerksom på hver minste detalj i metodens syntaks. Hvis den er feil, vil ikke programmet bli utført.

## Hva er `main()` i Java?

Uansett hvilket prosjekt du ønsker å implementere med programmeringsspråket, eller hvilken kortfattet eller omfattende kode du bruker til det, starter alle applikasjoner i Java med metoden `main()`. Hvis den ikke er tilgjengelig, **kan ikke** koden **kjøres**. Før dette sendes til `main()`, lastes Java Virtual Machine (JVM) inn i minnet og koden kompileres. Når disse trinnene er fullført, sjekkes koden med `main()` metoden. Deretter kjøres den forhåpentligvis riktig. I prinsippet er det også mulig å bruke flere av disse metodene, hvor maksimalt én hovedmetode per klasse.

## Hva er syntaksen til Java-metoden `main()`?

Syntaksen til Java-metoden `main()` er alltid den samme. Den består av flere viktige deler og ser slik ut:

```java
public static void main(String[] args)
```

Disse komponentene oppfyller følgende funksjoner:

- `public`: Denne komponenten sikrer at en klasse også kan nås fra utsiden.
- `static`: Denne delen erklærer metoden som statisk, noe som betyr at den kan eksistere uten at et objekt av en bestemt klasse er opprettet på forhånd.
- `void`: Dette sikrer at metoden `main()` i Java ikke trenger å returnere en verdi. `main`: Dette er det Java Virtual Machine bruker til å identifisere metoden når den kjører et program.
- `String[] args`: Dette er en matrise hvor kommandolinjeargumentene lagres og mottas.

## Hvorfor er de enkelte komponentene i `main()` viktige?

For å bedre forstå hvordan `main()` -metoden fungerer og hvorfor alle komponentene er så viktige, skal vi se på dem hver for seg i de følgende avsnittene. Viktigst av alt skal vi vise deg hva som skjer hvis **en del av signaturen mangler**. For å gjøre dette velger vi et veldig enkelt kodeeksempel, som vi skal skrive ut med Java-kommandoen `System.out.println`.

```java
public class main {
	public static void main(String[] args) {
		System.out.println("Here is your sample text.");
	}
}
```

Når du kjører denne koden, får du følgende utdata:

```java
Here is your sample text.
```

### `public`

`public` fungerer som en tilgangsspesifikator og signaliserer til Java Virtual Machine **hvor det tilsvarende programmet kjøres**. Det finnes andre tilgangsmodifikatorer, som default, private og protected. Hvis du bruker disse sammen med `main()` i Java, vil du imidlertid få en feilmelding:

```java
public class main {
	private static void main(String[] args) {
		System.out.println("Here is your sample text.");
	}
}
```

Det tilsvarende problemet er:

```java
Error: Main method not found in class, please define the main method as:
public static void main(String[] args)
or a JavaFX application class must extend javafx.application.Application
```

Denne feilmeldingen indikerer at det ikke er offentlig tilgang til metoden.

### `static`

Nøkkelordet `static` bekrefter at metoden som brukes er statisk. Dette betyr at den kan brukes **uavhengig av klasseinstanser**. Hvis du fjerner denne komponenten, vil koden se slik ut:

```java
public class main {
	public void main(String[] args) {
		System.out.println("Here is your sample text.");
	}
}
```

Her får du også en feilmelding:

```java
Error: Main method is not static in class test, please define the main method as:
public static void main(String[] args)
```

### `void`

`void` er et nøkkelord som angir at `main()` i Java **ikke skal returnere noen verdier**. Siden `main()` er start- og sluttpunktet for et program i Java, er rendering unødvendig. Slik ser koden ut uten `void`:

```java
public class main {
	public static main(String[] args) {
		System.out.println("Here is your sample text.");
	}
}
```

Dette er feilmeldingen du får hvis du utelater `void`:

```java
Error: Main method must return a value of type void in class Main, please define the main method as:
public static void main(String[] args)
```

### `main`

For hvert program i Java søker JVM først etter identifikatoren `main`. Dette angir **hvor utførelsen skal begynne og slutte**. Så snart metoden `main()` i Java fullfører utførelsen, avsluttes programmet. Dette er grunnen til at signaturen aldri bør endres eller legges til. Her er et eksempel på hvordan en endring i signaturen ser ut:

```java
public class main {
	public static void replacementMain(String[] args) {
		System.out.println("Here is your sample text.");
	}
}
```

Siden JVM ikke finner identifikatoren, vil den avslutte programmet direkte og vise følgende feilmelding:

```java
Error: Main method not found in class, please define the main method as:
public static void main(String[] args)
or a JavaFX application class must extend javafx.application.Application
```

### `String[] args`

`String[] args` tilsvarer **java.lang.String-klassen** og inneholder data som den lagrer som strengverdier. Hvis du utelater denne spesifikasjonen, vil koden se slik ut:

```java
public class main {
	public static void main() {
		System.out.println("Here is your sample text.");
	}
}
```

Uten argumentet kan ikke Java `main()` -metoden utføres. Som et resultat vil du motta følgende feilmelding igjen:

```java
Error: Main method not found in class, please define the main method as:
public static void main(String[] args)
or a JavaFX application class must extend javafx.application.Application
```

## Hvilke alternative stavemåter finnes det?

Kodeeksemplet som vises her, er skrevet i henhold til den vanligste syntaksen. Du kan imidlertid enkelt tilpasse det for å få en bedre oversikt. Du kan for eksempel plassere firkantparentesene rett etter `args`. Slik vil det se ut:

```java
public static void main(String args[]) { }
```

Du kan også lagre argumenter som variable argumenter (varargs). For å gjøre dette må du bruke tre prikker:

```java
public static void main(String...args) { }
```

Tip Du finner en rekke andre artikler om Java i vår digitale guide. Du kan lese om hvordan [Java og JavaScript sammenlignes](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/java-vs-javascript/) eller lære mer om Java-operatorer.


This is a markdown version of: [https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/java-metode-main/](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/java-metode-main/) for AI/LLM consumption.