Intellij Idea - Code-Refactoring

In diesem Kapitel erfahren Sie mehr über Code Refactoring und dessen Funktionsweise in IntelliJ. Code Refactoring ist die Umstrukturierung von Code, ohne dessen Funktionalität und Benutzerfreundlichkeit zu ändern. Code-Refactoring kann durchgeführt werden, um die Lesbarkeit und Leistung des Codes zu verbessern oder nicht verwendete / doppelte Funktionen zu entfernen. IntelliJ bietet hervorragende Unterstützung für das Code-Refactoring. In diesem Kapitel werden verschiedene Code-Refactoring-Aktionen erläutert.

Umbenennen

Umbenennungsaktionen können verwendet werden, um Methoden, ihre Parameter, Klassenattribute, lokale Variablen usw. umzubenennen. Lassen Sie uns die folgende Klasse in IntelliJ erstellen.

public class Employee {
   private String name;
   private String address;
   private int age;
   public Employee() {
      this("Jarvis", "Palo Alto", 35);
   }
   public Employee(String name, String address, int age) {
      this.name = name;
      this.address = address;
      this.age = age;
   }
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
   public String getAddress() {
      return address;
   }
   public void setAddress(String address) {
      this.address = address;
   }
   public int getAge() {
      return age;
   }
   public void setAge(int age) {
      this.age = age;
   }
   
   @Override
   public String toString() {
      return "Employee{" +
      "name='" + name + '\'' +
      ", address='" + address + '\'' +
      ", age=" + age +
      '}';
   }
   public static void main(String args[]) {
      Employee e = new Employee();
      System.out.println(e);
   }
}

Lassen Sie uns jetzt umbenennen Employee Klasse zu Person. Diese Aktion führt Änderungen an Konstruktoren und dermain() Methode -

Wählen Sie Mitarbeiterwort
Gehe zu Refactor → Rename und benenne es mit Person um.

Code-Duplikate ersetzen

Dies ist eine der mächtigen Refactoring-Aktionen. IntelliJ identifiziert Code-Duplikate und ersetzt sie durch geeigneten Code. Lassen Sie uns die Codeduplizierung einführen und umgestalten. Geben Sie den folgenden Code in den Editor ein -

public class Employee {
   private String name;
   private String address;
   private int age;
   public Employee() {
      this("Jarvis", "Palo Alto", 35);
   }
   public Employee(String name, String address, int age) {
      this.name = name;
      this.address = address;
      this.age = age;
   }
   public void setData(String name, String address,  int age) {
      this.name = name;
      this.address = address;
      this.age = age;
   }
   public void showEmployeeDetail() {
      System.out.println("Name = " + name + ", Address = " + address + ", Age = " + age);
   }
   public static void main(String args[]) {
      Employee e = new Employee();
      e.showEmployeeDetail();
   }
}

In diesem Beispiel Mitarbeiter (Stringname, Stringadresse, int Alter) Konstruktor und public void setData (Stringname, Stringadresse, intAlter) Methode sind genau identisch. Nach dem Refactoring wird der Konstruktor Employee (String name, String address, int age) wie folgt geändert:

public Employee(String name, String address, int age) {
   setData(name, address, age);
}

So ersetzen Sie die Duplikate -

Gehen Sie zu Refactor → Suchen und Ersetzen von Code-Duplikaten.
Wählen Sie den Refactor-Bereich aus und befolgen Sie die Schritte auf dem Bildschirm, um die Aktion abzuschließen.

Refactoring kopieren

In diesem Abschnitt erfahren Sie, wie Sie eine Klasse in eine andere kopieren. Kopieren wir die Employee-Klasse in die Person-Klasse. Wir können es in das vorhandene oder ein neues Modul kopieren. IntelliJ nimmt die erforderlichen Änderungen in Abhängigkeit davon vor. Befolgen Sie diese Schritte, um das Refactoring von Kopien durchzuführen -

Gehe zu Refactor → Copywird das Dialogfeld geöffnet.
Geben Sie einen neuen Namen und ein neues Zielpaket ein.
Klicken Sie auf die Schaltfläche OK und es wird das Notwendige tun.

Refactoring verschieben

Das Verschieben von Refactoring ähnelt dem Kopieren, aber anstatt eine weitere Kopie zu erstellen, wird der Code in ein anderes Paket verschoben oder als innere Klasse einer anderen Klasse erstellt.

Befolgen Sie diese Schritte, um das Refactoring von Verschiebungen durchzuführen -

Gehen Sie zu Refactor → Verschieben.
Ein neues Fenster wird angezeigt.
Wählen Sie eine der Optionen entsprechend Ihrer Wahl und klicken Sie auf Refactor.

Sicheres Löschen

Mit der Aktion "Sicheres Löschen" wird das Objekt nur gelöscht, wenn auf keine Stelle im Projekt verwiesen wird. Das Ziel für diese Option kann Klasse, Schnittstelle, Methode, Feld oder Parameter sein.

Lassen Sie uns dies in Aktion sehen. Geben Sie den folgenden Code in den Editor ein -

public class HelloWorld {
   static void sayHello() {
      System.out.println("Hello, World !!!");
   }
   public static void main(String[] args) {
      sayHello();
   }
}

Führen Sie die folgenden Schritte aus, um die Aktion zum sicheren Löschen auszuführen.

Wähle aus sayHello() Methode.
Klicken Sie mit der rechten Maustaste darauf und wählen Sie die Refactor → Safe Delete Möglichkeit.
Während die sayHello () -Methode verwendet wird, wird ein Fehler wie im folgenden Screenshot angezeigt -

Unterschrift ändern

Die Aktion ändert die Methodensignatur. Es kann den Methodennamen, seine Parameter, Typen, Rückgabewerte usw. ändern. Nehmen wir eine Methode aus dem obigen Beispiel und ändern ihre Signatur.

Führen Sie die folgenden Schritte aus, um die Aktion "Signatur ändern" auszuführen.

Methode auswählen.
Klicken Sie mit der rechten Maustaste darauf und wählen Sie die Aktion Refactor → Signatur ändern
Ein neues Fenster wird angezeigt, in dem Sie die oben genannten Aktionen ausführen können.
Am unteren Rand des Fensters wird die Vorschau der neuen Signatur angezeigt.

Geben Sie Migration ein

Die Typmigration ändert den Typ des Symbols. Dieses Symbol kann ein Methodenparameter oder ein Klassenattribut sein. Betrachten wir die folgende Methode, bevor Sie die erforderliche Aktion ausführen:

static void sayHello(String name) {
   System.out.println(name);
}

Führen Sie die folgenden Schritte aus, um eine Typmigration durchzuführen.

Wählen Sie den Datentyp "String".
Klicken Sie mit der rechten Maustaste darauf und wählen Sie Refactor → Type migration.

Geben Sie den gewünschten Datentyp in das angegebene Textfeld ein.
Wählen Sie den Bereich und klicken Sie auf die Schaltfläche Refactor.