Java változók

Ebben a cikkben minden Java tanulónak elmagyarázzuk, mik azok a Java változók, és hogyan kell velük dolgozni.

Mi az a Java változó

A Java változókat doboznak tekinthetjük. Ennek a „doboznak” van egy bizonyos mérete: a hozzá lefoglalt memória. A lefoglalt memória mennyisége a változó típusától függ, de erről egy kicsit később fogunk beszélni. Ugyanakkor magának a doboznak a mérete a létrehozása után nem változtatható, a tartalma viszont igen. Lehet, hogy a doboz üres. Valamilyen értéket "beilleszthet" bele, majd kivonhat és behelyezhet egy másik értéket. Így a változó egy olyan mező, amely egy Java program végrehajtása során adatértékeket tárol. Ez a doboz fontos tulajdonságokkal rendelkezik:

• mindig csak egy értéket tartalmazhat (vagy lehet üres is, ebben az esetben az alapértelmezett értéket fogja tartalmazni),
• Adattípusa van. Mérete függ az adatok típusától, valamint attól, hogy a memória melyik területétől van lefoglalva a hely (hol található).

Hogyan deklaráljunk változókat

A Java változók deklarálásához meg kell adni a típusát és nevét. Íme egy példa három változó deklarálására:

int myInt;
String s;
Object variableName;

Itt az int , String és Object az adattípus, a myInt , s , variableName pedig változónevek. Az adattípust a program igényei alapján kell kiválasztani, és érdemesebb úgy nevet választani, hogy egyértelmű legyen, miről van szó. Természetesen kezdőknek ez nem olyan szigorú, de nagy projekteknél az olyan változónevek, mint az „s”, ronthatják a kód olvashatóságát. Jobb tehát megszokni a változók olyan elnevezését, amelyből már az elején világossá válik, mire valók. Ésszerű keretek között természetesen.

Hogyan inicializáljuk a változókat

Amikor deklarál egy változót, memóriát foglal le neki. Az inicializálás azt jelenti, hogy egy bizonyos értéket "behelyez" a "dobozba". Ez megtehető azonnal a változó deklarálása során vagy később. Ezenkívül egy változó értéke változhat a program végrehajtása során. Példa:

public class VariableTest {
    public static void main(String[] args) {
        int myInt = 5;
        String s;
        s = "init";
        System.out.println(s);
        s = s+5;
        System.out.println(s);
    }
}

Itt egy sorban deklaráltuk és inicializáltuk a myInt változót, azonnal memóriát foglalva neki (32 bit minden int számhoz), nevet adtunk neki, majd az 5-ös értéket a lefoglalt memóriába helyeztük. Aztán kijelentettük, hogy memóriaterületet foglalunk le az s karakterláncnak , és már egy külön parancs beírta az „init” értéket. Ezt követően kinyomtattuk a stringet és megváltoztattuk az s változó értékét . Ebben a programban kinyomtattuk a sorokat, és ha futtatod, a következő eredményt fogod látni:

A Java változóinak adattípusai: primitív és nem primitív

A Java változóinak adattípusai két csoportra oszthatók:

• A primitív adattípusok a következők: byte , short , int , long , float , double , boolean és char
• Nem primitív adattípusok, például String , Arrays és Classes

Íme egy példa a változókkal való munkavégzésre:

public class VariableTest {
   public static void main(String[] args) {

       int myInt = - 5;               // integer (whole number)
       float myFloat = 2.718281828459045f;    // Floating point number
       char myLetter = 'a';         // character
       boolean myBool = true;       // boolean
       String myText = "Hero";     // String
       System.out.println(myInt + " " +
               myFloat +" " + myLetter + " " +  myBool + " " + myText);
       Student myStudent = new Student("Walker","Johnny", "Kyle", null);
      
   }
}

int , char , boolean és float primitívek. A karakterlánc nem primitív. Mi a helyzet a myStudent változóval? Ez a felhasználó által létrehozott Student osztály objektuma . Egyszerűen azért hozták létre, hogy a munkát nem primitív változókkal illusztrálják. Javaban ők vannak többségben, mivel ebben a programozási nyelvben szinte minden objektum. A megértés kedvéért itt van a tanulói osztály kódja:

import java.util.Date;

public class Student {
   String surname;
   String name;
   String secondName;
   Long birthday; // Long instead of long is used by Gson/Jackson json parsers and various orm databases

   public Student(String surname, String name, String secondName, Date birthday ){
       this.surname = surname;
       this.name = name;
       this.secondName = secondName;
       this.birthday = birthday == null ? 0 : birthday.getTime();
   }

   @Override
   public int hashCode(){
       //TODO: check for nulls
       //return surname.hashCode() ^ name.hashCode() ^ secondName.hashCode() ^ (birthday.hashCode());
       return (surname + name + secondName + birthday).hashCode();
   }
   @Override
   public boolean equals(Object other_) {
       Student other = (Student)other_;
       return (surname == null || surname.equals(other.surname) )
               && (name == null || name.equals(other.name))
               && (secondName == null || secondName.equals(other.secondName))
               && (birthday == null || birthday.equals(other.birthday));
   }
}

A Java változók típusai: helyi, példány és statikus

A Java-ban három különböző típusú változó létezik, ezeket a következők szerint soroltuk fel:

1. Helyi változók
2. Példányváltozók
3. Statikus változók

Helyi változók

A metódus törzsében deklarált változót lokális változónak nevezzük. A lokális változók a konstruktorok és blokkok belsejében is deklarálva vannak. A helyi változókat csak azon a metóduson, konstruktoron vagy blokkon belül használhatja, ahol létrehozták, és az osztály többi metódusa nem is tudja, hogy a változó létezik. Tehát lokális változók jönnek létre a metódus, a konstruktor vagy a blokk megadásakor, és a változó megsemmisül, ha a metódus, konstruktor vagy blokk nem működik. Helyi változó nem definiálható a statikus kulcsszóval. Még több: nem használhat hozzáférésmódosítókat a helyi változókhoz. Íme egy példa:

public class VariableTest {
   public static void main(String[] args) {
       System.out.println(myMethod("C plus "));
   }
           private static String myMethod(String myString) {
       String myOtherString = "plus";
       return myString + myOtherString;
   }
}

Itt a myOtherString egy helyi változó. A másik módszerből nem használhatod, hanem a myMethodból . A helyi változóknak nem lehetnek alapértelmezett értékei. Ha legalább egy helyi változó nincs inicializálva a programban, a program nem fog megfelelően működni. Vegyünk egy kis változtatást az előző példák egyikén, és „felejtsük el” inicializálni a myBool változót:

public class VariableTest {
   public static void main(String[] args) {

       int myInt = - 5;               // integer (whole number)
       float myFloat = 2.718281828459045f;    // Floating point 
       char myLetter = 'a';         // character
       boolean myBool;       // boolean
       String myText = "Hero";     // String
       System.out.println(myInt + " " +
               myFloat +" " + myLetter + " " +  myBool + " " + myText);
       Student myStudent = new Student("Walker","Johnny", "Kyle", null);

   }
}

Ha megpróbáljuk futtatni a programot, hibát fog kiadni:

Példányváltozók

Az osztályon belül, de bármely metódus, konstruktor vagy blokk törzsén kívül deklarált változót példányváltozónak nevezzük. A példányváltozók akkor jönnek létre, amikor egy objektumot az új kulcsszó használatával hoz létre. Megsemmisül, amikor a tárgy megsemmisül. Nem deklarálható statikusnak, de használhat hozzáférésmódosítókat például változókhoz. A példányváltozók az osztály összes metódusához, konstruktorához és blokkjához láthatók. A példányváltozók általában privátak, de módosíthatja az alosztályok láthatóságát. A példányváltozóknak a helyi változókkal szemben alapértelmezett értékeik vannak. Minden számprimitív típusnál az alapértelmezett érték 0, logikai értékeknél false, objektumhivatkozásoknál pedig null. Az értékek a deklaráció során vagy a konstruktoron belül rendelhetők hozzá. Íme egy példa:

//instance variable example
public class Employee {

   // here we have a public instance variable. It is visible for this class and child classes
   public String name;

   //this instance variable is private so it’s visible for the Employee class only. You can use setters and getters to get it
   private double salary;

   public Employee (String empName) {
       name = empName;
   }

   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }

   public double getSalary() {
       return salary;
   }

   public void setSalary(double employeeSalary) {
       salary = employeeSalary;
   }

   public static void main(String args[]) {
       Employee employee = new Employee("Johnny");
       employee.setSalary(1500);
       System.out.println("name = " + employee.getName());
       System.out.println("salary = " + employee.getSalary());
   }
}

Statikus változók

A statikusnak deklarált változót statikus változónak nevezzük. A Java felajánlja az ilyen változók metóduson, konstruktoron vagy blokkon kívüli deklarálását. Nem lehet lokális, osztályhoz tartoznak, nem példányokhoz. Ez azt jelenti, hogy egy statikus változó egyetlen példányát létrehozták és megosztották az osztály összes példánya között. A statikus változók memóriafoglalása csak egyszer történik meg, amikor az osztály betöltődik a memóriába. Bármilyen láthatósággal rendelkezhetnek, de általában nyilvánosnak nyilvánítják őket. Alapértelmezett értékeik is vannak, például példányváltozók.

public class Box
{
   public void add(int data)
   {
       Storage.sum = Storage.sum + data;
       Storage.count++;
   }

   public void remove(int data)
   {
       Storage.sum = Storage.sum - data;
       Storage.count--;
   }
}

public class Storage
{
   public static int count = 0;
   public static int sum = 0;
}

A fenti példában létrehoztunk egy külön Storage osztályt, áthelyeztük ebbe a count és sum változókat, és statikusnak nyilvánítottuk. A nyilvános statikus változók bármely programmetódusból (és nem csak metódusból) elérhetők. A tanultak megerősítése érdekében javasoljuk, hogy nézzen meg egy videóleckét a Java-tanfolyamról