Hur man använder Java-primitiv

Det finns 8 primitiva datatyper i Java, som alla har en fast storlek och ett de­fi­ni­e­rat vär­de­in­ter­vall. De används för att skapa variabler och tilldela dem in­di­vi­du­el­la siffror, tecken eller logiska värden. De 8 primitiva da­ta­ty­per­na i Java är boolean, byte, char, double, float, int, long och short.

Vad är Java-primitiv?

Liksom andra pro­gram­me­rings­språk har Java olika datatyper. I Java delas dessa in i två ka­te­go­ri­er. Den första är re­fe­ren­sty­per, som hänvisar till ett objekt som kan de­fi­nie­ras fritt, såsom strängar, matriser, klasser och gräns­snitt. Sedan finns det Java-primitiv. De har en fast storlek som är densamma på alla platt­for­mar. De har också sin egen wrapper-klass, är oför­än­der­li­ga och har ett fast vär­de­in­ter­vall. Java-primitiv används för att skapa variabler för enskilda siffror, tecken eller logiska värden.

I Java finns det åtta olika primitiva datatyper som främst skiljer sig åt i termer av vilka värden de lagrar. Gemensamt för dem alla är att de endast kan innehålla ett enda värde. Eftersom vissa av dem används i liknande si­tu­a­tio­ner kan vi dela in Java-pri­mi­ti­ver­na i fyra ka­te­go­ri­er:

• Logisk datatyp (boolean)
• Integral datatyp (byte, short, int och long)
• Flyt­tal­s­typ (float och double)
• Tecken datatyp (char)

Eftersom de lagras direkt i stacken är deras storlek särskilt viktig. Vi kommer att diskutera detta mer ingående längre fram i denna guide. Java-pri­mi­tiv­ty­per är också viktiga eftersom Java är ett statiskt typat språk. När du skapar ett program måste du alltså redan definiera vilken datatyp en variabel är, annars kommer du att få fel­med­de­lan­den. Här är en översikt över Java-pri­mi­tiv­ty­per­na:

Hur man använder den primitiva booleska typen i Java

En Java-boolean kallas också för ett san­nings­vär­de. Det är den enklaste primitiva datatypen i Java, eftersom den bara har två möjliga värden: ”true” eller ”false”. Den används när en logisk operand behövs och är den enda logiska datatypen. I uttryck står dess två möjliga värden van­ligt­vis för ett villkor som antingen är uppfyllt (true) eller inte (false). Om du inte tilldelar ett värde till en Boolean får den stan­dard­vär­det false. Boolean kan kom­bi­ne­ras med Boolean-ope­ra­to­rer i Java, såsom AND och OR. Att tilldela ett värde till en Boolean ser ut så här:

public class Main {
	public static void main(String[] args) {
		boolean x = true;
		System.out.println(x);
	}
}

Om du använder Java-kommandot System.out.prinln för att ini­ti­a­li­se­ra en utdata kommer utdata att se ut så här:

true

byte

byte är den minsta datatypen bland hel­tal­s­ty­per­na. Den har ett mycket begränsat vär­de­in­ter­vall, nämligen från -128 till 127. Men den använder bara 8 bitar minne. Faktum är att den har fått sitt namn från det faktum att 8 bitar utgör en byte. Om du bara arbetar med ett mycket begränsat vär­de­in­ter­vall kan du deklarera en byte så här:

public class Main {
	public static void main(String[] args) {
		byte x = 101;
		System.out.println(x);
	}
}

Re­sul­ta­tet ser ut som följer:

101

kort

short är dubbelt så stort som byte, vilket innebär att det också är en av de mer sällan använda Java-pri­mi­ti­ver­na. Men om byte är för litet och int är för stort, kan short vara den hel­tal­s­typ du letar efter. Så här de­kla­re­rar du den:

public class Main {
	public static void main(String[] args) {
		short x = -27412;
		System.out.println(x);
	}
}

Re­sul­ta­tet ser ut så här:

-27412

int

int är den mest använda av de hel­tal­s­ty­per­na. Den har ett mycket stort vär­de­in­ter­vall och sparar ändå utrymme. int är ett två­kom­ple­ment­vär­de och används också ofta för andra ändamål. Så här använder du det:

public class Main {
	public static void main(String[] args) {
		int x = 14;
		int y = 3;
		int z = x + y;
		System.out.println(x + " + " + y + " = " + z);
	}
}

Re­sul­ta­tet ser ut som följer:

14 + 3 = 17

lång

long är en ut­vidg­ning av int och kan innehålla ännu längre tal. int räcker i de flesta fall, men om du vill deklarera long kan du göra det på följande sätt:

public class Main {
	public static void main(String[] args) {
		long x = 47;
		System.out.println(x);
	}
}

Här är re­sul­ta­tet:

47

flyta

Det finns två Java-pri­mi­tiv­ty­per för att re­pre­sen­te­ra del­mäng­der av ra­tio­nel­la tal. float är den mindre av de två flyt­tals­da­ta­ty­per­na och använder 32 bitar. Den kan visa upp till 7 decimaler. Den är dock inte särskilt precis och används därför inte så ofta. Om du bestämmer dig för att använda den kan du deklarera den på följande sätt:

public class Main {
	public static void main(String[] args) {
		float x = 7.22f;
		System.out.println(x);
	}
}

Observera att du måste infoga ett gemenerat eller ver­sa­le­rat “f” efter siffran för att tala om för datorn att det är ett float och inte ett double. F:et visas inte i utdata:

7.22

dubbelt

Den andra datatypen för flyttal är double. Den är betydligt mer exakt än float, men ger fort­fa­ran­de inte helt exakta resultat. Om du letar efter ett al­ter­na­tiv kan du använda klassen Big­De­ci­mal. Om double passar dina behov kan du deklarera den så här:

public class Main {
	public static void main(String[] args) {
		double x = 7.2252;
		System.out.println(x);
	}
}

Observera att det inte finns någon extra bokstav här. Ut­mat­ning­en ser ut som följer:

7.2252

karaktär

char används för att re­pre­sen­te­ra Unicode-tecken. Det sträcker sig från ‘\u0000’ till ‘\uffff’, alltså från 0 till 65535. Datatypen character kan re­pre­sen­te­ra nästan alla eu­ro­pe­is­ka och asiatiska tecken. Den använder 16 bitar minne. Värdena för denna Java-primitiv anges inom enkla citat­tec­ken. Så här ser det ut i kod:

public class Main {
	public static void main(String[] args) {
		char x = '&';
		System.out.println(x);
	}
}

Re­sul­ta­tet ser ut som följer:

&