Schnellunterstützungen führen lokale Codeumsetzungen durch. Sie werden bei einem Auswahl- oder Einzelcursor
im Java-Editor aufgerufen und verwenden denselben Direktaufruf wie für Schnellkorrekturen
(Strg+1), aber eine Schnellunterstützung ist üblicherweise ausgeblendet, wenn ein Fehler vorliegt. Zum Anzeigen trotz Fehler, die in derselben Zeile vorliegen, drücken Sie Strg+1 ein zweites Mal.
Eine Auswahl der Schnellunterstützung kann auch einem Direktaufruf zugeordnet werden. Standardmäßig sind dies:
Auf der Benutzervorgabenseite
Allgemein > Tasten (in der Kategorie 'Quelle') können Sie weitere
Direktaufrufe zuordnen oder die standardmäßigen Direktaufrufe ändern.
Das Glühbirnensymbol für Schnellunterstützung kann auf der Benutzervorgabenseite
Java > Editor aktiviert werden.
| Name | Codebeispiel | Position der Aufrufe | ||
|---|---|---|---|---|
| Umgekehrte if-Anweisung |
if (x) a(); else b();
|
> |
if (!x) b(); else a();
|
bei 'if'-Anweisungen mit 'else'-Block |
| Umgekehrter boolescher Ausdruck |
a && !b
|
> |
!a || b
|
bei einem booleschen Ausdruck |
| Lokale Variable umkehren |
boolean a = false;
|
> |
boolean notA = true;
|
bei einer booleschen Variablen |
| Gleiche Werte umkehren |
a.equals(b)
|
> |
b.equals(a)
|
bei einem Aufruf von 'equals' |
| Umgekehrter Bedingungsausdruck |
x ? b : c
|
> |
!x ? c : b
|
bei einem Bedingungsausdruck |
| Negation hochsetzen |
b && c
|
> |
!(!b || !c)
|
bei einem booleschen Ausdruck |
| Negation herabsetzen |
!(b && c)
|
> |
!b || !c
|
bei einem negierten booleschen Ausdruck |
| Zusätzliche Klammern entfernen |
if ((a == b) && (c != d) {}
|
> |
if (a == b && c != d) {}
|
bei ausgewählten Ausdrücken |
| Ausdruck in runde Klammern setzen |
return a > 10 ? 1 : 2;
|
> |
return (a > 10) ? 1 : 2;
|
bei ausgewähltem Ausdruck |
| Ausdrücke in runde Klammern setzen |
if (a == b && c != d) {}
|
> |
if ((a == b) && (c != d)) {}
|
bei ausgewählten Ausdrücken |
| Verschachtelte If-Anweisungen verknüpfen |
if (a) { if (b) {} }
|
> |
if (a && b) {}
|
bei einer verschachtelten if-Anweisung |
| Verschachtelte if-Anweisungen austauschen |
if (a) { if (b) {} }
|
> |
if (b) { if (a) {} }
|
bei einer verschachtelten if-Anweisung |
| Eine if-Anweisung mit and'ed-Ausdruck trennen |
if (a && b) {}
|
> |
if (a) { if (b) {} }
|
bei einem mit 'and' verknüpften Ausdruck in einem 'if' |
| Ausgewählte 'if'-Anweisungen verknüpfen mit || |
if (a) x(); if (b) x();
|
> |
if (a || b) x();
|
bei ausgewählten 'if'-Anweisungen |
| 'if'-Sequenz in if-else-if verknüpfen |
if (a) x(); if (b) y();
|
> |
if (a) x(); else if (b) y();
|
bei ausgewählten 'if'-Anweisungen |
| Eine if-Anweisung mit or'd-Ausdruck trennen |
if (a || b) x();
|
> |
if (a) x(); if (b) x();
|
bei einem mit 'or' verknüpften Ausdruck in einem 'if' |
| If-else-Anweisung an Bedingungsausdruck |
if (a) x= 1; else x= 2;
|
> |
x= a ? 1 : 2;
|
bei einer 'if'-Anweisung |
| If-else-Rückgabe an Bedingungsausdruck |
if (a) return 1;
|
> |
return a ? 1 : 2;
|
bei einer 'if'-Anweisung |
| Bedingungsausdrucksanweisung an If-else |
x= a ? 1 : 2;
|
> |
if (a) x= 1; else x= 2;
|
bei einem Bedingungsausdruck |
| Bedingungsausdrucksrückgabe an If-else |
return
a ? 1 : 2;
|
> |
if (a) return 1; else return 2;
|
bei einem Bedingungsausdruck |
| Switch in If-else |
switch (kind) {
|
> |
if (kind == 1) {
|
bei einer switch-Anweisung |
| Fehlende case-Anweisungen bei Aufzählungen hinzufügen |
switch (e){
|
> |
switch (e){
|
bei einer switch-Anweisung |
| Operanden austauschen |
a + b
|
> |
b + a
|
bei einer infix-Operation |
| Umsetzen und Zuweisen |
if (obj instanceof Vector) {
|
> |
if (obj instanceof Vector) {} |
bei einem Ausdruck 'instanceof' in einer 'if'- oder 'while'-Anweisung |
| Separate catch-Blöcke verwenden |
try {
|
> |
try {
|
In multi-catch-Block (1.7 oder höher) |
| Ausnahmebedingungen in separate catch-Blöcke verschieben |
try {
|
> |
try {
|
Bei Ausnahmebedingungen in einer multi-catch-Klausel (1.7 oder höher) |
| catch-Blöcke kombinieren |
try {
|
> |
try {
|
Bei einem catch-Block (1.7 oder höher) |
| Einen finally-Block hinzufügen |
try {
|
> |
try {
|
bei einer try/catch-Anweisung |
| Einen else-Block hinzufügen |
if (a) b();
|
> |
if (a) b(); else { }
|
bei einer if-Anweisung |
| Anweisung mit Block ersetzen |
if (a) b();
|
> |
if (a) { b(); }
|
bei einer if-Anweisung |
| Blöcke entpacken |
{ a() }
|
> |
a()
|
bei Blöcken, if/while/for-Anweisungen |
| Eine Zeichenfolge auswählen |
"abcdefgh"
|
> |
"abc" + "de" + "fgh"
|
einen Teil eines Zeichenfolgeliterals auswählen |
| Verkettung von Zeichenfolgen in StringBuilder (J2SE 5.0) oder StringBuffer umwandeln |
"Hello " + name
|
> |
StringBuilder builder= new StringBuilder();
|
ein Zeichenfolgeliteral auswählen |
| Verkettung von Zeichenfolgen in MessageFormat umwandeln |
"Hello " + name
|
> |
MessageFormat.format("Hello {0}", name);
|
ein Zeichenfolgeliteral auswählen |
| Variable teilen |
int i= 0;
|
> |
int i; i= 0;
|
bei einer Variablen mit Initialisierung |
| Variable verknüpfen |
int i; i= 0;
|
> |
int i= 0
|
bei einer Variablen ohne Initialisierung |
| Zuordnung zu Variabler |
foo()
|
> |
X x= foo();
|
bei einer Ausdrucksanweisung |
| In lokal extrahieren |
foo(getColor());
|
> |
Color color= getColor();
|
bei einem Ausdruck |
| Parameter zu Feld zuordnen |
public A(int color) {}
|
> |
Color fColor;
|
bei einem Parameter |
| Array-Initialisierungsoperator für Array-Erstellung |
int[] i= { 1, 2, 3 }
|
> |
int[] i= new int[] { 1, 2, 3 }
|
bei einem Array-Initialisierungsoperator |
| Convert to 'enhanced for loop' (J2SE 5.0) |
for (Iterator i= c.iterator();i.hasNext();) {
|
> |
for (x : c) {
|
bei einer Schleife |
| Konvertierung in indexierte 'for'-Schleife (J2SE 5.0) |
for (x : c) {
|
> |
for (int i = 0; i < c.size(); i++) {
|
Bei erweiterter 'for'-Schleife |
| Konvertierung zu iteratorbasierter 'for'-Schleife (J2SE 5.0) |
for (x : c) {
|
> |
for (Iterator i= c.iterator();i.hasNext();) {
|
Bei erweiterter 'for'-Schleife |
| Methode in Superklasse erstellen |
|
|
|
bei einer Methodendeklaration |
| In eine Datei umbenennen |
|
|
|
bei Kennungen |
| Im Arbeitsbereich umbenennen |
|
|
|
bei Kennungen |
| Zur lokalen Variablen extrahieren |
a= b*8;
|
> |
int x= b*8;
|
bei Ausdrücken |
| In Konstante extrahieren |
a= 8;
|
> |
final static int CONST= 8;
|
bei Ausdrücken |
| Methode extrahieren |
int x= p * 5;
|
> |
int x= getFoo(p);
|
bei Ausdrücken und Anweisungen |
| Lokale Variable integrieren |
int a= 8, b= a;
|
> |
int b= 8;
|
bei lokalen Variablen |
| Lokale Variable in Feld konvertieren |
void foo() { int a= 8; }
|
> |
int a= 8; void foo() {}
|
bei lokalen Variablen |
| Anonyme Klasse in verschachtelte Klasse konvertieren |
new Runnable() { };
|
> |
class RunnableImplementation implements Runnable { }
|
bei anonymer Klasse |
| Durch Getter und Setter ersetzen (Feld einkapseln) |
p.x;
|
> |
p.getX();
|
bei Feldern |
| Abgeleitete Typargumente einfügen |
List<String> list = new ArrayList<>();
|
> |
List<String> list = new ArrayList<String>();
|
Bei generischen Instanzerstellungsausdrücken (1.7 oder höher) |
Die folgenden Schnellunterstützungen stehen im Editor für Eigenschaftendateien zur Verfügung:
Java-Editor
Schnellkorrektur und Schnellunterstützung