'final' modifier on a class in Java

Question

I have a quick and simple question. I have a habit of making every class 'final' unless of course, it needs to be extended by another.

Is this a bad habit? A good habit? Does it even matter? I understand the effect of the modifier to a class.

Thanks a lot in advance!

Edit: Here is an example code. This class will not be extended by any other classes.

public final class Application {

    /**
     * Starts the application.
     * 
     * @param arguments arguments provided from command-line
     */
    public static void main(String[] arguments) {
        LaunchUtilities util = new LaunchUtilities(new EventHandler());

        try {
            util.addListener(43594);
        } catch (IOException ioe) {
            Logger.getLogger(Application.class.getName()).log(Level.SEVERE, "Could not bind a port to a listener!", ioe);
        }

        util.start();
    }
}

Answer 1

Programmers (even Java gurus) disagree on this.

Josh Bloch, who designed the Java Collections library, java.Math, assert, and is chief java architect at Google (or was before they hired Gosling) has a section of his book "Effective Java" devoted to this issue. I go with what he has to say:

Item 17: Design and document for inheritance or else prohibit it

He points out that subclassing classes that were not designed for it often leads to disaster.

Furthermore, designing for inheritance is expensive.

1. It puts major limits on what your class can do
2. You have to write more documentation so that sub class authors know how public methods are used internally by the class
3. You must test it. This requires testing writing subclasses

You can always change your mind and make something non-final. You cant make something final that use to be not final.

Read "Effective Java" it makes this argument much more compellingly. It will also make you a better programmer.

Answer 2

I'm going to say bad habit, for the following reasons:

• You have not specified any particular need for the class to be final.
• You are violating the open/closed principle. Classes should be open for extension, but closed for modification.
• Finalized classes can be difficult to test with mocking frameworks.

For example:

public static void main(String[] args) {
    final Fruit mockFruit = Mockito.mock(Fruit.class);
}

private static final class Fruit {

}

...will yield...

Exception in thread "main" org.mockito.exceptions.base.MockitoException: 
Cannot mock/spy class org.foo.Foo$Fruit
Mockito cannot mock/spy following:
  - final classes
  - anonymous classes
  - primitive types

Of course, there are valid scenarios for finalizing classes. For example, your class is immutable.