Java-variabler

I denne artikkelen skal vi forklare alle Java-elever hva Java-variabler er og hvordan de kan jobbe med dem.

Hva er Java-variabel

En variabel i Java kan betraktes som en boks. Denne "boksen" har en viss størrelse: minnet som er tildelt den. Hvor mye minne som vil bli tildelt avhenger av typen variabel, men vi skal snakke om dette litt senere. Samtidig kan størrelsen på selve boksen ikke endres etter opprettelsen, men innholdet kan. Boksen kan være tom. Du kan "sette inn" en verdi i den, og deretter trekke ut og sette inn en annen verdi. Dermed er en variabel et felt som lagrer dataverdier under kjøringen av et Java-program. Denne boksen har viktige funksjoner:

den kan alltid inneholde bare én verdi (eller kan være tom, i så fall vil den inneholde standardverdien),
Den har en datatype. Størrelsen avhenger av typen data, så vel som av hvilket spesielt minneområde stedet er tildelt for det (hvor det ligger).

Hvordan deklarere variabler

For å deklarere variabler i Java, må du spesifisere typen og navnet. Her er et eksempel på å deklarere tre variabler:

int myInt;
String s;
Object variableName;

Her er int , String og Object datatypen og myInt , s , variableName er variabelnavn. Datatypen må velges ut fra programmets behov, og det er bedre å velge navn slik at det er tydelig hva det handler om. For nybegynnere er det selvfølgelig ikke så strengt, men i store prosjekter kan variabelnavn som 's' svekke lesbarheten til koden. Så det er bedre å venne seg til å navngi variabler på en måte som gjør det klart hva de er til for helt fra begynnelsen. Innenfor rimelighetens grenser, selvfølgelig.

Hvordan initialisere variabler

Når du erklærer en variabel, tildeler du minne for den. Initialisering betyr at du "putter" en viss verdi inn i "boksen". Dette kan gjøres umiddelbart under deklarasjonen av variabelen eller senere. Dessuten kan verdien av en variabel endres under programkjøring. Eksempel:

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

Her deklarerte og initialiserte vi myInt -variabelen på én linje, og allokerte umiddelbart minne for den (32 biter for hvert int-nummer), ga den et navn og plasserte deretter verdien 5 i det tildelte minnet. Så erklærte vi at vi allokerte minneplass for strengen s , og allerede en egen kommando la verdien "init" inn i den. Etter det skrev vi ut strengen og endret verdien på variabelen s . I dette programmet skrev vi ut linjene, og hvis du kjører det, vil du se følgende resultat:

init init5

Datatyper av variabler i Java: primitiv og ikke-primitiv

Datatyper av variabler i Java er delt inn i to grupper:

Primitive datatyper inkluderer byte , short , int , long , float , double , boolean og char
Ikke-primitive datatyper som String , Arrays og Classes

Her er et eksempel på arbeid med variabler:

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 og float er primitiver. Strengen er ikke-primitiv. Hva med myStudent- variabelen? Dette er et objekt av den brukeropprettede klassen Student . Den ble laget ganske enkelt for å illustrere arbeidet med ikke-primitive variabler. De er flertallet i Java, siden nesten alt i dette programmeringsspråket er et objekt. For å forstå, her er koden for studentklassen :

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

Variabletyper i Java: lokale, forekomster og statiske

Det er tre forskjellige typer variabler i Java, vi har listet dem opp som følger:

Lokale variabler
Forekomstvariabler
Statiske variabler

Lokale variabler

En variabel deklarert inne i metoden kalles en lokal variabel. Også lokale variabler er deklarert inne i konstruktører og blokker. Du kan bruke lokale variabler bare innenfor den metoden, konstruktøren eller blokken der de ble opprettet, og de andre metodene i klassen er ikke engang klar over at variabelen eksisterer. Så lokale variabler opprettes når metoden, konstruktøren eller blokken legges inn og variabelen blir ødelagt når metoden, konstruktøren eller blokken ikke fungerer. En lokal variabel kan ikke defineres med det statiske nøkkelordet. Enda mer: du kan ikke bruke tilgangsmodifikatorer for lokale variabler. Her er et eksempel:

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

Her er myOtherString en lokal variabel. Du kan ikke bruke den fra den andre metoden, men myMethod . Lokale variabler kan ikke ha standardverdier. Hvis minst én lokal variabel ikke er initialisert i programmet, vil ikke programmet fungere korrekt. La oss gjøre en liten endring i et av de foregående eksemplene og "glemme" å initialisere myBool- variabelen:

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

   }
}

Hvis vi prøver å kjøre programmet, vil det gi en feilmelding:

Feil:(10, 50) java: variabel myBool har kanskje ikke blitt initialisert

Forekomstvariabler

En variabel deklarert inne i klassen, men utenfor kroppen til en hvilken som helst metode, konstruktør eller blokk, kalles en forekomstvariabel. Forekomstvariabler opprettes når et objekt opprettes ved å bruke det nye nøkkelordet. Den blir ødelagt når gjenstanden blir ødelagt. Det kan ikke erklæres som statisk, men du kan bruke tilgangsmodifikatorer for for eksempel variabler. Forekomstvariabler er synlige for alle metoder, konstruktører og blokker i klassen. Vanligvis er forekomstvariabler private, men du kan endre synligheten for underklasser. Forekomstvariabler i motsetning til lokale variabler har standardverdier. For alle primitive talltyper er standardverdien 0, for booleaner er den falsk, og for objektreferanser er den null. Verdier kan tildeles under erklæringen eller innenfor konstruktøren. Her er et eksempel:

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

Statiske variabler

En variabel som er erklært som statisk kalles en statisk variabel. Java tilbyr deg å deklarere slike variabler utenfor en metode, konstruktør eller blokk. Det kan ikke være lokalt, de tilhører klassen, ikke instanser. Det betyr at en enkelt kopi av en statisk variabel en gang er opprettet og delt mellom alle forekomstene av klassen. Minneallokering for statiske variabler skjer bare én gang når klassen er lastet inn i minnet. De kan ha hvilken som helst synlighet, men vanligvis er de erklært som offentlige. De har også standardverdier som forekomstvariabler.

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

I eksemplet ovenfor opprettet vi en egen lagringsklasse , flyttet telle- og sumvariablene inn i den og erklærte dem statiske. Offentlige statiske variabler kan nås fra hvilken som helst programmetode (og ikke bare fra en metode). For å forsterke det du lærte, foreslår vi at du ser en videoleksjon fra vårt Java-kurs