Saklaw ng Java

Alam nating lahat na ang mga bansa ay may mga hangganan at may sariling batas. Ang mga batas ng bansa ay gumagana sa loob ng mga hangganan. Gayundin sa bansa mayroong, halimbawa, mga organisasyon, tulad ng mga paaralan o museo, na may sariling mga lokal na panuntunan. Hindi nila sinasalungat ang mga batas ng bansa, ngunit gumagana lamang sa loob ng balangkas ng tinukoy na organisasyon. Ang parehong ay totoo sa programming. Kaya sa programming, at partikular sa wikang Java, mayroong terminong "saklaw". Ito ay tumutukoy sa mga lugar ng programa kung saan gumagana ang ilang partikular na data, gaya ng mga variable o pamamaraan. Sa artikulong ito, aalamin natin kung ano ang mga saklaw para sa mga variable sa Java at kung paano tukuyin ang mga ito.

Saklaw ng Java sa pangkalahatan

Bakit kailangang paghiwalayin ang mga saklaw ng mga variable at pamamaraan? Ang katotohanan ay kung minsan ang mga programa ay napakalaki at maaaring mahirap subaybayan ang isa o isa pang variable. Bilang karagdagan, sa malalaking proyekto, ang malinaw na pagpapangalan ng mga variable ay kanais-nais upang ito ay malinaw kung para saan ang mga ito. Ang saklaw ay partikular na nagbibigay-daan sa iyo na magkaroon ng iba't ibang mga variable na may parehong pangalan sa iba't ibang bahagi ng programa. Ang ganitong code ay mas madaling mapanatili at basahin. Ang saklaw ng Java ay tumutukoy kung saan naa-access ang isang partikular na variable o pamamaraan sa isang programa. Sa madaling sabi:

Ang isang variable na idineklara sa isang pamamaraan ay makikita mula sa simula ng deklarasyon hanggang sa katapusan ng pamamaraan (saklaw ng pamamaraan).
Ang isang variable na ipinahayag sa isang bloke ng code ay umiiral hanggang sa katapusan ng bloke ng code na iyon.
Umiiral ang mga variable na mga argumento ng pamamaraan hanggang sa katapusan ng pamamaraan.
Umiiral ang mga variable ng klase/object para sa buhay ng naglalaman ng object. Ang kanilang visibility ay kinokontrol ng mga espesyal na access modifier.
Umiiral ang mga static na variable ng klase sa lahat ng oras na tumatakbo ang programa. Ang kanilang visibility ay tinutukoy din ng mga modifier ng access.

Saklaw ng Antas ng Pamamaraan

Ang anumang variable na idineklara sa isang pamamaraan, kabilang ang mga argumento, ay hindi naa-access sa labas ng pamamaraang iyon. Ang lahat ng mga variable na ipinahayag sa loob ng mga pamamaraan ay makikita mula sa simula ng kanilang deklarasyon hanggang sa katapusan ng pamamaraan. Narito ang isang halimbawa ng saklaw ng variable na pamamaraan:

public class JScopeTest1 {


   public static void main(String[] args) {

       System.out.println(myMethod(5));
       System.out.println(myMethod(17));

   }
   public static int  myMethod(int arg) {
       int secondArg = 100; //local method variable
       return secondArg + arg;
   }
}

Narito mayroon kaming secondArg , isang lokal na variable o argumento ng pamamaraan. Hindi namin magagamit ang variable na ito sa labas ng myMethod method o bago ito ideklara. Kung ang variable ay isang function argument, makikita ito sa buong katawan ng pamamaraang ito. Sa halimbawa sa itaas mayroon kaming dalawang ganoong argumento: arg sa myMethod at args sa pangunahing pamamaraan.

Saklaw ng Antas ng Klase

Saklaw ng Antas ng Klase (Mga Variable ng Instance) — anumang variable na idineklara sa isang klase ay available para sa lahat ng pamamaraan ng klase na iyon. Depende sa access modifier nito (ibig sabihin pampubliko o pribado), maaari itong ma-access minsan sa labas ng klase. Kaya kung ang isang variable ay isang variable ng klase, kung gayon ito ay nakatali sa isang partikular na bagay at umiiral hangga't mayroong isang bagay ng klase na ito. Kung walang object, walang kopya ng variable. Ang variable ay makikita mula sa lahat ng mga pamamaraan ng klase, hindi alintana kung idineklara ang mga ito bago o pagkatapos nito. Ang bawat bagay ay may sariling variable na independiyente sa iba pang mga bagay. Ang pag-access sa isang variable mula sa mga static na pamamaraan ay hindi posible.

Halimbawa ng code

public class Student {

//class level variables
   public String surname;
   String name;
   String secondName;
   private 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));
   }
}

Ang apelyido , pangalan , pangalawangName at kaarawan ay mga variable ng Instance.

Block Saklaw

Kung ang isang variable ay tinukoy/idineklara sa ilang bloke ng code, ito ay umiiral hanggang sa katapusan ng bloke ng code na iyon. Karaniwan, ang mga naturang variable ay umiiral sa pagitan ng mga kulot na brace kung saan ang mga ito ay tinukoy. Kadalasan, ang saklaw ng block ay maaaring isang loop variable. Ang isang variable na idineklara sa isang para sa kundisyon ng loop ay hindi naa-access sa labas ng loop, maliban kung tinukoy mo ito nang maaga.

public class JScopeTest2 {
   public static void main(String[] args) {
       for (int i = 0; i < 10; i++) {
           int sum = 0;
           sum = sum + i;
       }

       int sum = 1;
       System.out.println(sum);
   }
}

Parehong unang sum at i variable ay idineklara sa loob ng loop at hindi umiiral sa labas ng loop na ito. Gayunpaman, ang pangalawang kabuuan ay idineklara sa labas ng loop kaya ang partikular na variable na ito ay ipi-print.

Mga static na variable

Kung ang isang variable ay idineklara bilang static (minarkahan ng static na keyword), kung gayon ito ay umiiral hangga't ang klase nito ay umiiral. Karaniwan, ang JVM ay naglo-load ng isang klase sa memorya sa unang paggamit, kapag ang mga static na variable ay nasimulan.

import java.util.Date;

public class Student {
   public static int today = 2022;
   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();
   }


   public static void main(String[] args) {
       System.out.println(today);
   }

}

Hindi ka dapat gumawa ng bagong instance ng Student class para magamit ang variable na static today . Dito ipi-print ang "2022".

I-access ang mga modifier

Ang Java ay may 4 na access modifier upang paghigpitan ang pag-access sa paraan o variable. Maaari mong gamitin ang mga ito sa loob ng mga klase, hindi sa loob ng mga pamamaraan.

pribado ang pinaka mahigpit na modifier. Pinaghihigpitan nito ang pag-access sa mga pamamaraan at variable sa klase na idineklara nila. Kung hindi kailangang gumamit ng ilang mga pamamaraan o variable sa labas ng klase, gumamit ng pribado. Karaniwang pribado ang mga variable ng klase sa Java.
Kung walang tinukoy na access modifier, tatanggapin ng paraan o variable ang default na modifier. pinapayagan lamang ng default ang pag-access mula sa kasalukuyang package.
pinapayagan ng protected modifier ang pag-access sa isang paraan o variable mula lamang sa loob ng kasalukuyang package, maliban kung ito ay na-access sa pamamagitan ng child class sa labas ng package.
pampubliko ang pinakamaliit na restrictive modifier. Pinapayagan ka nitong ma-access ang isang klase, pamamaraan o variable hindi lamang mula sa klase na idineklara nila, kundi pati na rin mula sa labas. Ang modifier na ito ay talagang madalas na ginagamit.