Eclipse 作为 IDE - 作为 Java 初学者，您发现缺少什么？
我正在开发一种解决方案，旨在解决新手程序员在生产中的代码修复错误/执行更改请求时“修改代码”时遇到的问题。众所周知，Eclipse 是一个很棒的 IDE。与使用 Textpad 之类的工具相比，代码完成、开放声明、类型层次结构、包资源管理器、导航器、查找引用等功能可以帮助人们更快地修复问题。
如果您是一名新手 Java 程序员并且正在使用 Eclipse IDE，您认为 Eclipse IDE 的哪些方面不太有帮助/不太直观？如果您是一位经验丰富的程序员，新手期待您解决哪些常见问题？
请忽略与以下相关的问题：领域专业知识（业务知识）、基础设施（在哪里测试您的更改等）、性能相关（Eclipse 搜索速度慢等）、特定语言的技能水平（将开发人员视为菜鸟）。 .. 并考虑一种语言 - Java
我在我的小团队中进行了一项本地调查，以下是一些：
- 新手使用 Eclipse 来处理编写到在运行时提供实现的接口的代码。进行“开放声明”将始终向您显示一个界面。有时这可能会令人困惑。
- 开发 EJB 时 Eclipse 并不直观。当然，您知道创建新 bean 所需要做的就是右键单击并“创建 Bean”，但是，一旦创建，它就不会显示下一步应该做什么的上下文帮助。例如，生成存根。
- 当使用实体 bean 进行数据源映射时，更改某些内容会搞乱整个事物流程，并且 eclpise 永远不会抱怨/提示。
- 开发使用 Struts 的应用程序时，Eclipse 不会告诉您当您更改 struts-config.xml 时，特定的 Web 流程会受到影响。
在这一点上，对于我来说，作为一个有兴趣为我的研究收集意见的人，Eclipse 似乎可以使用更多的“上下文运行时提示”。
我相信社区还会有更多内容需要添加...请添加更多您的负面经历（仅从代码更改的角度来看）。
编辑： 我想，我的问题太冗长且令人困惑。我将稍微改一下措辞并保持简短：
在“进行代码更改”时（与代码格式化、基础相关活动、CVS 等不同...说类似重构之类的东西），什么Eclipse IDE 的功能是您最不喜欢/最讨厌的吗？以下是示例：
- 修改已写入接口的代码时：“对象实例上的打开声明 /F3 会在运行时提供实现时向您显示接口”。
- 使用 EJB 更改应用程序时：没有上下文帮助
- 使用 MVC（Spring / Struts）更改应用程序时：没有有关更改影响的警告。
I am working on a solution that aims at solving problems that newbie programmers experience when they are "modifying code" while bug fixing / doing change requests, on code in production. Eclipse, as we all know is a great IDE. Features such as Code Completion, Open Declaration, Type Hierarchy, Package Explorer, Navigator, Finding References etc aids people in fixing things quicker compared to say using something like Textpad.
If you are a newbie java programmer and you are using Eclipse IDE, what areas of the Eclipse IDE do you think were less helpful/ less intuitive? If you are a seasoned programmer, what are the common issues that newbies look up to you to solve for them?
Please ignore issues related to : Domain Expertise (Business Knowledge), Infra( where to test your change etc), performance related (eclipse search being slow,etc), Skill level in a particular language (think of the developer as a noob) ... and think one language - Java
I did a local survey in my small team and here are some:
- Newbies using Eclipse to handle code that is written to interfaces where the implementation is supplied at runtime. Doing a 'Open Declaration' will always show you an interface. This could be confusing at times.
- Eclipse is not intuitive while developing EJBs. Sure, you know all you have to do to create a new bean is to right click and 'Create Bean', however, once created it shows no contextual help to what the next step should be. For instance, generating stubs.
- When Data Source Mapping with entity beans, changing something screws up the entire flow of things and eclpise never complains / hints.
- Developing applications that make use of Struts, eclipse doesn't tell you that when you change struts-config.xml, particular web flow would get affected.
At this point, to me, as someone who is interested in collecting opinions for my research, it appears as if Eclipse could use more 'contextual runtime hints'.
I am sure the community would have a lot more to add... Please add more of your negative experiences (just from the code change perspective).
EDIT:
I guess, my question was too lengthy and confusing. I am gonna rephrase it a bit and keep it short:
While "making a code change" (not analogous to code formatting, infra related activities, CVS etc... say something like refactoring), what feature(s) of eclipse IDE did you not like / hate the most? Here are the examples:
- When modifying code that has been written to interfaces: 'Open Declaration /F3 on an object instance shows you the interface when the implementation is supplied at runtime'.
- When changing apps using EJBs: No contextual help
- When changing apps using MVCs(Spring / Struts) : No warnings about change impact.
如果你对这篇内容有疑问，欢迎到本站社区发帖提问 参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。
绑定邮箱获取回复消息
由于您还没有绑定你的真实邮箱，如果其他用户或者作者回复了您的评论，将不能在第一时间通知您！
发布评论
评论（19）
Eclipse 中缺少：
软件可视化，例如系统复杂性视图 [Lanza 2003 ]
还有 Lanza 的《类蓝图》[Ducasse 2005]
然后协同过滤“之前编辑过此方法的其他开发人员也编辑过” [Zimmermann 2005]
以及可浏览示例的集合，以及这些示例级别的自动完成功能。也就是说，例如，如果您写入
并点击自动完成，它应该在代码库和互联网上搜索将文件转换为字节缓冲区并在那里插入 10-20 行的示例。
给定输入参数类型的目标数据类型。 http://doi.acm.org/10.1145/1453101.1453129
给定输入参数类型的目标数据类型。http://doi.acm.org/10.1145/1064978.1065018
正在开发的代码片段的文本。 http://lsmr.cpsc.ucalgary.ca/papers/holmes-icse -2005.pdf
当然，我还可以编写单元测试，然后 IDE 在互联网上搜索通过测试的类。是的，这是可以做到的！
这个列表可以一直列下去，更多工作的良好起点是过去
这些都属于 ICSE 会议的范畴。
Missing in Eclipse are:
Software visualization, as for example System Complexity View [Lanza 2003]
And also by Lanza, the Class Blueprint [Ducasse 2005]
And then collaborative filtering "other developers that edited this method before also edited" [Zimmermann 2005]
And the collection of browsable examples, and autocompletion at the level of these examples. That is, for example if your write
and hit autocompletion it should search the codebase and the interwebs for examples that convert files to bytebuffers and insert that 10-20 lines there.
destination data type from given input parameter types. http://doi.acm.org/10.1145/1453101.1453129
destination data type from given input parameter types.http://doi.acm.org/10.1145/1064978.1065018
text for the code fragment under development. http://lsmr.cpsc.ucalgary.ca/papers/holmes-icse-2005.pdf
And of course also the feature that I can write a Unit test and then the IDE searches the interwebs for classes that pass the test. Yes, this can be done!
This list could go on and on, good starting points for more work are the proceedings of past
which are all under the umbrella of the ICSE conference.
我自己也遇到过“新手问题”（我已经使用 Eclipse 有一段时间了，但它偶尔会让我感到“惊讶”），并帮助刚开始使用 Eclipse 的同事：
"newbie issues" I've seen myself (I've used Eclipse for a good while, but it keeps "surprising" me occasionally) and helping colleagues just starting to use Eclipse:
对我来说，Eclipse 中的大多数新手问题都来自于它的优势之一，即它的可配置性和可配置性。插件结构。
当我需要更改 Eclipse 中的属性时，我似乎总是需要花几分钟来弄清楚在哪里更改它。示例：更改 Java 编辑器以插入 4 个空格而不是制表符。属性中的搜索栏总是受欢迎的:-)
当我设置项目时，某些插件缺乏文档总是很有趣。
编辑：您始终可以使用 ctrl-T 显示实现接口的类。
我要补充的一件事是，当我有一个复杂的项目时，我倾向于使用刷新和刷新。项目 -> 重建所有*很多”。我使用 TortoiseSVN 来操作 Eclipse 之外的东西，因为很多时候这更容易（例如一些重构）。但是，如果我在 Eclipse 之外修改项目，我“总是”退出 Eclipse，并在重新启动它时进行完全刷新和构建。否则 Eclipse 有时会变得非常混乱。
For me, most of the newbie problems in Eclipse come from one of it's strengths, its configurability & plugin structure.
When I need to change a property in Eclipse, I always seem to have to spend a few minutes working out where to change it. Example: changing the Java editor to insert 4 spaces instead of a tab. The search bar in the properties is always welcome :-)
That and the lack of documentation for some of the plugins always makes for fun when I'm setting up a project.
EDIT: You can always show the classes that implement an interface using ctrl-T.
One thing I would add is that when I have a complex project, I tend to use Refresh & Project->Rebuild All *a lot". And I use TortoiseSVN to maniuplate stuff outside of Eclipse, because a lot of times this is easier (some refactoring for instance). However, if I'm modifying the project outside of Eclipse, I *always" quit Eclipse, and do a full refresh and build when I restart it. Otherwise Eclipse gets very confused sometimes.
我认为我在使用 Eclipse 时面临（并且仍然面临）的最大问题是它没有特别了解现代 Java 开发的标准技术。如果我正在开发一个应用程序，它可能包括以下内容：
我认为 Eclipse 处理这些技术的意识水平不断提高：（所以 JUnit 会很好，它开箱即用；Subversion 需要Subclipse，它比 CVS 支持稍微复杂一些；需要安装一些 WTP 工具……您最好设置自己的外部工具命令，而不是信任 M2Eclipse，除非它最近变得明显更好。 times; 和Spring，好吧，正如你所说，尝试按住ctrl键单击一个方法，你几乎肯定会得到一个接口，因为实现隐藏在Spring配置文件后面）。
让所有这些一起发挥作用并签出/编译，然后编译/运行测试/签入是困难的一点。代码更改本身可能很容易:)
I think the biggest problem I faced (and still face) with Eclipse is that it isn't particularly aware of standard technologies that surround modern Java development. If I'm developing an application, it might include the following:
I think Eclipse handles those technologies in increasing levels of awareness: (so JUnit will be fine, it works out of the box; Subversion requires Subclipse, and it's a little ropier than the CVS support; JSF needs some WTP tooling to be installed; Maven...you're probably best off setting up your own external tools commands rather than trust M2Eclipse, unless it's become dramatically better in recent times; and Spring, well, as you say, try ctrl-clicking on a method and you'll almost certainly get an interface, because the implementation is hidden away behind a Spring config file).
Getting all of that to play together and check out/compile, then later compile/run tests/check in is the difficult bit. The code change itself is probably easy :)
对我来说，学习有效使用 Eclipse 的最大障碍是了解在哪里设置类路径，以及如何准确地找出各个开发阶段（编译、构建、测试）的类路径中包含的内容。很长一段时间我对编译时间、调试配置和运行配置类路径之间的区别感到困惑。然后，如果您将 ant 添加到混合中（它会自动创建运行配置），这会让新手更加困惑。
For me, the biggest hurdle to learning to use eclipse effectively was understanding where to set the classpath and also how to figure out exactly what is included on the classpath for various stages of development (compile, build, test). I was confused for a long time about the difference between compile time, debug configurations, and run configurations classpaths. Then if you throw ant into the mix (which automatically creates a run configuration ) it makes it even more confusing for newbies.
作为初学者，我没有做过 EJB 或 Struts 的东西。甚至数据源映射。所以我认为这个问题的标题可能有点误导。
当我在调试等过程中点击它时，我会很高兴内置像 JadClipse 这样的东西来“查看”库代码。但应该非常清楚的是，这是“重构的代码”，并不意味着被黑客入侵。
其次，菜鸟需要更加意识到 Shift-F2 将为他们提供任何类/方法的 API 文档。正在看。我认识太多的新手 Java 程序员，他们只是通过代码补全来探索 API。他们缺少图书馆作者提供的许多有价值的提示。
As a beginner, I didn't do EJB or Struts stuff. Or even data source mapping. So I think the question's title may be a little misleading.
I would have appreciated having something like JadClipse built in to "look at" library code when I hit it in debugging or such. But it should be made VERY clear that this is "reconstituted code" and not meant to be hacked around in.
Second, noobs need to be made much more aware that Shift-F2 will get them the API documentation for whatever class/method they're looking at. I know too many novice Java programmers who explore their APIs with nothing more than code completion; they're missing many valuable hints provided by the library authors.
一个可以动态生成代码的读心器，只需单击一下就足以完成一个项目。
A mindreader which generates code on the fly, so that a single click is sufficient to complete a project.
我发现 Visual Studio 很容易上手，我尝试单击每个按钮至少一次，并弄清楚整个事情的作用。它是由最高级别的单一设计团队精心设计的，一切都或多或少地遵循自上而下的标准。
然后，我就玩 Eclipse。从技术角度来说，它充其量只是很糟糕。查看首选项对话框；这是一个压倒性的火车残骸，除非你已经确切地知道你在寻找什么，以及开发该功能的开发人员决定如何称呼它。
Eclipse 的可配置性依赖于您已经知道如何配置它。那里的学习曲线很糟糕，唯一的可取之处是大多数默认值一开始就可以。
I found Visual Studio easy to pick up, I tried clicking on each button at least once, and figured out what the whole thing does. It's thought out by a single design team at the highest level, and everything follows the standards top to bottom, more or less.
Then, I play with Eclipse. In technical terms, it's janky at best. Look at the preferences dialog; it's an overwhelming trainwreck, unless you already know exactly what you're looking for, and what the developer working on that feature decided to call it.
Eclipse's configurability relies on the fact you already know how to configure it. The learning curve there is awful, and the only saving grace is that most of the defaults are okay to begin with.
我最近是个 Eclipse 菜鸟，主要从事 Android 和 BlackBerry 的工作。至今令我困惑的一件事是，有大量的选项和设置以及可以在各个位置找到它们。例如，如果您安装了插件（例如黑莓插件），则可以在常规首选项中找到该设置或 BlackBerry 首选项或项目首选项。
这总是一场狩猎。
I was a noob to eclipse recently, mostly doing Android and BlackBerry stuff. And one thing that eludes me to this day is the massive multitude of options and settings and various places they can be found in. For instance, if you have a plugin installed (say BlackBerry plugin), the setting might be found in the general prefs or BlackBerry prefs or the project prefs.
It's always a hunt.
据我所知，以下是基本缺失的功能：
这些功能在 IntelliJ 中非常有用。特别是#1和#5真的很有用。
Here are basic missing features as far as I know :
These features work great in IntelliJ. Especially #1 and #5 are really useful.
VCS 集成 - 通常开发人员对于合并更改、保持工作副本同步、解决冲突等方面还不熟悉。在 Eclipse 中通常有多种方法可以实现相同的目标，我曾多次看到这会导致混乱（实际上，我也曾在经验丰富的开发人员中看到过这种情况；他们知道 Subversion 但不知道 Eclipse，而后者试图“隐藏” ' 底层存储库操作）。
VCS integration - typically the developer is also new to merging changes, keeping working copies in sync, resolving conflicts and so on. There are often several ways of achieving the same thing in Eclipse and I've seen this cause confusion on several occasions (actually, I've seen this with experienced developers too; they know Subversion but not Eclipse, and the latter tries to 'hide' the underlying repository operations).
我认为对于初学者来说，所有 IDE 的问题都是与工具链的断开：编译器如何获取一些源代码并将其编译为字节码，然后使用具有正确配置的类路径的 VM 运行字节码。
作为一名开发人员，我喜欢这样一个事实：我不需要处理这个问题 - 而且我从未发现自己无法在更复杂的构建配置方面做我想做的事情 - 但这对于初学者来说太重要了了解当您按下要忽略的播放按钮时会发生什么。
I think the issue with all IDEs for beginners is the disconnection from the tool chain: how the compiler takes some source and compiles it to bytecode which I then run using the VM with a correctly configured classpath.
As a dev I love the fact I don't need to deal with this - and I've never found myself unable to do what I want concerning more complex build configurations - but it's too important for beginners to understand what's happening when you press that Play button to be ignored.
当我第一次尝试使用 Eclipse 时，我绝对讨厌它的复杂性。在你能够开始工作之前，你必须做一大堆事情。此外，您还有很多选项需要检查，并且并不总是能够自我解释每个按钮的作用。
相反，我开始使用 netbeans。方式更直观，更容易处理。检查那里的 gui.. 没有太多按钮，大多数时候你知道按钮的作用，即使你对 java 一无所知（就像我当时那样）。
当我改回 Eclipse 时（由于 Netbeans 不支持某些功能），使用它似乎要容易得多。因此，GUI 的某些部分可能只是以不直观的方式添加，初学者肯定会很难使用它。
when i first tried using eclipse i absolutely hated it's coplexity.. you had to do a whole bunch of things befor you were able to start working. furthermore you have way to many options to check and it's not always selfexplaining what each button does.
instead i started using netbeans. way more intuitive and easier to handle. check there gui.. not to much buttons and most of the time you know what the button does even if you have no clue of java (as i had at that time).
when i changed back to eclipse (due to some features not supported in netbeans) it seemed far easier to work with it. so some part of the gui might just be added in a not intuitive way and beginners will definitly have a hard time with it.
我可能会写得更详细，但我认为 Eclipse 过重并且过于注重功能 - 而不是易用性。 IMO，这涉及初学者和专业人士。
I might write it much more in detail, but i think, that eclipse is overweight and much too much oriented on features - instead of ease of use. IMO, this concerns beginners as well as professionals.
Eclipse 没有用于 Swing 组件的可视化设计器。
与 Visual Studio 相比，其中：
在 Eclipse 中，您要么必须使用 Netbeans（即不是 Eclipse...），要么使用 IBM 的 SWT，要么手动编写 Swing 表单。
我觉得在 Eclipse 中为 Swing 表单提供一个出色的所见即所得表单设计器会非常好。
Eclipse has no visual designer for Swing components.
Compare that to Visual Studio, where:
In Eclipse you either have to use Netbeans instead (ie not Eclipse...), or use IBM's SWT, or code the Swing forms by hand.
I feel it would be very nice to have a great wysiwyg forms designer in Eclipse for Swing forms.
另一个令人困惑的部分是，对于 Web 开发，需要使用一个单独的版本！嗯，我一点也不喜欢这个，而且我知道很多人就是不喜欢这个。
The other confusing part is that for web development there is a separate version that needs to be used! Well I didn't like this at all and I know that a lot of people just don't about this.
Eclipse 在标准发行版中缺少 Maven Embedded，Maven 将帮助任何用户获取其程序的所有 jar 和更好的库管理。
Netbeans 已经有这个工具了。
此外，Eclipse 还缺少使用 maven 进行 hibernate、spring、xfire 和 tomcat 部署的集成工具。
检查此网站 http://maven.apache.org/
Eclipse is missing Maven Embedded in standard distribution , Maven would help any user in getting their program all the jars and better library management .
Netbeans already has this tools.
Also eclipse misses integrated tools for hibernate , spring , xfire and tomcat deployment using maven.
Check this site http://maven.apache.org/
我已经提到了 Eclipse 的所有其他问题，除了一个：它太慢了。他们的目标是证明“Java 很慢”的人是对的吗？我猜这与“Eclipse 做一切”有关，但我停止使用它，因为每次我单击任何内容时它都会滞后。更改标签？落后。打开偏好设置？落后。更改首选项中的选项卡？落后。就像使用 32 Mb 内存的 Photoshop 一样。
哦，它非常丑陋。我希望我能通过真正的 GTK+ 集成来获得它。
All of my other problems with Eclipse have already been mentioned except one: It's slooooooooow. Was their goal to prove the "Java is slow" people right? I'm guessing this is related to the "Eclipse does everything", but I stopped using it because it lags every time I click on anything. Change tabs? Lag. Open preferences? Lag. Change tabs in preferences? Lag. It's like using Photoshop with 32 Mb of memory.
Oh and it's incredibly ugly. I wish I could get it with real GTK+ integration.
Android SDK 集成充满了卡顿。 xml 布局无法正确呈现。代码完成效果不佳。 IBM 肯定需要修复卡顿问题。
The android SDK integration is full of jank. xml layouts don't render correctly. Code completion doesn't work well. IBM needs to fix the jank for sure.