Utiliser les finalistes publics plutôt que privés

Je vois les POJO les plus immuables écrits comme ceci:

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;
    }
}

Pourtant, j'ai tendance à les écrire comme ceci:

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

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

Notez que les références sont finales, donc l'objet est toujours immuable. Cela me permet d’écrire moins de code et autorise un accès plus court (par 5 caractères: le getet ()).

Le seul inconvénient que je peux voir, c'est que si vous voulez modifier la mise en œuvre de getFoo()la suite pour faire quelque chose de fou, vous ne pouvez pas. Mais de manière réaliste, cela ne se produit jamais car l'objet est immuable; vous pouvez vérifier pendant l'instanciation, créer des copies défensives immuables pendant l'instanciation (voir Guava, ImmutableListpar exemple) et préparer les objets fooou barpour l' getappel.

Y a-t-il des inconvénients qui me manquent?

MODIFIER

Je suppose qu’un autre inconvénient qui me manque est la sérialisation des bibliothèques utilisant la réflexion par rapport aux méthodes commençant par getou is, mais c’est une pratique plutôt terrible ...

Quatre inconvénients auxquels je peux penser:

1. Si vous voulez avoir une forme en lecture seule et modifiable de la même entité, un modèle commun consiste à avoir une classe immuable Entity qui expose uniquement les accesseurs avec des variables de membre protégées, puis créez une MutableEntity qui l'étend et ajoute des setters. Votre version l’empêche.
2. L'utilisation de getters et de setters est conforme à la convention JavaBeans. Si vous souhaitez utiliser votre classe en tant que bean dans des technologies basées sur les propriétés, telles que JSTL ou EL, vous devez exposer les getters publics.
3. Si vous souhaitez jamais modifier l'implémentation pour dériver les valeurs ou les rechercher dans la base de données, vous devez refactoriser le code client. Une approche accesseur / mutateur ne vous permet de modifier que l'implémentation.
4. Le moindre étonnement - quand je vois des variables d'instance publiques, je cherche immédiatement qui peut le muter et crains d'ouvrir la boîte de Pandore car l'encapsulation est perdue. http://en.wikipedia.org/wiki/Principle_of_least_astonishment

Cela dit, votre version est nettement plus concise. S'il s'agit d'une classe spécialisée utilisée uniquement dans un package spécifique (la portée du package est peut-être une bonne idée ici), je peux envisager cette possibilité pour des éléments uniques. Mais je n'exposerais pas les principales API comme celle-ci.

Débarrassez-vous des getters / setters aussi, et tout va bien!

C'est un sujet très controversé parmi les programmeurs Java.

Quoi qu'il en soit, il y a deux situations où j'utilise des variables publiques à la place (!) Des getters / setters:

1. public final Pour moi, cela signifie "Je suis immuable", bien mieux qu’un simple getter. La plupart des IDE indiqueront le modificateur final avec un 'F' lors de la complétion automatique. Contrairement aux getters / setters, où vous devez rechercher l'absence d'un setXXX.
2. public non final J'adore ça pour les classes de données. Je viens d'exposer tous les champs publiquement. Pas de getters, setters, constructeurs. Non rien. Moins qu'un pojo. Pour moi, cela signifie immédiatement "regarde, je suis idiot. Je tiens des données, c'est tout. C'est VOTRE travail de mettre les bonnes données à l'intérieur de moi". Gson / JAXB / etc. gérer ces classes très bien. Ils sont un bonheur d'écrire. Il n'y a aucun doute sur leur but ou leurs capacités. Et plus important encore: vous savez qu'il n'y a pas d'effets secondaires lorsque vous modifiez une variable. IMHO cela aboutit à des modèles de données très concis avec peu d'ambiguïtés, alors que les accesseurs et les setters ont cet énorme problème où la magie se produit parfois à l'intérieur de ceux-ci.

En termes simples:

• Vous violez l’encapsulation afin de sauvegarder quelques lignes de code. Cela va à l'encontre du but de OOD.
• Le code client sera durement couplé aux noms des membres de votre classe. Le couplage est mauvais. L’objectif même de l’OOD est d’empêcher le couplage.
• Vous êtes également très sûr que votre classe n'aura jamais besoin d'être mutable. Les choses changent. Le changement est la seule chose qui soit constante.

Un inconvénient possible que je peux constater immédiatement est que vous êtes lié à la représentation interne des données dans la classe. Ce n'est probablement pas une grosse affaire, mais si vous utilisez les setters et que vous décidez que foo et bar seront retournés par une autre classe définie ailleurs, les classes consommant MyObject ne seront pas obligées de changer. Il vous suffira de toucher MyObject. Cependant, si vous utilisez les valeurs nues, vous devrez toucher partout où votre MyObject est utilisé.