In dit artikel gaan we aan alle Java-studenten uitleggen wat Java-variabelen zijn en hoe ermee te werken.
Wat is Java-variabele
Een variabele in Java kan worden gezien als een box. Deze "box" heeft een bepaalde grootte: het geheugen dat ervoor is toegewezen. Hoeveel geheugen wordt toegewezen, hangt af van het type variabele, maar we gaan hier later over praten. Tegelijkertijd kan de grootte van de doos zelf niet worden gewijzigd nadat deze is gemaakt, maar de inhoud wel. De doos kan leeg zijn. U kunt er een waarde in "invoegen" en vervolgens een andere waarde extraheren en plaatsen. Een variabele is dus een veld dat gegevenswaarden opslaat tijdens de uitvoering van een Java-programma. Deze box heeft belangrijke kenmerken:
het kan altijd slechts één waarde bevatten (of kan leeg zijn, in welk geval het de standaardwaarde bevat),
Het heeft een gegevenstype. De grootte hangt af van het type gegevens, evenals van welk specifiek geheugengebied de plaats ervoor is toegewezen (waar het ligt).
Hoe variabelen te declareren
Om variabelen in Java te declareren, moet u het type en de naam specificeren. Hier is een voorbeeld van het declareren van drie variabelen:
int myInt;
String s;
Object variableName;
Hier zijn int , String en Object het gegevenstype en myInt , s , variableName zijn variabelenamen. Het gegevenstype moet worden gekozen op basis van de behoeften van het programma en het is beter om een naam te kiezen zodat duidelijk is waar het over gaat. Voor beginners is het natuurlijk niet zo strikt, maar in grote projecten kunnen namen van variabelen zoals 's' de leesbaarheid van de code aantasten. Het is dus beter om te wennen aan het benoemen van variabelen op een manier die vanaf het begin duidelijk maakt waar ze voor dienen. Binnen redelijke grenzen natuurlijk.
Variabelen initialiseren
Wanneer u een variabele declareert, wijst u er geheugen voor toe. Initialisatie betekent dat u een bepaalde waarde in het "vak" "zet". Dit kan direct worden gedaan tijdens de declaratie van de variabele of later. Ook kan de waarde van een variabele veranderen tijdens de uitvoering van het programma. Voorbeeld:
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);
}
}
Hier hebben we de variabele myInt in één regel gedeclareerd en geïnitialiseerd , er onmiddellijk geheugen voor toegewezen (32 bits voor elk int-nummer), het een naam gegeven en vervolgens de waarde 5 in het toegewezen geheugen geplaatst. Toen verklaarden we dat we geheugenruimte aan het toewijzen waren voor de string s , en al een apart commando plaatste de waarde "init" erin. Daarna hebben we de string afgedrukt en de waarde van de variabele s gewijzigd . In dit programma hebben we de regels afgedrukt en als u het uitvoert, ziet u het volgende resultaat:
begin begin5
Gegevenstypen van variabelen in Java: primitief en niet-primitief
Gegevenstypen van variabelen in Java zijn verdeeld in twee groepen:
Primitieve gegevenstypen zijn onder meer byte , short , int , long , float , double , boolean en char
Niet-primitieve gegevenstypen zoals String , Arrays en Classes
Hier is een voorbeeld van het werken met variabelen:
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 en float zijn primitieven. String is niet-primitief. Hoe zit het met de variabele myStudent ? Dit is een object van de door de gebruiker gemaakte klasse Student . Het is eenvoudig gemaakt om het werk met niet-primitieve variabelen te illustreren. Ze vormen de meerderheid in Java, aangezien bijna alles in deze programmeertaal een object is. Voor de duidelijkheid, hier is de code van de Student- klasse:
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));
}
}
Soorten variabelen in Java: lokaal, instantie en statisch
Er zijn drie verschillende soorten variabelen in Java, we hebben ze als volgt opgesomd:
Lokale variabelen
Instantievariabelen
Statische variabelen
Lokale variabelen
Een variabele die binnen de body van de methode wordt gedeclareerd, wordt een lokale variabele genoemd. Ook worden lokale variabelen gedeclareerd binnen constructors en blokken. U kunt lokale variabelen alleen gebruiken binnen die methode, constructor of blok waar ze zijn gemaakt en de andere methoden in de klasse weten niet eens dat de variabele bestaat. Er worden dus lokale variabelen gemaakt wanneer de methode, constructor of blok wordt ingevoerd en de variabele wordt vernietigd zodra de methode, constructor of blok niet werkt. Een lokale variabele kan niet worden gedefinieerd met het statische trefwoord. Sterker nog: u kunt geen toegangsmodificatoren gebruiken voor lokale variabelen. Hier is een voorbeeld:
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;
}
}
Hier is myOtherString een lokale variabele. Je kunt het niet gebruiken vanuit de andere methode, maar myMethod . Lokale variabelen kunnen geen standaardwaarden hebben. Als ten minste één lokale variabele niet is geïnitialiseerd in het programma, zal het programma niet correct werken. Laten we een kleine wijziging aanbrengen in een van de vorige voorbeelden en "vergeten" de myBool- variabele te initialiseren :
Als we het programma proberen uit te voeren, geeft het een foutmelding:
Error:(10, 50) java: variabele myBool is mogelijk niet geïnitialiseerd
Instantievariabelen
Een variabele die binnen de klasse maar buiten de body van een methode, constructor of blok wordt gedeclareerd, wordt een instantievariabele genoemd. Instantievariabelen worden gemaakt wanneer een object wordt gemaakt met het nieuwe trefwoord. Het wordt vernietigd wanneer het object wordt vernietigd. Het kan niet als statisch worden gedeclareerd, maar u kunt toegangsmodificaties gebruiken voor instantievariabelen. Instantievariabelen zijn zichtbaar voor alle methoden, constructors en blokken in de klasse. Gewoonlijk zijn instantievariabelen privé, maar u kunt de zichtbaarheid voor subklassen wijzigen. Instantievariabelen hebben, in tegenstelling tot lokale variabelen, standaardwaarden. Voor alle typen primitieve getallen is de standaardwaarde 0, voor booleans is deze onwaar en voor objectreferenties is deze null. Waarden kunnen worden toegewezen tijdens de declaratie of binnen de constructor. Hier is een voorbeeld:
//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());
}
}
Statische variabelen
Een variabele die als statisch wordt gedeclareerd, wordt een statische variabele genoemd. Java biedt u de mogelijkheid om dergelijke variabelen buiten een methode, constructor of blok om te declareren. Het kan niet lokaal zijn, ze behoren tot klasse, niet tot instanties. Dat betekent dat een enkele kopie van een statische variabele eenmaal is gemaakt en gedeeld met alle instanties van de klasse. Geheugentoewijzing voor statische variabelen gebeurt slechts één keer wanneer de klasse in het geheugen wordt geladen. Ze kunnen enige zichtbaarheid hebben, maar meestal worden ze als openbaar verklaard. Ze hebben ook standaardwaarden zoals instantievariabelen.
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;
}
In het bovenstaande voorbeeld hebben we een aparte Storage- klasse gemaakt, de variabelen voor aantal en som erin verplaatst en statisch verklaard. Openbare statische variabelen zijn toegankelijk via elke programmamethode (en niet alleen via een methode). Om te versterken wat je hebt geleerd, raden we je aan een videoles van onze Java-cursus te bekijken
GO TO FULL VERSION