Hur man använder Java-primitiv

Det finns 8 primitiva datatyper i Java, som alla har en fast storlek och ett definierat värdeintervall. De används för att skapa variabler och tilldela dem individuella siffror, tecken eller logiska värden. De 8 primitiva datatyperna i Java är boolean, byte, char, double, float, int, long och short.

Vad är Java-primitiv?

Liksom andra programmeringsspråk har Java olika datatyper. I Java delas dessa in i två kategorier. Den första är referenstyper, som hänvisar till ett objekt som kan definieras fritt, såsom strängar, matriser, klasser och gränssnitt. Sedan finns det Java-primitiv. De har en fast storlek som är densamma på alla plattformar. De har också sin egen wrapper-klass, är oföränderliga och har ett fast värdeintervall. 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 situationer kan vi dela in Java-primitiverna i fyra kategorier:

• Logisk datatyp (boolean)
• Integral datatyp (byte, short, int och long)
• Flyttalstyp (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-primitivtyper ä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å felmeddelanden. Här är en översikt över Java-primitivtyperna:

Hur man använder den primitiva booleska typen i Java

En Java-boolean kallas också för ett sanningsvärde. 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 vanligtvis 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 standardvärdet false. Boolean kan kombineras med Boolean-operatorer 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 initialisera en utdata kommer utdata att se ut så här:

true

byte

byte är den minsta datatypen bland heltalstyperna. Den har ett mycket begränsat värdeintervall, 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ärdeintervall kan du deklarera en byte så här:

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

Resultatet 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-primitiverna. Men om byte är för litet och int är för stort, kan short vara den heltalstyp du letar efter. Så här deklarerar du den:

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

Resultatet ser ut så här:

-27412

int

int är den mest använda av de heltalstyperna. Den har ett mycket stort värdeintervall och sparar ändå utrymme. int är ett tvåkomplementvärde 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);
	}
}

Resultatet ser ut som följer:

14 + 3 = 17

lång

long är en utvidgning 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 resultatet:

47

flyta

Det finns två Java-primitivtyper för att representera delmängder av rationella tal. float är den mindre av de två flyttalsdatatyperna 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 versalerat “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 fortfarande inte helt exakta resultat. Om du letar efter ett alternativ kan du använda klassen BigDecimal. 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. Utmatningen ser ut som följer:

7.2252

karaktär

char används för att representera Unicode-tecken. Det sträcker sig från ‘\u0000’ till ‘\uffff’, alltså från 0 till 65535. Datatypen character kan representera nästan alla europeiska och asiatiska tecken. Den använder 16 bitar minne. Värdena för denna Java-primitiv anges inom enkla citattecken. Så här ser det ut i kod:

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

Resultatet ser ut som följer:

&