Java Primer Series (Typkonvertierung)

Einführung

Hallo. Dieser Artikel ist ein zusammenfassender Artikel über die Typkonvertierung für "Personen, die von nun an Java starten" und "Personen, die nach langer Zeit nach Java wechseln".

Es erklärt nicht die Programmierung selbst, wie z. B. welche Variablen es sind, daher ist es möglicherweise nicht für Anfänger geeignet.

Anweisungen zum Deklarieren von Java-Variablen und ihren Typen finden Sie im vorherigen Kapitel (https://qiita.com/aoyaman/items/3922c25589dc6084451a).

Die folgenden Artikel werden als einführende Java-Reihe vorbereitet.

• Variationen und Typen --Typkonvertierung ← Jetzt hier
• Variabler Umfang (in Vorbereitung)
• Zeichenfolgenoperation (in Vorbereitung) --Array-Betrieb (in Vorbereitung) --Operator (in Vorbereitung)
• Bedingter Zweig (in Vorbereitung)
• Wiederholen Sie die Verarbeitung (in Vorbereitung)
• Über die Klasse (in Vorbereitung)
• Abstrakte Klasse (in Vorbereitung)
• Schnittstelle (in Vorbereitung)
• Einkapselung (in Vorbereitung)
• Über das Modul (in Vorbereitung)

Was ist Typkonvertierung?

Sie müssen den Typ angeben, wenn Sie die Variable deklarieren. Es gibt verschiedene Fälle, in denen der Wert dieser Variablen in einen anderen Typ konvertiert wird.

Wenn der int-Typ vier Variablenregeln unterworfen ist Manchmal möchten Sie in einen langen Typ konvertieren, manchmal möchten Sie in einen doppelten Typ konvertieren.

Manchmal möchten Sie einem Zeichenfolgentyp einen numerischen Typ hinzufügen, um ihn auf dem Bildschirm anzuzeigen Es gibt verschiedene Dinge.

Der Begriff wird auch als Umwandlung des Gusstyps bezeichnet.

Die Möglichkeit, eine Typkonvertierung (Umwandlung) anzugeben, besteht darin, den Typnamen in () einzuschließen.

int a = 5;
double b = (int)a;

Darüber hinaus wird eine Typkonvertierung namens Heraufstufung durchgeführt, wenn vier Regeloperationen ausgeführt werden. (Siehe unten)

Konvertierung des Basistyps (primitiver Typ)

Konvertierung vom Bytetyp in den Int-Typ und den Long-Typ Konvertierung vom Typ int in long type usw.

Der Wert geht beim Konvertieren von klein nach groß nicht verloren.

class Main {
  public static void main(String[] args) {
    byte a = 127;
    byte b = -128;
    int c = (int)a;
    int d = (int)b;
    System.out.println(c); // ->"127" wird ausgegeben
    System.out.println(d); // -> 「-128 "wird ausgegeben

    int e = 2147483647;
    int f = -2147483648;
    long g = (long)e;
    long h = (long)f;
    System.out.println(g); // ->"2147483647" wird ausgegeben
    System.out.println(h); // -> 「-2147483648 "wird ausgegeben
  }
}

Umgekehrt geht beim Konvertieren von einer großen in eine kleine Größe der ** Wert ** verloren.

Wie es verloren geht, gehen die höheren Bits in Biteinheiten verloren. Im folgenden Beispiel wird es zum leichteren Verständnis hexadezimal ausgedrückt.

class Main {
  public static void main(String[] args) {
    int a = 0x12345;
    byte b = (byte)a;
    short c = (short)a;
    System.out.printf("0x%05x\n", a); // ->"0x12345" wird ausgegeben
    System.out.printf("0x%05x\n", b); // ->"0x00045" wird ausgegeben
    System.out.printf("0x%05x\n", c); // ->"0x02345" wird ausgegeben
  }
}

Für die Typkonvertierung zwischen Dezimaltyp wie float und double und Integer-Typ wie int und long Es ist ziemlich kompliziert, deshalb werde ich es in diesem Artikel weglassen (Einführungsstufe).

Konvertierung des Referenztyps (Klassentyp)

Wenn Klasse A Klasse B erbt Sie können von A nach B und von B nach A konvertieren.

public class OyaClass {
  public void print() {
    System.out.println("I am OyaClass! ");
  }
}

public class ChildClass extends OyaClass {
  private String moji;
  public ChildClass(String moji) {
    this.moji = moji;
  }
  public void print() {
    System.out.println("I am ChildClass! " + moji);
  }
}

class Main {
  public static void main(String[] args) {
    ChildClass cc = new ChildClass("Yes! Yes!");
    cc.print(); // -> 「I am ChildClass! Yes! Yes!Wird ausgegeben

    OyaClass oc = cc;
    oc.print(); // -> 「I am ChildClass! Yes! Yes!Wird ausgegeben

    ChildClass cc2 = (ChildClass)oc;
    cc2.print(); // -> 「I am ChildClass! Yes! Yes!Wird ausgegeben

    OyaClass oc2 = new OyaClass();
    oc2.print(); // -> 「I am OyaClass!Wird ausgegeben

    ChildClass cc3 = (ChildClass)oc2; // ->Eine Ausnahme tritt auf.
    cc3.print();
  }
}

Selbst wenn Sie den Typ der Variablen wie oben beschrieben ändern, wird die Entität (Instanz) von new erstellt. Beim Versuch, eine als letzte übergeordnete Klasse erstellte Entität in eine untergeordnete Klasse zu konvertieren Ich bekomme eine Ausnahme.

Exception in thread "main" java.lang.ClassCastException:
class OyaClass cannot be cast to class ChildClass
(OyaClass and ChildClass are in unnamed module of loader 'app')
 at Main.main(Main.java:15)

Die Typkonvertierung des Referenztyps (Klassentyp) wird in diesem Kapitel weiter weggelassen. Weitere Informationen finden Sie in den Kapiteln "Abstrakte Klassen" und "Schnittstellen".

Konvertierung in einen String

Alle Typen, einschließlich null, können in einen String-Typ konvertiert werden. Es wird in eine Zeichenfolge konvertiert, indem es mit einer Zeichenfolge mit dem Operator + verbunden wird.

class Main {
  public static void main(String[] args) {
    int a = -100;
    double b = 123.456;
    Integer c = null;
    int d = 100;

    String sa = "" + a;
    String sb = "" + b;
    String sc = "" + c;
    String sad = "" + a + d;
    String sad2 = "" + (a + d);
    System.out.println(sa);   // -> 「-100 "wird ausgegeben
    System.out.println(sb);   // -> 「123.456 "wird ausgegeben
    System.out.println(sc);   // ->"Null" wird ausgegeben
    System.out.println(sad);  // -> 「-"100100" wird ausgegeben
    System.out.println(sad2); // ->"0" wird ausgegeben
  }
}

Konvertierung, die einen Fehler verursacht

• Konvertierung vom Basistyp zum Referenztyp (ohne Konvertierung von Zeichenfolgen) --Umwandlung vom Referenztyp zum Basistyp

Konvertierungen wie führen zu einem Fehler.

Promotion (Promotion)

Wenn Variablen vom Typ wie Byte, Short, Char vier Regeln unterliegen (Addition, Subtraktion, Multiplikation und Division) Nach der Konvertierung in den Typ int unterliegt es vier Regeln (Addition, Subtraktion, Multiplikation und Division).

Dies "nach der Konvertierung in den Typ int" wird als Promotion bezeichnet.

Wie unten beschrieben, Nicht nur beim Multiplizieren von Variablen vom Typ int und vom Typ Byte Es wird auch in den Typ int konvertiert, wenn die Variablen Bytetyp und Bytetyp multipliziert werden. Der Bytetyp kann nur Werte von -128 bis 127 eingeben, aber Werte, die diese Werte überschreiten, werden ausgegeben.

class Main {
  public static void main(String[] args) {
    int a = 40;
    byte b = 30;
    byte c = 20;

    System.out.println(b*a); // ->"1200" wird ausgegeben
    System.out.println(b*c); // ->"600" wird ausgegeben
  }
}

Was passiert also, wenn Sie am Ende des obigen Programms die folgende Zeile einfügen?

class Main {
  public static void main(String[] args) {
    int a = 40;
    byte b = 30;
    byte c = 20;

    System.out.println(b*a); // ->"1200" wird ausgegeben
    System.out.println(b*c); // ->"600" wird ausgegeben
    byte d = b * c;
  }
}

Dies führt zu einem Kompilierungsfehler. Es ist ein Beweis dafür, dass "b * c" in den Typ int konvertiert wird.

abschließend

Das Obige ist die Erklärung der Typkonvertierung, aber wie war es?

Wenn Sie gerade erst anfangen, Java zu lernen, denke ich wahrscheinlich, dass es nur "Hey" sein wird. Während Sie Java programmieren, werden Sie definitiv auf eine Typkonvertierung stoßen Ich hoffe, Sie werden sich zu diesem Zeitpunkt daran erinnern.

Ende.