Beispiel-Tutorial zu Operatoren und Typkonvertierung in Java

Typkonvertierung:

Sortieren von klein nach groß, automatische Typkonvertierung (implizite Konvertierung)
Wenn ein kleiner Datentyp mit einem großen Datentyp bearbeitet wird, wird das Ergebnis automatisch in den großen konvertiert type
byte char short -->int -->long -->float -->double
Hinweis: Byte char short werden nicht ineinander konvertiert. Sie nehmen an Operationen teil und werden zuerst konvertiert in int-Typ

Format: Datentypvariable mit großem Bereich = Datentypwert mit kleinem Bereich

Erzwungene Typkonvertierung (Anzeigekonvertierung)
Große Datentypen können sein konvertiert, wenn der Präzisionsverlust toleriert werden kann. Konvertierung in kleine Datentypen
erzwingen. Format: Datentyp für kleine Bereiche. Variable = (Datentyp für kleine Bereiche) Datentyp für große Bereiche

. Konzept des Operators:

Für Konstanten Die Symbole, die mit Variablen arbeiten, werden Operatoren genannt

Das Konzept des Ausdrucks:

Die Verwendung von Operatoren zum Verbinden von Konstanten und einer Formel, die der Java-Syntax entspricht, kann als Ausdruck

Häufig verwendete Operatoren: arithmetische Operatoren, Zuweisungsoperatoren, relationale Operatoren, logische Operatoren, ternäre Operatoren

arithmetische Operatoren: + - * / % ++ --
in Java Das Ergebnis Der Divisionsvorgang zwischen zwei Daten vom Typ int ist ebenfalls ein int. Den Dezimalpunkt direkt abschneiden

Codedemonstration:

public static void main(String[] args) {

　int a = 10;
int b = 20;

System.out.println(a + b);
System.out.println(a * b); // 200
System.out.println(a / b); 0,5
System.out.println(1/3);//0
System.out.println(2/3);//0
System.out.println("===== == ===================");
// Wenn + zwischen einer Zeichenfolge und einer Zahl verwendet wird, zeigt es einen Link und letztendlich eine neue Zeichenfolge an wird erhalten
int d = 10;
　System.out.println("Heyhey"+10);//Heyhey 10
　System.out.println("Heyhey"+10+10);// Heyhey 1010
System.out.println("Heyhey"+(10+10));//Heyhey 20
System.out.println(10+10+"Heyhey");//20Heyhey

System .out.println("==========================");
System.out.println(10 %3); // Den Rest finden (modulo)
　System.out.println(7%2);// 1
　System.out.println("========== === =========");
​ // 'a' ---> 97 'b'---> 98
​ // 'A' -- -> 65
 // '0'---> 48
 System.out.println('a' + 10);// 107
 System.out.println(' A' + 10);// 75
System.out.println('0' + 10);// 58
System.out.println((char)('a' + 1));/ /b

}

++-Operator:

Wenn der ++-Operator allein verwendet wird, unabhängig davon, ob sich das ++-Symbol auf der linken oder rechten Seite der Variablen befindet, es bedeutet, die Variable um 1 zu erhöhen

Wenn + Wenn der +-Operator zusammen verwendet wird und sich das ++-Symbol auf der linken Seite der Variablen befindet, liegt der Schwerpunkt darauf, sie zuerst zu ändern (um 1 zu erhöhen) und dann abzugleichen it,

; wenn es sich auf der rechten Seite der Variablen befindet, wird zuerst der Abgleich und dann die Änderung (Erhöhen um 1) hervorgehoben

-- Operator:

Wenn - allein verwendet wird, unabhängig davon, ob - auf der linken oder rechten Seite einer Variablen steht, bedeutet dies, dass die Variable um 1 dekrementiert wird.

Wenn -- in Kombination verwendet wird, wenn -- auf der steht Auf der linken Seite der Variablen liegt die Betonung darauf, zuerst
zu ändern (um 1 zu verringern) und dann abzugleichen ändern (um 1 verringern)Codedemonstration:
public static void main(String[] args) {
int b = 10; System.out.println(b++);//10
System.out.println(b);//11 "============== ===="); int c = 20;

System.out.println(--c);// 19

System.out.println(c);// 19

int d = 30;
System.out.println(d--);//30
System.out.println(d );// 29
}

Zuweisungsoperator:

Grundlegender Zuweisungsoperator:=
Erweiterter Zuweisungsoperator:+= -= *= /= %=
Ändern Sie links und das Ergebnis weiter die rechte wird der linken zugewiesen
Hinweis: die linke Seite kann keine Konstante sein
impliziert eine erzwungene Typkonvertierung
Vorteile: effizienter
Code-Demonstration:
public static void main(String[] args) {

int a = 10;
a+=2; // a = a + (2) --- >
System.out.println(a); // 12

int b = 20;
b-=2; // b = b - (2) --->ｂ　＝ １８
　System.out.println(b);//18

　short c = 10;
　　//c = (short)(c + 10); // short = short + int ---> short = int
　c+=10;
　System.out.println(c);//20

}

Vergleichsoperatoren:

==(gleich) !=(ungleich) >(größer als) <(kleiner als) >=(größer als oder gleich) <=(kleiner als oder gleich)
Vergleichsoperatoren sind alle vom booleschen Typ, entweder wahr oder falsch
Codedemonstration:
public static void main(String[] args) {
// TODO Automatisch generierter Methoden-Stub
int a = 10;
int b = 20;
int c = 10;

System.out.println( a == b);// false
System. out.println( a == c);// true
System.out.println("=====================");
System.out. println( a != b);// true
　System.out.println( a != c);// false
　System.out.println("====== ===== ===========");
System.out.println( a >= b);// false
System.out.println( a > = c);/ / true
　System.out.println("=====================");
　System.out.println ( a <= b);// true
　System.out.println( a <= c);// true 　
　System.out.println("========== ===== =======");
System.out.println( a > b); // false
System.out.println( a > c); // false
System .out.println("======================");
System.out.println( a < b) ;// true
System.out.println( a < c);// false
System.out.println("================== ====" );

}

Logische Operatoren:

Logische Operatoren werden verwendet, um boolesche Ausdrücke und das Endergebnis zu verbinden Der Wert ist boolesch.
kann in Java nicht als 3 oder: | Ausdruck ist nur dann wahr, wenn beide Seiten gleichzeitig falsch sind
Nicht: ! Operationsregeln: true Ändern Sie false in true
Exklusives ODER: ^ Operationsregeln: Wenn beide Seiten gleich sind , es ist falsch, wenn sie unterschiedlich sind, ist es wahr
Codedemonstration:
public static void main(String[] args) {

System .out.println(true & true ); // T

System.out.println(false & true );// F
System.out.println(true & false );// F
System.out.println(false & false ) ;// F
System.out.println("=======================" );
System.out.println (true | true ); // T
System.out.println(false | true ); // T
System.out.println(true | false ); // T
　System.out. println(false | false );// F
　System.out.println("==================== =====");
System.out.println(!true);// F
System.out.println(!false);// T
System.out.println(" ========== ===============");
System.out.println(true ^ true ); // F
System. out.println(false ^ true );/ / T
　System.out.println(true ^ false );// T
　System.out.println(false ^ false );// F

}

Kurz -Schaltung und: &&
Kurzschluss und: ||.
Vorteil: höhere Effizienz
Kurzschluss und: &&
Die grundlegenden Betriebsregeln sind ähnlich wie bei &, der Unterschied besteht darin, dass, wenn die Die linke Seite ist falsch, die rechte Seite wird nicht ausgeführt und das Ergebnis wird direkt kurzgeschlossen
oder: || >Ternärer Ausdruck:
Ausdruck 1 : Ergebnis 2

Ausführung Prozess:
Berechnen Sie zuerst das Ergebnis von Ausdruck 1.
Wenn das Ergebnis wahr ist, geben Sie Ergebnis 1 zurück. Andernfalls geben Sie Ergebnis 2 zurück.
Codedemonstration: (Ermitteln Sie die größere der beiden Zahlen. )
(int x=3,y=4,z;z = (x>y)?x:y;//Die z-Variable speichert die große Zahl der beiden Zahlen.)
public class Demo09Operator {
public static void main(String[] args) {
　　int a = 10;
　　int b = 20;
　　int c = (a > b) ? System.out.println("c:" + c);
　}
}

(Vergleichen, ob zwei Daten gleich sind)
public class Demo10Operator {
public static void main(String[] args) {
// Definiere zwei Variablen vom Typ int
　　int a = 10;
　　int b = 20;

　　boolean flag = (a == b) ? true : false;
　　 // boolean flag = (a == b);
　　System. out.println(flag);
}
}

(Ermitteln Sie den Maximalwert unter drei Ganzzahlen)
public class Demo11Operator {
public static void main(String[] args ) {
// Definiere drei Variablen vom Typ int
　　int a = 10;
　　int b = 30;
　　int c = 20;

// Vergleiche die beiden ersten Großen Wert von integer
int temp = ((a > b) ? a : b);
int max = ((temp > c) ? temp : c);
System.out.println ("max :" + max);
　}

}

Das obige ist der detaillierte Inhalt vonBeispiel-Tutorial zu Operatoren und Typkonvertierung in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!