# Hvad er de forskellige datatyper i Java?

Java tilbyder otte primitive datatyper og adskillige komplekse datatyper. Disse bestemmer, hvilke værdier der kan gemmes og vises i en variabel. Visse datatyper tildeles alle variabler i Java.

## Hvilke datatyper findes der i Java?

I alle programmeringssprog findes der forskellige datatyper, der indeholder specifikke objekter og definerede operationer. Selvom de datatypemuligheder, som de forskellige sprog tilbyder, ofte ligner hinanden, er der nogle gange betydelige forskelle. Hvis man for eksempel [sammenligner Python og Java](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/python-vs-java/) og deres datatyper, vil man bemærke ligheder mellem de to, men også adskillige forskelle, der gør sprogene velegnede til forskellige typer opgaver.

Java anvender to forskellige typer datatyper: **primitive og komplekse**. Komplekse datatyper kaldes også referencetyper. Primitive og komplekse datatyper adskiller sig i størrelse og bestemmer, hvilke værdier der kan gemmes i en variabel. Mens primitive datatyper kun kan **gemme enkle værdier**, bruges referencetyper til **at oprette mere komplekse strukturer** og **organisere og manipulere store mængder data**.

Hvis du vil lære at programmere, er det vigtigt ikke kun at kende de forskellige datatyper, men også at vide, hvordan du får mest muligt ud af hver enkelt af dem. For at forstå, hvordan man bedst bruger datatyper, skal man ikke kun forstå deres funktionalitet, men også hvor meget hukommelse de bruger (eller sparer).

## Hvad er primitive datatyper i Java?

Der er i alt otte forskellige [primitive datatyper i Java](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/java-primitiver/), som indeholder fast definerede værdiintervaller. De kan opdeles i fire kategorier: **logiske datatyper, integrerede datatyper, flydende datatyper og tegn-datatyper**. De har ingen yderligere særlige egenskaber og kaldes også elementære datatyper. Hver datatype har et fast antal bits. Vi vil gennemgå de primitive datatyper mere detaljeret nedenfor. Java bruger følgende primitive typer:

- boolean
- byte
- kort
- int eller heltal
- lang
- float
- dobbelt
- char

### `boolean`

[Javas booleske](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/javas-primitive-datatype-boolean/) datatype er ikke en numerisk type. Den tilbyder kun to mulige værdier: **sand** og **falsk**. Den kan bruges til at bestemme, om en betingelse gælder (sand) eller ikke (falsk). Det er en logisk datatype, og dens standardværdi er `false`. Den består af 1 bit og har følgende syntaks:

```java
boolean booleanVar;
```

### `byte`

`byte` er en integreret datatype, der repræsenteres som en toers komplementværdi med en størrelse på 8 bit eller 1 byte. Den bruges typisk til at spare hukommelse i større arrays. Dens værdiområde spænder fra -128 til 127, og dens standardværdi er 0. Her er dens syntaks:

```java
byte byteVar;
```

### `short`

`short` er også en af de integrerede datatyper i Java og bruges hovedsageligt til at spare hukommelse i større arrays. Toers komplementværdien er i sig selv 16 bits eller 2 bytes i størrelse, og dens værdiområde strækker sig **fra -32768 til og med 32767**. Som standard er dens værdi 0. Sådan bruges `short`:

```java
short shortVar
```

### `int` eller heltal

`int` eller heltal er også en toers komplementværdi og en integreret datatype med en størrelse på 4 byte eller 32 bit. Dens værdiområde omfatter heltal **mellem -2147483648 og 2147483647**, og dens standardværdi er 0. Dens syntaks er som følger:

```java
int intVar
```

### `long`

Den største integrerede datatype er `long`. Dette gælder for det første dens værdiområde, som ligger **mellem -9223372036854775808 og 9223372036854775807**, og for det andet dens egen størrelse, som er 8 byte eller 64 bit. Toers komplementværdien bruges derfor, hvis de andre integrerede datatyper ikke er tilstrækkelige. Den kræver dog også langt den mest hukommelse. Dens standardværdi er 0. Dette er dens syntaks:

```java
lomg longVar
```

### `float`

`float` er en flydende datatype og bruges til at gemme reelle tal. Den har en størrelse på 32 bit og overholder IEEE 754-standarden, som definerer standardrepræsentationen af binære og decimale flydende tal i computere. Standardværdien for `float` er 0,0, og der kan repræsenteres op til **syv decimaler** i dens værdiområde. Sammenlignet med double er `float` dog ikke så præcis og bør derfor ikke bruges til værdier, hvor præcision spiller en afgørende rolle. Hvis dette ikke er tilfældet, kan du dog bruge `float` for at spare plads. Syntaksen for `float` er som følger:

```java
float floatVar;
```

### `double`

`double` er cirka dobbelt så præcis som float og opfylder et lignende formål. Den er 64 bit stor og kan repræsentere **op til 16 decimaler**. Dens standardværdi er også 0,0. Hvis du har brug for mere præcise værdier, bør du altid bruge `double`, selvom denne datatype heller ikke er særlig præcis. Hvis du vil arbejde med helt nøjagtige værdier, bør du i stedet bruge klassen BigDecimal. Syntaksen for `double` er som følger:

```java
double doubleVar;
```

### `char`

`char` er en karakterdatatype. Den gemmer tegn baseret på Unicode-tegnsættet, hvilket muliggør portabilitet til mange forskellige platforme. Hvert tegn kræver 2 byte hukommelse. Dens værdiområde svarer til ASCII (American Standard Code for Information Interchange) og ligger **mellem ‘\\u0000’ (dvs. 0) og ‘\\uffff’ (svarer til 65535)**. Standardværdien for char er ‘\\u0000’, og dens syntaks ser således ud:

```java
char charVar
```

## Hvad er komplekse datatyper i Java?

Den anden type datatyper i Java er referencetyper, også kaldet komplekse datatyper. De kaldes referencetyper, fordi de **refererer til objekter**. I modsætning til primitive datatyper er de normalt ikke foruddefinerede, men bestemmes af programmøren (en undtagelse herfra er streng). De kan bruge metoder og kan også have værdien 0 (i betydningen tom). Mens primitive datatyper starter med et lille bogstav, starter referencetyper med et stort bogstav. Her ser vi på de vigtigste referencetyper.

### Strengene

`String` er en klasse, der kan bruges til at repræsentere en **sekvens af tegn**, hvilket adskiller denne komplekse datatype fra den primitive datatype `char` samt andre datatyper. En streng eksisterer som et objekt i klassen `java.lang`. De forskellige metoder i String-klassen giver dig mulighed for at undersøge individuelle tegn i strengen, sammenligne strenge med hinanden, søge i strenge og kopiere strenge. Strenge identificeres ved hjælp af anførselstegn. Syntaksen for denne referencetype ser således ud:

```java
<string_type> <string_variable> = "<string_sequence>";
```

Her er et eksempel på, hvordan strenge fungerer:

```java
// How to create a string without a new operator
String a = "This is your new string";
/ / How to create a string with a new operator
String a1 = new string ("This is your new string");
```

### Arrays

Arrays bruges til at gemme **flere værdier i en variabel** i stedet for at oprette forskellige variabler for hver enkelt værdi. De oprettes ved hjælp af firkantede parenteser. De gemte værdier placeres i krøllede parenteser og adskilles med kommaer. Her er syntaksen for arrays:

```java
dataType[] arrayName = {value1, value2, value3,…};
```

Hvis du vil oprette en matrix med strenge, kan du gøre det på følgende måde:

```java
String[] colors = {"blue", "red", "yellow", "purple"};
```

Sådan opretter du en matrix med heltal:

```java
int[] figures = {5, 10, 15, 20};
```

### Undervisning

I Java er klasser datatyper, der **fungerer som skabeloner** til oprettelse af objekter. De indeholder forskellige komponenter, herunder klassens navn, modifikatorer og en krop omgivet af krøllede parenteser. Her er et eksempel på, hvordan en klasse ser ud i Java:

```java
public class Main {
	int a = 10;
}
```

### Grænseflader

I Java er en grænseflade en **abstrakt klasse**. Den fungerer som en grænseflade, som en klasse kan få adgang til forskellige funktioner gennem. For at gøre dette skal den dog først implementere dem. Grænseflader indeholder kun konstanter og abstrakte metoder. Deres syntaks ser sådan ud:

```java
interface {
	abstract methods
}
```

Vi vil her give et simpelt eksempel for at vise, hvordan grænseflader fungerer:

```java
interface Pizza {
	public void ingredientsList();
	public void preparation();
}
class Mushroom implements Pizza {
	public void ingredientsList() {
		System.out.println("mushrooms, tomato sauce, oregano, mozzarella");
}
public void preparation() {
	System.out.println("The pizza will be ready in 15 minutes.");
}
}
class Main {
	public static void main(String[] args) {
		Mushroom myMushroom = new Mushroom();
		myMushroom.ingredientsList();
		myMushroom.preparation();
	}
}
```

Den tilsvarende output fra Java-kommandoen `System.out.println` ser således ud:

```java
mushrooms, tomato sauce, oregano, mozzarella
The pizza will be ready in 15 minutes.
```

### Objekter

I Java er objekter også en kompleks datatype. Objekter er **instanser af klasser**, der derefter kan interagere med hinanden ved hjælp af metoder. I det følgende eksempel skal vi oprette flere objekter i en Main-klasse:

```java
public class Main {
	int a = 10;
public static void main(String[] args) {
	Main myObj1 = new Main();
	Main myObj2 = new Main();
	System.out.println(myObj1.a);
	System.out.println(myObj2.a);
	}
}
```

Resultatet ser således ud:

```java
10
10
```

### Enums

[Enums](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/java-enumerationer/) er en særlig klasse, der giver dig mulighed for at indarbejde **uforanderlige konstanter i din kode**. Disse variabler tildeles faste værdier, der ikke kan ændres. Denne datatype er især nyttig, hvis du har brug for variabler, der kun skal have få mulige tilstande. Syntaksen for en enum ser således ud:

```java
enum NameOfTheClass {
	VALUE1,
	VALUE2,
	VALUE3
}
```


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