Frage

Ich habe von Leuten gehört, die so oder so eingeschaltet haben und die von der einen oder anderen schwören.

Als ein großer Fan von Eclipse, aber die Zeit, um auszuprobieren, IntelliJ nicht gehabt zu haben, ich bin interessiert zu hören von IntelliJ Nutzer, die „ex-Eclipsians“ einige spezielle Dinge, die Sie mit IntelliJ tun können, dass Sie mit Eclipse nicht tun können, .

Hinweis : Dies ist nicht eine subjektive Frage noch gar in einen IDE heiligen Krieg zu drehen bedeutet. Bitte downvote keine flamebait Antworten .

War es hilfreich?

Lösung

CTRL-Klick funktioniert überall

CTRL-Klick das bringt Dich, wo geklickt Objekt funktioniert überall definiert ist - nicht nur in Java-Klassen und Variablen in Java-Code, sondern in Spring-Konfiguration (können Sie auf Klassennamen klicken, oder das Eigentum oder die Bohne Namen), in Hibernate (können Sie auf Eigenschaftsnamen oder Klasse klicken, oder enthalten Ressource), können Sie mit einem Klick von Java-Klasse navigieren, wo sie als Feder verwendet wird oder Ruhezustand Bohne; Anklicken enthielt JSP oder JSTL-Tag funktioniert auch, ctrl-Klick auf dem JavaScript-Variable oder Funktion bringt Sie an den Ort, es definiert oder zeigt ein Menü, wenn es mehr als ein Ort, darunter andere Js Dateien und JS-Code in HTML oder JSP Dateien.

Automatische Vervollständigung für viele languagues

Ruhezustand

Automatische Vervollständigung in HSQL Ausdrücke, in Hibernate-Konfiguration (einschließlich Klasse, Eigenschaft und DB Spaltennamen), im Frühjahr Konfiguration

<property name="propName" ref="<hit CTRL-SPACE>"

und es wird Ihnen Liste dieser Bohnen zeigen, die Sie in dieser Eigenschaft injizieren.

Java

Sehr intelligente Autovervollständigung in Java-Code:

interface Person {
    String getName();
    String getAddress();
    int getAge();
}
//---
Person p;
String name = p.<CTRL-SHIFT-SPACE>

und es zeigt Ihnen ONLY getName () getAddress () und toString () (nur sie nach Typ kompatibel sind) und < em> getName () ist zuerst in der Liste, weil sie relevanten Namen hat. Neueste Version 8, die nach wie vor in EAP ist, hat noch mehr intelligente Autovervollständigung.

interface Country{
}
interface Address {
    String getStreetAddress();
    String getZipCode();
    Country getCountry();
}
interface Person {
    String getName();
    Address getAddress();
    int getAge();
}
//--- 
Person p;
Country c = p.<CTRL-SHIFT-SPACE>

, und es wird es still automatisch vervollständigt zu

Country c = p.getAddress().getCountry();

Javascript

Smart zur automatischen Vervollständigung in JavaScript.

function Person(name,address) {
    this.getName = function() { return name };
    this.getAddress = function() { return address };
}

Person.prototype.hello = function() {
    return "I'm " + this.getName() + " from " + this.get<CTRL-SPACE>;
}

und es zeigt nur getName () und getAddress () , egal wie * Methoden erhalten Sie möglicherweise in anderen JS Objekte in Ihrem Projekt haben, und ctrl-Klick auf this.getName () bringt Sie, wo dieses definiert ist, auch wenn einige andere getName () in Ihrem Projekt Funktionen gibt es.

HTML

Habe ich erwähnt, die automatische Vervollständigung und Strg-Klick in Pfaden zu Dateien, wie

Andere Tipps

Es gibt nur einen Grund, warum ich intellij verwenden und nicht verdunkeln: Usability

Ob es sich um das Debugging, Refactoring, Auto-Vervollständigung .. Intellij ist viel einfacher, mit konsistenten Tastenbelegungen zu verwenden, verfügbare Optionen, wo man nach ihnen suchen etc. Eigenschaft weisen, wird es schwierig sein für IntelliJ mit Eclipse aufholen , da diese viel mehr Plug-in zur Verfügung, die intellij hat, und ist leicht erweiterbar.

Wahrscheinlich ist keine Frage von was können / kann nicht getan werden, aber wie .

Zum Beispiel beider Editor mit Dock-Panels für Projekt umgeben haben, Classpath, Leistung, Struktur etc. Aber in Idee, wenn ich beginne all dieser Zusammenbruch geben automatisch mich auf dem Code, um es selbst konzentrieren lassen; In Eclipse all diesen Platten offen halten meinen Editor-Bereich sehr reduziert verlassen, etwa 1/5 des gesamten sichtbaren Bereichs. Also muss ich die Maus greifen und klicken Sie in den Platten zu minimieren. Dadurch ganzen Tag lang eine sehr frustrierende Erfahrung in Eclipse.

Die genaue Gegenteil geschieht mit dem Blick Ausgabefenster. In Idee, ein Programm laufen bringt das Ausgabefenster / Platte die Ausgabe des Programms zu sehen, auch wenn es perviously minimiert wurde. In Eclipse muss ich wieder meine Maus greifen und für die Ausgabe Registerkarte sehen und klicken Sie, mein Programm Ausgabe anzuzeigen, da das Ausgabefenster / Platte nur ein anderer ist, wie der ganze Rest der Fenster, aber in Idea wird er behandelt, in eine besondere Art und Weise: „Wenn der Benutzer sein Programm ausgeführt werden soll, ist sehr wahrscheinlich, dass er will, wird der Ausgang dieses Programm sehen!“ Es scheint so natürlich, wenn ich es schreiben, aber eclipse nicht in diesem grundlegenden Bedienkonzept.

Wahrscheinlich gibt es eine Abkürzung für diesen in Eclipse (autohide Ausgabefenster während der Bearbeitung und es Autoshow, wenn das Programm ausgeführt wird), aber wie einige andere Zehn die Verknüpfung verfügen muß in Foren, Online-Hilfe etc. gejagt werden, während in Idee, ein wenig ist etwas mehr „natürlich“.

Dies kann für fast alle Funktionen wiederholt werden beide, die automatische Vervollständigung, Zeilenumbruch, schnelle Dokumentation Ansicht, alles. Ich denke, die User Experience in Idea viel angenehmer ist als in Eclipse. Dann wird das Motto wird wahr „Entwickeln mit Vergnügen“

Eclipse-Griffe schneller größere Projekte (+300 Gläser und 4000 Klassen) und ich denke, IntelliJ Idea 8 auf diese Arbeit.

All dies ist natürlich subjektiv. Wie können wir Benutzerfreundlichkeit messen?

Idea 8.0 hat die schönen Strg + Shift + space x 2, das tut folgende zum automatischen Vervollständigung:

 City city = customer.<ctrl-shift-space twice>

beschließt,

 City city = customer.getAddress().getCity();

durch eine beliebige Anzahl von Ebenen von Getter / Setter.

Sie "Vergleichen mit Zwischenablage" nicht vergessen.

Etwas, das ich die ganze Zeit in IntelliJ verwenden und die keine Entsprechung in Eclipse.

Meine Lieblingskombination in IntelliJ, die keine Entsprechung in Eclipse hat (die ich gefunden habe) ist ‚Zum Symbol‘ genannt. STRG-ALT-SHIFT-N können Sie mit der Eingabe beginnen und Klassen, Methodennamen, Variablennamen glob up, etc, aus dem gesamten Projekt.

Ich habe versucht, IntelliJ zu wechseln wegen des neuen Android-Studios. Aber ich bin jetzt sehr enttäuscht. Ich bin mit Eclipse mit dem Code-Recommanders Plugin. Hier ist ein einfaches Beispiel, warum Eclipse ist so genial:

Ich möchte ein neues SimpleTimeZone erstellen. SimpleTimeZone hat keinen Konstruktor mit null Argumente.

Strg + Leertaste in Eclipse

eingeben Bild Beschreibung hier

Strg + Leertaste in IntelliJ

eingeben Bild Beschreibung hier

In IntelliJ bekomme ich keine Informationen, welche Art von Konstrukteuren SimpleTimeZone hat.

Nach Enter in Eclipse

eingeben Bild Beschreibung hier

Ich erhalte den zuvor ausgewählten Konstruktor mit vordefinierten Variablennamen gefüllt. Und ich kann den Typ jedes Argument sehen. Mit-Code Recommanders Eclipse-errät der richtige Konstruktor von den zuvor definierten Variablentypen in dem aktuellen Bereich und füllt den Konstruktor mit diesem Vars.

Nach Enter in IntelliJ nichts passiert. Ich bekomme einen leeren Konstruktor. Ich muss die Taste Strg + P die erwarteten Argumente zu sehen.

eingeben Bild Beschreibung hier

Wenn Sie den Cursor auf ein Verfahren haben, dann CTRL + SHIFT + I wird die Methode Implementierung Popup. Wenn die Methode ein interface Methode ist, dann können Sie mit Auf- und Abwärtspfeile, um durch die Implementierungen:

Map<String, Integer> m = ...
m.contains|Key("Wibble");

Wo | ist (zum Beispiel), wo Sie den Cursor ist.

IntelliJ hat ein paar ziemlich fortschrittlich Code-Inspektionen (vergleichbar, aber anders FindBugs).

Obwohl ich ernsthaft ein FindBugs Plugin bei der Verwendung von IntelliJ verpassen (Die Eclipse / FindBugs Integration ist ziemlich cool).

Hier ist eine offizielle Liste von CodeInspections von IntelliJ unterstützt

EDIT: Schließlich gibt es eine findbugs-Plugin für IntelliJ. Es ist immer noch ein bisschen Beta, aber die Kombination von Code-Inspektionen und FindBugs ist einfach genial!

Weit, weit, weit mehr Refactorings.

Eine Sache, die ich regelmäßig verwenden setzt einen Haltepunkt, aber dann kontrollieren, was es tut. (Bei meinem letzten Job, die meisten anderen Eclipse-verwendet ... Ich erinnere mich, dass überrascht, dass niemand finden konnte, wie dies in Eclipse zu tun.)

Zum Beispiel kann den Haltepunkt haben eigentlich nicht stoppen, aber melden Sie sich einfach eine Nachricht an die Konsole. Was bedeutet, ich habe nicht mit „System.out.println (...)“ meinen Code Wurf haben und dann neu kompilieren.

Es gibt viele Dinge, die Idee in eine viel einfachere Art und Weise löst, oder es gibt keine Entsprechung:

  • Automatische Vervollständigung Aktionen: Handeln Strg + Shift + a Sie eine Idee Aktion von der Tastatur seine Tastenkombination ohne sich zu erinnern ... Denken Sie über gnome-do oder launchy in Fenster aufrufen können, und Sie haben die Idee! Auch diese Funktion unterstützt camelcase Abkürzungen;)

  • Regal:. Hier können Sie halten einfach einige Teile des Codes auseinander, und sie dann durch den Diff-Viewer überprüfen

  • Lokalgeschichte. Es ist viel besser verwaltet und einfacher

  • SVN Anmerkungen und Geschichte: einfacher zu kontrollieren, und auch können Sie bequem die Geschichte nur für einen solchen Teil einer ganzen Quelldatei finden Sie unter

  • .
  • Automatische Vervollständigung überall, wie der Ausdruck und die Unterbrechungsbedingung Fenster bewerten.

  • Maven Integration ... viel, viel einfacher und gut integriert.

  • refactors viel näher an die Hand, wie beispielsweise Schleifen Einführen, Wickel / Gießen, Umbenennen und Variablen hinzuzufügen.

  • Finden viel leistungsfähig und gut organisiert. Selbst in großen Projekten

  • Ein großer Stall mit mehreren Filialen eines großen Projektes zur gleichen Zeit zu arbeiten (als ehemaliger bugfixer von 1.5Gb durch Zweig Quellen, und die Notwendigkeit, in ihnen gleichzeitig zu arbeiten, Idee seine felsenfesten Fähigkeiten gezeigt)

  • Reiniger und einfachere Schnittstelle ...

  • Und einfacher zu bedienen nur mit der Tastatur, wodurch die Notwendigkeit für viele einfache taks die Maus verwenden lassen auseinander, sparen Sie Zeit und Sie mehr Fokus auf den Code zu geben ... wo es wichtig ist!

Und nun, Open-Source sein ... die Idee Nutzerbasis wächst exponentiell.

Struktur suchen und ersetzen.

Zum Beispiel, die Suche nach so etwas wie:

  System.out.println($string$ + $expr$);

Wo $ string $ ist eine wörtliche und $ expr $ ist ein Ausdruck des Typs my.package.and.Class, und ersetzen Sie dann mit:

  $expr$.inspect($string$);

My Timing ein wenig aus in Bezug auf diesen Thread sein kann, aber ich musste einfach reagieren zu können.

Ich bin ein großen Fan Eclipse - mit ihm, da es zum ersten Mal ist. Ein Freund erzählte mir dann (ab 10 Jahren), dass es ein Spieler sein würde. Er hatte recht.

Allerdings! Ich habe gerade erst begonnen IntelliJ verwenden, und wenn Sie nicht oder verwendet gesehen Änderungslisten -. Sie sind nicht auf die Programmierung Himmel aus

Die Fähigkeit, meine geänderte Dateien zu verfolgen (auf meinem Entwicklungszweig ala Clearcase) war etwas, das ich wurde für Eclipse in einem Plugin suchen. Intellij verfolgt alle Änderungen für einen einzelnen verpflichten, extrem einfach. Sie können geänderte Dateien mit benutzerdefinierten Listen isolieren. Ich benutze das für Konfigurationsdateien, die lokal eindeutig sein müssen, sind aber ständig gekennzeichnet, wenn ich synchronisieren oder vergleichen, gegen das Repository - sie unter einer Änderungs Auflistung, ich sie überwachen kann, aber sie ordentlich verstauen, so kann ich auf den realen Additionen konzentrieren ich mache.

Außerdem gibt es eine Log-Plugin Commit, die einen Text alle Änderungen für die SCCS gibt, die mit Ihrer Bug-Tracking-Software nicht integriert sind. Kleben Sie das Protokoll in eine Arbeitsgeschichte Ticket erfasst die Dateien, deren Version, Datum / Uhrzeit und die Zweig / Tags. Es ist cool, wie die Hölle.

All dies über Plugins unterstützt werden könnte (oder zukünftige Erweiterungen) in Eclipse, ich wette; doch macht Intellij eine Brise dieses.

Schließlich bin ich wirklich begeistert über die Mainstream-Liebe für dieses Produkt -. Die Tastenanschläge, so ist es schmerzhaft, aber Spaß

Der IntelliJ Debugger hat eine sehr praktische Funktion namens „Evaluate Expression“, die bei weitem besser ist als Anhänger Finsternisse. Es hat die volle Code-Vervollständigung und i concider es allgemein als „nützliches“.

Nun, für mich ist es tausend kleine Dinge. Einige der Makros, die GUI-Layout im Allgemeinen in Eclipse finde ich schrecklich. Ich kann nicht mehrere Projekte in verschiedenen Fenstern in Eclipse öffnen. Ich kann mehrere Projekte öffnen, aber es ist die Ansicht basiertes System tauscht dann ein paar Dinge auf mich um, wenn ich Dateien wechseln. IntelliJ der Code-Inspektionen scheinen besser. Seine Popup-Helfer häufig auftretende Probleme zu beheben, ist schön. Viele einfache Bedienbarkeit Dinge wie die Seitenleiste, wo kann ich einen Hot Spot schweben über und es wird mir sagen, jede Implementierung Unterklasse einer Methode oder die Methode, die ich bin der Umsetzung und von wo.

Jedes Mal, wenn ich habe, oder jemand Gebrauch zu beobachten, Eclipse-es scheint, wie sie die meisten Dinge tun kann ich in IntelliJ tun können, aber es dauert sie länger und es ist clunkier.

Variable einführen. ( Strg + Alt + V auf Windows, Cmd + Alt + V auf OSX)

Nehmen wir an Sie eine Methode aufrufen, service.listAllPersons() Hit Strg + Alt + V und Enter , und Variable für Rückgabewert von Methodenaufruf eingefügt:

List<Person> list = service.listAllPersons();

Speichern Sie eingeben, und Sie haben nicht den Rückgabetyp der Methode zu überprüfen, die Sie anrufen. Besonders nützlich bei der Verwendung von Generika, z.

new ArrayList<String>()

[Einführung Variable]

ArrayList<String> stringArrayList = new ArrayList<String>();

(natürlich können Sie ganz einfach den Namen der Variablen ändern, bevor man Enter )

IntelliJ hat Intellisense und Refactoring Unterstützung von Code in JSPX Dokumenten.

Für mich ist es IDEA Maven Unterstützung, vor allem in der Version 9 ist unübertroffen. Die on-the-fly-Synchronisierung des Projektes auf das Maven-Modell ist einfach fantastisch und macht die Entwicklung angenehm.

Intellij hat eine weit überlegene SVN-Plug-in als entweder Subversive oder Subclipse und es funktioniert! Die Menge an Zeit, die wir haben vergeudet verschmelzenden Quelldateien mit Eclipse über nicht auszudenken. Dies ist nicht ein Problem mit IntelliJ, weil das Plugin Sie viel mehr hilft.

Auch das Subclipse Plugin ist unzuverlässig - wir regelmäßig Fälle, wo das Plugin dort nicht denkt, jeder Code in SVN von anderen Entwicklern geprüft hat, aber es hat - der CI-Server sie verarbeitet

!

VIM Emulator. Dieses Plugin bietet eine nahezu vollständige vi / vim / gvim Emulation, während Dateien in IDEA bearbeiten.         Die folgende Funktionalität wird unterstützt:         

                
  • Bewegung Tasten
  •             
  • Löschen / Ändern
  •             
  • Einfügen-Modus Befehle
  •             
  • Marks
  •             
  • Register
  •             
  • VIM Undo / Redo
  •             
  • Visueller Modus Befehle
  •             
  • Einige Ex-Befehle
  •             
  • Einige: set-Optionen
  •             
  • Voll VIM reguläre Ausdrücke für die Suche und Suchen / Ersetzen
  •             
  • Makros
  •             
  • Diagraphs
  •             
  • Kommandozeilen-Geschichte
  •             
  • Suchen Geschichte
  •             
  • Jumplists
  •             
  • VIM Hilfe
  •         

einige Kommentare zu diesem Plugin von http://plugins.jetbrains.net/plugin/ ? id = 164

                                                                               Ich kann nicht immer ging zurück auf jeden anderen ide, weil dieser Plugins ..                                                                                                    Das Beste aus beiden Welten ... ehrfürchtiges !.                                                                                                     das ist, was ich war in allen IDEs fehlt.

Eine der guten Seiten meiner Meinung nach ist die Dependency Structure Matrix : http://www.jetbrains.com/idea/features/dependency_analysis.html#link0

Es gibt eine gute Einführung in der DSM-Nutzung und Nutzen in Lattix‘Website (ein eigenständiges Produkt): http://www.lattix.com/files/dl/slides /s.php?directory=4tour

Ein paar andere Dinge:

  • propagieren Parameter / Ausnahmen, wenn Ändern Methodensignatur, ganz praktisch für die Methoden der Aktualisierung tief innerhalb des Call-Stack
  • SQL-Code-Validierung in den Strings als Argumente an jdbc Anrufe übergeben (Und das ganze neu gebündelt Sprache Injektion Sachen)
  • implementiert in / überschrieben in Symbole für Schnittstellen und Klassen (und ihre Methoden) und die intelligente Umsetzung Navigation (Strg + Alt + Klick oder Strg + Alt + B)
  • Verknüpfung zwischen der EJB 2.1-Schnittstellen und Bean-Klassen (Einschließlich refactoring Unterstützung); alt ein, aber immer noch sehr wertvoll Bei Arbeiten an ältere Projekten

Zwei Dinge, die IntelliJ macht die Eclipse-nicht, dass ich sehr wertvoll sind:

Methode Separatoren: jene schwachen grauen Linien zwischen den Methoden Code machen viel lesbarer

Text-Anti-Aliasing: macht Code in der IDE so schön aussehen

Ein sehr nützliches Feature ist die Fähigkeit, ein Maven Reaktor Projekt teilweise zu bauen, so dass nur die Teile, die Sie sind enthalten müssen.

Dieses ein wenig klarer zu machen, betrachten wir den Fall einer Sammlung von WAR-Dateien mit vielen gemeinsamen Ressourcen (zB JavaScript, Frühlings- und Konfigurationsdateien usw.) zwischen ihnen geteilt werden mit der Overlay-Technik . Wenn Sie auf einige Web-Seite (läuft in Jetty) arbeiten und wollen einige der Overlay-Code ändern, die in einem separaten Modul gehalten wird, dann würde man normalerweise erwarten zu haben Jetty zu stoppen, führen die Maven bauen, starten Jetty wieder und fortsetzen. Dies ist der Fall mit Eclipse und fast jeder anderen IDE ich gearbeitet habe. Nicht so in IntelliJ. das Projekt mit den Einstellungen können Sie festlegen, welche Facette des Modul, das Sie in einem Hintergrund Build aufgenommen werden möchten. Damit Sie am Ende mit einem Prozess auf, die nahtlos erscheint. Sie nehmen eine Änderung des Projekts ziemlich jedem Code in und sofort ist es verfügbar, nachdem Sie den Browser aktualisieren.

Sehr ordentlich, und sehr schnell.

Ich konnte mir nicht vorstellen Codierung ein vorderes Ende in so etwas wie YUI Unterstützung auf DWR / SpringMVC ohne sie.

Präambel meine Antwort: Meine Verwendung von Eclipse ist begrenzt. Wir brauchten ein Java-IDE, die Arbeit an Windows und Mac und Mac-Port verlangsamten Tag für Tag. Das war vor Jahren, und ich bin sicher, dass es jetzt in Ordnung. Aber das ist, was hat uns zu IntelliJ wechseln, und wir haben mit ihm glücklich.

Jetzt meine Antwort: Ein großer Unterschied habe ich noch nicht erwähnt gesehen ist, dass Tech-Support mit IntelliJ / JetBrains ist besser. eine E-Mail an JetBrains Wir schicken und eine endgültige Antwort zurück in weniger als einer Stunde erhalten. Suche nach Antworten Probleme Ergebnisse in gewohntem Eclipse: „Du dummen Idiot“ Antworten (in der Regel eine kleine Anzahl der Antworten) zusammen mit der viel größeren Anzahl von interessanten, nützlichen Antworten. Aber es dauert einige Sortierung durch die richtige Antwort zu erhalten.

Etwas, das ich in IntelliJ verwenden die ganze Zeit Refactoring als ich geben. Ich habe neu geschrieben Klassen aus einem Ausdruck (ursprünglich in Eclipse geschrieben) die beiden IDEs mit und ich verwenden, um etwa 40% weniger Tastenanschläge / Mausklicks die gleichen Klassen in IntelliJ als Eclipse zu schreiben.

Ich möchte nicht, dass Eclipse verwenden, bis sie so viel Refactoring mit unvollständigen Teile des Codes unterstützen.

Hier ist eine längere Liste von Funktionen in IntelliJ 8.0 / 8.1 [ http: / /www.jetbrains.com/idea/features/index.html]

Es ist eine Sache, dass IntelliJ tut viel, viel besser als Eclipse und das ist deine Taschen leer!

ich jedoch bevorzuge es und einen großen Vorteil mit hat es über Eclipce die Art und Weise ist es mit dem Dateisystem synchronisiert, für große Projekte und langsame Computer (ja in Arbeitsumgebungen der PC viel langsamer als unsere diejenigen zu Hause) eclipse scheint zu kämpfen, wo IntelliJ schneller zu sein, wenn auch mit einer geringeren anfänglichen Indizierungszeit scheint.

IntelliJ Community Edition offensichtlich macht es frei verwenden, aber Sie wollen bald diese zusätzlichen Refactoring und nette kleine Leckereien nicht in der CC-Ausgabe enthalten.

Meiner Meinung nach, seine im Allgemeinen eine bessere Benutzererfahrung, aber ob sein Geld wert ist eine Frage für jeden Entwickler selbst zu beantworten.

Aber läßt sein dankbar, dass wir bis zu drei großen IDEs für Java haben jetzt mit NetBeans immer besser die ganze Zeit.

Datenflussanalyse Zwischenflanschen- prozeduralen Rückwärtsflussanalyse und Vorwärts-Flow-Analyse, wie beschrieben hier . Meine Erfahrungen basieren auf Community Edition, die ziemlich gut Datenflussanalyse der Fall ist. Es versagt hat (weigerte sich, etwas zu tun) in wenigen Fällen, wenn der Code sehr komplex ist.

Als erstes habe ich intellij lieben. Es gibt mindestens hundert kennzeichnet es, dass Eclipse Mangel hat. Ich spreche Größen besser in Zuverlässigkeit und Intelligenz, die keine Übertreibung beschreiben kann, wenn es um Refactoring kommt, Umbenennen, Verschieben und andere, die bereits erwähnt wurden.

Aber, es gibt eine Sache, die intellij nicht erlaubt, die Eclipse tut. Es erlaubt nicht mehrere Projekte auf einmal unter dem gleichen vm laufen.

Wenn Sie separate Projekte für die Front haben, mittleren, Kern, agents..etc, wo sie alle miteinander zu interagieren, können Sie nicht so schnell ändern und debuggen zur gleichen Zeit, afaik. Der einzige Weg, ich mit diesem Strom bewältigen ist ant-Skripte zu verwenden, zu installieren und zu aktualisieren Gläser in der abhängigen Projekten oder Verwendung Maven.

Eclipse-Projekte können mehrere ausgetestet unter einer ide vm Instanz werden.

Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top