Mga Static na Variable sa Java

Ano ang mga Static variable?

Ang mga static na variable o mga variable ng klase ay ibinabahagi sa lahat ng mga instance ng isang klase at maaaring ma-access at mabago nang hindi gumagawa ng isang instance ng klase. Magsagawa tayo ng malalim na pagsisid upang maunawaan ang mga gamit at pagpapatupad ng mga static na variable sa Java.

Halimbawa ng static na variable sa Java

Ang isa sa mga pinakakaraniwang gamit para sa mga static na variable ay ang pagbabahagi sa lahat ng pagkakataon ng isang klase. Halimbawa, isang counter variable na sumusubaybay sa bilang ng mga instance na ginawa, o isang CONSTANT na variable na mayroong value na hindi nagbabago. Isaalang-alang ang isang klase na kumakatawan sa isang bank account. Ipinapakita ng sumusunod na snippet ng code kung paano magagamit ang isang static na variable nextAccountNumber upang magtalaga ng mga natatanging account number sa bawat bagong account:

Halimbawa

// BankAccount class definition
class BankAccount {
  // Declare static variable nextAccountNumber
  static int nextAccountNumber = 1001;

  // Declare instance variables for accountNumber and balance.
  int accountNumber;
  double balance;

  // BankAccount constructor that assigns unique account number to each instance
  BankAccount() {
    // Assign the current value of nextAccountNumber to accountNumber.
    accountNumber = nextAccountNumber;

    // Increment nextAccountNumber for the next BankAccount object.
    nextAccountNumber++;
  }

  // Method to get the account number of this BankAccount object.
  int getAccountNumber() {
    return accountNumber;
  }

  // Method to get the balance of this BankAccount object.
  double getBalance() {
    return balance;
  }

  // Method to deposit an amount into this BankAccount object.
  void deposit(double amount) {
    // Increase balance by the amount deposited.
    balance += amount;
  }

  // Method to withdraw an amount from this BankAccount object.
  void withdraw(double amount) {
    // Decrease balance by the amount withdrawn.
    balance -= amount;
  }
}

// Main method definition
class Main {
  static void main(String[] args) {
    // Create three BankAccount objects: account1, account2, and account3.
    BankAccount account1 = new BankAccount();
    BankAccount account2 = new BankAccount();
    BankAccount account3 = new BankAccount();

    // Display the value of the static variable nextAccountNumber after creating each BankAccount object.
    System.out.println("Value of nextAccountNumber after creating account1: " + account1.getAccountNumber());
    System.out.println("Value of nextAccountNumber after creating account2: " + account2.getAccountNumber());
    System.out.println("Value of nextAccountNumber after creating account3: " + account3.getAccountNumber());
  }
}

Output

Sa halimbawang ito, ang pangunahing pamamaraan ay lumilikha ng tatlong pagkakataon ng klase ng BankAccount . Itinalaga ng tagabuo ng BankAccount ang nextAccountNumber sa bagong account at dinadagdagan ng 1 ang variable na nextAccountNumber . Ibinabalik ng paraan ng getAccountNumber ang account number ng bawat account. Ang pangunahing paraan ay nagpi-print ng account number at ang nextAccountNumber variable para sa bawat account. Makikita mo na ang bawat account number ay natatangi at ang nextAccountNumber variable ay dinaragdagan ng isa para sa bawat bagong account na ginawa. Magagamit din ang mga static na variable para ipatupad ang pattern ng disenyo ng Singleton, kung saan isang instance lang ng isang klase ang maaaring gawin. Ang singleton class ay isang klase na maaaring magkaroon lamang ng isang instance sa anumang Java application at sabay na nagbibigay ng global access point sa instance na ito. Ipinapakita ng sumusunod na snippet ng code kung paano magagamit ang isang static na variable na instance para magpatupad ng singleton class:

Halimbawa

public class Singleton {
    // using static variable in the singleton class
    private static Singleton instance;
    private Singleton() { }

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }

    public void displayMessage() {
        System.out.println("This is a singleton class");
    }

    public static void main(String[] args) {
        Singleton singleton1 = Singleton.getInstance();
        singleton1.displayMessage();

        Singleton singleton2 = Singleton.getInstance();
        singleton2.displayMessage();

        Singleton singleton3 = Singleton.getInstance();
        singleton3.displayMessage();
    }
}

Output

Sa halimbawang ito, ang pangunahing pamamaraan ay lumilikha ng tatlong pagkakataon ng klase ng Singleton sa pamamagitan ng pagtawag sa getInstance() na pamamaraan. Ang getInstance() method ay nagbabalik ng instance ng klase at gumagawa ng bagong instance kung wala ang isa. Ang paraan ng displayMessage ay nagpi-print lamang ng isang mensahe. Pagkatapos ay tinatawag ng pangunahing pamamaraan ang paraan ng displayMessage para sa bawat pagkakataon. Tulad ng nakikita mo, kahit na gumagawa kami ng tatlong mga pagkakataon, isang bagay lamang ang nilikha at ibinabahagi sa lahat ng mga pagkakataon. Pinatutunayan nito na isang instance lang ng klase ang nilikha at ibinahagi sa lahat ng pagkakataon at hawak ang static na variable na 'instance'. Mahalagang tandaan na ang halaga ng isang static na variable ay ibinabahagi sa lahat ng mga instance ng isang klase, kaya ang mga pagbabago sa variable na ginawa ng isang instance ay makikita ng lahat ng iba pang mga instance. Ang maingat na pagsasaalang-alang ay dapat ibigay sa mga static na variable upang maiwasan ang mga potensyal na salungatan at mga bug sa iyong code. Halimbawa, hindi inirerekomenda ang paggamit ng static na variable para magkaroon ng value na partikular sa isang instance ng isang klase, gaya ng balanse ng account. Upang palakasin ang iyong natutunan, iminumungkahi naming manood ka ng isang video lesson mula sa aming Java Course

Konklusyon

Upang tapusin ito, ang isang static na variable sa Java ay nagbibigay-daan sa pagbabahagi ng data sa lahat ng mga pagkakataon ng isang klase. Magagamit ang mga ito para sa mga variable na ibinabahagi sa lahat ng pagkakataon, tulad ng mga counter, at constant o para ipatupad ang pattern ng disenyo ng Singleton. Gayunpaman, mahalagang tandaan na ang halaga ng isang static na variable ay ibinabahagi sa lahat ng mga instance ng isang klase, kaya ang mga pagbabago sa variable na ginawa ng isang instance ay makikita ng lahat ng iba pang mga instance.