Sa artikulong ito, ipapaliwanag namin sa lahat ng nag-aaral ng Java kung ano ang mga variable ng Java at kung paano gagana sa kanila.
Ano ang variable ng Java
Ang isang variable sa Java ay maaaring isipin bilang isang kahon. Ang "kahon" na ito ay may isang tiyak na sukat: ang memorya na inilaan para dito. Kung gaano karaming memorya ang ilalaan ay depende sa uri ng variable, ngunit pag-uusapan natin ito sa ibang pagkakataon. Kasabay nito, ang laki ng kahon mismo ay hindi mababago pagkatapos ng paglikha nito, ngunit ang mga nilalaman ay maaari. Maaaring walang laman ang kahon. Maaari mong "ipasok" ang ilang halaga dito, at pagkatapos ay kunin at ilagay ang ilang iba pang halaga. Kaya, ang isang variable ay isang field na nag-iimbak ng mga halaga ng data sa panahon ng pagpapatupad ng isang Java program. Ang kahon na ito ay may mahahalagang katangian:
maaari itong palaging naglalaman ng isang halaga lamang (o maaaring walang laman, kung saan maglalaman ito ng default na halaga),
Mayroon itong uri ng data. Ang laki nito ay depende sa uri ng data, pati na rin kung saang partikular na lugar ng memorya ang lugar ay inilalaan para dito (kung saan ito namamalagi).
Paano magdeklara ng mga variable
Upang magdeklara ng mga variable sa Java, kailangan mong tukuyin ang uri at pangalan nito. Narito ang isang halimbawa ng pagdedeklara ng tatlong variable:
int myInt;
String s;
Object variableName;
Dito int , String , at Object ang uri ng data at myInt , s , variableName ay variable na pangalan. Ang uri ng data ay dapat piliin batay sa mga pangangailangan ng programa, at ito ay mas mahusay na pumili ng isang pangalan upang ito ay malinaw kung tungkol saan ito. Siyempre, para sa mga nagsisimula ay hindi ganoon kahigpit, ngunit sa malalaking proyekto, ang mga variable na pangalan tulad ng 's' ay maaaring makapinsala sa pagiging madaling mabasa ng code. Kaya't mas mabuting masanay sa pagbibigay ng pangalan sa mga variable sa paraang malinaw kung para saan ang mga ito mula pa sa simula. Sa loob ng dahilan, siyempre.
Paano simulan ang mga variable
Kapag nagdeklara ka ng variable, naglalaan ka ng memory para dito. Ang ibig sabihin ng initialization ay "naglalagay" ka ng isang tiyak na halaga sa "kahon". Magagawa ito kaagad sa panahon ng deklarasyon ng variable o mas bago. Gayundin, ang halaga ng isang variable ay maaaring magbago sa panahon ng pagpapatupad ng programa. Halimbawa:
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);
}
}
Dito namin ipinahayag at pinasimulan ang myInt variable sa isang linya, agad na naglalaan ng memorya para dito (32 bits para sa bawat int number), binigyan ito ng pangalan, at pagkatapos ay inilagay ang halaga 5 sa inilalaan na memorya. Pagkatapos ay ipinahayag namin na naglalaan kami ng puwang ng memorya para sa string s , at mayroon nang isang hiwalay na utos na naglagay ng halagang "init" dito. Pagkatapos nito, nai-print namin ang string at binago ang halaga ng variable s . Sa program na ito, nag-print kami ng mga linya, at kung patakbuhin mo ito, makikita mo ang sumusunod na resulta:
init init5
Mga uri ng data ng mga variable sa Java: primitive at non-primitive
Ang mga uri ng data ng mga variable sa Java ay nahahati sa dalawang pangkat:
Kasama sa mga primitive na uri ng data ang byte , short , int , long , float , double , boolean , at char
Mga hindi primitive na uri ng data gaya ng String , Arrays , at Classes
Narito ang isang halimbawa ng pagtatrabaho sa mga variable:
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 , at float ay primitives. Ang string ay hindi primitive. Paano ang myStudent variable? Ito ay isang object ng class na nilikha ng user na Student . Nilikha lamang ito upang ilarawan ang gawain na may mga di-primitive na variable. Sila ang karamihan sa Java, dahil halos lahat ng bagay sa programming language na ito ay isang object. Para sa pag-unawa, narito ang code ng klase ng Mag-aaral :
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));
}
}
Mga uri ng mga variable sa Java: lokal, halimbawa, at static
Mayroong tatlong magkakaibang uri ng mga variable sa Java, inilista namin ang mga ito bilang mga sumusunod:
Mga Lokal na Variable
Mga Variable ng Instance
Mga Static na Variable
Mga Lokal na Variable
Ang isang variable na ipinahayag sa loob ng katawan ng pamamaraan ay tinatawag na isang lokal na variable. Gayundin, ang mga lokal na variable ay ipinahayag sa loob ng mga konstruktor at mga bloke. Maaari kang gumamit ng mga lokal na variable lamang sa loob ng pamamaraang iyon, tagabuo, o bloke kung saan ginawa ang mga ito at ang iba pang mga pamamaraan sa klase ay hindi alam na umiiral ang variable. Kaya't ang mga lokal na variable ay nilikha kapag ang pamamaraan, constructor, o block ay ipinasok at ang variable ay nawasak kapag ang paraan, constructor, o block ay hindi gumana. Ang isang lokal na variable ay hindi matukoy gamit ang static na keyword. Higit pa: hindi ka maaaring gumamit ng mga modifier ng access para sa mga lokal na variable. Narito ang isang halimbawa:
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;
}
}
Narito ang myOtherString ay isang lokal na variable. Hindi mo ito magagamit mula sa ibang paraan, ngunit myMethod . Ang mga lokal na variable ay hindi maaaring magkaroon ng mga default na halaga. Kung hindi bababa sa isang lokal na variable ang hindi nasimulan sa programa, hindi gagana nang tama ang program. Gumawa tayo ng maliit na pagbabago sa isa sa mga nakaraang halimbawa at "kalimutan" na simulan ang myBool variable:
Kung susubukan naming patakbuhin ang programa, ito ay magtapon ng isang error:
Error:(10, 50) java: variable myBool ay maaaring hindi nasimulan
Mga Variable ng Instance
Ang isang variable na ipinahayag sa loob ng klase ngunit sa labas ng katawan ng anumang pamamaraan, constructor o block ay tinatawag na isang instance variable. Ang mga variable ng instance ay nilikha kapag ang isang bagay ay ginawa gamit ang bagong keyword. Ito ay nawasak kapag ang bagay ay nawasak. Hindi ito maaaring ideklara bilang static, ngunit maaari kang gumamit ng mga access modifier para sa mga variable na halimbawa. Ang mga variable ng instance ay makikita para sa lahat ng mga pamamaraan, constructor at block sa klase. Karaniwang pribado ang mga variable ng instance, ngunit maaari mong baguhin ang visibility para sa mga subclass. Ang mga variable ng instance kumpara sa mga lokal na variable ay may mga default na halaga. Para sa lahat ng mga primitive na uri ng numero ang default na halaga ay 0, para sa mga boolean ay mali, at para sa mga sanggunian ng bagay ay null. Maaaring italaga ang mga halaga sa panahon ng deklarasyon o sa loob ng constructor. Narito ang isang halimbawa:
//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());
}
}
Mga static na variable
Ang isang variable na idineklara bilang static ay tinatawag na isang static na variable. Nag-aalok sa iyo ang Java na magdeklara ng mga naturang variable sa labas ng isang paraan, constructor o block. Hindi ito maaaring lokal, kabilang sila sa klase, hindi sa mga pagkakataon. Nangangahulugan iyon na ang isang solong kopya ng isang static na variable ay minsang ginawa at ibinahagi sa lahat ng mga pagkakataon ng klase. Ang paglalaan ng memorya para sa mga static na variable ay nangyayari nang isang beses lamang kapag ang klase ay na-load sa memorya. Maaari silang magkaroon ng anumang visibility, ngunit kadalasan sila ay idineklara bilang pampubliko. Mayroon din silang mga default na halaga tulad ng mga variable ng instance.
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;
}
Sa halimbawa sa itaas, gumawa kami ng hiwalay na klase ng Storage , inilipat ang mga variable ng bilang at kabuuan dito, at idineklara ang mga ito na static. Maaaring ma-access ang mga pampublikong static na variable mula sa anumang paraan ng programa (at hindi lamang mula sa isang paraan). Upang palakasin ang iyong natutunan, iminumungkahi naming manood ka ng isang video lesson mula sa aming Java Course
GO TO FULL VERSION