Pembolehubah Java

Dalam artikel ini, kami akan menerangkan kepada semua pelajar Java tentang pembolehubah Java dan cara bekerja dengannya.

Apakah pembolehubah Java

Pembolehubah dalam Java boleh dianggap sebagai kotak. "Kotak" ini mempunyai saiz tertentu: memori yang diperuntukkan untuknya. Berapa banyak memori yang akan diperuntukkan bergantung pada jenis pembolehubah, tetapi kita akan membincangkan perkara ini sedikit kemudian. Pada masa yang sama, saiz kotak itu sendiri tidak boleh diubah selepas penciptaannya, tetapi kandungannya boleh. Kotak itu mungkin kosong. Anda boleh "menyisipkan" beberapa nilai ke dalamnya, dan kemudian mengekstrak dan meletakkan beberapa nilai lain. Oleh itu, pembolehubah ialah medan yang menyimpan nilai data semasa pelaksanaan program Java. Kotak ini mempunyai ciri penting:

• ia sentiasa boleh mengandungi hanya satu nilai (atau boleh kosong, dalam hal ini ia akan mengandungi nilai lalai),
• Ia mempunyai jenis data. Saiznya bergantung pada jenis data, serta pada kawasan memori tertentu tempat itu diperuntukkan untuknya (di mana ia terletak).

Bagaimana untuk mengisytiharkan pembolehubah

Untuk mengisytiharkan pembolehubah dalam Java, anda perlu menentukan jenis dan namanya. Berikut ialah contoh mengisytiharkan tiga pembolehubah:

int myInt;
String s;
Object variableName;

Di sini int , String , dan Object ialah jenis data dan myInt , s , variableName ialah nama pembolehubah. Jenis data mesti dipilih berdasarkan keperluan program, dan lebih baik memilih nama supaya jelas mengenainya. Sudah tentu, untuk pemula ia tidak begitu ketat, tetapi dalam projek besar, nama pembolehubah seperti 's' boleh menjejaskan kebolehbacaan kod. Oleh itu, adalah lebih baik untuk membiasakan diri dengan menamakan pembolehubah dengan cara yang menjelaskan kegunaannya dari awal lagi. Dalam sebab, sudah tentu.

Bagaimana untuk memulakan pembolehubah

Apabila anda mengisytiharkan pembolehubah, anda memperuntukkan memori untuknya. Inisialisasi bermakna anda "meletakkan" nilai tertentu ke dalam "kotak". Ini boleh dilakukan serta-merta semasa pengisytiharan pembolehubah atau kemudian. Juga, nilai pembolehubah boleh berubah semasa pelaksanaan program. Contoh:

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

Di sini kami mengisytiharkan dan memulakan pembolehubah myInt dalam satu baris, dengan serta-merta memperuntukkan memori untuknya (32 bit untuk setiap nombor int), memberikannya nama, dan kemudian meletakkan nilai 5 dalam memori yang diperuntukkan. Kemudian kami mengisytiharkan bahawa kami memperuntukkan ruang memori untuk rentetan s , dan sudah pun perintah berasingan meletakkan nilai "init" ke dalamnya. Selepas itu, kami mencetak rentetan dan menukar nilai pembolehubah s . Dalam program ini, kami mencetak baris, dan jika anda menjalankannya, anda akan melihat hasil berikut:

Jenis data pembolehubah dalam Java: primitif dan bukan primitif

Jenis data pembolehubah di Jawa dibahagikan kepada dua kumpulan:

• Jenis data primitif termasuk byte , short , int , long , float , double , boolean , dan char
• Jenis data bukan primitif seperti String , Arrays , dan Classes

Berikut ialah contoh bekerja dengan pembolehubah:

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 , dan float adalah primitif. Rentetan bukan primitif. Bagaimana dengan pembolehubah myStudent ? Ini ialah objek kelas ciptaan pengguna Student . Ia dicipta semata-mata untuk menggambarkan kerja dengan pembolehubah bukan primitif. Mereka adalah majoriti di Jawa, kerana hampir semua dalam bahasa pengaturcaraan ini adalah objek. Untuk pemahaman, berikut ialah kod kelas Pelajar :

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

Jenis pembolehubah dalam Java: tempatan, contoh, dan statik

Terdapat tiga jenis pembolehubah yang berbeza di Jawa, kami telah menyenaraikannya seperti berikut:

1. Pembolehubah Setempat
2. Pembolehubah Instance
3. Pembolehubah Statik

Pembolehubah Setempat

Pembolehubah yang diisytiharkan di dalam badan kaedah dipanggil pembolehubah tempatan. Juga, pembolehubah tempatan diisytiharkan di dalam pembina dan blok. Anda boleh menggunakan pembolehubah tempatan hanya dalam kaedah, pembina atau blok di mana ia dicipta dan kaedah lain dalam kelas tidak menyedari bahawa pembolehubah itu wujud. Jadi pembolehubah tempatan dicipta apabila kaedah, pembina atau blok dimasukkan dan pembolehubah dimusnahkan sebaik sahaja kaedah, pembina atau blok tidak berfungsi. Pembolehubah tempatan tidak boleh ditakrifkan dengan kata kunci statik . Lebih-lebih lagi: anda tidak boleh menggunakan pengubah suai akses untuk pembolehubah setempat. Berikut adalah contoh:

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

Di sini myOtherString ialah pembolehubah tempatan. Anda tidak boleh menggunakannya daripada kaedah lain, tetapi myMethod . Pembolehubah setempat tidak boleh mempunyai nilai lalai. Jika sekurang-kurangnya satu pembolehubah tempatan tidak dimulakan dalam program, program tidak akan berfungsi dengan betul. Mari buat perubahan kecil dalam salah satu contoh sebelumnya dan "lupa" untuk memulakan pembolehubah myBool :

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

   }
}

Jika kita cuba menjalankan program, ia akan menimbulkan ralat:

Pembolehubah Instance

Pembolehubah yang diisytiharkan di dalam kelas tetapi di luar badan mana-mana kaedah, pembina atau blok dipanggil pembolehubah instance. Pembolehubah instance dibuat apabila objek dibuat menggunakan kata kunci baharu . Ia musnah apabila objek dimusnahkan. Ia tidak boleh diisytiharkan sebagai statik, tetapi anda boleh menggunakan pengubah suai akses sebagai contoh pembolehubah. Pembolehubah contoh boleh dilihat untuk semua kaedah, pembina dan blok dalam kelas. Biasanya pembolehubah contoh adalah peribadi, tetapi anda boleh menukar keterlihatan untuk subkelas. Pembolehubah instance berbanding dengan pembolehubah tempatan mempunyai nilai lalai. Untuk semua jenis primitif nombor nilai lalai ialah 0, untuk boolean ia palsu, dan untuk rujukan objek ia adalah batal. Nilai boleh diberikan semasa pengisytiharan atau dalam pembina. Berikut adalah contoh:

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

Pembolehubah statik

Pembolehubah yang diisytiharkan sebagai statik dipanggil pembolehubah statik. Java menawarkan anda untuk mengisytiharkan pembolehubah tersebut di luar kaedah, pembina atau blok. Ia tidak boleh tempatan, ia tergolong dalam kelas, bukan contoh. Ini bermakna bahawa satu salinan pembolehubah statik pernah dibuat dan dikongsi antara semua kejadian kelas. Peruntukan memori untuk pembolehubah statik berlaku hanya sekali apabila kelas dimuatkan dalam memori. Mereka boleh mempunyai apa-apa keterlihatan, tetapi biasanya mereka diisytiharkan sebagai awam. Mereka juga mempunyai nilai lalai seperti pembolehubah contoh.

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

Dalam contoh di atas, kami mencipta kelas Storan yang berasingan , mengalihkan pembolehubah kiraan dan jumlah ke dalamnya, dan mengisytiharkannya statik. Pembolehubah statik awam boleh diakses daripada mana-mana kaedah program (dan bukan sahaja dari kaedah). Untuk mengukuhkan perkara yang anda pelajari, kami cadangkan anda menonton pelajaran video daripada Kursus Java kami