Existe-t-il une inférence de type automatique en Java?

Existe-t-il un autotype de variable en Java comme vous l'avez en C ++?

Un exemple:

for ( auto var : object_array)
    std::cout << var << std::endl;

for( auto var : object_array)
    var.do_something_that_only_this_particular_obj_can_do();

Je sais qu'il existe une boucle for améliorée en Java, mais y a-t-il une auto? Sinon, y a-t-il un hack pour faire cela? Je fais référence à la nouvelle fonctionnalité de C ++ 11

Répondu avant la modification de la question :

Non, il n'y a pas de autotype de variable en Java. La même boucle peut être réalisée comme:

for ( Object var : object_array)
  System.out.println(var);

Java a des variables locales, dont la portée est dans le bloc où elles ont été définies. Similaire à C et C ++, mais il n'y a pas de mot clé auto ou register. Cependant, le compilateur Java ne permettra pas l'utilisation d'une variable locale non explicitement initialisée et donnera une erreur de compilation (contrairement à C et C ++ où le compilateur ne donnera généralement qu'un avertissement). Gracieuseté: Wikipedia .

Non, il n'y a pas d'inférence de type traditionnelle en Java comme C ++. Il y avait un RFE mais celui-ci a été fermé comme "Ne résoudra pas", la raison invoquée était:

Les humains bénéficient de la redondance de la déclaration de type de deux manières. Tout d'abord, le type redondant sert de documentation précieuse - les lecteurs n'ont pas à rechercher la déclaration de getMap () pour savoir quel type elle renvoie. Deuxièmement, la redondance permet au programmeur de déclarer le type voulu, et ainsi de bénéficier d'une vérification croisée effectuée par le compilateur.

Peut-être que Java 10 a ce que vous (et moi) voulons, grâce au varmot - clé.

var list = new ArrayList<String>();  // infers ArrayList<String>
var stream = list.stream();          // infers Stream<String>

À partir des propositions d'amélioration JDK 286

Mise à jour: Oui, cette fonctionnalité a été intégrée à la version Java 10!

Java 7 introduit la syntaxe du diamant

Box<Integer> integerBox = new Box<>(); // Java 7

Par rapport à l'ancien java

Box<Integer> integerBox = new Box<Integer>(); // Before Java 7

Le lecteur critique remarquera que cette nouvelle syntaxe n'aide pas à écrire les boucles for dans la question d'origine. Cela semble correct et tout à fait intentionnel. Voir l'autre réponse qui cite la base de données de bogues d'Oracle.

Dans Java 8, vous pouvez utiliser l'inférence de type lambda pour éviter de déclarer le type. L'analogue aux exemples de l'interrogateur serait:

object_array.forEach(var -> System.out.println(var)); 
object_array.forEach(var -> var.do_something_that_only_this_particular_obj_can_do());

qui peuvent également être simplifiés à l'aide de références de méthode:

object_array.forEach(System.out::println); 
object_array.forEach(ObjectType::do_something_that_only_this_particular_obj_can_do);

En bref, non, il n'y a pas de type automatique. Si tout ce que vous faites est d'imprimer la valeur, vous pouvez simplement vous référer à la valeur comme un Object.

Ce n'est pas une solution Java pure, cependant l'ajout d'une bibliothèque appelée lombok permettra à la magie ci-dessous de compiler et de fonctionner de manière très similaire au automot-clé en C ++

List<String> strList = Arrays.asList("foo", "bar", "baz");
for (val s: strList){
    System.out.println(s.length());
}