# Sådan bruges Java-metoden main():

Metoden `main()` findes i begyndelsen og slutningen af hvert program i Java. Kun sætninger, der ligger inden for dens rækkevidde, tages i betragtning under udførelsen. Derfor er det så vigtigt at være opmærksom på alle detaljer i metodens syntaks. Hvis den er forkert, vil programmet ikke blive udført.

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

Uanset hvilket projekt du ønsker at implementere med programmeringssproget, eller hvilken kortfattet eller omfattende kode du bruger til det, starter alle applikationer i Java med metoden `main()`. Hvis den ikke er tilgængelig, **kan** koden **ikke udføres**. Inden dette videregives til `main()`, indlæses Java Virtual Machine (JVM) i hukommelsen, og koden kompileres. Når disse trin er gennemført, kontrolleres koden med `main()` metoden. Derefter udføres den forhåbentlig korrekt. I princippet er det også muligt at bruge flere af disse metoder, hvor det maksimale antal er én hovedmetode pr. klasse.

## Hvad er syntaksen for Java-metoden `main()`?

Syntaksen i Java’s `main()` metode er altid den samme. Den består af flere vigtige dele og ser således ud:

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

Disse komponenter udfører følgende funktioner:

- `public`: Denne komponent sikrer, at en klasse også kan tilgås udefra.
- `static`: Denne del erklærer metoden som statisk, hvilket betyder, at den kan eksistere uden at der på forhånd er oprettet et objekt af en bestemt klasse.
- `void`: Dette sikrer, at metoden `main()` i Java ikke behøver at returnere en værdi. `main`: Dette er det, Java Virtual Machine bruger til at identificere metoden, når den udfører et program.
- `String[] args`: Dette er en matrix, hvor kommandolinjeargumenterne gemmes og modtages.

## Hvorfor er de enkelte komponenter i `main()` vigtige?

For bedre at forstå, hvordan `main()` -metoden fungerer, og hvorfor alle komponenterne er så vigtige, vil vi se nærmere på dem hver for sig i de følgende afsnit. Vigtigst af alt vil vi vise dig, hvad der sker, hvis **en del af signaturen mangler**. Til dette vil vi vælge et meget simpelt kodeeksempel, som vi vil udskrive 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 udfører denne kode, får du følgende output:

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

### `public`

`public` fungerer som en adgangsspecifikator og signalerer til Java Virtual Machine **, hvor det tilsvarende program udføres**. Der findes andre adgangsmodifikatorer, såsom default, private og protected. Hvis du bruger disse sammen med `main()` i Java, vil du dog modtage en fejlmeddelelse:

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

Det tilsvarende problem 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 fejlmeddelelse angiver, at der ikke er offentlig adgang til metoden.

### `static`

Nøgleordet `static` bekræfter, at den anvendte metode er statisk. Det betyder, at den kan bruges **uafhængigt af klasseinstanser**. Hvis du fjerner denne komponent, vil koden se således ud:

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

Her får du også en fejlmeddelelse:

```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øgleord, der angiver, at `main()` i Java **ikke skal returnere nogen værdier**. Da `main()` er start- og slutpunktet for et program i Java, er rendering unødvendig. Sådan ser koden ud uden `void`:

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

Dette er den fejlmeddelelse, du får, hvis du udelader `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øger JVM først efter identifikatoren `main`. Dette angiver, **hvor udførelsen skal begynde og slutte**. Så snart metoden `main()` i Java har afsluttet sin udførelse, afsluttes programmet. Derfor bør signaturen aldrig ændres eller tilføjes. Her er et eksempel på, hvordan en ændring af signaturen ser ud:

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

Da JVM ikke kan finde identifikatoren, afslutter den programmet direkte og viser følgende fejlmeddelelse:

```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` svarer til klassen **java.lang.String** og indeholder data, som den gemmer som strengværdier. Hvis du udelader denne specifikation, vil koden se således ud:

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

Uden argumentet kan Java `main()` -metoden ikke udføres. Som følge heraf vil du igen modtage følgende fejlmeddelelse:

```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åder findes der?

Det her viste kodeeksempel er skrevet i henhold til den mest almindelige syntaks. Du kan dog nemt tilpasse det, så du får et bedre overblik. Du kan f.eks. placere de firkantede parenteser direkte efter `args`. Sådan vil det se ud:

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

Du kan også gemme argumenter som variable argumenter (varargs). For at gøre dette skal du bruge en ellipse:

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

Tip Du kan finde en række andre artikler om Java i vores digitale guide. Du kan læse om, hvordan [Java og JavaScript sammenlignes](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/java-vs-javascript/), eller lære mere om Java-operatorer.


This is a markdown version of: [https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/java-metode-main/](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/java-metode-main/) for AI/LLM consumption.