Aidez-moi à rattraper ce que j'ai manqué depuis Java 1.4.2 [fermé]

Je suis sur le point de commencer ma première carrière professionnelle en tant que développeur de logiciels, et je vais probablement écrire beaucoup de code Java. Je ne sais pas grand-chose sur ce que j'écrirai spécifiquement, et en plus, j'ai un intérêt assez large quand il s'agit de coder de toute façon.

Pour des raisons qui ne valent pas la peine d'être discutées, mon dernier stage m'a fait coder uniquement pour les SDK Java 1.3 et 1.4. De plus, mes études universitaires se sont principalement concentrées sur les algorithmes, les structures de données et d'autres théories, pas sur les fonctionnalités de langage ou les bibliothèques.

Donc, avec ce qui précède à l'esprit, quelles fonctionnalités, classes, etc. dans la version actuelle de Java (quel nombre sommes-nous actuellement, de toute façon?) Valent mon temps pour lire et pourquoi? Qu'est-ce que j'ai raté depuis 1.4.2 qui vous facilite la vie en tant que programmeur?

Des exemples et des histoires sur la façon dont vous avez découvert un package particulier ou un tel et l'avez utilisé seraient également formidables.

Les changements que je considère les plus importants sont:

• Génériques (par exemple, collections typées, comme Set)

• Enhanced for loop (for (String s: set) {...})

• Autoboxing / unboxing (convertir automatiquement entre des types comme Integer en int et vice versa)

• Énumérations Typesafe (enum est maintenant un mot-clé, les types peuvent être créés à partir d'énumérations)

• Varargs (pour la fonction printf (), permet un nombre variable d'arguments)

• Importation statique (peut désormais importer des méthodes statiques d'une classe, telles que java.lang.Math)

• Annotations

• java.util.concurrent (illustre la concurrence de java)

Lisez aussi Quel Java visez-vous? , pour mieux comprendre chacune des trois versions.

Le changement le plus important dans votre vie de programmation quotidienne est l'introduction de génériques qui seront très probablement utilisés dans chaque nouveau module que vous serez invité à écrire, et c'est une nouvelle syntaxe déroutante.

Les génériques sont le mécanisme permettant par exemple Listà a de contenir des chaînes au lieu d'objets nus, où le compilateur impose qu'un élément à mettre dans la liste soit une chaîne, et il sait que lorsque vous extrayez un élément d'une liste, c'est une chaîne .

Cela fait de meilleurs programmes car vous évitez le cast d'exécution explicite vers le type cible (qui est une source fréquente d'erreurs si vous vous trompez) et l'IDE peut vous aider à faire tout le sale boulot car il en sait beaucoup plus sur votre code que il l'a fait quand ce n'était qu'une liste d'objets.

Joshua Bloch a écrit une bonne introduction aux génériques, qui est disponible comme exemple de chapitre sur http://java.sun.com/docs/books/effective/

Autoboxing est une fonctionnalité intéressante introduite avec Java 5. Tout comme en C #, le compilateur effectue maintenant une conversion automatique entre les types primitifs (de base) et leurs classes d'encapsulage d'objets correspondantes (int en entier, etc.) et inversement. Cela rend le travail avec Java Collections beaucoup moins pénible.

Pour chaque boucle, je pense que c'était aussi nouveau dans Java 5. Il facilite l'itération sur les tableaux (et les collections), car il élimine une grande partie de l'encombrement habituel impliquant la configuration et la gestion d'une variable d'index ou d'itérateurs. Par exemple:

void myMethod(Collection<myObjectType> c) {
    for (myObjectType o : c)
        o.foo();
}

Enums , pour remplacer la statique et les constantes finales et vous aider à supprimer les références aux chaînes et aux nombres magiques. Un exemple tiré des bonnes personnes au soleil / oracle :

public enum Planet {
    MERCURY (3.303e+23, 2.4397e6),
    VENUS   (4.869e+24, 6.0518e6),
    EARTH   (5.976e+24, 6.37814e6),
    MARS    (6.421e+23, 3.3972e6),
    JUPITER (1.9e+27,   7.1492e7),
    SATURN  (5.688e+26, 6.0268e7),
    URANUS  (8.686e+25, 2.5559e7),
    NEPTUNE (1.024e+26, 2.4746e7),
    PLUTO   (1.27e+22,  1.137e6);

    private final double mass;   // in kilograms
    private final double radius; // in meters
    Planet(double mass, double radius) {
        this.mass = mass;
        this.radius = radius;
    }
    public double mass()   { return mass; }
    public double radius() { return radius; }

    // universal gravitational constant  (m3 kg-1 s-2)
    public static final double G = 6.67300E-11;

    public double surfaceGravity() {
        return G * mass / (radius * radius);
    }
    public double surfaceWeight(double otherMass) {
        return otherMass * surfaceGravity();
    }
}

et

public static void main(String[] args) {
        double earthWeight = Double.parseDouble(args[0]);
        double mass = earthWeight/EARTH.surfaceGravity();
        for (Planet p : Planet.values())
           System.out.printf("Your weight on %s is %f%n",
                             p, p.surfaceWeight(mass));
    }

java.util.concurrent a été introduit dans la version 1.5. La meilleure ressource pour l'apprendre est (probablement) le livre Java Concurrency in Practice . La simultanéité à mon humble avis est l'avantage concurrentiel le plus important de Java par rapport à toute autre chose, donc il vaut vraiment la peine de bien le savoir.

Eh bien, cela StringBuilderm'a aidé à accélérer mon programme. C'est l'équivalent de la StringBuffersécurité sans filetage.

Je vais vous aider en catégorisant la réponse utile de @ykombinator. Sa liste est une liste des éléments que vous utiliserez au quotidien lors du développement java "général".

Impact faible et faible difficulté:

• Enhanced for loop (for (String s: set) {...})
• Autoboxing / unboxing (convertir automatiquement entre des types comme Integer en int et vice versa)
• Varargs (pour la fonction printf (), permet un nombre variable d'arguments)
• Importation statique (peut désormais importer des méthodes statiques d'une classe, telles que java.lang.Math)

Impact élevé et difficulté moyenne:

• Énumérations Typesafe (enum est maintenant un mot-clé, les types peuvent être créés à partir d'énumérations)

Impact élevé et difficulté élevée:

• Annotations
• Génériques

Impact faible et élevé difficile (ne sera utilisé que si vous effectuez un filetage avancé)

• java.util.concurrent (illustre la concurrence de java)

Je vous suggère donc de lire la documentation / l'aide sur les pièces à faible impact et à faible difficulté - elles sont faciles à ramasser. Passez un peu de temps sur les annotations et les génériques - les annotations sont très utiles et les génériques peuvent devenir assez compliqués.

Ne regardez le nouveau contenu de concurrence que si vous avez besoin de faire du filetage.

Comme je ne peux pas commenter parce que j'ai moins de 50 ans, je vais laisser une réponse. Cela a déjà été mentionné mais je le répéterai encore: Annotations! Ce type de métadonnées est devenu la chose la plus importante de mes années d'expérience Java. Bien utilisé comme certains frameworks, il rend le code beaucoup plus concis et propre. Par exemple, les annotations peuvent:

• Convertir un objet en une entité @Entity
• Convertir une méthode en service REST @GET
• Expliquez qu'une méthode ne retournera jamais null @nonnull
• Définissez un objet sur un champ pour l'injection de dépendances @inject

Et bien sûr, vous pouvez créer vos propres annotations et savoir si une méthode, une classe ou un champ est annoté par réflexion.

Apprendre par l'exemple fonctionne pour moi

Voici un exemple rapide de Java 6 idiomatique

public class Main {
  public static void main(String[] args) {
    // Shows a list forced to be Strings only
    // The Arrays helper uses generics to identify the return type
    // and takes varargs (...) to allow arbitary number of arguments
    List<String> genericisedList = Arrays.asList("A","B","C");

    // Demonstrates a for:each loop (read as for each item in genericisedList)
    for (String item: genericisedList) {
      System.out.printf("Using print formatting: %s%n",item);
    }

    // Note that the object is initialised directly with a primitive (autoboxing)
    Integer autoboxedInteger = 1;
    System.out.println(autoboxedInteger);

  }
}

Ne vous embêtez pas avec Java5, il est obsolète par rapport à Java6.

Étape suivante, les annotations. Ceux-ci définissent simplement les aspects de votre code qui permettent aux lecteurs d'annotations de remplir la configuration standard pour vous. Prenons un service Web simple qui utilise la spécification JAX-RS (il comprend les URI RESTful). Vous ne voulez pas vous embêter à faire tout le méchant WSDL et déblayer avec Axis2, etc., vous voulez un résultat rapide. Bon, faites ceci:

// Response to URIs that start with /Service (after the application context name)
@Path("/Service")
public class WebService {

  // Respond to GET requests within the /Service selection
  @GET
  // Specify a path matcher that takes anything and assigns it to rawPathParams
  @Path("/{rawPathParams:.*}")
  public Response service(@Context HttpServletRequest request, @PathParam("rawPathParams") String rawPathParams) {
    // Do some stuff with the raw path parameters 

    // Return a 200_OK
    return Response.status(200).build();
  }
}

Coup. Avec un peu de magie de configuration dans votre web.xml, c'est parti. Si vous construisez avec Maven et que le plugin Jetty est configuré, votre projet aura son propre petit serveur Web dès la sortie de la boîte (pas de tripotage avec JBoss ou Tomcat pour vous), et le code ci-dessus répondra aux URI des forme:

GET http://localhost:8080/contextName/Service/the/raw/path/params

Travail accompli.

Wow, c'était une explosion du passé! Je n'ai pas utilisé Java depuis 4 ans maintenant - et rien n'a changé du tout depuis!

Il y a une liste de fonctionnalités par version , mais voici le bit important (plagié bien sûr) ...

J2SE 5.0 (30 septembre 2004)

• Génériques: fournit une sécurité de type (statique) au moment de la compilation pour les collections et élimine le besoin de la plupart des transtypages (conversion de type).
• Métadonnées: également appelées annotations; permet aux constructions de langage telles que les classes et les méthodes d'être étiquetées avec des données supplémentaires, qui peuvent ensuite être traitées par des utilitaires sensibles aux métadonnées.
• Autoboxing / unboxing: conversions automatiques entre les types primitifs (tels que int) et les classes wrapper primitives (telles que Integer).
• Énumérations: le mot clé enum crée une liste de valeurs ordonnée et sécurisée (comme Day.MONDAY, Day.TUESDAY, etc.). Auparavant, cela ne pouvait être réalisé que par des entiers constants non-typesafe ou des classes construites manuellement (modèle d'énumération typesafe).
• Swing: nouveau look et sensation skinnable, appelé synthé.
• Varargs: Le dernier paramètre d'une méthode peut maintenant être déclaré en utilisant un nom de type suivi de trois points (par exemple void drawtext (String ... lines)). Dans le code appelant, un certain nombre de paramètres de ce type peuvent être utilisés et ils sont ensuite placés dans un tableau pour être passés à la méthode, ou bien le code appelant peut passer un tableau de ce type.
• Amélioré pour chaque boucle: la syntaxe de la boucle for est étendue avec une syntaxe spéciale pour itérer sur chaque membre d'un tableau ou de tout Iterable, comme les classes Collection standard, en utilisant une construction de la forme:

Java SE 6 (11 décembre 2006)

• La prise en charge des anciennes versions de Win9x a été supprimée. Officieusement, Java 6 Update 7 est la dernière version de Java qui fonctionne sur ces versions de Windows. On pense que cela est dû aux changements majeurs de la mise à jour 10.
• Prise en charge du langage de script: API générique pour une intégration étroite avec les langages de script et intégration de Mozilla JavaScript Rhino
• Améliorations spectaculaires des performances pour la plate-forme principale et Swing.
• Prise en charge améliorée des services Web via JAX-WS
• Prise en charge de JDBC 4.0.
• API du compilateur Java une API permettant à un programme Java de sélectionner et d'appeler un compilateur Java par programmation.
• Mise à niveau de JAXB vers la version 2.0: y compris l'intégration d'un analyseur StAX.
• Prise en charge des annotations enfichables
• De nombreuses améliorations de l'interface graphique, telles que l'intégration de SwingWorker dans l'API, le tri et le filtrage des tableaux et la véritable double mémoire tampon Swing (éliminant l'effet de zone grise).
• Les améliorations de la machine virtuelle Java incluent: la synchronisation et les optimisations des performances du compilateur, de nouveaux algorithmes et des mises à niveau des algorithmes de récupération de place existants et les performances de démarrage des applications.

C'est à peu près ça. Java SE 7.0 semble plus intéressant mais n'est pas encore sorti.

Compte tenu du nombre de nouvelles fonctionnalités de langage et d'API ajoutées à C # au cours des 4 dernières années, je suis assez étonné. Que s'est-il passé chez Sun / Oracle?