Usar público final en lugar de captadores privados

Veo los POJO más inmutables escritos así:

public class MyObject {
    private final String foo;
    private final int bar;

    public MyObject(String foo, int bar) {
        this.foo = foo;
        this.bar = bar;
    }

    public String getFoo() {
        return foo;
    }

    public int getBar() {
        return bar;
    }
}

Sin embargo, tiendo a escribirlos así:

public class MyObject {
    public final String foo;
    public final int bar;

    public MyObject(String foo, int bar) {
        this.foo = foo;
        this.bar = bar;
    }
}

Tenga en cuenta que las referencias son finales, por lo que el objeto sigue siendo inmutable. Me permite escribir menos código y permite un acceso más corto (por 5 caracteres: el gety ()).

La única desventaja que puedo ver es que si quieres cambiar la implementación getFoo()en el futuro para hacer algo loco, no puedes. Pero de manera realista, esto nunca sucede porque el Objeto es inmutable; puede verificar durante la creación de instancias, crear copias defensivas inmutables durante la creación de instancias (consulte Guava's, ImmutableListpor ejemplo) y preparar los objetos foou barpara la getllamada.

¿Hay alguna desventaja que me falta?

EDITAR

Supongo que otra desventaja que me falta son las bibliotecas de serialización que utilizan la reflexión sobre los métodos que comienzan con geto is, pero esa es una práctica bastante terrible ...

Cuatro desventajas en las que puedo pensar:

1. Si desea tener una forma de solo lectura y mutable de la misma entidad, un patrón común es tener una Entidad de clase inmutable que exponga solo los accesores con variables miembro protegidas, luego cree una MutableEntity que la extienda y agregue setters. Tu versión lo impide.
2. El uso de getters y setters se adhiere a la convención JavaBeans. Si desea utilizar su clase como un bean en tecnologías basadas en propiedades, como JSTL o EL, debe exponer a los captadores públicos.
3. Si alguna vez desea cambiar la implementación para derivar los valores o buscarlos en la base de datos, deberá refactorizar el código del cliente. Un enfoque de acceso / mutador le permite cambiar solo la implementación.
4. Menos asombro: cuando veo variables de instancia pública, inmediatamente busco quién puede estar mutando y me preocupa que esté abriendo la caja de Pandora porque se pierde la encapsulación. http://en.wikipedia.org/wiki/Principle_of_least_astonishment

Dicho esto, tu versión es definitivamente más concisa. Si se tratara de una clase especializada que solo se utiliza dentro de un paquete específico (tal vez el alcance del paquete es una buena idea aquí), entonces podría considerar esto para casos únicos. Pero no expondría las principales API como esta.

Deshazte de los captadores / setters también, ¡y estás bien!

Este es un tema muy controvertido entre los programadores de Java.

De todos modos, hay dos situaciones en las que uso variables públicas en lugar de (get) / setters:

1. público final Para mí esto indica "soy inmutable" mucho mejor que un simple captador. La mayoría de los IDE indicarán el modificador final con una 'F' durante la finalización automática. A diferencia de los getters / setters, donde debes buscar la ausencia de un setXXX.
2. público no final Me encanta esto para las clases de datos. Solo expongo todos los campos públicamente. Sin captadores, colocadores, constructores. No nada. Menos que un pojo. Para mí, esto inmediatamente indica "mira, soy tonto. Tengo datos, eso es todo. Es TU trabajo poner los datos correctos dentro de mí". Gson / JAXB / etc. manejar estas clases muy bien. Son una dicha para escribir. No hay duda sobre su propósito o capacidades. Y lo más importante: sabes que no hay efectos secundarios cuando cambias una variable. En mi humilde opinión, esto da como resultado modelos de datos muy concisos con pocas ambigüedades, mientras que los captadores y establecedores tienen este gran problema donde a veces ocurre magia dentro de ellos.

En palabras simples:

• Viola la encapsulación para guardar algunas líneas de código. Eso derrota el propósito de OOD.
• El código del cliente estará unido a los nombres de los miembros de su clase. El acoplamiento es malo. Todo el propósito de OOD es evitar el acoplamiento.
• También está muy seguro de que su clase nunca tendrá que ser mutable. Las cosas cambian. El cambio es lo único que es constante.

Una posible desventaja que puedo ver de improviso es que está vinculado a la representación interna de los datos en la clase. Probablemente esto no sea un gran problema, pero si usa los setters, y decide que foo y bar serán devueltos de alguna otra clase definida en otro lugar, las clases que consumen MyObject no deberían cambiar. Solo necesitaría tocar MyObject. Sin embargo, si usa los valores desnudos, entonces tendría que tocar en todas partes el MyObject que usé.