Summarize some suggestions from Effective Java that can help Android development

Effective Java is considered by many to be one of the most important books on writing Java code that is both maintainable and efficient over the long term. Android uses the Java language, so this means that all the advice given in this book must apply to Android, right? The answer is: not necessarily.

Some people think that most of the advice given in this book is not applicable to Android development. In my opinion, this is not the case. I think some parts of the book are not applicable because not all Java features are optimized for Android (such as enumerations, serialization, etc.) and because mobile devices have their own limitations (such as Dalvik/ART behaves differently from the JVM). Despite this, most of the examples in this book can be used without or with minimal modification and can help to build a healthier, cleaner, and maintainable code base.

This article focuses on the key points in the book that I think are essential for Android development. For those who have read the book, this article can serve as a review of the principles/knowledge mentioned in the book. For those who have not read it (yet), this article can give them a chance to try the book.

Forced not to be instantiable

If you do not want to use the new keyword to create an object, then force the use of a private constructor. This is more useful for utility classes that only contain static methods.

 List<Movie> latestMovies() {
    if (db.query().isEmpty()) {
 return Collections.emptyList();
 }
 [...]
 }

Static Factory

Instead of using the _new_ keyword and constructors, use static factory methods (and a private constructor). These factory methods are named, do not need to return a new object instance every time, and can return different subtypes as needed.

 class Movie {
 [...]
 public   static Movie create (String title) {
 return new Movie(title);
 }
 }

[Update] Reader @stsdema28 made a useful suggestion: using a static factory can make testing difficult. If this is the case, consider using a non-static factory that can be mocked during testing (or a factory interface that can be implemented).

Builders

When you need more than three construction parameters, use Builder to construct the object. It may be a bit verbose to write, but it is very scalable and readable. If you are creating a value type, consider AutoValue.

 class Movie {
 static Builder newBuilder() {
 return new Builder();
 }
 static class Builder {
 String title;
        Builder withTitle(String title) {
            this.title = title;
 return this;
 }
 Movie build() {
 return new Movie(title);
 }
 } 
  
    private Movie(String title) {
 [...]
 }
 }
 // Use like this:
 Movie matrix = Movie.newBuilder().withTitle( "The Matrix" ).build();

Avoid mutability

Immutable objects remain unchanged throughout their lifetime. All required data is provided when the object is created. This approach has many advantages such as simplicity, thread safety, and shareability.

 class Movie {
 [...]
 Movie sequel() {
 return Movie.create ( this.title + " 2" );
 }
 }
 // Use like this:
 Movie toyStory = Movie. create ( "Toy Story" );
 Movie toyStory2 = toyStory.sequel();

It may be difficult to make every class immutable. In this case, make your classes immutable as much as possible (e.g. use private final fields, final class declarations). Object creation is more expensive on mobile devices, so don't overdo it.

Static member class

If you define an inner class that does not depend on the outer class, don't forget to define it as static. Failure to do so will result in each instance of the inner class having a reference to the outer class.

 class Movie {
 [...]
 static class MovieAward {
 [...]
 }
 }

Generics are (almost) everywhere

Java provides type safety, and we should be grateful for it (see JS). Try to avoid using raw types or object types. Generics provide a mechanism to make your code type safe at compile time in most cases.

 // DON'T
 List movies = Lists.newArrayList();
 movies.add ( "Hello!" );
 [...]
 String movie = (String) movies.get(0); 
  
 // DO
 List<String> movies = Lists.newArrayList();
 movies.add ( "Hello!" );
 [...]
 String movie = movies.get(0);

Don't forget that you can use generics in function parameters and return values.

 // DON'T
 List sort(List input) {
 [...]
 } 
  
 // DO
 <T> List<T> sort(List<T> input) {
 [...]
 }

For more flexibility you can use bounded wildcards to expand the range of acceptable types.

 // Read stuff from collection - use "extends"  
 void readList(List<? extends Movie> movieList) {
 for (Movie movie : movieList) {
        System. out .print(movie.getTitle());
 [...]
 }
 } 
  
 // Write stuff to collection - use "super"  
 void writeList(List<? super Movie> movieList) {
    movieList. add (Movie. create ( "Se7en" ));
 [...]
 }

Returns empty (list/set)

Avoid using null when you must return an empty list/set. Returning an empty set results in a simpler interface (no need to document and declare that the function returns null) and avoids unexpected NullPointerExceptions. *** Return the same empty set instead of creating a new one.

 List<Movie> latestMovies() {
    if (db.query().isEmpty()) {
 return Collections.emptyList();
 }
 [...]
 }

Don't use + to concatenate Strings

If you want to concatenate a few strings, the + operator might work. But never use it to do a large number of string concatenations, as the performance will be terrible. Use StringBuilder instead.

 String latestMovieOneLiner(List<Movie> movies) {
    StringBuilder sb = new StringBuilder();
 for (Movie movie : movies) {
 sb.append(movie);
 }
 return sb.toString();
 }

Recoverable exceptions

I don't like throwing exceptions to indicate errors, but if you do, make sure the exception is checked and the catcher of the exception can recover from the error.

 List<Movie> latestMovies() throws MoviesNotFoundException {
    if (db.query().isEmpty()) {
        throw new MoviesNotFoundException();
 }
 [...]
 }

Summarize

This is not a complete list of advice given in the book, nor is it a brief in-depth review. It is just a list of useful suggestions :).