Java-variabler

I den här artikeln kommer vi att förklara för alla Java-elever vad Java-variabler är och hur man arbetar med dem.

Vad är Java-variabel

En variabel i Java kan ses som en box. Denna "låda" har en viss storlek: minnet som är tilldelat för den. Hur mycket minne som kommer att tilldelas beror på typen av variabel, men vi ska prata om detta lite senare. Samtidigt kan storleken på själva lådan inte ändras efter att den skapats, men innehållet kan. Lådan kan vara tom. Du kan "infoga" något värde i det och sedan extrahera och lägga in något annat värde. Således är en variabel ett fält som lagrar datavärden under körningen av ett Java-program. Denna låda har viktiga funktioner:

det kan alltid bara innehålla ett värde (eller kan vara tomt, i så fall kommer det att innehålla standardvärdet),
Den har en datatyp. Dess storlek beror på typen av data, såväl som på vilket särskilt minnesområde platsen är tilldelad för den (var den ligger).

Hur man deklarerar variabler

För att deklarera variabler i Java måste du ange dess typ och namn. Här är ett exempel på att deklarera tre variabler:

int myInt;
String s;
Object variableName;

Här är int , String och Object datatypen och myInt , s , variableName är variabelnamn. Datatypen måste väljas utifrån programmets behov och det är bättre att välja ett namn så att det framgår vad det handlar om. Naturligtvis är det inte så strikt för nybörjare, men i stora projekt kan variabelnamn som 's' försämra kodens läsbarhet. Så det är bättre att vänja sig vid att namnge variabler på ett sätt som gör det tydligt vad de är till för redan från början. Inom rimliga gränser förstås.

Hur man initierar variabler

När du deklarerar en variabel allokerar du minne för den. Initialisering innebär att man "lägger" ett visst värde i "rutan". Detta kan göras omedelbart under deklarationen av variabeln eller senare. Dessutom kan värdet på en variabel ändras under programkörning. Exempel:

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

Här deklarerade och initierade vi myInt -variabeln på en rad, allokerade omedelbart minne för den (32 bitar för varje int-nummer), gav den ett namn och placerade sedan värdet 5 i det allokerade minnet. Sedan förklarade vi att vi allokerade minnesutrymme för strängen s , och redan ett separat kommando lade in värdet "init" i den. Efter det skrev vi ut strängen och ändrade värdet på variabeln s . I det här programmet skrev vi ut raderna, och om du kör det kommer du att se följande resultat:

init init5

Datatyper av variabler i Java: primitiva och icke-primitiva

Datatyper av variabler i Java är indelade i två grupper:

Primitiva datatyper inkluderar byte , short , int , long , float , double , boolean och char
Icke-primitiva datatyper som String , Arrays och Classes

Här är ett exempel på hur man arbetar 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 och float är primitiver. Sträng är icke-primitiv. Hur är det med myStudent- variabeln? Detta är ett objekt av den användarskapade klassen Student . Den skapades helt enkelt för att illustrera arbetet med icke-primitiva variabler. De är majoriteten i Java, eftersom nästan allt i detta programmeringsspråk är ett objekt. För förståelse, här är koden för 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));
   }
}

Typer av variabler i Java: lokal, instans och statisk

Det finns tre olika typer av variabler i Java, vi har listat dem enligt följande:

Lokala variabler
Instansvariabler
Statiska variabler

Lokala variabler

En variabel som deklareras inuti metoden kallas en lokal variabel. Lokala variabler deklareras också inuti konstruktörer och block. Du kan bara använda lokala variabler inom den metod, konstruktor eller block där de skapades och de andra metoderna i klassen är inte ens medvetna om att variabeln finns. Så lokala variabler skapas när metoden, konstruktorn eller blocket skrivs in och variabeln förstörs när metoden, konstruktorn eller blocket inte fungerar. En lokal variabel kan inte definieras med det statiska nyckelordet. Ännu mer: du kan inte använda åtkomstmodifierare för lokala variabler. Här är ett exempel:

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

Här är myOtherString en lokal variabel. Du kan inte använda det från den andra metoden, men myMethod . Lokala variabler kan inte ha standardvärden. Om minst en lokal variabel inte initieras i programmet kommer programmet inte att fungera korrekt. Låt oss göra en liten ändring i ett av de tidigare exemplen och "glömma" att initiera myBool- variabeln:

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

   }
}

Om vi försöker köra programmet kommer det att ge ett felmeddelande:

Fel:(10, 50) java: variabeln myBool kanske inte har initierats

Instansvariabler

En variabel som deklareras inuti klassen men utanför kroppen av någon metod, konstruktor eller block kallas en instansvariabel. Instansvariabler skapas när ett objekt skapas med det nya nyckelordet. Det förstörs när föremålet förstörs. Det kan inte deklareras som statiskt, men du kan använda åtkomstmodifierare till exempel variabler. Instansvariabler är synliga för alla metoder, konstruktörer och block i klassen. Vanligtvis är instansvariabler privata, men du kan ändra synligheten för underklasser. Förekomstvariabler i motsats till lokala variabler har standardvärden. För alla primitiva taltyper är standardvärdet 0, för booleaner är det falskt och för objektreferenser är det null. Värden kan tilldelas under deklarationen eller inom konstruktören. Här är ett exempel:

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

Statiska variabler

En variabel som deklareras som statisk kallas en statisk variabel. Java erbjuder dig att deklarera sådana variabler utanför en metod, konstruktor eller block. Det kan inte vara lokalt, de tillhör klassen, inte till instanser. Det betyder att en enda kopia av en statisk variabel en gång skapats och delas mellan alla instanser av klassen. Minnestilldelning för statiska variabler sker endast en gång när klassen laddas i minnet. De kan ha vilken synlighet som helst, men vanligtvis deklareras de som offentliga. De har också standardvärden som instansvariabler.

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 exemplet ovan skapade vi en separat Storage- klass, flyttade in count- och summavariablerna till den och förklarade dem statiska. Offentliga statiska variabler kan nås från vilken programmetod som helst (och inte bara från en metod). För att förstärka det du lärde dig föreslår vi att du tittar på en videolektion från vår Java-kurs