Was sind Java-Variablen?
Variablen sind die Grundeinheiten zum Speichern von Informationen in Java. Der Variablenname ist der für diese Einheiten zugewiesene Name. Ein Java-Code benötigt möglicherweise Informationen in Form einer Zahl oder eines Zeichenfolgenwerts. Dieselbe Menge von Werten kann in mehreren Stufen eines Codes erforderlich sein. Hier kommt eine Variable ins Bild.
Alle diese erforderlichen Werte können verschiedenen Variablen zugewiesen werden, die an ihren jeweiligen Speicherorten gespeichert werden. Eine Variable ist also nichts anderes als der Name eines Speicherorts. Das Speichern von Werten in Variablen ist effizienter als das Wiederholen der Werte überall im Code. Dies ist auch hilfreich, wenn sich der erforderliche Wert ändert, da es ausreichend ist, ihn nur an einer Stelle der Variablendeklaration zu ändern, anstatt ihn an mehreren Stellen ändern zu müssen.
Variablendeklaration
Eine Variable kann erst verwendet werden, wenn sie deklariert wurde. Der Datentyp, den wir während der Deklaration zuweisen, definiert den Typ des Werts, den sie enthalten kann. Einer Variablen können verschiedene Datentypen wie int, float, string, char, boolean, long, double zugewiesen werden. Die allgemeine Syntax zum Deklarieren einer Variablen in Java lautet wie folgt:
Beispiel: int a = 1;
wo;
int -> datentyp
a -> Variablenname
1 -> variabler Wert
Das folgende Diagramm zeigt die bildliche Darstellung desselben:
Initialisierung von Variablen
Das Zuweisen eines Standardwerts zu der Variablen wird als Initialisierung dieser Variablen bezeichnet. Eine Variable kann sowohl während der Deklaration als auch während der späteren Programmphasen nach Bedarf initialisiert werden.
Beispiele:
Im Folgenden sind einige der Werte aufgeführt, die wir einer Variablen in Bezug auf ihren jeweiligen Datentyp zuweisen können
1) int i; i = 10;
2) Schnurstadt; Stadt = ”Bangalore”;
3) char a; a = 'H';
4) float dec; dec = 3, 5;
5) Boolescher Wert; val = wahr;
Arten von Variablen
In Java gibt es drei Arten von Variablen:
- Lokale Variable
- Instanzvariable
- Statische Variable
1) Lokale Variablen
- Dies sind Variablen, die in einer bestimmten Methode oder einem bestimmten Block oder Konstruktor deklariert sind, in dem sie sich befinden.
- Ihr Variablenwert, der während der Deklaration gespeichert wird, ist nur im Rahmen dieser Methode gültig und geht beim Verlassen der Methode verloren.
- Eine lokale Variable mit demselben Variablennamen kann in mehreren Methoden oder Blöcken ohne Konflikte deklariert werden.
Beispiel:
a) Im folgenden Beispiel betrachten wir "num" und "name" als lokale Variablen
public class PatientDetails(
public void Patient()
(
// local variable num
//local variable name
int num = 1200;
string name = "Harish";
id = id + 1;
System.out.println("Patient Name is: " + name + " Patient Number is: " + num);
name = "Sudha";
System.out.println("Patient Name is: " + name + " Patient Number is: " + num);
)
public void DoctorDetails()
(
int num = 12000;
string name = "Vijay";
num = num +1;
System.out.println("Doctor Name is: " + name + " Doctor ID is: " + num);
name = "Suma";
System.out.println("Doctor Name is: " + name + " Doctor ID is: " + num);
)
public static void main(String args())
(
PatientDetails pat = new PatientDetails();
pat. Patient();
pat.DoctorDetails();
)
)
Ausgabe:
Patientenname ist: Harish
Patientennummer ist: 1200
Der Patientenname lautet: Sudha
Patientennummer ist: 1201
Doktor Name ist: Vijay
Der Arztausweis lautet: 12000
Doktor Name ist: Suma
Die Arzt-ID lautet: 12001
Dies zeigt, dass dieselben lokalen Variablennamen "num" und "name", wenn sie in zwei verschiedenen Methoden deklariert werden, dh "Patient" und "DoctorDetails", zum Zuweisen einer beliebigen Anzahl unterschiedlicher Werte verwendet werden können.
Beispiel:
b) Die gleichen lokalen Variablen "num" und "name" sind ungültig, wenn wir versuchen, ihren Wert außerhalb ihrer Methode anzuzeigen
public class PatientDetails(
public void Patient()
(
// local variable num
//local variable name
int id = 1200;
)
public static void main(String args())
(
System.out.println("Patient Number is: " + num);
//printing local variable outside it's method
)
)
Ausgabe:
Kompilierungsfehler im Java-Code: -
prog.java:12: Fehler: Symbol kann nicht gefunden werden
System.out.println ("Patientennummer ist:" + num);
^
Symbol: Variablennummer
Ort: Klasse Patientendetails
1 Fehler
2) Instanzvariablen
- Instanzvariablen sind solche, die innerhalb einer Klasse und nicht innerhalb einer Methode deklariert werden.
- Sie werden erstellt, wenn ein Objekt erstellt wird, und ihr Wert geht verloren, wenn das Objekt zerstört wird.
- Die Initialisierung dieser Variablen ist nicht obligatorisch und der Wert wird standardmäßig als Null angenommen.
- Sie sind nicht statische Variablen, dh der Speicher für die Variable wird zugewiesen, wenn ein neues Objekt erstellt wird.
Beispiel:
Hierbei sind a, b, c die Instanzvariablen, die in zwei verschiedenen Instanzen von zwei verschiedenen Objekten deklariert werden.
import java.io.*;
class Marks (
// a, b, c are instance variables
// a, b, c variables are being declared inside a class and not function
int a;
int b;
int c;
)
class MarksDemo (
public static void main(String args())
(
// first object declaration
Alpha alp1 = new Alpha();
alp1 .a= 44;
alp1 .b= 77;
alp1 .c= 88;
// second object declaration
Alpha alp2 = new Alpha();
alp2 .a= 77;
alp2 .b= 55;
alp2 .c= 74;
// displaying variable values for first object
System.out.println("Values for first object:");
System.out.println(alp1.a);
System.out.println(alp1.b);
System.out.println(alp1.c);
// displaying variable values for second object
System.out.println("Values for second object:");
System.out.println(alp2.a);
System.out.println(alp2.b);
System.out.println(alp2.c);
)
)
Ausgabe:
Werte für das erste Objekt:
44
77
88
Werte für das zweite Objekt:
77
55
74
3) Statische Variablen
- Statische Variablen werden am Anfang des Programms deklariert, dem das Schlüsselwort static vorangestellt ist.
- Wie bei Instanzvariablen ist die Initialisierung statischer Variablen nicht obligatorisch und ihr Standardwert ist 0.
- Es kann nur einen statischen Variablennamen geben, der beim Programmstart erstellt wird und nach Beendigung der Ausführung verloren geht.
- Der Speicher für diese Variablen wird zum Zeitpunkt des Ladens der Klasse nur einmal zugewiesen und kann von mehreren Objekten gemeinsam genutzt werden.
- Wenn sich die Objekte unterscheiden, werden die Änderungen, die am Wert der statischen Variablen in einem der Objekte vorgenommen wurden, in allen anderen Instanzvariablen wiedergegeben, in denen die in einem Objekt deklarierten Werte nicht in anderen Objekten wiedergegeben werden.
Beispiel:
import java.io.*;
class Students (
//static variable rollno
public static double rollno;
public static String name = "Lilly";
public static classnum;
)
public class StudentDetails (
public static void main(String args())
)
(
// no need of object to access static variables
Students .rollno= 101;
Students.classnum=3;
System.out.println(Students .name + "'s rollno is:" + Students .rollno + "and class number is:" + Students.classnum);
)
)
Ausgabe:
Lilly's rollno ist: 101 und die Klassennummer ist: 3
Fazit - Variablen in Java
Variablen bilden den elementaren Teil eines Java-Programms. Sie zeigen auf einen bestimmten Speicherort, wenn sie erstellt werden, und derselbe wird freigegeben, wenn das Objekt nicht mehr referenziert wird. Dieser Speicher, der freigegeben wird, wird gelöscht, wenn die Speicherbereinigung stattfindet. Dieser Prozess kann auch als Lebenszyklus einer Variablen betrachtet werden.
Empfohlene Artikel
Dies ist eine Anleitung zu Variablen in Java. Hier diskutieren wir die Typen zusammen mit der Initialisierung und Deklaration von Variablen. Sie können sich auch die folgenden Artikel ansehen, um mehr zu erfahren -
- While-Schleife in Java
- Sternchenmuster in Java
- Beste Java IDE
- Beste Java-Compiler
- Wie initialisiere ich Variablen in C #?
- Variablen in JavaScript
- Statisches Schlüsselwort in C