I would know how to implement a Java IDE using Java language.
My IDE should :
compile, run and debug a source code.
import or export file from a directory.
allow generating code from class diagram.
allow modifying Java text editor.
allow generate Swing source code from, I mean it will offer a ability of drag and drop, then it generates source code.
it gives possibility to save, delete, undo and redo.
it support JUnit, maven and Ant.
So, I ask about technologies that will help me to realize this Java IDE. How to implement this IDE?
Except for the "drug" part which I am not sure of, I can tell it is not a trivial amount of work and of course I'd use the Java's GUI API
http://en.wikipedia.org/wiki/Swing_%28Java%29
Will not be sarcastic like others around here so I will try to give a short answer.
Despite there are some very very mature Java IDE's (Eclipse,NetBeans,INtelliJ ,JCreator,Codeguide etc) around it is your right to do another (who know someday maybe better then existing ones).
This being said you can do it
Swing (here you have to start from
zero)
use RCP Eclipse
Netbeans platform
QT it might be a solution
etc.
All of this support drag and drop and have support for creting class diagrams...
I warn you it is not easy....not easy at all.
Eclipse was audited recently and it has apx. 46 millions line of code
Good luck !
I'd safe yourself loads of time and just use Netbeans out of the box. Does everything you've listed and more. It's also free and has a module architecture to allow new functionality to be added fairly easily.
I want to use emacs for java coding, but I'm confused on what mode to use for java coding. There's jdee, which seems ide-like; malabar, who is said to be more well versed in java 1.5 constructs than jdee; and emacs-eclim, which is an eclipse backend for emacs. There are also a wealth of completion extensions for emacs, and I'm also confused on which one to use. In fact, I'm so confused that I deferred using any of them until I get recommendations.
What is the current best option for java-mode + completion in emacs? And, if ever I decide to use a combination of what I mentioned above, will conflicts happen?
For those used to the power of Emacs text manipulation then Eclipse can seem like pedaling a bicycle with one foot. The Emacs+ plugin from http://www.mulgasoft.com/ is excellent for getting Emacs key bindings into Eclipse.
I use both Eclipse and Emacs a lot, but if I only did Java development I might use only Eclipse with Emacs+. It takes some work to get many Eclipse features enabled on Emacs.
My advice is to use Emacs >= 23. If you are on a Mac, look at AquaMacs. I use JDEE as the Java plugin. This has the serious drawback of not playing well with generics. It's not that it stops working, it's just that a lot of stuff isn't recognized. Do not use the old 2.3.5 JDEE plugin (that comes with most Linux distributions), but get the 2.4 version from the sourceforge site. Also get the Emacs Code Browser (ECB); this is a plugin that will give you stuff like Eclipse's Project Explorer and Outline views (other developers will look at this and not believe you when tell them that it's Emacs). I've used this setup for commercial projects on Windows, Mac, and Linux in the past year.
In fact, Eclipse plays pretty well with Emacs and I often switch between the two. Eclipse has some nice refactoring tools that I used to use sed for, and it has a good debugger interface. You can use them simultaneously. I find that I use Eclipse when working with other people's code and Emacs when I am writing my own code---Emacs is that much faster. Note that for me, a lot of the value of Emacs is the non-Java functionality, like editing Tomcat configuration files on remote servers from my local Emacs, writing professional documents with LaTeX, developing in Python or Bash or MATLAB or XML, and the odd text manipulation task (e.g., converting CVS files into String[] arrays).
I haven't used the other two projects you mention. It is possible to use the Eclipse compiler with Emacs already, so I'm not sure I see the point of the emacs-eclim project, which seems to be moribund anyway. The Malabar project might be interesting, but seems to be the product of one somewhat cranky developer (e.g., the warning "if you're not using Maven (why?) you should not consider malabar-mode"---I'll tell my clients that?).
Java on Emacs is in a sad state. I wish for JDEE to be revitalized, but it's not clear when or if that will happen. The web site and mailing list offer few clues.
I use emacs-eclim with auto-complete-mode support and java-mode highlighting exclusively for Java programming. 90% of my work is done in emacs, but I switch to eclipse when I need to debug, run unit tests or do major refactorings. All in all, this setup works very well for me.
I haven't tried JDEE for years, but I remember it was a b*tch to set up. I didn't care for the UI very much, as it put up lots of prearranged windows that were locked in place. I like to be able to switch back and forth between editing buffers, often showing just one window, but splitting and rearranging on the fly when it becomes necessary.
Note: I am an emacs-eclim maintainer, and this has probably coloured my judgement.
If you're using Maven, then I'd recommend malabar-mode. It will set everything up for you automagically, no need for editing project files like you'd have to do with JDEE. The downside I've found with malabar, is that it can consume a lot of memory if you've got a lot of multi level module projects open.
Both Malabar and JDEE will give you "true" completion, i.e. only completions that are possible. However, there are two amazing "intelligent guessing completion frameworks" in Emacs. hippie-expand and auto-complete.
The former is great (can complete whole code blocks for you, making it possible to e.g. cycle through all if-tests in your projects), but auto-complete mode is even better. It'll give you a nice intelli sense style menu, will "learn" as you use it, and allows you to define a file with the completions you'd like to be available in the various languages.
I used Eclipse with the Android SDK to develop the original application. I ask since this was my first Java (and Eclipse, and Android, and XML) project. I assume that most of the Java should run on the PC without too much trouble. I may want to restructure the code to isolate the Android specific functions. Should I stay with Eclipse or move to something like NetBeans? Any advice would be terrific.
Eclipse vs Netbeans is irrelevant to your problem. They are both just glorified text editors that let you edit java code, with a little bit of compilation help. You can write any java app in either, its really just personal preference.
The ease of porting to windows really depends on what your application is. If you have a large chunk of code that is not dependent on any of the UI or lifecycle stuff, then you should be able to create a separate java library for that and reference it in both your android app, and your windows app.
The challange will be replacing the UI. As Fredley mentioned, swing is the built in option. Its a bit of a pain, but you should be able to find plenty of documentation on it.
If your application is tightly tied to the UI, then you are going to have a very hard time finding any code in common.
Assuming that most of your code is in Android-independant classes, your biggest hurdle will be the GUI. Investigate swing to start off with.
The choice between NetBeans and Eclipse is largely one of preference. NetBeans has some nice GUI tools- but so does Eclipse. In my opinion, it's usually best to stay with what you know.
Here's a decent post on the subject of Java IDEs: What is the best free IDE for Java Programming
I have an application of some 85 "frames" which was originally written with JBuilder 5 - an early IDE. The app is pure Java and I think it's all mostly Swing and AWT. So, the core question is: What IDEs can help me both maintain my existing application, possibly convert it from standalone to JSP, and hopefully also help with new development via a GUI interface?
Last summer ('08), I downloaded Eclipse and it sure beats JBuilder, except for the lack of a visual GUI WYSIWYG editor - the Visual Editor was dead even then. I like Ganymede (the current version) standard toolset, but lack of a visual editor concerns me. (And, I had a lot of trouble integrating it into an existing development environment.) While it lets you work with existing code, it didn't even have a (current) GUI editor, so working with my old code was the old-fashioned way ("blind").
In doing my homework, I found a company that makes/made a current-version Eclipse-based IDE that had a full-blown GUI environment that they claim make it easy to develop one GUI and then deploy it either as a stand-alone (pure Java) app, or deploy it as a web page (using JSP, etc). And, they suggested, it would let you work with existing applications, something none of the other systems do - that I've found so far. IIRC, it was about $250 for a license.
Unfortunately for me, life-events prevented action at that moment - long story short, I lost the link to their site. I thought it would be no problem to find them again, but the number of "plug-ins" and partners has EXPLODED! They now have nearly 1200 plug ins available and about 60 GUIs! YOWZER!
I came here to SO and got the idea from one of the several questions on "best IDE for Java" that NetBeans 6.5 is worth a look-see. I tried it. It's horrifically slow, even on a 3ghz box with 3G memory, etc. But, it integrated into the environment more quickly and I like its deployment details. I then found out that its GUI environment is only good for new code, and some here on SO suggest that it's a bit brittle and that if you have to hack it much (which I will need to do!) then it may break the ability of the GUI to continue to be editable in the IDE...
I've spent countless hours doing my homework on this, especially including looking here on SO and the web pages to which they often point. A lot of articles on Java IDE GUIs are old now, but I've read them anyway, and learned a lot...
Ideally, I'd like to find one tool that:
Competently, and without undue hassle works as a modern IDE for Java with a good GUI
Can help convert between types of applications - stand-alone vs JSP (mobile?)
Can work with existing applications (not written using that toolset).
Doesn't hook the code in to proprietary libraries.
If not in one tool, as multiple tools, it would still be nice to have all these abilities!
I do not require "free!"
Your input appreciated!
I suggest you look at Visual Editor again, as it should be able to work with existing code if this code is not too complex (in terms of business logic being mixed with the gui code).
Otherwise your time may be well spent in refactoring out the GUI code to a state where Visual Editor can handle it. I have not seen other free IDE's which can work with existing code.
NetBeans is powerful IDE for Java and have a good GUI builder.
If you already have Eclipse, I would recommend trying MyEclipse. This has a plug-in called Matisse4MyEclipse that is a nice GUI builder.
As it currently stands, this question is not a good fit for our Q&A format. We expect answers to be supported by facts, references, or expertise, but this question will likely solicit debate, arguments, polling, or extended discussion. If you feel that this question can be improved and possibly reopened, visit the help center for guidance.
Closed 10 years ago.
Is there any IDE that simplifies creating Swing applications (ideally something along the lines of Visual Studio)
Like others have mentioned, NetBeans' visual editor is pretty good, but it's based pretty heavily on the Swing Application Framework, so you'd need to get an understanding of how it works to properly use it (although you don't need to dig in to just test things).
Other than that there are also:
the IntelliJ IDEA visual editor (flash demo of the features)
and Eclipse's Visual Editor
Personally I've used NetBeans' and IDEA's visual editors. Both are nice, but I thought NetBeans had a leg up, because it doesn't use any proprietary way of saving the GUI structure and instead does something similar to what Visual Studio does - auto-generating the code that you can then add to. IDEA stores the information in a separate file which means you have to use IDEA to edit the layout visually later.
I have not used Eclipse's Visual Editor.
My vote is for NetBeans' visual editor. I think it satisfies what most people are looking for in a visual editor and leaves it flexible enough to plug the holes manually through code without affecting the visual editor (so you can switch back and forth between code and design views without breaking either).
I like the Swing GUI Builder from the NetBeans IDE.
For me, the best visual Swing editor is JFormDesigner, which you can run standalone or as a plugin for IntelliJ IDEA and Eclipse.
It generates proper (actually readable) source code, it's very ergonomic and intuitive and, above all, very extensible. That last point is really important, because if you want to build a decent Swing application, you'll have to extend the base components or use some third-party libraries and it must be easy to integrate those in the visual editor.
It's not free, but it's a bargain for the power you get (129 EUR / 159 USD). I've been using it for a few years and love it.
There are two that you can use (I've used them both, and they are both very powerful, and easy to use):
NetBeans which has a built in GUI Builder.
Or you can use:
Eclipse with the Windowbuilder plugin
(it can be downloaded here and here)
Personally, I prefer Eclipse with Windowbuilder, but that's just me. You can use either one.
Here is a picture of the Windowbuilder plugin:
And here is a picture of NetBeans' built in GUI Builder:
Netbeans has some GUI-building support, and it's one of the most popular Java IDEs on the market. Give it a look.
Try Instantiations' Windows Builder Pro. It includes Swing Designer, which is a Swing UI builder. It is based on Eclipse.
Abeille is very good and is based on the JGoodies FormLayout. Unlike almost every other Java GUI builder, Abeille does not generate code by default. In the project I used it on, it was wonderful to avoid reading or scrolling through the layout code (because that code no longer existed). Most of our hand-written code concerned itself with connecting events to actions, simply asking the layout for the relevant controls.
It's a crime that code generation is the default way to layout code in Java because better ways of doing GUIs have been around for decades. I have used Matisse, the NetBeans GUI code generator. While Matisse (now known as "Swing GUI Builder") makes it pleasant to layout components, it is similar to all other code generation tools because when you use Matisse you must live in constant fear that someone else edited the "you cannot edit this in NetBeans" GUI sections outside of NetBeans. As soon as you touch the layout builder again it could destroy their work and then you have a broken GUI. There might be some simple task like re-ordering a variable initialization and its use or re-naming a variable (this was especially a problem when using Matisse's database feature). You know how to do this by editing the un-editable source code but may waste time trying to figure out how to do the same thing in the GUI builder. Like most code generation tools, it might get you started, but eventually you will have to maintain the generated code yourself.
WindowBuilder Pro for Eclipse
Free!
It works with existing code and doesn't lock you in (as opposed to NetBeans)
It works with MiGLayout
It does have some conventions that your view classes have to follow, though.
Installing in Eclipse v4.2 (Juno):
Goto - menu Help → Install New Software...
Select - Work With: Juno - http://download.eclipse.org/releases/juno.
The WindowBuilder items are under "General Purpose Tools" (or use the filter).
Older versions and zips are available at http://www.eclipse.org/windowbuilder/download.php.
The latest version of NetBeans include a very nice and simple visual editor for Swing called Matisse
Matisse
I have a very good experience with NetBeans. It's so easy if you know every minor parts of these applications.
The most complicated part is using, for example, the layouts (if you can not handle complicated parts), but everything is almost plug & play.
And in addition, you can put JFrame into other frames without creating another frame class for this. I think that will be good.
I recommend WindowBuilder plugin for Eclipse IDE 3.7.2 Indigo / 24 February 2012.
Here's for the step-by-step installation: Create Java GUI as Easy as Visual Basic
NetBeans is the simplest to use (http://netbeans.org/). However, it does not allow you to edit (fine tune) the generated code.
JDeveloper (http://www.oracle.com/technetwork/developer-tools/jdev/overview/index.html) is another solution and does allow you to edit the code... but I feel NetBeans is more intuitive.
Frankly, I've never seen an editor which comes even close to what I can do manually in a text editor. All the visual editors are nice if you only have very simple needs like putting a few buttons in a window. When things become more complex, visual editors quickly loose their competitive edge.
I usually use a bunch of high-level classes built from more basic widgets and wire my UI from that. This also allows me to easily test my UI with automated JUnit tests (because I can control what the source looks like).
Lastly, changes to the UI won't generate unnecessary noise in the version control system.
Eclipse Visual Editor is pretty dull in my experience. I had more luck with JBuilder, which is also based on Eclipse, simply adding a few plugins to it as many other commercial products do. It is still not able to parse any Swing code (I doubt any Swing WISIWYG editor does), but if you start with it, it gives you relatively seamless experience.
You need to pay for it though.
At the end of the day, I have worked with different similar UI tools, Flash Builder, Delphi etc., but unless you do some relatively trivial UI design, not including much business logic and communication with other layers, you'll have to accept that what you are capable of creating in code once you learn to do it properly is much more powerful than what any editor is capable of providing you with.
I have switched between several IDEs and the one that I believe has the best GUI builder in terms of use and performance would have to be NetBeans.
I have tried a few and the closest I have found that comes close to Visual Studio is NetBeans. Version 6.5 is excellent and really improved over version 5.
I'm a big fan of JetBrains, and when it comes to Java, IntelliJ is the best IDE I have used.
For Swing, they have a fully interactive UI builder. And, for actual coding, their intellisense can't be beat.
JFormDesigner.
I used NetBeans extensively in the past for GUI design, but I am now using IntelliJ with the JFormDesigner plugin. I have tried several other solutions, and this is the one I am sticking with.
JFormDesigner also works with JBuilder and Eclipse, so you are not locking your projects to one particular IDE.
Of course you should use NetBeans for building a Java Swing GUI. The drag and drop features and auto-code generation are quite mature.
For Eclipse, I am not sure. But because IBM has its own SWT package for GUI, I am not sure whether it support Swing.
I used to use MyEclipse quite a bit. It had a decent IDE for making Swing forms and such. I assume it has improved in the past year - they seem to add features in gobs and heaps, quite often.
http://www.myeclipseide.com/
Use NetBeans, I have also successfully developed one application using NetBeans.
It is realy awesome, it helps you while writing the code.
Since Swing generates some code on its own so it is really helpful to use Netbeans.
Go through it and you can always ask question and problems.
It will be good if you go for latest version release.
I have always coded my UIs by hand. The frustration of dealing with screen builders and filling out all those property sheets is too much for me. After a couple of screens and a little research I am just as productive.
As I'm using Eclipse, I use the Visual Editor plugin. It generates clean source code, with good patterns and easy to patch/modify/extend.
Unfortunately, it is not very stable. But it's worth trying.
I like Eclipse's VisualEditor (VE), and sometime ago I've tried to switch to
another editor, but I found it impossible. Visual editor has this
feature that it generates manageable, readable, editable, and easy-to-understand code.
Unlike both mentioned earlier NetBeans editor and WindowBuilder it uses the lazy initialization pattern to separate initialization of components. Also it does not need to lock down parts of code that you can't edit; you may edit code by hand, and VE is still able to work with your changes.
The only disadvantage of VE is that it uses Eclipse v3.2 (Callisto) (there is no official build for Eclipse v3.4 (Ganymede), or Eclipse v3.3 (Europa)), so effectively you have to use two Eclipses instances, one for VE and one for the rest of the development.
I took it from recent discussion on comp.lang.java.gui (I was the author of this post, so I could do it rightfully). Here is the link to the whole discussion.
We have been doing Swing development for nearly the past 10 years. There are some nice GUI builders available (e.g. JFormDesigner), but all restrict us too much in different kinds.
For example, we have a lot of components without public no-arg constructor (e.g. a JTable subclass which requires the model in the constructor) or we have component factories.
Desktop applications usually have to be obfuscated. Obfuscation very easily breaks user interfaces created with a GUI designer or requires much work to avoid obfuscating such classes.
Another often happening case is that, for example, a panel should only contain some components depending on some condition. Simply hiding them would make the GUI look bad; they rather should not be added instead. I never found a GUI editor which provides this flexibility and even if there would be one, it would be so hard to use, that I definitely would be faster with good old Java code.
I think the best editor that can exist is Visual editor for Eclipse.
The only drawback is the fact that we can't re-edit the visual part when we modified the source code. I hope one day we will have a tool that rivals Visual Studio in this aspect.
I have not used anything other than NetBeans for Swing, but I have been extremely happy with it. I used it for 18 months on a $25M application and to develop an prototype application to replace a Windows Forms app.
Up and until Microsoft came out with WPF, in my opinion, there was not a better tool kit for traditional desktop applications. (I always found Windows Forms too limiting).
I personally will suggest NetBeans Swing Builder. Yet, if you want total control and to gain an in-depth understanding of the Swing framework, I have noticed doing it free hand is the ultimate choice.
window builder pro is good option and it is free also.
As others have mentioned, my best experience with Java SWING applications is with NetBeans. NetBeans has a WYSIWYG editor, and the code is automatically generated for you, which is then protected, however you can add custom code to add listeners and other events that the end user may be interested in using, such as buttons, text forms and areas, and other nice GUI tools.