Deskriptor
Deskriptoren sind Schlüsselwörter, die Sie zu diesen Definitionen hinzufügen, um ihre Bedeutung zu ändern. Die Java -Sprache hat viele Deskriptoren, einschließlich der folgenden:
öffentliche Klassenklassenklassenname {// ...} private boolean myflag; statische endgültige doppelte Wochen = 9,5; geschützte statische endgültige int boxwidth = 42; public static void main (String [] Argumente) {// Methodekörper} Zugängliche Deskriptoren
Java bietet eine Reihe von zugänglichen Deskriptoren, um die Zugangsniveaus von Klassen, Variablen, Methoden und Konstruktoren festzulegen. Die vier Zugangsebenen sind wie folgt:
Standardmäßig sichtbar für die Kapselung. Es ist kein Deskriptor erforderlich.
Unzugänglicher Deskriptor
Java bietet einige unzugängliche Deskriptoren, um andere Funktionen zu befriedigen.
Grundbetreiber
Java bietet eine Reihe von Betreibern für die Manipulation von Variablen. Wir können alle Java -Operatoren in die folgenden Gruppen teilen:
Die Verwendung von arithmetischen Operatoren in mathematischen Ausdrücken entspricht der Verwendung in Algebra. In der folgenden Tabelle werden die arithmetischen Operatoren aufgeführt:
Unter der Annahme, dass es 10 Variable A und 20 Variable B gibt, dann: dann:
Beispiel
| Betreiber | beschreiben | Beispiel |
|---|---|---|
| + | Addition wird am anderen Ende des Bedieners hinzugefügt | A+B ist 30 |
| - - | Die Subtraktion subtrahiert den Operanden rechts vom Operanden links vom Operanden | A - B ist -10 |
| * | Multiplikation multipliziert die Werte an beiden Enden des Bedieners | A * b ist 200 |
| / | Teilen Sie den linken Operanden durch den rechten Operanden | B/a ist 2 |
| % | Koeffizient - Teilen Sie den linken Operanden mit dem rechten Operanden und geben Sie den Rest zurück | B % A ist 0 |
| ++ | Inkrement erhöht den Wert des Operanden um 1 | B ++ ist 21 |
| - | Decrement subtrahiert 1 zum Operandenwert | B-is 19 |
Beispiel
| Betreiber | beschreiben | Beispiel |
|---|---|---|
| == | Überprüfen Sie, ob die Werte der Operanden beider Seiten gleich sind. Wenn sie gleich sind, ist die Bedingung wahr. | (A == b) nicht wahr. |
| ! = | Überprüfen Sie, ob die Werte der Operanden beider Seiten gleich sind. Wenn nicht gleich, ist die Bedingung wahr. | (A! = B) ist wahr. |
| > | Überprüfen Sie, ob der Operand links größer ist als der Operand rechts. Wenn es größer ist, ist der Zustand wahr | (A> b) nicht wahr. |
| < | Überprüfen Sie, ob der Operand links kleiner ist als der Operand auf der rechten Seite. Wenn es kleiner ist, ist der Zustand wahr | (A <b) ist wahr. |
| > = | Überprüfen Sie, ob der Operand links größer oder gleich dem Operanden rechts ist. Wenn ja, ist der Zustand wahr | (A> = b) nicht wahr. |
| <= | Überprüfen Sie, ob der Operand links kleiner oder gleich dem Operanden rechts ist. Wenn ja, ist der Zustand wahr | (A <= b) ist wahr. |
Der Bit -Operator wirkt auf die Übertragungsstandards zwischen binären Systemen und führt bitime Operationen durch. Nehmen wir an, wenn a gleich 60 ist; B ist gleich 13; Jetzt sind sie in binärer Form wie folgt:
a = 0011 1100b = 0000 1101 ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
In der folgenden Tabelle werden Bit -Operatoren aufgeführt:
Angenommen, es gibt dann 60 Ganzzahlvariablen A und 13 B: dann:
Beispiel
| Betreiber | beschreiben | Beispiel |
|---|---|---|
| & | Binär- und Bediener kopieren eine für das Ergebnis, wenn beide Operanden gleichzeitig existieren | (A & b) ist 12, d. H. 0000 1100 |
| | | Der Binär- oder Bediener kopiert ein wenig auf das Ergebnis, wenn es in einem Operanden vorliegt | (A | b) ist 61, d. H. 0011 1101 |
| ^ | Der binäre XOR -Operator kopiert das Bit, wenn es auf einem Operanden anstelle von zwei festgelegt ist. | (A ^ b) ist 49, d. H. 0011 0001 |
| ~ | Der Binary Supplement -Operator ist unär und B hat die Wirkung von "Flip" -Bits | (~ A) ist -61. Da es sich um eine signierte Binärzahl handelt, beträgt die Komplementform von 2 1100 0011 |
| << | Binärer linker Schaltoperator. Der Wert des Operanden links bewegt sich nach der Anzahl der vom Operanden rechts angegebenen Bits nach links. | A << 2 ist 240, d. H. 1111 0000 |
| >> | Binärer Rechtsschichtoperator. Der Wert des Operanden auf der linken Seite bewegt sich nach der Anzahl der vom Operanden rechts angegebenen Bits nach rechts. | A >> 2 ist 15, d. H. 1111 |
| >>> | Bewegen Sie sich rechts, um den Null -Operator zu füllen. Der Wert des linken Operanden wird nach rechts nach der Anzahl der vom rechten Operanden angegebenen Bits bewegt, und der übertragene Wert wird mit Null gefüllt. | A >>> 2 ist 15, d. H. 0000 1111 |
Unter der Annahme, dass die boolesche mathematische Systemvariable A wahr ist und B falsch ist, dann:
Beispiel
| Betreiber | beschreiben | Beispiel |
|---|---|---|
| && | Es heißt Logik und Operator. Wenn beide Operanden nicht Null sind, ist die Bedingung wahr. | (A && b) ist wahr. |
| || | Als Logik oder Operator bezeichnet. Wenn keiner der Operanden Null ist, ist die Bedingung wahr. | (A || b) ist wahr. |
| ! | Ein logischer Nichtbearbeiter genannt. Es wird als logischer Zustand der Flipoperanden verwendet. Wenn eine Bedingung wahr ist, ist der logische Nichtoperator falsch. | ! (A && b) ist wahr. |
Beispiel
| Betreiber | beschreiben | Beispiel |
|---|---|---|
| = | Einfache und Bediener weisen den Wert des Operanden rechts dem Operanden links zu | C = A + B weist den Wert von A + B zu C zu |
| += | Fügen Sie den Operator hinzu und zuweisen | C + = a ist gleich c = c + a |
| -= | Subtraktions- und Zuordnungsoperator, der den rechten Operanden vom linken Operanden subtrahiert und dem linken Operanden das Ergebnis zuweist | C - = a ist gleich c = c - a |
| *= | Multiplizieren Sie und Zuordnungsbetreiber, der den rechten Operanden links multipliziert und dem linken Operanden das Ergebnis zuweist | C = a ist gleich c = c a |
| /= | Teilen- und Zuordnungsoperator, der den rechten Operanden links teilt und dem linken Operanden das Ergebnis zuweist | C / = a ist gleich c = c / a |
| %= | Der Koeffizient- und Zuordnungsbetreiber verlangt den Koeffizienten, zwei Operanden zu verwenden und dem Operanden links das Ergebnis zuzuweisen. | C % = a ist gleich c = c % a |
| << = | Operatoren der linken Schicht und Zuordnungen | C << = 2 gleich c = c << 2 |
| >> = | Rechte Schicht- und Zuordnungsoperatoren | C >> = 2 gleich c = c >> 2 |
| & = | Bitweise und Zuordnungsbetreiber | C & = 2 gleich c = c & 2 |
| ^= | Bitwise XOR und Zuweisungsoperatoren | C ^ = 2 gleich c = c ^ 2 |
| | = | Bitweise oder Operatoren zuweisen | C | = 2 gleich c = c | 2 |
Bedingter Operator (? :) :)
Bedingte Operatoren werden auch ternäre Operatoren bezeichnet. Dieser Betreiber besteht aus drei Operanden und wird zur Bewertung von booleschen mathematischen Ausdrücken verwendet. Der Zweck dieses Operators besteht darin, zu bestimmen, welche Werte der Variablen zugeordnet werden sollten. Dieser Bediener ist wie folgt geschrieben:
Variable x = (Ausdruck)? Wert, wenn wahr: Wert wenn falsch
Hier ist ein Beispiel:
public class test {public static void main (String args []) {int a, b; a = 10; B = (a == 1)? 20: 30; System.out.println ("Wert von B ist:" + b); B = (a == 10)? 20: 30; System.out.println ("Wert von B ist:" + b); }}Dies führt zu Folgendem:
Der Wert von B ist: 30 VVALUE VON B IST: 20
Instanz des Symbols
Dieser Operator wird nur für Objektreferenzvariablen verwendet. Dieser Bediener prüft, ob ein Objekt ein eindeutiger Typ ist (Typ oder Schnittstellentyp). Der Instanzbetreiber ist geschrieben als:
(Objektreferenzvariable) Instanz (Klasse/Schnittstellentyp)
Wenn das Objekt links vom Bediener, auf das die Variable verwiesen wird, der Typ- oder Schnittstellentyp rechts ist, indem Sie IS-A-Prüfung übergeben, ist das Ergebnis wahr. Hier ist ein Beispiel:
public class test {public static void main (String args []) {String name = "James"; // folgen wird true zurückgegeben, da der Name Typ des String booleschen Ergebnis = Name Instanz der Zeichenfolge ist. System.out.println (Ergebnis); }}Dies führt zu den folgenden Ergebnissen:
Kopieren Sie den Code wie folgt: Richtig
Dieser Bediener kehrt weiterhin zu True zurück, wenn das verglichene Objekt eine Zuordnung ist, die mit dem richtigen Typ kompatibel ist. Hier ist ein weiteres Beispiel: Klasse Fahrzeug {} public Class Car erweitert das Fahrzeug {public static void main (String args []) {Fahrzeug a = new Car (); boolescher Ergebnis = ein Instanz des Autos; System.out.println (Ergebnis); }}Dies führt zu den folgenden Ergebnissen:
WAHR
Java -Operator Priorität
Die Priorität des Bedieners bestimmt die Gruppierung von Begriffen in einem Ausdruck. Es wirkt sich aus, wie ein Ausdruck bewertet wird. Ein bestimmter Bediener hat eine höhere Priorität als andere Betreiber. Zum Beispiel: Der Multiplikationsbetreiber hat eine höhere Priorität als der Additionsbetreiber:
Zum Beispiel x = 7+3 2; Hier wird X 13, nicht 20 zugewiesen, da der Bediener eine höhere Priorität hat als der Bediener +, sodass er zunächst die Multiplikation 3*2 betreibt und dann 7 hinzugefügt wird.
Hier liegen die Betreiber mit höchster Priorität auf der höchsten Ebene dieser Tabelle, und diejenigen mit der niedrigsten Priorität stehen unten auf. In einem Ausdruck wird zuerst der Prioritätsoperator bewertet.
| Art | Betreiber | Relevanz |
|---|---|---|
| Suffix | () []. (Punktbetreiber) | Von links nach rechts |
| Ein Dollar | ++ - -! ~ | Von rechts nach links |
| Multiplikation | */ % | Von links nach rechts |
| Zusatzstoff | + - | Von links nach rechts |
| Schicht | >> >>> << | Von links nach rechts |
| Beziehung | >> = <<= | Von links nach rechts |
| gleich | ==! = | Von links nach rechts |
| Bit und | & | Von links nach rechts |
| Außergewöhnliche Position oder | ^ | Von links nach rechts |
| bit oder | | | Von links nach rechts |
| Logik und | && | Von links nach rechts |
| Logisch oder | || | Von links nach rechts |
| Bedingt | ?: | Von rechts nach links |
| Abtretung | = += -= *= /= %= >> = << = & = ^== | Von rechts nach links |
| Komma | Anwesend | Von links nach rechts |