Java Değişkenleri

Bu yazıda, tüm Java öğrencilerine Java değişkenlerinin ne olduğunu ve onlarla nasıl çalışılacağını açıklayacağız.

Java değişkeni nedir

Java'da bir değişken bir kutu olarak düşünülebilir. Bu "kutunun" belirli bir boyutu vardır: kendisine ayrılan hafıza. Ne kadar bellek ayrılacağı değişkenin türüne göre değişir ama bundan biraz sonra bahsedeceğiz. Aynı zamanda, kutunun boyutu oluşturulduktan sonra değiştirilemez, ancak içeriği değiştirilebilir. Kutu boş olabilir. İçine bir değer "ekleyebilir" ve ardından başka bir değeri ayıklayabilir ve koyabilirsiniz. Dolayısıyla değişken, bir Java programının yürütülmesi sırasında veri değerlerini depolayan bir alandır. Bu kutunun önemli özellikleri vardır:

her zaman yalnızca bir değer içerebilir (veya boş olabilir, bu durumda varsayılan değeri içerecektir),
Bir veri tipine sahiptir. Büyüklüğü, veri türüne ve ayrıca belleğin hangi alanına tahsis edildiğine (yerin bulunduğu yere) bağlıdır.

değişkenler nasıl bildirilir

Java'da değişken bildirmek için türünü ve adını belirtmeniz gerekir. İşte üç değişken bildirmenin bir örneği:

int myInt;
String s;
Object variableName;

Burada int , String ve Object veri tipidir ve myInt , s , variableName değişken isimleridir. Veri türü, programın gereksinimlerine göre seçilmelidir ve ne hakkında olduğunun net olması için bir ad seçmek daha iyidir. Elbette yeni başlayanlar için o kadar katı değil ama büyük projelerde 's' gibi değişken adları kodun okunabilirliğini bozabilir. Bu nedenle, değişkenleri en başından ne işe yaradıklarını açıkça gösterecek şekilde adlandırmaya alışmak daha iyidir. Elbette mantıklı.

Değişkenler nasıl başlatılır

Bir değişken bildirdiğinizde, onun için bellek ayırırsınız. Başlatma, "kutuya" belirli bir değer "koyduğunuz" anlamına gelir. Bu, değişkenin bildirimi sırasında veya daha sonra hemen yapılabilir. Ayrıca, program yürütülürken bir değişkenin değeri değişebilir. Örnek:

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);
    }
}

Burada myInt değişkenini tek bir satırda ilan edip başlattık , hemen onun için bellek ayırdık (her int numarası için 32 bit), ona bir ad verdik ve ardından ayrılan belleğe 5 değerini yerleştirdik. Daha sonra s dizisi için bellek alanı ayırdığımızı ilan ettik ve zaten ayrı bir komut ona "init" değerini koydu. Bundan sonra, dizeyi yazdırdık ve s değişkeninin değerini değiştirdik . Bu programda satırları yazdırdık ve çalıştırırsanız aşağıdaki sonucu göreceksiniz:

başlangıç init5

Java'daki değişkenlerin veri türleri: ilkel ve ilkel olmayan

Java'daki değişkenlerin veri türleri iki gruba ayrılır:

İlkel veri türleri arasında byte , short , int , long , float , double , boolean ve char bulunur
String , Arrays ve Classes gibi ilkel olmayan veri türleri

İşte değişkenlerle çalışmaya bir örnek:

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 ve float ilkeldir. Dize ilkel değildir. Peki ya myStudent değişkeni? Bu, kullanıcı tarafından oluşturulan Student sınıfının bir nesnesidir . Çalışmayı ilkel olmayan değişkenlerle göstermek için oluşturuldu. Bu programlama dilinde hemen hemen her şey bir nesne olduğundan, Java'da çoğunluktadırlar. Anlamak için, işte Student sınıfının kodu :

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));
   }
}

Java'daki değişken türleri: yerel, örnek ve statik

Java'da üç farklı değişken türü vardır, bunları aşağıdaki gibi listeledik:

Yerel Değişkenler
Örnek değişkenler
Statik Değişkenler

Yerel Değişkenler

Yöntemin gövdesi içinde bildirilen bir değişkene yerel değişken denir. Ayrıca, yerel değişkenler yapıcılar ve bloklar içinde bildirilir. Yerel değişkenleri yalnızca oluşturuldukları yöntem, yapıcı veya blok içinde kullanabilirsiniz ve sınıftaki diğer yöntemler değişkenin varlığından haberdar bile değildir. Bu nedenle, yöntem, yapıcı veya blok girildiğinde yerel değişkenler oluşturulur ve yöntem, yapıcı veya blok çalışmadığında değişken yok edilir. Statik anahtar kelime ile yerel bir değişken tanımlanamaz . Dahası: yerel değişkenler için erişim değiştiricileri kullanamazsınız. İşte bir örnek:

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;
   }
}

Burada myOtherString yerel bir değişkendir. Diğer yöntemden kullanamazsınız, ancak myMethod . Yerel değişkenler varsayılan değerlere sahip olamaz. Programda en az bir yerel değişken başlatılmazsa, program düzgün çalışmayacaktır. Önceki örneklerden birinde küçük bir değişiklik yapalım ve myBool değişkenini başlatmayı "unutalım":

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);

   }
}

Programı çalıştırmayı denersek, bir hata verir:

Hata:(10, 50) java: myBool değişkeni başlatılmamış olabilir

Örnek değişkenler

Sınıfın içinde bildirilen ancak herhangi bir yöntemin, yapıcının veya bloğun gövdesinin dışında bildirilen bir değişkene örnek değişken denir. Örnek değişkenler, new anahtar sözcüğü kullanılarak bir nesne oluşturulduğunda oluşturulur . Nesne yok edildiğinde yok olur. Statik olarak bildirilemez, ancak örnek değişkenler için erişim değiştiricileri kullanabilirsiniz. Örnek değişkenleri, sınıftaki tüm yöntemler, yapıcılar ve bloklar için görülebilir. Genellikle örnek değişkenleri özeldir, ancak alt sınıfların görünürlüğünü değiştirebilirsiniz. Örnek değişkenler, yerel değişkenlerin aksine varsayılan değerlere sahiptir. Tüm ilkel sayı türleri için varsayılan değer 0'dır, mantıksal değerler için yanlıştır ve nesne referansları için boştur. Değerler, bildirim sırasında veya yapıcı içinde atanabilir. İşte bir örnek:

//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());
   }
}

statik değişkenler

Statik olarak bildirilen bir değişkene statik değişken denir. Java, bu tür değişkenleri bir yöntemin, yapıcının veya bloğun dışında bildirmenizi sağlar. Yerel olamazlar, örneklere değil, sınıfa aittirler. Bu, bir kez statik bir değişkenin tek bir kopyasının oluşturulduğu ve sınıfın tüm örnekleri arasında paylaşıldığı anlamına gelir. Statik değişkenler için bellek tahsisi, sınıf belleğe yüklendiğinde yalnızca bir kez gerçekleşir. Herhangi bir görünürlüğe sahip olabilirler, ancak genellikle herkese açık olarak ilan edilirler. Ayrıca örnek değişkenler gibi varsayılan değerlere sahiptirler.

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;
}

Yukarıdaki örnekte, ayrı bir Storage sınıfı oluşturduk, count ve sum değişkenlerini buna taşıdık ve statik olarak bildirdik. Genel statik değişkenlere herhangi bir program yönteminden erişilebilir (yalnızca bir yöntemden değil). Öğrendiklerinizi pekiştirmek için Java Kursumuzdan bir video dersi izlemenizi öneririz.