Nuances ng pagtatrabaho sa mga variable

Mga Constant

"Amigo, alam mo ba na sa Java hindi lahat ng variable ay maaaring baguhin?"

"Paano 'yan, Kim? Sa katunayan, ang mismong salitang 'variable' ay nagsasalita ng pagbabago."

"Walang duda tungkol doon. Tulad ng maraming iba pang mga programming language, ang Java ay may mga constants , iyon ay, mga variable na ang mga halaga ay hindi mababago . At ang mismong salitang 'constant' ay nagsasalita ng constancy."

"At para saan sila?"

"Karaniwan, ginagamit ang mga ito para sa ilang uri ng pangunahing bagay tulad ng bilang Pio bilang ng mga araw sa mga buwan ng taon. Iyon ay sinabi, sa prinsipyo, ang isang programmer ay maaaring gumawa ng anumang variable na isang pare-pareho, kung siya ay nagpasya na gawin iyon. kaya kailangan."

"Ang ibig mong sabihin ay parang pangalan, kulay ng kotse, o pangalan ng araw ng linggo?"

"You've got the right idea. Anumang bagay na hindi dapat baguhin."

"At ano ang hitsura ng mga constant na ito sa Java?"

"Ang Java ay may espesyal na keyword para sa kanila: final. Ang paglikha ng hindi nababagong variable ay mukhang katulad ng paglikha ng ordinaryong isa. Ang pagkakaiba lang ay bago ang uri ng variable kailangan mong isulat ang salita final, tulad nito:

final Type name = value;

"Ano ang mangyayari kung lumikha ka ng isang pare-pareho at pagkatapos ay subukang magtalaga ng ibang halaga dito?"

"Iyan ang tamang tanong na itatanong! At ang tamang sagot ay ito: kung susubukan mong magtalaga ng ibang halaga sa isang finalvariable, kung gayon ang iyong programa ay hindi mag-compile."

"Paano kung magdeklara ka ng finalvariable ngunit hindi magtalaga ng halaga dito?"

"Walang saysay ang paggawa nito, kaya hindi rin ito pinahihintulutan sa Java. finalDapat masimulan ang isang variable kapag ito ay idineklara, ibig sabihin, dapat kang magtalaga ng halaga dito. May isang pagbubukod sa panuntunang ito: maaari mong ilipat ang pagsisimula ng isang static na variable ng klase sa isang constructor. Ngunit malalaman mo iyon mamaya.

"Sabi nga, hindi lahat ng bagay ay finalpare-pareho. Upang bawasan ang bilang ng mga keyword, ginagamit ng mga developer ng Java ang salita finalpara sa higit pa sa pagdedeklara ng mga pare-pareho. finalay maaari ding ilapat sa mga pamamaraan at maging sa mga klase. Ang mga pamamaraan na ipinahayag bilang finalhindi maaaring ma-override, at isang klase ipinahayag bilang finalhindi maaaring manahin."

"Uh... Overridden? Manang? Anong lenggwahe ang sinasalita mo ngayon?"

"The language of object-oriented programming. You will get to it very soon. Hanggang doon na lang, enjoy the beautiful terminology."

"Okay. Kaya, finalmaaaring ilagay bago ang mga variable, klase, at pamamaraan, at ginagawa ng keyword na ito na hindi nababago ang mga ito sa ilang kahulugan?"

"Oo. Higit pa rito, finalmaaaring idagdag ang modifier bago ang anumang mga variable: mga lokal na variable, mga parameter ng pamamaraan, mga field ng klase, at mga static na variable ng klase.

"Narito ang mahalagang bagay na dapat tandaan: finalbago ang isang variable na pangalan ay proteksyon lamang laban sa anumang mga pagbabago sa variable na iyon . Kung ang isang variable ay nag-iimbak ng isang reference sa isang bagay, kung gayon ang bagay ay maaari pa ring baguhin."

"Hindi ko masyadong maintindihan."

"Maiintindihan mo talaga sa lalong madaling panahon. Narito ang isang halimbawa:

final int[] data = {1, 2, 3, 4, 5, 6};

data = {6, 7, 8, 9};

data[0] = 0;
data[1] = 0;
data[2] = 0;

"Got it. Nakakalito yan."

Global constants

"Ano sa palagay mo ang mga global constants?"

"Sa palagay ko ang mga global constant ay malamang na parang mga global variable, mga constant lang?"

"Eksakto. Kung kailangan mong magdeklara ng mga global constant sa iyong programa, lumikha ng mga static na variable ng klase , at gawin ang mga ito publicat final. Mayroong isang espesyal na istilo para sa mga pangalan ng naturang mga variable: ang mga ito ay nakasulat sa lahat ng malalaking titik, na may salungguhit na karakter na ginagamit upang magkahiwalay na salita.

Mga halimbawa:

class Solution
{
   public static final String SOURCE_ROOT = "c:\\projects\\my\\";
   public static final int DISPLAY_WIDTH = 1024;
   public static final int DISPLAY_HEIGHT = 768;
}

Variable shadowing

"Tulad ng sinabi ko dati, hindi ka makakagawa ng maramihang mga lokal na variable na may parehong mga pangalan sa isang paraan. Sa iba't ibang pamamaraan, magagawa mo."

"Alam ko yan!"

"Ngunit ang malamang na hindi mo alam ay ang mga variable sa isang klase at mga lokal na variable sa isang pamamaraan ay maaaring magkaroon ng parehong pangalan.

Halimbawa:

public class Solution
{
   public int count = 0;
   public int sum = 0;

   public void add(int data)
   {
     sum = sum + data;
     int sum = data * 2;
     count++;
   }
}

count, sum
count, sum
count, sum
count, sum
count, sum
count, sum, data
count, sum, data
count, sum, data
count, sum, data
count, sum

"Sa addpamamaraan, nagdeklara kami ng lokal na variable na pinangalanang sum. Hanggang sa katapusan ng pamamaraan, nililiman nito (o tinatakpan ) ang sumvariable ng instance."

"Hmm... I would say in some sense this is the expected behavior."

"Ngunit hindi iyon ang katapusan ng kuwento. Lumalabas na kung ang isang variable ng instance ay nililiman ng isang lokal na variable, mayroon pa ring paraan upang sumangguni sa variable ng instance sa loob ng pamamaraan. Ginagawa namin ito sa pamamagitan ng pagsulat ng keyword bago ang pangalan thisnito :

this.name

"Narito ang isang halimbawa kung saan matagumpay na naresolba ang salungatan sa pangalan:

public class Solution
{
   public int count = 0;
   public int sum = 0;

   public void add(int data)
   {
     int sum = data * 2;
     this.sum = this.sum + data;
     count++;
   }
}

this.count, this.sum
this.count, this.sum
this.count, this.sum
this.count, this.sum
this.count, this.sum
this.count, this.sum, data
this.count, this.sum, data, sum
this.count, this.sum, data, sum
this.count, this.sum, data, sum
this.count, this.sum

Ang countat summga variable ay magagamit saanman mayroon o wala ang thiskeyword. Sa mga linya kung saan sumnililiman ng lokal na variable ang sumvariable ng instance, summaa-access lang ang variable ng instance gamit ang thiskeyword.

"Obviously, kailangan kong sanayin ito."

"Ikaw na ang bahala."

"Paano kung ang isang static na variable ng klase ay na-shadow sa halip na isang (non-static) na instance variable? Hindi mo ito ma-access sa pamamagitan ng this?"

"Tama ka. Hindi gagana ang keyword na ito. Kailangan mong i-refer ito sa pamamagitan ng pangalan ng klase:

ClassName.name

Halimbawa:

public class Solution
{
   public static int count = 0;
   public static int sum = 0;

   public void add(int data)
   {
     int sum = data * 2;
     Solution.sum = Solution.sum + data;
     count++;
   }
}

Solution.count, Solution.sum
Solution.count, Solution.sum
Solution.count, Solution.sum
Solution.count, Solution.sum
Solution.count, Solution.sum
Solution.count, Solution.sum, data
Solution.count, Solution.sum, data, sum
Solution.count, Solution.sum, data, sum
Solution.count, Solution.sum, data, sum
Solution.count, Solution.sum

"Bigyang-pansin: maa-access mo ang countat sumstatic na mga variable saanman mayroon man o hindi ginagamit ang pangalan ng klase Solutionbilang prefix. Sa mga linyang iyon kung saan sumnililiman ng lokal na variable ang suminstance variable, ang pag-access sa sumvariable ng klase ay posible lamang kapag ginagamit Solutionbilang prefix.

Mga variable sa loob ng isang forloop

"At isa pang maliit ngunit kawili-wiling katotohanan. Mayroon ding isang lugar kung saan ang isang variable ay idineklara sa isang espesyal na paraan — I'm talking about inside a forloop ." Karaniwan, ang isang forloop ay may countervariable sa mga panaklong. At ano ang magiging visibility ng variable na ito? Pagkatapos ng lahat, wala ito sa katawan ng loop. Ito ba ang buong pamamaraan? O hindi?"

"May narinig na ako tungkol dito. Sa pagkakaintindi ko, ang isang variable na idineklara sa header ng isang forloop ay makikita lang sa katawan ng loop at sa header ng forloop ."

"Magaling, Amigo. Ngunit gayon pa man, tingnan ang isang halimbawa upang palakasin ang materyal na ito:

public static void main(String[] args)
{
   int a = 0;

   for (int i = 0; i < 10; i++)
   {
     System.out.println(i);
   }

   System.out.println("end");
}

a
a
a, i
a, i
a, i
a
a
a

"Kaya sinasabi mo na sa aking code maaari akong magsulat ng ilang mga loop nang sunud-sunod na may isang counter variable na may parehong pangalan, at walang magiging problema?"

"Walang magiging problema. Narito, tingnan mo:

public static void main(String[] args)
{
   int a = 0;

   for (int i = 0; i < 10; i++)
   {
     System.out.println(i);
   }

   for (int i = 0; i < 10; i--)
   {
     System.out.println(i);
   }

   System.out.println("end");
}

a
a
a, i
a, i
a, i
a
a
a, i
a, i
a, i
a
a
a