A Java változók olyan tárolók, amelyek különböző Java adattípusokat képesek tárolni. Ide tartoznak a helyi változók, az instáns változók és a statikus változók. A Java változók mérete utólag nem módosítható, de tartalmuk a létrehozás után megváltoztatható.

Mik azok a Java változók?

Minden programozási nyelv rendelkezik változókkal, amelyek a program kódjának kezeléséhez használatosak. A változók olyan tárolók, amelyek egy adott adattípusú adatokat (és csak az adott típusú adatokat) tárolnak. A Java nyelvben a változók tartalmazhatnak Java primitív adattípusokat, mint például egész számokat, lebegőpontos számokat, igazságértékeket és egyedi számjegyeket. Emellett komplex adattípusokat is tárolhatnak, mint például Java karakterláncokat. A Java változóknak van egy meghatározott, egyértelműen definiált méretük, amely utólag nem módosítható. A változó tartalma azonban később megváltoztatható. Ebben az oktatóanyagban bemutatjuk a különböző változótípusokat, és megmutatjuk, hogyan lehet változókat létrehozni különböző adattípusokhoz.

Hogyan kell deklarálni és inicializálni var Java-ban

Az első dolog, amit tudnod kell, az a Java változók deklarálása és inicializálása. Ez a folyamat minden típusú változó esetében azonos. A változó deklarálásához két paraméterre van szükség. Az első az a adattípus, amelyet a változóban tárolni szeretnél. A második a változó neve.

Amikor inicializálja a változót, három összetevőre van szükség. Nemcsak a változó adattípusára és nevére van szükség, mint fent, hanem egy értékre is. A változó inicializálása egy korábban üres változóhoz érték hozzárendelését jelenti.

Így néz ki a szintaxis:

Datatype Name = Value;
java

Melyek a három változótípusok Java-ban?

A Java nyelvben háromféle változó létezik: helyi változók, példányváltozók és statikus változók.

Helyi változók

A Java nyelvben a helyi változókat egy metódus, konstruktor vagy blokk testében deklarálják. A változó ezután csak az adott metóduson belül használható. Íme, hogyan néz ez ki a gyakorlatban:

public class Main {
	public static void main(String[] args) {
		int var = 5;
		System.out.println("The local variable is: " + var);
	}
}
java

A kimenet a következőképpen fog kinézni:

The local variable is: 5
java

Példányváltozók

Az instánsváltozók egy osztályon belül, de egy metóduson, konstruktoron vagy blokkon kívül jönnek létre. Akkor keletkeznek, amikor a „new” kulcsszóval hozol létre egy objektumot. A helyi változóktól eltérően az instánsváltozóknak standard értékeik vannak. Számok esetében a standard érték 0 vagy 0,0. Boole-értékek esetében ez false. Objektumhivatkozások esetében ez null.

Az alábbi példában láthatjuk, hogyan használják az instance változókat Java-ban. A kódban létrehozunk egy csoportot azokból az emberekből, akik szeretnének hozzájárulni egy születésnapi ajándékhoz, és felsoroljuk, hogy ki mennyit adott hozzá.

public class Gift  {
	public String name;
	private double contribution;
	public Gift (String person) {
		name = person;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public double getContribution() {
		return contribution;
	}
	public void setContribution(double participantContribution) {	
		contribution = participantContribution;
	}
	public static void main(String[] args) {
		Gift participant = new Gift ("Peter");
		participant.setContribution(10);
		System.out.println("Name: " + participant.getName());
		System.out.println("Contribution = " + participant.getContribution());
		Gift participant2 = new Gift ("Maria");
		participant2.setContribution(15);
		System.out.println("Name: " + participant2.getName());
		System.out.println("Contribution  = " + participant2.getContribution());
	}
}
java

Íme a kód kimenete:

Name: Peter
Contribution = 10.0
Name: Maria
Contribution = 15.0
java

Statikus változók

Míg a másik két Java változótípus nem deklarálható statikusan, a statikus változók igen. Ezeket egy metódus, konstruktor vagy blokk kívül deklarálják, így az osztályhoz tartoznak, és nem egy példányhoz. Az osztály összes példánya használja őket. A statikus változók memóriát kapnak, amikor az osztály betöltődik a memóriába. Íme egy példa kódban:

public class Gift {
	public static String participant = "Peter";
	public static void main(String[] args) {
		System.out.println("Participant: " + Gift.participant);
	}
}
java

Itt van az eredmény:

Participant: Peter
java

Hogyan lehet különböző adattípusú változókat létrehozni?

A Java változók létrehozásának folyamata az adat típusok között meglehetősen hasonló. Bemutatunk néhány példát a leggyakoribb adat típusokra, és elmagyarázzuk azok közötti különbségeket.

boolean

A Boolean típus csak igaz vagy hamis értéket tartalmazhat. A következőképpen deklarálható:

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

Itt van az eredmény:

true
java

int

Az int a leggyakrabban használt adattípus az egész számokhoz. Az int típusú Java var-t így lehet deklarálni:

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

Itt van az eredmény:

10
java

lebeg

A float típus tizedes számokhoz használatos. Így lehet float változót deklarálni Java-ban:

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

Itt van az eredmény:

-17.03
java

kar

A char egyetlen karaktert tartalmaz, amelyet egyszerű idézőjelek között jelölünk. Így néz ki ez a kódban:

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

Itt van az eredmény:

S
java

String

A fentebb bemutatott primitív adattípusok mellett a Java változók teljes karakterláncokat is tartalmazhatnak. A karakterláncokat dupla idézőjelek között kell megadni:

public class Main {
	public static void main(String[] args) {
		String example = "This is a string in Java.";
		System.out.println(example);
	}
}
java

Itt van az eredmény:

This is a string in Java.
java
Ugrás a főmenübe