java variables their types with examples
In diesem Tutorial werden Java-Variablen, Variablentypen, Java-Instanzen, Umfang und Lebensdauer einer Variablen anhand von Beispielen untersucht:
Wir werden auch einige häufig gestellte Fragen sehen, die Ihnen helfen, das Thema besser zu verstehen.
Nachdem Sie dieses Lernprogramm durchgearbeitet haben, erhalten Sie Einblicke in die Java-Variablen, lokalen und globalen Variablen, die Instanzvariable und andere Unterthemen, die sich auf Java-Variablen beziehen.
=> Überprüfen Sie ALLE Java-Tutorials hier.
Was du lernen wirst:
Java-Variablen
Wie wir wissen, ist eine Java-Variable eine Speichereinheit in einem Java-Programm. Eine Java-Variable ist eine Kombination aus 'Typ', 'Bezeichner', 'Bezeichnerwert'. Das Deklarieren einer Variablen erfordert 'Typ' und 'Bezeichner'.
Wenn Sie jedoch den Wert einer Variablen nach dem Deklarieren der Variablen angeben, wird dieser Prozess als Initialisierung einer Variablen bezeichnet.
Syntax:
type identifier [ = value][, identifier [= value] ...]
Beispiele
// declaring three variables a, b and c. int a, b, c; // initializing variables a and c. int a = 10, b, c = 5;
Dynamische Initialisierung
Hier sehen wir die dynamische Initialisierung einer Variablen. Wir werden die Diskriminante der quadratischen Gleichung der Mathematik berechnen.
Die mathematische Formel zur Berechnung der Diskriminante lautet b²-4ac für die Gleichung ax² + bx + c
Wir müssen lediglich die Diskriminante mithilfe der dynamischen Initialisierung berechnen.
public class DynamicInitialization { public static void main(String[] args) { int a = 1, b = 2, c = 3; /* * d is dynamically initialized which will be the * discriminant of the quadratic equation */ double d = b*b -4*a*c; System.out.println('Discriminant is: ' + d); } }
Ausgabe
Umfang und Lebensdauer von Variablen
In diesem Abschnitt werden der Umfang und die Lebensdauer einer Java-Variablen erläutert. Hier nehmen wir eine Variable 'a', die dem gesamten Programm bekannt ist, und demonstrieren dann den Wert dieser Variablen, der für einen Block innerhalb des Programms spezifisch ist.
Wie rufe ich eine Methode mit einem Array von Objekten in Java auf?
Wieder werden wir eine weitere Variable 'b' in einem Block erstellen, die vom Wert von 'a' abhängt. Sobald der Geltungsbereich endet, endet auch der Geltungsbereich der Variablen 'b', während 'a' dem Programm noch bekannt ist.
class VariableScope { public static void main(String args[]) { // a is known to entire program int a; a = 15; // starting new scope known only to this block if (a == 15) { int b = 20; // a and b both known here. System.out.println('a and b: ' + a + ' ' + b); a = b / 2; } /* b is unknown here which means * if we print b, it will throw an error * whereas a is still known */ System.out.println('a is ' + a); } }
Ausgabe
Java-Variablentypen
In diesem Abschnitt lernen wir die verschiedenen Arten von Java-Variablen kennen, die unten erwähnt werden.
- Lokale Variable
- Instanzvariable
- Statische oder Klassenvariable
Lokale Variablen
Diese Variablen werden im Hauptteil einer Methode deklariert. Diese können innerhalb derselben Methode verwendet werden, bei der sie initialisiert werden.
Einige der Eigenschaften einer lokalen Variablen umfassen:
- Lokale Variablen werden in einer Methode, einem Konstruktor oder einem Block deklariert.
- Keine Zugriffsmodifikatoren für lokale Variablen.
- Diese können nur innerhalb desselben Blocks, derselben Methode oder desselben Konstruktors verwendet werden, in dem sie initialisiert wurden.
- Kein Standardwert, nachdem Sie Ihre lokale Variable deklariert haben. Sie müssen Ihre deklarierte lokale Variable initialisieren.
- Es kann nicht durch ein statisches Schlüsselwort definiert werden.
Im Folgenden ist das Programm angegeben, in dem lokale Variablen verwendet wurden, die innerhalb einer Methode einer Klasse initialisiert wurden. Da „height“ eine lokale Variable ist, die mit der berechne () -Methode initialisiert wurde, wird der Umfang dieser Variablen auf die Methode beschränkt.
public class local { public void calculate() { // initialized a local variable 'height' int height = 0; // incrementing the value of height height = height + 170; System.out.println('height is: ' + height + ' cm'); } public static void main(String args[]) { // a is a reference used to call calculate() method local a = new local(); a.calculate(); } }
Ausgabe
Instanzvariablen
Instanzvariablen sind diejenigen Variablen, die innerhalb einer Klasse deklariert werden. Im Gegensatz zu lokalen Variablen können diese Variablen nicht innerhalb eines Blocks, einer Methode oder eines Konstruktors deklariert werden.
Nachfolgend sind die Eigenschaften der Instanzvariablen aufgeführt:
- Sie werden innerhalb einer Klasse, jedoch außerhalb eines Blocks, einer Methode oder eines Konstruktors deklariert.
- Es kann nicht durch ein statisches Schlüsselwort definiert werden.
- Im Gegensatz zu lokalen Variablen haben diese Variablen einen Standardwert.
- Der Integer-Typ hat den Standardwert '0' und der Boolesche Typ hat den Standardwert 'false'.
- Im Gegensatz zu lokalen Variablen haben wir Zugriffsmodifikatoren für Instanzvariablen.
Im Folgenden finden Sie das Programm, in dem wir die Instanzvariable demonstriert haben. Wir haben Variablen außerhalb der Hauptmethode deklariert und ihnen dann die Werte zugewiesen, indem wir Objekte verwendet haben, bei denen eine Variable die „Nummer“ nicht zugewiesen hat.
Schließlich haben wir die Werte dieser Instanzvariablen gedruckt und die nicht zugewiesene Variable 'number' hat standardmäßig '0' gedruckt.
public class instance { // Declaring instance variables public int rollNum; public String name; public int totalMarks; public int number; public static void main(String[] args) { // created object instance in = new instance(); in.rollNum = 95; in.name = 'Saket'; in.totalMarks = 480; // printing the created objects System.out.println(in.rollNum); System.out.println(in.name); System.out.println(in.totalMarks); /* * we did not assign the value to number so it * will print '0' by default */ System.out.println(in.number); } }
Ausgabe
Statische oder Klassenvariable
Im Gegensatz zur Variablen Local und Instance (bei der keine statische Variable verwendet werden kann) haben wir einen anderen Variablentyp, der als statisch deklariert ist und als 'statische Variable oder Klassenvariable' bezeichnet wird.
Im Folgenden sind einige der Eigenschaften der Variablen 'Statisch' oder 'Klasse' aufgeführt:
- Diese Variablen können nicht lokal sein.
- Statische Variablen werden von allen Instanzen einer Klasse gemeinsam genutzt.
- Die Standardwerte für statische / Klassenvariablen sind dieselben wie für die Instanzvariablen.
- Statische Variablen können innerhalb eines Programms durch Aufrufen von className.variableName verwendet werden
- Der zum Speichern statischer Variablen zugewiesene Speicher ist der statische Speicher.
Im folgenden Programm berechnen wir den Umfang eines Kreises unter Verwendung eines privaten variablen Radius und eines konstanten pi. Beide Variablen werden als statisch deklariert.
public class StaticVariable { // radius is declared as private static private static int radius; // pi is a constant of type double declared as static private static final double pi = 3.14; public static void main(String[] args) { // assigning value of radius radius = 3; // calculating and printing circumference System.out.println('Circumference of a circle is: ' + 2*pi*radius); } }
Ausgabe
Java-Instanz von
Die Java-Instanz von ist ein Operator, mit dem festgestellt wird, ob das erstellte Objekt eine Instanz des Typs ist oder nicht. Typ kann eine Klasse oder eine Schnittstelle sein.
Der Rückgabetyp ist Boolesch, d. H. Entweder 'wahr' oder 'falsch'.
Zum Beispiel, Im folgenden Programm haben wir eine Referenzvariable a1 vom Typ A erstellt und versucht herauszufinden, ob a1 eine Instanz von A ist oder nicht. Da a1 eine Instanz von A ist, hat es 'true' zurückgegeben.
class A { public static void main(String args[]) { A a1 = new A(); System.out.println(a1 instanceof A); } }
Ausgabe
Häufig gestellte Fragen
F # 1) Was sind globale Java-Variablen?
Antworten: Globale Variablen sind die Variablen, auf die das gesamte Programm zugreift und die zu Beginn des Programms deklariert werden.
Globale Variablen gehören nicht zu Java, da Java eine reine objektorientierte Programmiersprache ist und alles zur Java-Klasse gehört. Nur um Daten und Mitglieder (Variablen) der Klasse zu schützen, unterstützt Java keine globalen Variablen.
Wir haben jedoch statische Variablen, die global deklariert sind und auf die alle Methoden und Unterklassen eines Programms zugreifen können.
F # 2) Wie lösche ich den Wert einer Variablen in Java?
Antworten: Dies kann mit einer in Java integrierten Methode erfolgen, die java.DoubleAdder.reset () ist.
Die Syntax dieser Methode lautet
Public void reset();
Diese Methode gehört zum Paket 'java.util.concurrent.atomic.DoubleAdder'. Sie müssen dieses Paket also importieren, bevor Sie fortfahren können.
Im folgenden Programm haben wir DoubleAdder einige Elemente hinzugefügt und dann versucht, es zurückzusetzen, und schließlich den Wert nach dem Zurücksetzen gedruckt.
import java.util.concurrent.atomic.DoubleAdder; public class clearValue { public static void main(String[] args) { DoubleAdder a = new DoubleAdder(); // adding elements into DoubleAdder a.add(99); a.add(83); a.add(75); a.add(105); //Printing the value of 'a' System.out.println('Value after adding elements: ' +a); // resetting the value of a a.reset(); // Printing the value of 'a' after reset System.out.println('Value after resetting: ' + a); } }
Ausgabe
# 3) Wie überprüfe ich den folgenden Variablentyp in Java?
String a = 'Test';
Antworten: Wenn die Variable vom Typ String ist, können Sie referenceVariable.getClass (). GetName () verwenden.
class A { public static void main(String args[]) { String a = 'test'; System.out.println(a.getClass().getName()); } }
Ausgabe
# 4) Wie aktualisiere ich eine Variable in Java?
Antworten: Im Folgenden finden Sie ein einfaches Programm, in dem wir eine Variable in Java aktualisiert haben.
public class updateVariable { public static void main(String[] args) { int a = 10; System.out.println(a); a = 20; System.out.println(a);}}
Ausgabe
Fazit
In diesem Lernprogramm haben wir Java-Variablen erläutert und einen Einblick in die dynamische Initialisierung, den Umfang und die Lebensdauer einer Variablen sowie die Erläuterung der verschiedenen Java-Variablentypen und der Java-Instanz des Operators gegeben.
Jedes Hauptkonzept wurde anhand geeigneter Programmierbeispiele erläutert, damit Sie das Thema besser verstehen.
Empfohlene Lektüre = >> VBA-Variablen und Option explizit
Gegen Ende haben wir auch einige häufig gestellte Fragen gesehen, die Sie über die verschiedenen Fragen informieren, die während Java-Interviews gestellt werden könnten.
=> Sehen Sie sich hier die einfache Java-Schulungsreihe an.
Literatur-Empfehlungen
- JMeter-Variablen und -Funktionen
- In VBA explizite VBA-Variablen und -Optionen
- VBScript-Variablen: Deklarieren und Verwenden von Variablen - VBScript Dim
- PL SQL-Datentypen, Variablen, Konstanten und Literale
- Arbeiten mit Unix-Variablen: Funktionen von Shell Scripting
- Variablen in C ++
- Python-Variablen
- JAVA-Tutorial für Anfänger: Über 100 praktische Java-Video-Tutorials