Grundlegende Datentypen
Variablen sind Speicherorte, die für das Speichern von Werten reserviert sind. Dies bedeutet, dass beim Erstellen einer Variablen ein bestimmter Speicherplatz im Speicher eingeladen wird.
Basierend auf dem Datentyp der Variablen führt das Betriebssystem Speicherzuweisung und entscheidet, was im reservierten Speicher gespeichert wird. Indem Sie Variablen unterschiedliche Datentypen zuweisen, können Sie Ganzzahlen, Dezimalstellen oder Buchstaben in diesen Variablen speichern.
In Java gibt es zwei effiziente Datentypen:
Originaldatentyp
Java unterstützt 8 primitive Datentypen. Der ursprüngliche Datentyp wird durch die Sprache vordefiniert und mit Schlüsselwörtern benannt. Erfahren wir unten mehr über diese 8 Datentypen.
Byte Typ (Byte)
Byte-Typ ist eine 8-Bit-binäre Ganzzahl mit positivem und negativem Minimalwert-128 (-2^7)
Der Maximalwert beträgt 127 (2^7-1)
Der Standardwert ist 0
Byte -Datentypen werden hauptsächlich zum Speichern von Platz in großen Arrays verwendet und hauptsächlich zum Ersetzen von Ganzzahlen verwendet. Weil der Byte -Typ 4 -mal kleiner ist als Ganzzahlen.
Zum Beispiel:
Byte A = 100, Byte B = -50
Kurze Ganzzahl (kurz)
Kurze Ganzzahl ist eine 16-Bit-binäre Ganzzahl mit positivem und negativem Mindestwert-32768 (-2^15)
Der Maximalwert beträgt 32767 (2^15-1)
Kurzbezahlte Typdaten können auch verwendet werden, um Platz wie Byte -Typen zu sparen. Kurze Ganzzahlen sind zweimal kleiner als Ganzzahlen. Der Standardwert ist 0.
Zum Beispiel:
kurz S = 10000, kurz R = -20000
Int type (int)
Ganzzahltyp ist eine 32-Bit-binäre Ganzzahl mit positivem und negativem Mindestwert beträgt-2,147.483.648 (-2^31).
Der Maximalwert beträgt 2.147.483.647 (2^31 -1)
Ganzzahltypen werden im Allgemeinen standardmäßig auf ganzzahlige Werte angewendet, es sei denn, Sie sind besorgt über den unzureichenden Speicher.
Der Standardwert ist 0
Zum Beispiel:
int a = 100000, int b = -200000
Langer Typ (lang)
Long Ganzzahl ist eine 64-Bit-binäre Ganzzahl mit positivem und negativem Mindestwert-9.223.372.036.854.775.808 (-2^63)
Der Maximalwert beträgt 9.223.372.036.854.775.807 (2^63 -1)
Dieser Datentyp wird im Allgemeinen angewendet, wenn ein größerer Bereich als ein ganzzahliger Typ erforderlich ist.
Der Standardwert beträgt 0L
Zum Beispiel:
lang a = 100000l, int b = -200000l
Schweben
Gleitkomma-Daten sind eine einzelne Precision 32-Bit IEEE 754 Standard-Gleitkomma-Daten.
Schwimmpunktdaten werden hauptsächlich zum Speichern von Speicher in großen digitalen Arrays des schwebenden Punktes verwendet.
Der Standardwert beträgt 0,0F.
Schwimmpunktdaten können nicht für präzise Daten wie Währung verwendet werden.
Zum Beispiel:
float f1 = 234,5f
Doppeler Präzisionstyp (doppelt)
Doppel-Präzisionsdaten sind eine doppelte Präzision 64-Bit-IEEE 754 Standard-Schwimmpunktdaten.
Dieser Datentyp wird hauptsächlich standardmäßig verwendet, um den Wert der Dezimalzahl darzustellen, und ist im Allgemeinen die Standardauswahl.
Daten mit doppelter Präzision können nicht für präzise Daten wie Währung verwendet werden.
Der Standardwert beträgt 0,0D
Zum Beispiel:
Doppel D1 = 123,4
Boolean
Boolesche Daten stellen ein Informationsbit dar.
Es hat nur zwei mögliche Werte: wahr (wahr) und falsch (falsch)
Dieser Datentyp wird für einfache Tags unter realen oder falschen Bedingungen verwendet.
Der Standardwert ist falsch (falsch)
Zum Beispiel:
boolean One = true
Charaktertyp (char)
Charakterdaten sind einfache 16-Bit-Unicode-Standardzeichen.
Der Mindestwert lautet: '/u0000' (oder 0).
Der Maximalwert lautet: '/Uffffff' (oder 65.535).
Zeichendaten können verwendet werden, um jeden Buchstaben zu speichern.
Zum Beispiel: Zeichenbuchstaben a (Zeichenbuchstaben a) = 'a'
Referenzdatentyp
Der Referenzdatentyp wird vom Editor der Klasse definiert. Sie werden verwendet, um auf Objekte zuzugreifen. Diese Variablen sind als spezifische Typen definiert, die nicht veränderbar sind. Zum Beispiel: Mitarbeiter, Welpen usw.
Klassenobjekte und Array -Variablen sind diese Art von Referenzdatentyp.
Der Standardwert für einen referenzierten Datentyp ist leer.
Für jedes Objekt, das deklariert und kompatible Typen deklariert, kann ein Referenzdatentyp verwendet werden.
Zum Beispiel:
Tiertier = neues Tier ("Giraffe"); Java -Konstanten
Konstanten sind Quellcode, die feste Werte darstellen. Sie werden direkt in Codeform ohne Schätzungen dargestellt.
Konstanten können jedem ursprünglichen variablen Typ zugewiesen werden. Zum Beispiel:
Byte a = 68; char a = 'a' '
Byte, Ganzzahl, lang und kurz können auch durch Dezimal-, Hexadezimal- und Oktalzählsysteme dargestellt werden.
Wenn diese technischen Systeme direkte Mengen darstellen, soll das Präfix 0 Oktal angeben, und das Präfix 0x soll hexadezimal angezeigt werden. Zum Beispiel:
int decimal = 100; int Octal = 0144; int hexa = 0x64;
Die Bestimmungen von Stringkonstanten in Java sollten wie die meisten anderen Sprachen auch in der Mitte des Doppelzitats geschrieben werden. Beispiele für die direkte Menge vom String-Typ sind wie folgt:
"Hallo Welt" "Two/nLines" "/" das ist in Zitate/""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
Zeichen- und Stringkonstanten können alle Unicode -Buchstaben enthalten. Zum Beispiel:
char a = '/u0001'; String a = "/u0001";
Die Java -Sprache unterstützt auch spezielle Fluchtsequenzen von Zeichen und Zeichenfolgen direkt. Sie sind:
| Flucht Charaktere | Bedeutung |
|---|---|
| /N | Zeilenpause (0x0a) |
| /R | Geben Sie (0x0d) ein |
| /F | Seitenwechsel (0x0c) |
| /B | Rückraum (0x08) |
| /S | Raum (0x20) |
| /T | Tab |
| /" | Doppelzitate |
| /' | Einzelne Zitate |
| / | Backslash |
| /ddd | Oktalzeichen (DDD) |
| /uxxxxx | Hexadezimale Unicode -Zeichen (xxxx) |
Bevor Sie es verwenden, müssen Sie jetzt die Variable deklarieren, die Sie verwenden möchten. Das Grundformat der Deklaration von Variablen lautet wie folgt:
Datentypvariable [= value] [, variable [= value] ...];
Der Datentyp hier ist ein Datentyp in Java, und Variable ist der Name einer Variablen. Um mehr als einen spezifischen variablen Typ zu deklarieren, können Sie mit Kommas es trennen.
Im Folgenden finden Sie Beispiele für gültige variable Erklärungen und Zuordnungen in Java:
int a, b, c; // deklariert drei INTs, a, b und C. in A = 10, B = 10; // Beispiel für InitializationByte B = 22; // Initialisiert eine Byte -Typ -Variable B.Double pi = 3.14159; // deklariert und weist einen Wert von pi.char a = 'a' zu; // Die char Variable a IIS mit Wert 'a' initialisiert
In Java gibt es drei Variablen:
Lokale Variablen
Beispiel
Hier ist Alter (Alter) eine lokale Variable. Dies ist unter der Methode pupage () definiert, und sein Umfang ist auf diese Methode beschränkt.
public class test {public void pupage () {int age = 0; Alter = Alter + 7; System.out.println ("Welpenalter ist:" + Alter); } public static void main (String args []) {Test test = new Test (); test.pupage (); }}Der obige Code gibt die folgenden Ergebnisse aus:
Welpenalter ist: 7
Beispiel Das folgende Beispiel verwendet das lokale variable Alter, wird jedoch nicht initialisiert, sodass beim Bearbeiten ein Fehler angezeigt wird.
public class test {public void pupage () {int age; Alter = Alter + 7; System.out.println ("Welpenalter ist:" + Alter); } public static void main (String args []) {Test test = new Test (); test.pupage (); }}Der folgende Fehler wird während der Bearbeitung generiert:
Test.java:4:Variable -Zahl wurde möglicherweise nicht initialisiert = Alter + 7;^1 Fehler
Instanzvariablen
Beispiel
Importieren Sie Java.io.*; Mitarbeiter der öffentlichen Klasse {// Diese Instanzvariable ist für jede Kinderklasse sichtbar. öffentlicher String -Name; // Gehaltsvariable ist nur in der Mitarbeiterklasse sichtbar. privates Doppelgehalt; // Die Namensvariable wird im Konstruktor zugewiesen. öffentlicher Mitarbeiter (String EMPNAME) {name = Empname; } // Der Gehaltsvariable wird ein Wert zugewiesen. public void setSalary (Double Empsal) {Gehalt = Empsal; } // Diese Methode druckt die Mitarbeiterdetails. public void printEmp () {System.out.println ("Name:" + Name); System.out.println ("Gehalt:" + Gehalt); } public static void main (String args []) {Mitarbeiter Empone = New Employee ("Ransika"); Empone.SetSalary (1000); empone.printemp (); }}Der obige Code gibt die folgenden Ergebnisse aus:
Name: Ransikasalary: 1000.0
Klasse, statische Variablen
Beispiel
Java.io importieren. // Abteilung ist eine konstante öffentliche statische endgültige String -Abteilung = "Entwicklung"; public static void main (String args []) {Gehalt = 1000; System.out.println (Abteilung+"Durchschnittsgehalt:"+Gehalt); }}Der obige Code gibt die folgenden Ergebnisse aus:
Entwicklungsdurchschnittsgehalt: 1000
Hinweis: Wenn auf eine Variable von außerhalb der Klasse zugegriffen wird, muss die Konstante als Mitarbeiterabteilung zugegriffen werden.