# Hoe gebruik je de Java-methode main():

De `main()` staat aan het begin en einde van elk programma in Java. Alleen statements die binnen het bereik ervan vallen, worden tijdens de uitvoering in aanmerking genomen. Daarom is het zo belangrijk om op elk detail van de syntaxis van de methode te letten. Als deze onjuist is, wordt het programma niet uitgevoerd.

## Wat is de `main()` -methode in Java?

Ongeacht welk project u met de programmeertaal wilt uitvoeren of welke beknopte of uitgebreide code u daarvoor gebruikt, in Java begint elke toepassing met de `main()`. Als deze niet beschikbaar is, **kan** de code **niet worden uitgevoerd**. Voordat dit wordt doorgegeven aan `main()`, wordt de Java Virtual Machine (JVM) in het geheugen geladen en wordt de code gecompileerd. Zodra deze stappen zijn voltooid, wordt de code gecontroleerd met de `main()`. Vervolgens wordt deze hopelijk correct uitgevoerd. In principe is het ook mogelijk om meerdere van deze methoden te gebruiken, waarbij het maximum één hoofdmethode per klasse is.

## Wat is de syntaxis van de Java-methode `main()`?

De syntaxis van `main()` van Java is altijd hetzelfde. Deze bestaat uit meerdere belangrijke onderdelen en ziet er als volgt uit:

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

Deze componenten vervullen de volgende functies:

- `public`: Dit onderdeel zorgt ervoor dat een klasse ook van buitenaf toegankelijk is.
- `static`: Dit deel verklaart de methode als statisch, wat betekent dat deze kan bestaan zonder dat er vooraf een object van een specifieke klasse is aangemaakt.
- `void`: Dit zorgt ervoor dat de `main()` in Java geen waarde hoeft terug te geven. `main`: Dit is wat Java Virtual Machine gebruikt om de methode te identificeren wanneer het een programma uitvoert.
- `String[] args`: Dit is een array waarin de commandoregelargumenten worden opgeslagen en ontvangen.

## Waarom zijn de afzonderlijke componenten van `main()` belangrijk?

Om beter te begrijpen hoe de Java `main()` werkt en waarom alle componenten zo belangrijk zijn, zullen we ze in de volgende paragrafen afzonderlijk bekijken. Het belangrijkste is dat we u laten zien wat er gebeurt als **een deel van de handtekening ontbreekt**. Hiervoor kiezen we een heel eenvoudig codevoorbeeld, dat we met het Java-commando `System.out.println` zullen uitvoeren.

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

Wanneer u deze code uitvoert, krijgt u de volgende uitvoer:

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

### `public`

`public` fungeert als een toegangsspecificatie en geeft aan de Java Virtual Machine door **waar het bijbehorende programma wordt uitgevoerd**. Er zijn nog andere toegangsmodificatoren, zoals default, private en protected. Als u deze echter gebruikt met de `main()` in Java, krijgt u een foutmelding:

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

De bijbehorende kwestie is:

```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
```

Deze foutmelding geeft aan dat er geen openbare toegang tot de methode is.

### `static`

Het sleutelwoord `static` bevestigt dat de gebruikte methode statisch is. Dit betekent dat deze **onafhankelijk van klasse-instanties** kan worden gebruikt. Als u dit onderdeel verwijdert, ziet de code er als volgt uit:

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

Hier krijgt u ook een foutmelding:

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

### `void`

`void` is een trefwoord dat aangeeft dat de `main()` in Java **geen waarden mag retourneren**. Aangezien `main()` het begin- en eindpunt van een programma in Java is, is weergave overbodig. Zo ziet de code eruit zonder `void`:

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

Dit is de foutmelding die u krijgt als u `void` weglaat:

```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`

Voor elk programma in Java zoekt de JVM eerst naar de identificatiecode `main`. Deze geeft aan **waar de uitvoering moet beginnen en eindigen**. Zodra de methode `main()` in Java is uitgevoerd, wordt het programma beëindigd. Daarom mag de handtekening nooit worden gewijzigd of aangevuld. Hier volgt een voorbeeld van hoe een wijziging in de handtekening eruitziet:

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

Aangezien de JVM de identificatie niet kan vinden, zal het programma direct worden beëindigd en de volgende foutmelding geven:

```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`

De array `String[] args` komt overeen met de klasse **java.lang.String** en bevat gegevens die als tekenreekswaarden worden opgeslagen. Als u deze specificatie weglaat, ziet de code er als volgt uit:

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

Zonder het argument kan de Java `main()` niet worden uitgevoerd. Als gevolg hiervan krijgt u opnieuw de volgende foutmelding:

```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
```

## Welke alternatieve spellingen zijn er?

Het hier getoonde codevoorbeeld is geschreven volgens de meest gangbare syntaxis. U kunt het echter eenvoudig aanpassen om uzelf een beter overzicht te geven. U kunt bijvoorbeeld de vierkante haken direct achter `args` plaatsen. Zo zou het er dan uitzien:

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

Je kunt argumenten ook opslaan als variabele argumenten (varargs). Hiervoor moet je een ellips gebruiken:

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

Tip In onze digitale gids vindt u nog een reeks andere artikelen over Java. U kunt lezen hoe [Java en JavaScript zich tot elkaar verhouden](https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/java-versus-javascript/) of meer te weten komen over Java-operatoren.


This is a markdown version of: [https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/java-methode-main/](https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/java-methode-main/) for AI/LLM consumption.