What's your favorite feature in Java?

Question

After the series of Hidden feature posts, now is the time for listing down your favorite features. This thread will be used for listing Java specific features.

This is a community wiki. Please be specific.

Update : For .Net, please post your answers here: What’s your favorite feature in .NET?

Answer 1

Beans. Purely because of the name. Every time i hear it, i think of Bob & Ray. Or lame fart jokes. Name anything else, for any other language, that can inspire such thoughts. I dare you...

Answer 2

The number one thing that as a C# guy makes me jealous is java.util.concurrent.

Answer 3

Garbage collection!

Answer 4

No #include,ifdef,undef,define. Building multifile projects is 100 times easier than in C/C++ because the order of the classes doesn't matter. I thinks this is pretty damn important for newbies to programming. No wrestling with Makefiles and weird compiler errors.

Answer 5

More of a meta-feature: The fact that we can work in an environment using Macs, Windows and Linux computers based a personal preference and deploy to other Unix (Solaris and AIX) environments while almost disregarding the platform.

Answer 6

Collections! You youngsters probably don't remember what it was like not to have a bunch of different collection types provided. Having to constantly reinvent the wheel (and the list and the dictionary). Ugh. The memories make me shudder!

Answer 7

From an enterprise developer of 20 years who's worked in C, C++, Basic, Assembly and Java with a diverse range of talents (mostly "un"), I may have a different view than some others.

Simplicity and the lack of surprises and the fact that it's hard for another programmer to hide subtle issues behind cool tricks.

By this I mean:

• the fact that a class must be contained entirely in one source file, any references (includes) are clearly pointed out and easy to follow.
• The fact that there aren't too many "Neat/fun" constructs and the language is fairly consistent.
• The inability to change the effect of the programming language, the way it is always explicit--eliminating operator overloading and no macro type functionality.
• Very explicit reflection--sometimes it's quite useful--but I'm really glad it's not easier.

Answer 8

That it is now Open Source!

It's nice to see the various Linux distributions having a fully functional Java out of the box. Not to mention that soon we don't have to rely on Apple for Java on OS X.

Answer 9

I like the strong static types in Java. It is a key component of the language and most people will look past it.

I've tried Python and Javascript. I don't much care for dynamic typing.

Answer 10

Binary portability.

Everyone loves the vast multitude of free, 3rd party libraries available for Java. But what makes them particularly compelling is how easy they are to use. Almost no other free software out there is distributed in binary form. Almost all of it is in source code, save for Java.

Sure, you can get the source code for your favorite 3rd party libs and apps, but most folks go straight for the jar. Who here builds Tomcat from scratch? Unless you're a developer, there's basically no need to. (Which is a good thing, early Tomcat was a nightmare to build.) Rather, extract the zip file and fire it up -- Unix, Windows, Mac, whatever.

This portability and ease of use is a strong force in the Java world. You have a huge marketplace of users, they already "know" how to install your code with hardly a glance at the documentation. Heck, some libraries are a combination library and running application.

If we as Java coders had to build all of our software from scratch, playing "DLL Hell" that seems to permeate all of the popular platforms, we'd be doing a lot more reinvention instead of reuse, if for no other reason than to avoid the pain of getting some random library built.

Answer 11

1. The advanced refactoring you can do with certainty across a large codebase: rename variables, methods, classes, packages. Push/pull members/methods up or down a class hierarchy. Extract constants.

2. Reflection allows frameworks to handle unknown code at runtime, a very powerful concept.

3. Customizable class loading. Data == code.

Answer 12

Very IDE-friendly. Most of the cool stuff Eclipse is helped by the language- no preprocessor, static typing, etc.

Runner-ups:

1. Fantastic API. Flexible, complete and well thought of. The major problem it has, it does not accomodate the learning programmer. Some shortcuts would be helpful for the "simple stuff"; i.e. parsing XML without dealing with too many factories and the like. You can write these shortcuts yourself if you have some experience, but doing simple stuff can be too baffling for newbies. Most other problems would be solved if they actually read the Java Tutorial.
2. GC
3. Anonymous classes. Too verbose, but very handy.
4. Reflection and proxies.

I'm not counting here the ecosystem. For some reason or other, there's lot of high quality Java code out there, and it's easy to find.

Answer 13

My favourite "feature" in Java is IntelliJ IDEA :)

Answer 14

Being able to run languages other than Java on it.

Answer 15

Cross platform of course. Develop in PC deploy in HP-UX or AIX mosters!!! with absolutely no changes.

Answer 16

I thought annotations were a really neat feature in 1.5. I like how it simplifies code while improving code readability. Hibernate and Web Servies are two examples I can think of that have benefited strongly from annotations.

Answer 17

My favourite Java feature is Scala.

Answer 18

The number of opensource libraries available.

Also, call me sick, but I love the way java code looks.

Answer 19

The for-each loop from Java 1.5. An awesome improvement in terms of readability, by hiding the index or iterator variables .

Answer 20

Annotations (.NET: Attributes).

Answer 21

the synchronized keyword. Thread safety is so much easier...

Answer 22

Choice.

There are several IDEs (Eclipse, NetBeans, and the best of all, IntelliJ). You can use EJBs using several app servers or pass and use Spring POJO development. There are lots of persistence technologies: Hibernate, iBatis, TopLink, OpenJDO. There are literally HUNDREDS of web MVC frameworks: JSF, Struts, Wicket. There are several DI engines: Spring, Guice, PicoContainer. There are different aspect-oriented implementations: Spring aspects or AspectJ.

Some people think this is confusing and a drawback. It's certainly easier to simply point to whatever Microsoft is offering and say, "We'll use that."

But I like the choice.

Answer 23

Pre-Java 5 lack of templates. I am sorry, but I've read every argument as to what to include them, and it still does not justify having to write monstrosities like

for(Iterator i = myCollectioon.iterator(); (MyTargetType)i.next(); )
{
///
}

And so on and so on.

I wrote a large program in 2001-2002 that did a lot of set theory processing, and it was gruesome.

Answer 24

I know it may be like giving a crazy monkey a loaded gun, but I love reflection. Every time I have to do something, my brains try to think a reflection-wise way to do it. A pity I currently work with C++ (don't hit me please!)

Answer 25

java enum is better than c#. you can write inner class in enum class to do your business logic. in c#,enum is just a data list.

Answer 26

parent Classes, i really would like to have this in c++ as well:(

Answer 27

Generics. Now, I don't have to worry about writing returning or passing Object. Instead I can parameterize it. It's very effective when done well (mostly with inheritance). :-)

Answer 28

It's simplicity, yet extreme depth. Someone can learn Java quickly, but it can take a lifetime to become an expert in every bit of Java. It can do so much, and can continually surprise you with what it (or a new library) can do.

A lot of this simplicity is down to it's inheritance model, no need for pointers and it's garbage collection.

Answer 29

• Strong typing, checked Exceptions: no surprises at runtime.
• Neat java.io library design.
• Neat collections framework design.
• Dynamic classloading mechanisms (you can load even bytecode).
• Threads/Monitors as part of the language.
• Reflection API.
• Garbage collection. Weak references.