[Einführung in Java] Informationen zu Variablen und Typen (Variablendeklaration, Initialisierung, Datentyp)

Zweck

Für diejenigen, die gerade mit dem Programmieren einschließlich der Java-Sprache begonnen haben, und für diejenigen, die es bereits gelernt haben, zur Überprüfung Ich schreibe, um Variablendeklaration, Initialisierung und Datentypen zu lernen.

[Einführung in Java] Diesmal geht es ** um Variablen und Typen **.

・ Variablen und Typen ← Jetzt hier ・ Typkonvertierung ・ Umfang der Variablen

• String-Operation
• Vereinbarung ・ Operator ・ Bedingte Verzweigung (in Vorbereitung) ・ Verarbeitung wiederholen (in Vorbereitung) ・ Über den Unterricht (in Vorbereitung) ・ Abstrakter Unterricht (in Vorbereitung) ・ Schnittstelle (in Vorbereitung) ・ Einkapselung (in Vorbereitung) ・ Über das Modul (in Vorbereitung) ・ Informationen zur Ausnahmebehandlung ・ Informationen zum Lambda-Ausdruck ・ Informationen zur Stream-API

Variablendeklaration und -initialisierung

Was ist eine Variable? `Ein Container zum Speichern der im Programm verwendeten Daten. ``

Um es von anderen Variablen zu unterscheiden

In der Java-Sprache sollte beim Deklarieren von Variablen Folgendes beachtet werden:

・ Welche Werte werden gespeichert, z. B. Zahlen und Zeichenfolgen? ・ Welche Art von Namen soll ich verwenden? ・ Was ist der erste zu speichernde Wert?

Deklaration von Variablen

Datentyp Variablenname; Muss sein. (Der Datentyp wird später beschrieben)

Main.java

class Main {
  public static void main(String args[]) {
    //Deklaration von Variablen
    int num;

    //Ich erhalte eine Fehlermeldung, wenn ich versuche auszugeben
    System.out.println(num); // The local variable num may not have been initialized
  }
}

Dieser Fehler ist eine Variablendeklaration, aber nicht initialisiert. Tritt auf, weil Sie eine Variable verwendet haben, für die kein Wert festgelegt wurde.

Variable Initialisierung

Nach dem Erstellen des Datentypvariablennamens; Variablenname = Wert; Muss sein.

Main.java

class Main {
  public static void main(String args[]) {
    //Deklaration von Variablen
    int num;

    //Variable Initialisierung(Ersetzen Sie num durch 10)
    num = 10;

    //Ausgabe
    System.out.println(num); // 10
  }
}

1. Deklarieren Sie den Variablennamen "num"
2. Initialisieren Sie, indem Sie num durch 10 ersetzen. (Wert einstellen)
3. Ausgabe

Variablendeklaration und Initialisierung gleichzeitig

Datentyp Variablenname = Wert; Es ist auch möglich.

Main.java

class Main {
  public static void main(String args[]) {
    //Variablendeklaration und -initialisierung
    int num = 10;

    //Ausgabe
    System.out.println(num); // 10
  }
}

Regeln für Variablennamen

・ Als erstes Zeichen können nur die folgenden Zeichen verwendet werden. Alphabet (a ~ z, A ~ Z), Dollarzeichen ($), Unterstrich (_)

・ Nach dem zweiten Zeichen können Zahlen verwendet werden.

・ Der Fall wird streng unterschieden.

-Die Anzahl der Zeichen (Länge) ist unbegrenzt.

-Null, true, false kann nicht verwendet werden.

・ Reservierte Wörter können nicht verwendet werden.

Reservierte Wörter sind Namen, die bereits in der Java-Sprache verwendet werden. Beispiel: if, while, switch, etc.

Details zu reservierten Wörtern: Offizielles Dokument

Über den Typ

In Java mussten Sie beim Deklarieren einer Variablen den Datentyp angeben.

Die Datentypen sind grob wie folgt klassifiziert.

・ Basisdatentyp (primitiver Typ) ・ Referenztyp

Schauen wir uns jeden an.

Grunddatentyp (primitiver Typ)

Boolescher Typ

Main.java

class Main {
  public static void main(String args[]) {
    boolean a = true;
    boolean b = false;

    System.out.println(a); // true
    System.out.println(b); // false
  }
}

Ganzzahliger Typ

Wir haben es mit ganzzahligen Daten zu tun.

Main.java

System.out.println("Mindestwert des Bytes= " + Byte.MIN_VALUE); // Mindestwert des Bytes= -128
System.out.println("Maximaler Wert des Bytes= " + Byte.MAX_VALUE); // Maximaler Wert des Bytes= 127

System.out.println("Mindestwert von kurz= " + Short.MIN_VALUE); // Mindestwert von kurz= -32768
System.out.println("Maximalwert von kurz= " + Short.MAX_VALUE); // Maximalwert von kurz= 32767

System.out.println("Mindestwert von int= " + Integer.MIN_VALUE); // Mindestwert von int= -2147483648
System.out.println("Maximalwert von int= " + Integer.MAX_VALUE); // Maximalwert von int= 2147483647

System.out.println("Mindestwert von long= " + Long.MIN_VALUE); // Mindestwert von long= -9223372036854775808
System.out.println("Maximalwert von long= " + Long.MAX_VALUE); // Maximalwert von long= 9223372036854775807

Die Beziehung ist "Byte <kurz <int <lang".

Übrigens, wenn die Minimal- und Maximalwerte überschritten werden, werden die Werte invertiert. (Überlaufende Ziffern)

Main.java

System.out.println("Mindestwert des vorherigen Bytes= " + Byte.MIN_VALUE); //Mindestwert des Bytes= -128
byte minByte = Byte.MIN_VALUE;
minByte--;
System.out.println("Und der Mindestwert von Byte= " +  minByte); //Mindestwert des Bytes=127 ← invertiert

System.out.println("Maximalwert des vorherigen Bytes= " + Byte.MAX_VALUE); //Maximaler Wert des Bytes= 127
byte maxByte = Byte.MAX_VALUE;
maxByte++;
System.out.println("Und der Maximalwert von Byte= " + maxByte); //Maximaler Wert des Bytes= -128 ← invertiert

Es wird bei der Berechnung von ganzen Zahlen verwendet.

Main.java

int a = 1;
int b = 1;
int sum = a + b;

System.out.println(sum); // 3

Vorsichtsmaßnahmen bei Verwendung von Long Type

Wenn Sie eine Ganzzahl speichern, die den int-Typ in einer Variablen überschreitet, fügen Sie am Ende "L" oder "l" hinzu.

Main.java

//Ich bekomme eine Fehlermeldung
long longNumber = 214748364712342; // The literal 214748364712342 of type int is out of range

long longNumber = 214748364712342L; //Muss mit "L" oder "l" versehen werden.

System.out.println(longNumber); // 214748364712342

Gleitkomma-Typ

Wir haben es mit numerischen Daten einschließlich Dezimalstellen zu tun.

Main.java

System.out.println("Mindestwert von float= " + Float.MIN_VALUE); // Mindestwert von float= 1.4E-45
System.out.println("Maximaler Auftrieb= " + Float.MAX_VALUE); // Maximaler Auftrieb= 3.4028235E38

System.out.println("Mindestwert von double= " + Double.MIN_VALUE); // Mindestwert von double= 4.9E-324
System.out.println("Maximalwert von double= " + Double.MAX_VALUE); // Maximalwert von double= 1.7976931348623157E308

Es wird verwendet, wenn eine kleine Anzahl von Berechnungen durchgeführt wird.

Main.java

//int Typenteilung
int a = 10;
int b = 3;
int result1 = a / b;

System.out.println(result1); // 3

//Float-Typteilung

//Gleitkommazahlen werden standardmäßig als Doppeltyp erkannt
// float c = 10.0; // Type mismatch: cannot convert from double to float

float c = 10F; //Fügen Sie daher beim Zuweisen zu einer Variablen vom Typ float am Ende F oder f hinzu.
float d = 3f; //Das gleiche wie oben
float result2 = c / d;

System.out.println(result2); // 3.3333333

//Doppelte Typteilung
double e = 10.0D; //Fügen Sie am Ende D oder d hinzu
double f = 3.0; //Wie oben erwähnt, wird es jedoch standardmäßig als Dobule-Typ erkannt, sodass es kein Problem gibt, wenn Sie es weglassen.
double result3 = e / f;

System.out.println(result3); // 3.3333333333333335

char type

Es wird verwendet, um ein Zeichen darzustellen.

Es wird verwendet, um ein Zeichen zu behandeln.

Vorsichtsmaßnahmen bei der Verwendung des Zeichentyps

In einfache Anführungszeichen setzen. Es muss ein Buchstabe sein.

Main.java

//Ich bekomme eine Fehlermeldung
char a = 'Ah'; // Invalid character constant
char a = "Ah";  // Type mismatch: cannot convert from String to char

char a = 'Ah';
System.out.println(a); //Ah

Referenztyp

Alle Typen außer grundlegenden Datentypen, einschließlich Klassen, Arrays, Schnittstellen usw., sind Referenztypen.

Die Variable enthält nicht den Wert selbst, sondern den Ort, an dem sich der Wert befindet. Referenztyp, da er sich auf den Speicherort bezieht.

Test.java

public class Test {
  public int number = 0;
}

Main.java

class Main {
  public static void main(String args[]) {
    Test test = new Test();
    test.number = 10;
    System.out.println(test.number); // 10

    Test test2 = new Test();
    test2.number = 10;
    System.out.println(test2.number); // 10

    test = test2; //Der Wert von test2 wird nicht test zugewiesen, sondern der Ort, an dem der Wert von test2 platziert wird.
    test.number = 99; //Wenn Sie hier den Test auf 99 ändern, wird er daher in test2 geändert.

    System.out.println(test.number); // 99
    System.out.println(test2.number); // 99

  }
}

test = test2; Der Wert von test2 wird nicht test zugewiesen, sondern der Ort, an dem der Wert von test2 platziert wird.

test.number = 99; Wenn Sie den Test auf 99 ändern, wird er daher in test2 geändert.

Wrapper-Klasse

Ein Wert des Basisdatentyps kann als Referenztyp behandelt werden.

Obwohl es sich um einen Referenztyp handelt, entspricht er dem Basisdatentyp und sein Wert wird nicht geändert. Der Wert selbst wird zugewiesen, nicht der Ort, an dem der Wert platziert wird.

Main.java

class Main {
  public static void main(String args[]) {
    Integer num = 10;
    Integer num2 = 10;
    System.out.println(num); // 10
    System.out.println(num2); // 10

    num = num2;
    num = 99;
    System.out.println(num); // 99
    System.out.println(num2); // 10

    String greet = "Guten Morgen";
    String greet2 = "Hallo";
    System.out.println(greet); //Guten Morgen
    System.out.println(greet2); //Hallo

    greet = greet2;
    greet = "Good Morning";
    System.out.println(greet); // Good Morning
    System.out.println(greet2); //Hallo
  }
}

Am Ende

Sie haben Informationen zu Variablendeklaration, Initialisierung und Datentypen erhalten. Nächstes Mal werde ich mich mit [Typkonvertierung] befassen (https://qiita.com/morioheisei/items/28ab5fd69570e01cd317).