ADT Tipps & Tricks: Effiziente ABAP-Entwicklung in Eclipse

kategorie

DevOps

Veröffentlicht

Feb 13, 2026

autor

ABAP Development Tools (ADT) in Eclipse bieten weit mehr Funktionalität als auf den ersten Blick sichtbar. Mit den richtigen Shortcuts, Templates und Features kannst du deine Produktivität deutlich steigern.

Wichtigste Shortcuts

Die folgenden Tastenkürzel sollte jeder ABAP-Entwickler kennen:

Shortcut	Funktion	Beschreibung
Ctrl+Shift+A	Open ABAP Development Object	Schnelle Suche nach beliebigen Objekten
F3	Navigate to Definition	Zur Definition springen
Alt+Left/Right	Back/Forward	In der Navigation vor/zurück
Ctrl+O	Quick Outline	Übersicht aller Methoden und Attribute
Ctrl+T	Type Hierarchy	Vererbungshierarchie anzeigen
Ctrl+Shift+G	Where-Used List	Verwendungsnachweis
Ctrl+H	Search	Globale Suche
Ctrl+L	Go to Line	Zu bestimmter Zeile springen
F4	Open Type	Typ-Definition öffnen

Code-Bearbeitung

Shortcut	Funktion	Beschreibung
Ctrl+1	Quick Fix	Schnellkorrektur und Vorschläge
Ctrl+Space	Code Completion	Codevervollständigung
Ctrl+Shift+F	Format Source Code	Code formatieren (Pretty Printer)
Ctrl+/	Toggle Comment	Zeile auskommentieren
Ctrl+D	Delete Line	Zeile löschen
Alt+Up/Down	Move Line	Zeile verschieben
Ctrl+Alt+Up/Down	Duplicate Line	Zeile duplizieren
Ctrl+Shift+Enter	Insert Line Above	Neue Zeile oberhalb einfügen
Shift+Enter	Insert Line Below	Neue Zeile unterhalb einfügen

Refactoring

Shortcut	Funktion	Beschreibung
Alt+Shift+R	Rename	Element umbenennen
Alt+Shift+M	Extract Method	Code in Methode auslagern
Alt+Shift+L	Extract Local Variable	Lokale Variable extrahieren
Alt+Shift+C	Change Method Signature	Methodensignatur ändern
Alt+Shift+I	Inline	Variable/Methode inline setzen

Ausführung und Debug

Shortcut	Funktion	Beschreibung
F8	Run	Ausführen
F9	Toggle Breakpoint	Breakpoint setzen/entfernen
F5	Step Into	In Methode springen (Debug)
F6	Step Over	Über Methode springen (Debug)
F7	Step Return	Aus Methode zurückspringen
Ctrl+F2	Terminate	Debugging beenden

Editor-Management

Shortcut	Funktion	Beschreibung
Ctrl+E	Switch Editor	Zwischen offenen Editoren wechseln
Ctrl+W	Close Editor	Editor schließen
Ctrl+Shift+W	Close All	Alle Editoren schließen
Ctrl+M	Maximize/Restore	Editor maximieren/wiederherstellen
Ctrl+F6	Next Editor	Nächster Editor
Ctrl+Shift+F6	Previous Editor	Vorheriger Editor

Hidden Features

ADT bietet viele weniger bekannte, aber sehr nützliche Features:

1. Link with Editor

Synchronisiert den Project Explorer mit dem aktuellen Editor:

┌──────────────────────────────────────────────────────────────┐
│  Project Explorer                                              │
├──────────────────────────────────────────────────────────────┤
│                                                                │
│  [🔗] Toggle Link with Editor                                  │
│       ↓                                                        │
│  Wenn aktiv: Beim Öffnen einer Datei wird diese               │
│  automatisch im Project Explorer markiert                      │
│                                                                │
│  Aktivieren: Toolbar-Icon oder View Menu → Link with Editor   │
│                                                                │
└──────────────────────────────────────────────────────────────┘

2. Block Selection Mode

Ermöglicht Spalten-basierte Auswahl und Bearbeitung:

" Normal: Zeilenweise Auswahl
" Block Mode (Alt+Shift+A): Spaltenweise Auswahl

" Vorher - Mit Block Selection mehrere Zeilen gleichzeitig bearbeiten:
DATA lv_field1 TYPE string.
DATA lv_field2 TYPE string.
DATA lv_field3 TYPE string.

" Block markieren und ändern → alle Zeilen gleichzeitig bearbeitet

Aktivierung: Alt+Shift+A oder Edit → Toggle Block Selection Mode

3. Compare With

Verschiedene Vergleichsmodi für Code:

Rechtsklick auf Objekt → Compare With:

┌─────────────────────────────────────────────────┐
│ Local History...      │ Frühere lokale Versionen │
│ Revision...           │ Bestimmte Revision       │
│ Latest from Server    │ Aktuelle Server-Version  │
│ Active/Inactive       │ Aktiv vs. Inaktiv        │
│ Each Other           │ Zwei Objekte vergleichen │
└─────────────────────────────────────────────────┘

4. Local History

Eclipse speichert automatisch lokale Versionen:

Rechtsklick → Compare With → Local History

┌──────────────────────────────────────────────────────────────┐
│  Local History for ZCL_ORDER_SERVICE                          │
├──────────────────────────────────────────────────────────────┤
│                                                                │
│  📅 Feb 13, 2026, 14:32:15  │ Current Version                 │
│  📅 Feb 13, 2026, 14:15:22  │ Before refactoring              │
│  📅 Feb 13, 2026, 13:45:08  │ After method extract            │
│  📅 Feb 13, 2026, 11:20:33  │ Initial version                 │
│                                                                │
│  [ Compare ] [ Replace ] [ Restore ]                          │
│                                                                │
└──────────────────────────────────────────────────────────────┘

Tipp: Auch nach versehentlichem Löschen wiederherstellbar!

5. Annotations

ADT zeigt nützliche Annotations am Zeilenrand:

┌────┬──────────────────────────────────────────┐
│ 42 │  METHOD process_data.                    │ ← Methodenbeginn
│ 43 │    DATA lv_result TYPE string.           │
│ ⚡ │    SELECT SINGLE *                       │ ← Performance-Warnung
│ 45 │      FROM ztable                         │
│ 46 │      INTO @DATA(ls_data)                 │
│ 🔴 │      WHERE field = @iv_param.            │ ← Breakpoint
│ 48 │                                          │
│ ⚠️ │    IF ls_data IS INITIAL. "TODO: Handle │ ← TODO/FIXME Marker
│ 50 │      RETURN.                             │
│ 51 │    ENDIF.                                │
│ 52 │  ENDMETHOD.                              │
└────┴──────────────────────────────────────────┘

Zeigt den aktuellen Pfad im Code:

┌──────────────────────────────────────────────────────────────┐
│  ZCL_ORDER_SERVICE > PUBLIC SECTION > process_order          │
│  ↑                   ↑                 ↑                      │
│  Klick: Zeigt        Klick: Zeigt     Klick: Zeigt           │
│  alle Klassen        alle Sections    alle Methoden          │
└──────────────────────────────────────────────────────────────┘

Aktivieren: Window → Preferences → General → Editors → Show breadcrumb

7. Quick Access

Universelles Kommando-Fenster:

Ctrl+3 → Quick Access öffnen

┌──────────────────────────────────────────────────────────────┐
│  🔍 [activate                                          ]      │
├──────────────────────────────────────────────────────────────┤
│  Commands                                                     │
│    ▸ Activate Object (Ctrl+F3)                               │
│    ▸ Activate All Inactive Objects                           │
│                                                               │
│  Views                                                        │
│    ▸ Activation Log                                          │
│                                                               │
│  Preferences                                                  │
│    ▸ ABAP Development → Editors → Source Code → Activation   │
└──────────────────────────────────────────────────────────────┘

Code Templates

Code Templates beschleunigen das Schreiben von wiederkehrendem Code erheblich.

Eingebaute Templates

ADT enthält viele vordefinierte Templates. Tippe den Template-Namen und drücke Ctrl+Space:

Template	Ausgabe	Beschreibung
`method`	Methoden-Definition	Erstellt Methodenrumpf
`class`	Klassen-Definition	Erstellt Klassenstruktur
`if`	IF-Block	Erstellt IF…ENDIF
`loop`	LOOP AT	Erstellt LOOP-Block
`select`	SELECT-Statement	Erstellt SELECT-Abfrage
`try`	TRY…CATCH	Erstellt Fehlerbehandlung
`data`	DATA-Deklaration	Erstellt Variablendeklaration
`const`	CONSTANTS	Erstellt Konstante

Template-Verwendung

" Tippe: loop + Ctrl+Space

" Template wird eingefügt:
LOOP AT ${itab} INTO DATA(${wa}).
  ${cursor}
ENDLOOP.

" ${itab}, ${wa} = Platzhalter zum Ausfüllen (mit Tab navigieren)
" ${cursor} = Finale Cursorposition

Eigene Templates erstellen

Window → Preferences → ABAP Development → Editors → Source Code → Templates

┌──────────────────────────────────────────────────────────────┐
│  Templates                                                     │
├──────────────────────────────────────────────────────────────┤
│                                                                │
│  [New...] [Edit...] [Remove] [Import...] [Export...]          │
│                                                                │
│  ┌──────────────────────────────────────────────────────────┐ │
│  │ Name           │ Context  │ Description                  │ │
│  ├────────────────┼──────────┼──────────────────────────────┤ │
│  │ logentry       │ ABAP     │ Application Log Entry        │ │
│  │ singleton      │ ABAP     │ Singleton Pattern            │ │
│  │ rapaction      │ ABAP     │ RAP Action Method            │ │
│  │ unittest       │ ABAP     │ Unit Test Method             │ │
│  └──────────────────────────────────────────────────────────┘ │
│                                                                │
└──────────────────────────────────────────────────────────────┘

Praktische Custom Templates

RAP Action Template (rapaction):

METHOD ${action_name} FOR MODIFY
  IMPORTING keys FOR ACTION ${entity}~${action_name}.

  READ ENTITIES OF ${root_entity} IN LOCAL MODE
    ENTITY ${entity}
    ALL FIELDS WITH CORRESPONDING #( keys )
    RESULT DATA(lt_entities).

  LOOP AT lt_entities ASSIGNING FIELD-SYMBOL(<ls_entity>).
    ${cursor}
  ENDLOOP.

  MODIFY ENTITIES OF ${root_entity} IN LOCAL MODE
    ENTITY ${entity}
    UPDATE FIELDS ( ${fields} )
    WITH VALUE #( FOR ls_entity IN lt_entities (
      %tky = ls_entity-%tky
      ${field_assignments}
    ) )
    REPORTED DATA(lt_reported).

  reported = CORRESPONDING #( DEEP lt_reported ).
ENDMETHOD.

Unit Test Template (unittest):

METHOD ${test_name}.
  " Given
  ${given}

  " When
  DATA(lo_cut) = NEW ${class_under_test}( ).
  DATA(lv_result) = lo_cut->${method_under_test}( ${parameters} ).

  " Then
  cl_abap_unit_assert=>assert_equals(
    act = lv_result
    exp = ${expected}
    msg = '${message}' ).
ENDMETHOD.

Application Log Template (logentry):

DATA(lo_log) = cl_bali_log=>create_with_header(
  header = cl_bali_header_setter=>create(
    object    = '${log_object}'
    subobject = '${log_subobject}'
  )
).

lo_log->add_item(
  item = cl_bali_message_setter=>create_from_sy( )
).

cl_bali_log_db=>get_instance( )->save_log( log = lo_log ).

Template-Variablen

Variable	Beschreibung
`${cursor}`	Finale Cursorposition
`${word_selection}`	Aktuell ausgewähltes Wort
`${line_selection}`	Aktuell ausgewählte Zeile
`${date}`	Aktuelles Datum
`${time}`	Aktuelle Uhrzeit
`${user}`	Benutzername
`${enclosing_method}`	Name der umgebenden Methode
`${enclosing_type}`	Name der umgebenden Klasse

Quick Fixes und Refactoring-Tools

Quick Fix (Ctrl+1)

Die mächtigste Funktion in ADT. Verfügbar wenn ein Problem oder Vorschlag existiert:

Fehlende Methode erstellen:

" Schreibe Methodenaufruf für nicht existierende Methode:
DATA(lv_result) = calculate_total( lt_items ).

" Cursor auf calculate_total → Ctrl+1
" → "Create method calculate_total" wählen
" → Methodensignatur wird automatisch generiert

Fehlende Variable deklarieren:

" Schreibe Code mit undeklarierter Variable:
lv_status = 'ACTIVE'.

" Cursor auf lv_status → Ctrl+1
" → "Declare local variable lv_status" wählen
" → DATA lv_status TYPE ??? wird eingefügt

Import hinzufügen:

" Verwende Klasse ohne USE-Statement:
DATA(lo_client) = cl_web_http_client_manager=>create_by_http_destination( ... ).

" Ctrl+1 auf der Klasse
" → Fehlende Imports werden vorgeschlagen

Verfügbare Quick Fixes

Situation	Quick Fix Option
Undefinierte Variable	Declare local/instance variable
Undefinierte Methode	Create method
Undefinierter Typ	Create class/interface/type
Nicht behandelte Exception	Add CATCH block / Add to signature
Obsolete Syntax	Convert to modern syntax
Unreachable code	Remove unreachable code
Unused variable	Remove unused declaration
Missing ENDIF/ENDLOOP	Insert missing statement

Extract Method (Alt+Shift+M)

Extrahiert markierten Code in eine neue Methode:

" Vorher - Code markieren:
METHOD process_order.
  " --- Markierter Code Start ---
  SELECT *
    FROM zorder_items
    INTO TABLE @DATA(lt_items)
    WHERE order_id = @iv_order_id.

  DATA(lv_total) = REDUCE #( INIT sum = 0
                             FOR ls_item IN lt_items
                             NEXT sum += ls_item-amount ).
  " --- Markierter Code Ende ---

  " Weitere Verarbeitung...
ENDMETHOD.

" Alt+Shift+M → Methodenname eingeben: "calculate_order_total"

" Nachher:
METHOD process_order.
  DATA(lv_total) = calculate_order_total( iv_order_id ).
  " Weitere Verarbeitung...
ENDMETHOD.

METHOD calculate_order_total.
  SELECT *
    FROM zorder_items
    INTO TABLE @DATA(lt_items)
    WHERE order_id = @iv_order_id.

  rv_total = REDUCE #( INIT sum = 0
                       FOR ls_item IN lt_items
                       NEXT sum += ls_item-amount ).
ENDMETHOD.

Rename (Alt+Shift+R)

Benennt Elemente projektübergreifend um:

┌──────────────────────────────────────────────────────────────┐
│  Rename Method                                                 │
├──────────────────────────────────────────────────────────────┤
│                                                                │
│  Rename method 'process_order' to:                            │
│  [process_sales_order                              ]           │
│                                                                │
│  ☑ Update references                                          │
│  ☑ Update text pool entries                                   │
│  ☐ Keep original method as deprecated wrapper                 │
│                                                                │
│  Preview:                                                      │
│  ┌──────────────────────────────────────────────────────────┐ │
│  │ ✓ ZCL_ORDER_SERVICE - Method Definition                  │ │
│  │ ✓ ZCL_ORDER_SERVICE - Method Implementation              │ │
│  │ ✓ ZCL_ORDER_PROCESSOR - Method Call (Line 45)            │ │
│  │ ✓ ZCL_TEST_ORDER - Test Method Call (Line 23)            │ │
│  └──────────────────────────────────────────────────────────┘ │
│                                                                │
│                              [ Preview > ] [ OK ] [ Cancel ]   │
│                                                                │
└──────────────────────────────────────────────────────────────┘

Change Method Signature (Alt+Shift+C)

Ändert Parameter und aktualisiert alle Aufrufer:

┌──────────────────────────────────────────────────────────────┐
│  Change Method Signature: process_order                        │
├──────────────────────────────────────────────────────────────┤
│                                                                │
│  Parameters:                                                   │
│  ┌─────────┬──────────┬───────────────┬────────────────┐      │
│  │ Kind    │ Name     │ Type          │ Default        │      │
│  ├─────────┼──────────┼───────────────┼────────────────┤      │
│  │ IMPORT  │ iv_order │ zorder_id     │                │      │
│  │ IMPORT  │ iv_mode  │ string        │ 'DEFAULT'      │ NEW  │
│  │ RETURN  │ rv_ok    │ abap_bool     │                │      │
│  └─────────┴──────────┴───────────────┴────────────────┘      │
│                                                                │
│  [Add] [Remove] [Move Up] [Move Down]                         │
│                                                                │
│  ☑ Update all callers                                         │
│                                                                │
└──────────────────────────────────────────────────────────────┘

Nützliche Views und Perspektiven

Die wichtigsten Views

1. ABAP Element Info (F2)

Zeigt Dokumentation und Details zum Element unter dem Cursor:

┌──────────────────────────────────────────────────────────────┐
│  ABAP Element Info                                             │
├──────────────────────────────────────────────────────────────┤
│                                                                │
│  METHOD process_order                                          │
│  ─────────────────────                                         │
│                                                                │
│  Importing:                                                    │
│    IV_ORDER_ID  TYPE ZORDER_ID  - Order identifier            │
│    IV_MODE      TYPE STRING     - Processing mode (optional)  │
│                                                                │
│  Returning:                                                    │
│    RV_SUCCESS   TYPE ABAP_BOOL  - Processing result           │
│                                                                │
│  Exceptions:                                                   │
│    ZCX_ORDER_ERROR - If order cannot be processed             │
│                                                                │
│  Documentation:                                                │
│  Processes the given order according to business rules.       │
│  The order must be in status 'OPEN' or 'PENDING'.            │
│                                                                │
└──────────────────────────────────────────────────────────────┘

2. Transport Organizer

Verwaltet Transportaufträge:

Window → Show View → Other → ABAP → Transport Organizer

┌──────────────────────────────────────────────────────────────┐
│  Transport Organizer                                           │
├──────────────────────────────────────────────────────────────┤
│                                                                │
│  📁 Modifiable                                                 │
│   └─ 📦 DEVK900123 - Feature: Order Processing                │
│       └─ 📄 ZCL_ORDER_SERVICE                                  │
│       └─ 📄 ZI_ORDER                                           │
│       └─ 📄 ZC_ORDER                                           │
│                                                                │
│  📁 Released                                                   │
│   └─ 📦 DEVK900120 - Bugfix: Null pointer                     │
│   └─ 📦 DEVK900118 - Enhancement: Logging                     │
│                                                                │
└──────────────────────────────────────────────────────────────┘

3. ABAP Language Help (F1)

Öffnet kontextsensitive Hilfe:

Cursor auf Keyword (z.B. REDUCE) → F1

→ Öffnet SAP-Dokumentation im Browser
→ Syntax, Beispiele, Einschränkungen

4. Problems View

Zeigt alle Fehler und Warnungen:

Window → Show View → Problems

┌──────────────────────────────────────────────────────────────┐
│  Problems                                                      │
├──────────────────────────────────────────────────────────────┤
│                                                                │
│  🔴 Errors (2)                                                 │
│   └─ Variable LV_RESULT not defined (ZCL_ORDER:45)            │
│   └─ Method GET_DATA not found (ZCL_ORDER:67)                 │
│                                                                │
│  ⚠️ Warnings (5)                                               │
│   └─ Variable LV_TEMP declared but not used (ZCL_ORDER:23)    │
│   └─ Consider using inline declaration (ZCL_ORDER:34)         │
│   └─ SELECT without ORDER BY (ZCL_REPORT:89)                  │
│                                                                │
│  ℹ️ Info (3)                                                   │
│   └─ TODO: Implement error handling (ZCL_ORDER:102)           │
│                                                                │
└──────────────────────────────────────────────────────────────┘

" Doppelklick → Springt zur Problemstelle

5. ATC Results

Zeigt Ergebnisse der ABAP Test Cockpit Prüfung:

Run → ABAP Test Cockpit → Check ABAP Development Object

┌──────────────────────────────────────────────────────────────┐
│  ATC Results                                                   │
├──────────────────────────────────────────────────────────────┤
│                                                                │
│  Object: ZCL_ORDER_SERVICE                                    │
│  Check Variant: STANDARD                                      │
│                                                                │
│  🔴 Priority 1 (Blocking)                                      │
│   └─ Possible SQL injection (Line 78)                         │
│                                                                │
│  ⚠️ Priority 2 (Warning)                                       │
│   └─ Hard-coded text found, use text symbol (Line 45)         │
│   └─ Method too complex (cyclomatic complexity > 10)          │
│                                                                │
│  ℹ️ Priority 3 (Information)                                   │
│   └─ Consider using REF TO instead of TYPE REF TO             │
│                                                                │
└──────────────────────────────────────────────────────────────┘

6. Outline View

Strukturübersicht des aktuellen Objekts:

Window → Show View → Outline

┌──────────────────────────────────────────────────────────────┐
│  Outline                                                       │
├──────────────────────────────────────────────────────────────┤
│                                                                │
│  📦 ZCL_ORDER_SERVICE                                          │
│   ├─ 📂 PUBLIC SECTION                                         │
│   │   ├─ 📋 INTERFACES: if_order_service                       │
│   │   ├─ ⚙️ METHODS                                            │
│   │   │   ├─ process_order                                    │
│   │   │   ├─ cancel_order                                     │
│   │   │   └─ get_status                                       │
│   │   └─ 📊 TYPES                                              │
│   │       └─ ty_order_status                                  │
│   │                                                            │
│   ├─ 📂 PRIVATE SECTION                                        │
│   │   ├─ 📦 DATA                                               │
│   │   │   ├─ mv_client                                        │
│   │   │   └─ mo_logger                                        │
│   │   └─ ⚙️ METHODS                                            │
│   │       ├─ validate_order                                   │
│   │       └─ calculate_total                                  │
│   │                                                            │
│   └─ 📂 IMPLEMENTATION                                         │
│                                                                │
└──────────────────────────────────────────────────────────────┘

Perspektiven wechseln

ADT bietet spezialisierte Perspektiven für verschiedene Aufgaben:

Window → Perspective → Open Perspective → Other...

┌──────────────────────────────────────────────────────────────┐
│  Open Perspective                                              │
├──────────────────────────────────────────────────────────────┤
│                                                                │
│  ▸ ABAP                         Standard-Entwicklung          │
│  ▸ ABAP Profiling               Performance-Analyse           │
│  ▸ Debug                        Debugging-Session             │
│  ▸ ABAP Cross Trace            Trace-Analyse                  │
│  ▸ Git                         Versionskontrolle              │
│                                                                │
└──────────────────────────────────────────────────────────────┘

ABAP Profiling Perspektive:

Für Performance-Analyse von ABAP-Code:

ABAP Trace View
SQL Trace Results
Memory Analysis
Runtime Analysis

Custom View-Layout speichern

1. Views nach Wunsch anordnen
2. Window → Perspective → Save Perspective As...
3. Name vergeben: "My ABAP Development"
4. Über Window → Perspective → Open Perspective abrufbar

Erweiterte Tipps

Favoriten und Bookmarks

Favoriten (für häufig genutzte Objekte):

Rechtsklick auf Objekt → Add to Favorites

Window → Show View → Favorites

┌──────────────────────────────────────────────────────────────┐
│  Favorites                                                     │
├──────────────────────────────────────────────────────────────┤
│  ★ ZCL_ORDER_SERVICE                                          │
│  ★ ZI_ORDER_ROOT                                              │
│  ★ ZORDER_CONFIG                                              │
│  ★ SE80 (Transaction)                                         │
└──────────────────────────────────────────────────────────────┘

Bookmarks (für Code-Stellen):

Rechtsklick auf Zeilennummer → Add Bookmark

Window → Show View → Bookmarks

┌──────────────────────────────────────────────────────────────┐
│  Bookmarks                                                     │
├──────────────────────────────────────────────────────────────┤
│  📑 TODO: Refactor this method (ZCL_ORDER:45)                 │
│  📑 Bug: Edge case not handled (ZCL_PROCESSOR:128)            │
│  📑 Review: Performance optimization needed (ZCL_REPORT:67)   │
└──────────────────────────────────────────────────────────────┘

Task Tags

ADT erkennt spezielle Kommentar-Tags automatisch:

" TODO: Implement retry logic
" FIXME: This causes memory leak
" XXX: Temporary workaround, remove after release
" HACK: Quick fix for demo, refactor later

" Diese erscheinen automatisch in der Tasks View:
" Window → Show View → Tasks

Multi-Cursor Editing

Mehrere Cursor gleichzeitig für parallele Bearbeitung:

Ctrl+Klick → Fügt zusätzlichen Cursor hinzu
Ctrl+Shift+L → Cursor an jede Zeile der Selektion

" Beispiel: Alle Variablen umbenennen
DATA lv_var1 TYPE string.  | ← Cursor 1
DATA lv_var2 TYPE string.  | ← Cursor 2
DATA lv_var3 TYPE string.  | ← Cursor 3

" Gleichzeitig tippen ändert alle Zeilen

Zen Mode (Fokus-Modus)

Maximiert den Editor ohne Ablenkungen:

Ctrl+M → Editor maximieren
Ctrl+M+M → Voller Bildschirm (Zen Mode)

Oder: Window → Appearance → Toggle Full Screen

Semantic Highlighting anpassen

Window → Preferences → ABAP Development → Editors → Source Code → Syntax Coloring

Anpassbare Elemente:
- Keywords (DATA, IF, LOOP...)
- Strings und Literale
- Kommentare
- Methoden und Attribute
- Lokale vs. globale Variablen

Best Practices

Thema	Empfehlung
Shortcuts lernen	Mit den 10 wichtigsten starten, schrittweise erweitern
Quick Fix nutzen	Ctrl+1 ist die mächtigste Funktion - immer zuerst prüfen
Templates erstellen	Für wiederkehrende Patterns eigene Templates anlegen
Views anordnen	Eigenes Layout speichern und als Perspektive sichern
Bookmarks setzen	Für Codereviews und TODOs Bookmarks verwenden
Local History	Vor großen Änderungen prüfen - Rettungsanker bei Fehlern
ATC regelmäßig	Code-Qualität kontinuierlich mit ATC prüfen
Block Selection	Für Massenänderungen Alt+Shift+A nutzen
Keyboard-first	Weniger Maus = schnellere Entwicklung
Perspektiven wechseln	Für Debugging und Profiling spezialisierte Perspektiven nutzen

Weiterführende Themen

ABAP Cleaner - Automatisches Code-Cleanup
CI/CD mit ABAP Cloud - Automatisierte Pipelines
ABAP Unit Testing - Testgetriebene Entwicklung