Pembolehubah dalam Jawa

Pembolehubah ialah unit asas yang digunakan untuk menyimpan sebarang maklumat dalam Java. Nama pembolehubah ialah nama yang diperuntukkan untuk unit ini. Kod Java mungkin memerlukan maklumat dalam bentuk angka atau nilai rentetan. Set nilai yang sama mungkin diperlukan dalam berbilang peringkat kod. Di sinilah pembolehubah muncul dalam gambar.

Semua nilai yang diperlukan ini boleh diberikan kepada pembolehubah berbeza yang akan disimpan di lokasi memori masing-masing; maka pembolehubah hanyalah nama lokasi memori. Menyimpan nilai kepada pembolehubah adalah lebih cekap daripada mengulangi nilai di mana-mana dalam kod. Selain itu, ia membantu apabila terdapat perubahan dalam nilai yang diperlukan, kerana hanya menukarnya di satu tempat pengisytiharan pembolehubah akan mencukupi dan bukannya perlu menukar di berbilang lokasi.

Mulakan Kursus Pembangunan Perisian Percuma Anda

Pembangunan web, bahasa pengaturcaraan, ujian perisian & lain-lain

Pengisytiharan Pembolehubah

Sesuatu pembolehubah tidak boleh digunakan sehingga dan melainkan ia diisytiharkan, dan jenis data yang kami tetapkan semasa pengisytiharan mentakrifkan jenis nilai yang boleh dipegangnya. Pelbagai jenis data seperti int, float, string, char, Boolean, long, double boleh ditugaskan kepada pembolehubah.

Sintaks umum untuk mengisytiharkan pembolehubah dalam Java adalah seperti berikut:

Ex: int a = 1;

Di mana,

• int – jenis data
• a – nama pembolehubah
• 1 – nilai berubah

Rajah berikut memberikan gambaran bergambar yang sama:

Permulaan Pembolehubah

Menetapkan nilai lalai kepada pembolehubah dipanggil permulaan pembolehubah itu. Pembolehubah boleh dimulakan semasa pengisytiharan dan semasa peringkat akhir program seperti yang diperlukan. Contoh: Berikut ialah beberapa nilai yang boleh kita tetapkan kepada pembolehubah berkenaan dengan jenis data tertentu:

•  int i; i=10;
•  bandar rentetan; bandar =”Bangalore”;
•  char a; a=’H’;
•  selepas terapung; dec=3.5;
•  Boolean val; val=true;

Jenis Pembolehubah

Terdapat 3 jenis pembolehubah dalam Java:

• Pembolehubah Setempat
• Pembolehubah Instance
• Pembolehubah Statik

1. Pembolehubah Setempat

• Ini adalah pembolehubah yang diisytiharkan di dalam kaedah atau blok atau pembina tertentu di mana ia berada.
• Nilai pembolehubahnya, yang disimpan semasa pengisytiharan, hanya sah dalam skop kaedah itu dan hilang apabila kaedah itu dikeluarkan.
• Pembolehubah tempatan dengan nama pembolehubah yang sama boleh diisytiharkan dalam berbilang kaedah atau blok tanpa sebarang konflik.

Contoh: Dalam contoh berikut, kami mempertimbangkan "bilangan" dan "nama" sebagai pembolehubah setempat. Kod:

public class PatientDetails{
public void Patient()
{
// local variable num
//local variable name
int num = 1200;
string name = "Harish";
id = id + 1;
System.out.println("Patient Name is: " + name + " Patient Number is: " + num);
name = "Sudha";
System.out.println("Patient Name is: " + name + " Patient Number is: " + num);
}
public void DoctorDetails()
{
int num = 12000;
string name = "Vijay";
num = num +1;
System.out.println("Doctor Name is: " + name + " Doctor ID is: " + num);
name = "Suma";
System.out.println("Doctor Name is: " + name + " Doctor ID is: " + num);
}
public static void main(String args[])
{
PatientDetails pat = new PatientDetails();
pat. Patient();
pat.DoctorDetails();
}
}

Output:

Nama pesakit ialah: Harish
Nombor Pesakit ialah: 1200
Nama pesakit ialah: Sudha
Nombor Pesakit ialah: 1201
Nama Doktor ialah: Vijay
ID Doktor ialah: 12000
Nama Doktor ialah: Suma
ID Doktor ialah: 12001

Ini menunjukkan bahawa nama pembolehubah tempatan yang sama "num" dan "nama" apabila diisytiharkan dalam dua kaedah berbeza, iaitu Butiran Pesakit dan Doktor, boleh digunakan untuk menetapkan sebarang bilangan nilai yang berbeza.

Contoh:

Pembolehubah tempatan yang sama "num" dan "nama" akan menjadi tidak sah jika kami cuba memaparkan nilainya di luar kaedahnya.

Kod:

public class PatientDetails{
public void Patient()
{
// local variable num
//local variable name
int id = 1200;
}
public static void main(String args[])
{
System.out.println("Patient Number is: " + num);
//printing local variable outside it's method
}
}

Output:

Ralat Penyusunan dalam kod java:-
prog.java:12: ralat: tidak dapat mencari simbol
System.out.println(“Nombor Pesakit ialah: ” + nombor);
simbol: nombor pembolehubah
lokasi: kelas Butiran Pesakit
1 ralat

2. Pembolehubah Contoh

• Pembolehubah instance ialah pembolehubah yang diisytiharkan dalam kelas dan bukan dalam mana-mana kaedah.
• Ia dicipta apabila objek dicipta, dan nilainya hilang apabila objek dimusnahkan.
• Pemulaan pembolehubah ini tidak wajib dan secara lalai, nilainya diambil sebagai sifar.
• Ia adalah pembolehubah bukan statik, bermakna memori pembolehubah akan diperuntukkan apabila objek baharu dicipta.

Contoh:

Di sini a, b, c ialah pembolehubah tika yang diisytiharkan dalam dua kejadian berbeza oleh dua objek berbeza.

Kod:

import java.io.*;
class Marks {
// a, b, c are instance variables
// a, b, c variables are being declared inside a class and not function
int a;
int b;
int c;
}
class MarksDemo {
public static void main(String args[])
{
// first object declaration
Alpha alp1 = new Alpha();
alp1 .a= 44;
alp1 .b= 77;
alp1 .c= 88;
// second object declaration
Alpha alp2 = new Alpha();
alp2 .a= 77;
alp2 .b= 55;
alp2 .c= 74;
// displaying variable values for first object
System.out.println("Values for first object:");
System.out.println(alp1.a);
System.out.println(alp1.b);
System.out.println(alp1.c);
// displaying variable values for second object
System.out.println("Values for second object:");
System.out.println(alp2.a);
System.out.println(alp2.b);
System.out.println(alp2.c);
}
}

Output:

Nilai untuk objek pertama:
44
77
88
Nilai untuk objek kedua:
77
55
74

3. Static Variables

• Static variables are declared at the beginning of the program, preceded by the static keyword.
• Like instance variables, the initialization of static variables is not mandatory, and their default value is 0.
• Only one static variable name will be created when the program is started and lost when execution has ended.
• The memory for these variables is allocated only once at the time of loading the class and can be shared by multiple objects.
• When the objects are different, the changes made in the value of the static variable in one of the objects will be reflected in all unlike instance variables where the values declared in one object will not be reflected in others.

Example:

Code:

import java.io.*;
class Students {
//static variable rollno
public static double rollno;
public static String name = "Lilly";
public static classnum;
}
public class StudentDetails {
public static void main(String args[])
}
{
// no need of object to access static variables
Students .rollno= 101;
Students.classnum=3;
System.out.println(Students .name + "'s rollno is:" + Students .rollno + "and class number is:" + Students.classnum);
}
}

Output:

Lilly’s rollno is 101, and the class number is: 3

Conclusion – Variables in Java

Variables form the elemental part of a Java program. They point to a particular memory location when they are created, and the same is released when the object is not referenced anymore. This memory which is released, will be swept away when garbage collection takes place. This process can also be considered as the life cycle of a variable.

Atas ialah kandungan terperinci Pembolehubah dalam Jawa. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!