# Hva er de forskjellige datatypene i Java?

Java tilbyr åtte primitive datatyper og en rekke komplekse datatyper. Disse bestemmer hvilke verdier som kan lagres og vises i en variabel. Visse datatyper tilordnes alle variabler i Java.

## Hvilke datatyper finnes det i Java?

I alle programmeringsspråk finnes det ulike datatyper som inneholder spesifikke objekter og definerte operasjoner. Selv om datatypealternativene som tilbys av ulike språk ofte ligner hverandre, er det noen ganger betydelige forskjeller. Hvis du for eksempel [sammenligner Python og Java](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/python-mot-java/) og deres datatyper, vil du se likheter mellom de to, men også mange forskjeller som gjør språkene egnet for ulike typer oppgaver.

Java bruker to forskjellige typer datatyper: **primitive og komplekse**. Komplekse datatyper kalles også referansetyper. Primitive og komplekse datatyper skiller seg fra hverandre når det gjelder størrelse og bestemmer hvilke verdier som kan lagres i en variabel. Mens primitive datatyper kun kan **lagre enkle verdier**, brukes referansetyper til **å lage mer komplekse strukturer** og **organisere og manipulere store datamengder**.

Hvis du vil lære å programmere, er det viktig ikke bare å kjenne til de ulike datatypene, men også hvordan du får mest mulig ut av hver av dem. For å forstå hvordan du best kan bruke datatyper, må du ikke bare forstå funksjonaliteten deres, men også hvor mye minne de bruker (eller sparer).

## Hva er primitive datatyper i Java?

Det finnes totalt åtte forskjellige [primitive datatyper i Java](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/java-primitiver/), som inneholder fast definerte verdier. De kan deles inn i fire kategorier: **logiske datatyper, integrerte datatyper, flytende datatyper og tegnbaserte datatyper**. De har ingen ekstra spesielle funksjoner og kalles også elementære datatyper. Hver datatype har et fast antall biter. Vi vil gå nærmere inn på primitive datatyper nedenfor. Java bruker følgende primitive typer:

- boolean
- byte
- kort
- int eller heltall
- lang
- float
- dobbel
- char

### `boolean`

[Javas booleanske](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/javas-primitive-datatype-boolean/) datatype er ikke en numerisk type. Den har bare to mulige verdier: **true** og **false**. Den kan brukes til å avgjøre om en betingelse gjelder (true) eller ikke (false). Det er en logisk datatype, og standardverdien er `false`. Den består av 1 bit og har følgende syntaks:

```java
boolean booleanVar;
```

### `byte`

`byte` er en integrert datatype som representeres som en toers komplementverdi med en størrelse på 8 bit eller 1 byte. Den brukes vanligvis for å spare minne i større matriser. Verdiene spenner fra -128 til 127, og standardverdien er 0. Her er syntaksen:

```java
byte byteVar;
```

### `short`

`short` er også en av de integrerte datatypene i Java og brukes hovedsakelig til å spare minne i større matriser. Toers komplementverdien er 16 bits eller 2 bytes i størrelse, og verdien strekker seg **fra -32768 til og med 32767**. Standardverdien er 0. Slik brukes `short`:

```java
short shortVar
```

### `int` eller heltall

`int` eller heltall er også en toers komplementverdi og en integrert datatype med en størrelse på 4 byte eller 32 bit. Verdien omfatter heltall **mellom -2147483648 og 2147483647**, og standardverdien er 0. Syntaksen er som følger:

```java
int intVar
```

### `long`

Den største integrerte datatypen er `long`. Dette gjelder for det første verdien, som ligger **mellom -9223372036854775808 og 9223372036854775807**, og for det andre størrelsen, som er 8 byte eller 64 bit. Toers komplementverdi brukes derfor hvis de andre integrerte datatypene ikke er tilstrekkelige. Den krever imidlertid også langt mest minne. Standardverdien er 0. Dette er syntaksen:

```java
lomg longVar
```

### `float`

`float` er en flytende datatype og brukes til å lagre reelle tall. Den har en størrelse på 32 bit og er i samsvar med IEEE 754-standarden, som definerer standardrepresentasjonen av binære og desimale flytende tall i datamaskiner. Standardverdien for `float` er 0,0, og opptil **syv desimaler** kan representeres i verdifeltet. Sammenlignet med double er `float` imidlertid ikke like presist og bør derfor ikke brukes for verdier der presisjon spiller en avgjørende rolle. Hvis dette ikke er tilfelle, kan du imidlertid bruke `float` for å spare plass. Syntaksen for `float` er som følger:

```java
float floatVar;
```

### `double`

`double` er omtrent dobbelt så presist som float og oppfyller et lignende formål. Det er 64 bit i størrelse og kan representere **opptil 16 desimaler**. Standardverdien er også 0,0. Hvis du trenger mer presise verdier, bør du alltid bruke `double`, selv om denne datatypen heller ikke er så presis. Hvis du vil arbeide med helt eksakte verdier, bør du bruke BigDecimal-klassen i stedet. Syntaksen til `double` er som følger:

```java
double doubleVar;
```

### `char`

`char` er en karakterdatatype. Den lagrer tegn basert på Unicode-tegnsettet, noe som muliggjør portabilitet til en rekke forskjellige plattformer. Hvert tegn krever 2 byte minne. Verdien tilsvarer ASCII (American Standard Code for Information Interchange) og ligger **mellom ‘\\u0000’ (dvs. 0) og ‘\\uffff’ (tilsvarer 65535)**. Standardverdien for char er «\\u0000», og syntaksen ser slik ut:

```java
char charVar
```

## Hva er komplekse datatyper i Java?

Den andre typen datatyper i Java er referansetyper, også kalt komplekse datatyper. De kalles referansetyper fordi de **refererer til objekter**. I motsetning til primitive datatyper er de normalt ikke forhåndsdefinerte, men bestemmes av programmereren (et unntak fra dette er streng). De kan bruke metoder og kan også ha verdien 0 (i betydningen tom). Mens primitive datatyper starter med en liten bokstav, starter referansetyper med en stor bokstav. Her skal vi se på de viktigste referansetypene.

### Strenger

`String` er en klasse som kan brukes til å representere en **sekvens av tegn**, og skiller denne komplekse datatypen fra den primitive datatypen `char` samt andre datatyper. En streng eksisterer som et objekt i klassen `java.lang`. De ulike metodene i String-klassen lar deg undersøke enkelttegn i strengen, sammenligne strenger med hverandre, søke i strenger og kopiere strenger. Strenger identifiseres ved hjelp av anførselstegn. Syntaksen for denne referansetypen ser slik ut:

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

Her er et eksempel på hvordan strenger 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");
```

### Matriser

Arrays brukes til å lagre **flere verdier i en variabel** i stedet for å opprette forskjellige variabler for hver enkelt verdi. De opprettes ved hjelp av firkantede parenteser. De lagrede verdiene plasseres i krøllparenteser og skilles med komma. Her er syntaksen for arrays:

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

Hvis du vil opprette en matrise med strenger, kan du gjøre det slik:

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

Slik oppretter du en matrise med heltall:

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

### Klasser

I Java er klasser datatyper som **fungerer som maler** for å opprette objekter. De inneholder ulike komponenter, blant annet navnet på klassen, modifikatorer og en kropp omsluttet av krøllparenteser. Her er et eksempel på hvordan en klasse ser ut i Java:

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

### Grensesnitt

I Java er et grensesnitt en **abstrakt klasse**. Det fungerer som et grensesnitt som en klasse kan bruke til å få tilgang til ulike funksjoner. For å gjøre dette må den imidlertid først implementere dem. Grensesnitt inneholder bare konstanter og abstrakte metoder. Syntaksen deres ser slik ut:

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

Vi skal ta et enkelt eksempel her for å vise hvordan grensesnitt 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 utdataen fra Java-kommandoen `System.out.println` ser slik ut:

```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 av klasser** som deretter kan samhandle med hverandre ved hjelp av metoder. I det følgende eksemplet skal vi opprette 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 slik ut:

```java
10
10
```

### Enums

[Enums](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/java-enumerasjoner/) er en spesiell klasse som lar deg innlemme **uforanderlige konstanter i koden din**. Disse variablene tildeles faste verdier som ikke kan endres. Denne datatypen er spesielt nyttig hvis du trenger variabler som bare skal ha noen få mulige tilstander. Syntaksen til en enum ser slik ut:

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


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