Zmienne Javy

W tym artykule wyjaśnimy wszystkim uczącym się języka Java, czym są zmienne Java i jak z nimi pracować.

Co to jest zmienna Java

Zmienną w Javie można traktować jako pudełko. To „pudełko” ma określony rozmiar: przydzieloną mu pamięć. To, ile pamięci zostanie przydzielone, zależy od typu zmiennej, ale o tym porozmawiamy nieco później. Jednocześnie rozmiar samego pudełka nie może zostać zmieniony po jego utworzeniu, ale zawartość może. Pudełko może być puste. Możesz „wstawić” do niego jakąś wartość, a następnie wyodrębnić i umieścić inną wartość. Zatem zmienna jest polem, które przechowuje wartości danych podczas wykonywania programu Java. To pudełko ma ważne cechy:

zawsze może zawierać tylko jedną wartość (lub może być pusta, wtedy będzie zawierała wartość domyślną),
Ma typ danych. Jej wielkość zależy od rodzaju danych, a także od tego, w jakim konkretnym obszarze pamięci miejsce jest dla niej przeznaczone (gdzie się znajduje).

Jak deklarować zmienne

Aby zadeklarować zmienną w Javie, musisz określić jej typ i nazwę. Oto przykład deklaracji trzech zmiennych:

int myInt;
String s;
Object variableName;

Tutaj int , String i Object to typ danych, a myInt , s , nazwa_zmiennej to nazwy zmiennych. Typ danych należy wybrać w oparciu o potrzeby programu, a lepiej wybrać nazwę, aby było jasne, o co chodzi. Oczywiście dla początkujących nie jest to takie ścisłe, ale w dużych projektach nazwy zmiennych, takie jak „s”, mogą pogorszyć czytelność kodu. Lepiej więc przyzwyczaić się do nazywania zmiennych w taki sposób, aby od samego początku było jasne, do czego służą. Oczywiście w granicach rozsądku.

Jak zainicjować zmienne

Deklarując zmienną, przydzielasz jej pamięć. Inicjalizacja oznacza, że „umieściłeś” określoną wartość w „polu”. Można to zrobić natychmiast podczas deklaracji zmiennej lub później. Również wartość zmiennej może się zmieniać w trakcie wykonywania programu. Przykład:

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);
    }
}

Tutaj zadeklarowaliśmy i zainicjowaliśmy zmienną myInt w jednym wierszu, natychmiast przydzielając jej pamięć (32 bity na każdą liczbę int), nadaliśmy jej nazwę, a następnie umieściliśmy wartość 5 w przydzielonej pamięci. Następnie zadeklarowaliśmy, że przydzielamy miejsce w pamięci dla ciągu znaków s i już osobnym poleceniem wstawiliśmy do niego wartość „init”. Następnie wydrukowaliśmy łańcuch i zmieniliśmy wartość zmiennej s . W tym programie wydrukowaliśmy linie, a jeśli go uruchomisz, zobaczysz następujący wynik:

init init5

Typy danych zmiennych w Javie: prymitywne i nieprymitywne

Typy danych zmiennych w Javie dzielą się na dwie grupy:

Prymitywne typy danych obejmują byte , short , int , long , float , double , boolean i char
Typy danych, które nie są prymitywne, takie jak String , Arrays i Classes

Oto przykład pracy ze zmiennymi:

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 i float są prymitywami. Ciąg nie jest prymitywny. A co ze zmienną myStudent ? To jest obiekt utworzonej przez użytkownika klasy Student . Został stworzony po prostu w celu zilustrowania pracy ze zmiennymi nieprymitywnymi. Stanowią większość w Javie, ponieważ prawie wszystko w tym języku programowania jest obiektem. Dla zrozumienia, oto kod klasy Student :

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));
   }
}

Typy zmiennych w Javie: lokalne, instancyjne i statyczne

Istnieją trzy różne typy zmiennych w Javie, wymieniliśmy je w następujący sposób:

Zmienne lokalne
Zmienne instancji
Zmienne statyczne

Zmienne lokalne

Zmienna zadeklarowana w ciele metody nazywana jest zmienną lokalną. Ponadto zmienne lokalne są deklarowane wewnątrz konstruktorów i bloków. Możesz używać zmiennych lokalnych tylko w tej metodzie, konstruktorze lub bloku, w którym zostały utworzone, a inne metody w klasie nie są nawet świadome, że zmienna istnieje. Tak więc zmienne lokalne są tworzone, gdy wprowadzana jest metoda, konstruktor lub blok, a zmienna jest niszczona, gdy metoda, konstruktor lub blok nie działa. Zmiennej lokalnej nie można zdefiniować za pomocą słowa kluczowego static . Co więcej: nie można używać modyfikatorów dostępu do zmiennych lokalnych. Oto przykład:

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;
   }
}

Tutaj myOtherString jest zmienną lokalną. Nie możesz go użyć z innej metody, ale myMethod . Zmienne lokalne nie mogą mieć wartości domyślnych. Jeśli przynajmniej jedna zmienna lokalna nie zostanie zainicjowana w programie, program nie będzie działał poprawnie. Wprowadźmy małą zmianę w jednym z poprzednich przykładów i „zapomnijmy” o zainicjowaniu zmiennej myBool :

public class VariableTest {
   public static void main(String[] args) {

       int myInt = - 5;               // integer (whole number)
       float myFloat = 2.718281828459045f;    // Floating point
       char myLetter = 'a';         // character
       boolean myBool;       // boolean
       String myText = "Hero";     // String
       System.out.println(myInt + " " +
               myFloat +" " + myLetter + " " +  myBool + " " + myText);
       Student myStudent = new Student("Walker","Johnny", "Kyle", null);

   }
}

Jeśli spróbujemy uruchomić program, zgłosi błąd:

Błąd:(10, 50) java: zmienna myBool mogła nie zostać zainicjowana

Zmienne instancji

Zmienna zadeklarowana wewnątrz klasy, ale poza ciałem jakiejkolwiek metody, konstruktora lub bloku, nazywana jest zmienną instancji. Zmienne instancji są tworzone, gdy obiekt jest tworzony przy użyciu słowa kluczowego new . Jest niszczony, gdy obiekt jest niszczony. Nie można go zadeklarować jako statycznego, ale można użyć modyfikatorów dostępu dla zmiennych instancji. Zmienne instancji są widoczne dla wszystkich metod, konstruktorów i bloków w klasie. Zazwyczaj zmienne instancji są prywatne, ale można zmienić widoczność podklas. Zmienne instancji, w przeciwieństwie do zmiennych lokalnych, mają wartości domyślne. Dla wszystkich pierwotnych typów liczb domyślną wartością jest 0, dla logicznych jest to fałsz, a dla odwołań do obiektów jest to wartość zerowa. Wartości można przypisywać podczas deklaracji lub w konstruktorze. Oto przykład:

//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());
   }
}

Zmienne statyczne

Zmienna zadeklarowana jako statyczna nazywana jest zmienną statyczną. Java umożliwia deklarowanie takich zmiennych poza metodą, konstruktorem lub blokiem. Nie mogą być lokalne, należą do klasy, a nie do instancji. Oznacza to, że jedna kopia zmiennej statycznej została raz utworzona i udostępniona wszystkim instancjom klasy. Alokacja pamięci dla zmiennych statycznych odbywa się tylko raz, gdy klasa jest ładowana do pamięci. Mogą mieć dowolną widoczność, ale zazwyczaj są deklarowane jako publiczne. Mają także wartości domyślne, takie jak zmienne instancji.

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;
}

W powyższym przykładzie utworzyliśmy oddzielną klasę Storage , przenieśliśmy do niej zmienne count i sum i zadeklarowaliśmy je jako statyczne. Dostęp do publicznych zmiennych statycznych można uzyskać z dowolnej metody programu (a nie tylko z metody). Aby utrwalić to, czego się nauczyłeś, zalecamy obejrzenie lekcji wideo z naszego kursu języka Java