Ayúdame a ponerme al día con lo que me he perdido desde Java 1.4.2 [cerrado]

14

Estoy a punto de comenzar mi primera carrera profesional como desarrollador de software, y probablemente escribiré muchos códigos Java. No sé mucho sobre qué escribiré específicamente y, además, tengo intereses bastante amplios cuando se trata de código de todos modos.

Por razones que no valen la pena discutir, mi última pasantía me hizo programar solo para Java 1.3 y 1.4 SDK. Además, mi educación universitaria se ha centrado principalmente en algoritmos, estructuras de datos y otras teorías, no en funciones de lenguaje o bibliotecas.

Entonces, teniendo en cuenta lo anterior, ¿qué características, clases, etc. en la versión actual de Java (de qué número estamos ahora, de todos modos?) valdría mi tiempo para leer y por qué? ¿Qué he perdido desde la versión 1.4.2 que hace que tu vida como programador sea más fácil?

Los ejemplos e historias de cómo descubrió un paquete en particular o algo así y lo pusieron en uso también serían excelentes.

    
pregunta DGH 06.12.2010 - 07:34
fuente

10 respuestas

15

Los cambios que considero más importantes son:

  
  • Genéricos (por ejemplo, colecciones escritas, como Set)

  •   
  • Mejorado para bucle (para (String s: set) {...})

  •   
  • Autoboxing / unboxing (convierte automáticamente entre tipos como Integer a int y viceversa)

  •   
  • Enums con seguridad de tipos (enum es ahora una palabra clave, los tipos se pueden crear a partir de enums)

  •   
  • Varargs (para la función printf (), permite un número variable de argumentos)

  •   
  • Importación estática (ahora puede importar métodos estáticos de una clase, como java.lang.Math)

  •   
  • Anotaciones

  •   
  • java.util.concurrent (Demuestra la concurrencia de java)

  •   

Lea también ¿A qué Java apunta? , para comprenderlo mejor de cada una de las tres versiones.

    
respondido por el ykombinator 06.12.2010 - 10:34
fuente
10

El cambio más importante en su vida diaria de programación es la introducción de genéricos , que probablemente se usará en cada nuevo módulo que se le pedirá que escriba, y es un nuevo confuso sintaxis.

Los genéricos es el mecanismo que permite, por ejemplo, un List para contener cadenas en lugar de objetos desnudos, donde el compilador aplica que un elemento que se va a colocar en la lista es una cadena, y sabe que cuando se obtiene un elemento de una lista es una cadena.

Esto lo convierte en mejores programas al evitar la conversión explícita en tiempo de ejecución al tipo de destino (que es una fuente frecuente de errores si se equivoca) y el IDE puede ayudarlo a hacer todo el trabajo sucio, ya que sabe mucho más sobre su código como lo hizo cuando era solo una lista de objetos.

Joshua Bloch ha escrito una buena introducción a los genéricos, que está disponible como el capítulo de muestra en enlace

    
respondido por el user1249 06.12.2010 - 08:39
fuente
6

Autoboxing es una buena característica introducida con Java 5. Al igual que en C #, el compilador ahora realiza una conversión automática entre los tipos primitivos (básicos) y sus correspondientes clases de envoltorios de objetos (int a Integer, etc.) y de regreso. Eso hace que trabajar con Java Collections sea mucho menos doloroso.

Para-cada el bucle también fue nuevo en Java 5, creo. Facilita la iteración de matrices (y colecciones), ya que elimina gran parte del desorden habitual que implica la configuración y la gestión de una variable de índice o iteradores. En el ejemplo:

void myMethod(Collection<myObjectType> c) {
    for (myObjectType o : c)
        o.foo();
}
    
respondido por el Ray 06.12.2010 - 09:13
fuente
6

Enums , para reemplazar las estadísticas y constantes finales y ayudarlo a eliminar las referencias a cadenas y números mágicos. Un ejemplo tomado de la gente buena en sun / 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();
    }
}

y

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));
    }
    
respondido por el NimChimpsky 06.12.2010 - 11:36
fuente
6

java.util.concurrent se introdujo en 1.5. El mejor recurso para aprender es (probablemente) el libro Java Concurrency in Practice . La concurrencia IMHO es la ventaja competitiva más importante de Java en comparación con cualquier otra cosa, por lo que definitivamente vale la pena conocerla bien.

    
respondido por el Joonas Pulakka 06.12.2010 - 11:27
fuente
4

Bueno, StringBuilder me ayudó a acelerar mi programa. Es un equivalente de StringBuffer sin la seguridad de los hilos.

    
respondido por el duros 06.12.2010 - 13:12
fuente
4

Ayudaré categorizando la respuesta útil de @ykombinator. Su lista es una lista de los elementos que utilizará a diario mientras realiza el desarrollo de Java "general".

Bajo impacto y baja dificultad:

  • Mejorado para bucle (para (String s: set) {...})
  • Autoboxing / unboxing (convierte automáticamente entre tipos como Integer a int y viceversa)
  • Varargs (para la función printf (), permite un número variable de argumentos)
  • Importación estática (ahora puede importar métodos estáticos de una clase, como java.lang.Math)

Alto impacto y dificultad media:

  • Enumeración segura para los tipos (enum es ahora una palabra clave, los tipos se pueden crear a partir de enumeraciones)

Alto impacto y alta dificultad:

  • Anotaciones
  • Genéricos

Bajo impacto y alto dificultad (solo se utilizará a menos que hagas subprocesos avanzados)

  • java.util.concurrent (Demuestra la concurrencia de java)

Le sugeriría, por lo tanto, que lea los documentos / ayuda sobre piezas difíciles de bajo impacto - son fáciles de recoger. Dedique un poco de tiempo a Annotations and Generics - las anotaciones son muy útiles, y los genéricos pueden complicarse bastante.

Solo mira el nuevo contenido de concurrencia si necesitas hacer hilos.

    
respondido por el Michael Wiles 06.12.2010 - 14:38
fuente
4

Como no puedo comentar porque estoy por debajo de 50, le dejaré una respuesta. Ya se ha mencionado, pero lo repetiré de nuevo: ¡Anotaciones! Este tipo de metadatos se convirtió en lo más importante en mis años de experiencia con Java. Se usa bien, como lo hacen algunos marcos, hace que el código sea mucho más conciso y limpio. Por ejemplo, las anotaciones pueden:

  • Convierta un objeto en una entidad @Entity
  • Convierta un método en un servicio REST @GET
  • Explique que un método nunca devolverá el valor nulo @nonnull
  • Establezca un objeto en un campo para inyección de dependencia @inject

Y, por supuesto, puede crear sus propias anotaciones y saber si un método, clase o campo se anota mediante la reflexión.

    
respondido por el Luciano 06.12.2010 - 15:59
fuente
3

Aprender por ejemplo funciona para mí

Aquí hay un ejemplo rápido de Java 6 idiomático

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

  }
}

No se moleste con Java5, está obsoleto con respecto a Java6.

Siguiente paso, anotaciones. Estos solo definen aspectos de su código que permiten que los lectores de anotaciones completen la configuración de boilerplate por usted. Considere un servicio web simple que use la especificación JAX-RS (entiende URIs RESTful). No querrás molestarte en hacer todo el desagradable WSDL y jugar con Axis2, quieres un resultado rápido. Bien, haz esto:

// 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();
  }
}

Bang. Con un poco de magia de configuración en tu web.xml estás fuera. Si está construyendo con Maven y tiene configurado el plugin Jetty, su proyecto tendrá su propio servidor web de forma inmediata (sin necesidad de jugar con JBoss o Tomcat), y el código anterior responderá a los URI del forma:

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

Trabajo hecho.

    
respondido por el Gary Rowe 06.12.2010 - 11:25
fuente
3

Wow, eso fue una explosión del pasado! Hace 4 años que no uso Java, ¡y nada ha cambiado en ese momento!

Hay una lista de características por versión , pero aquí está el bit importante (plagiado por supuesto) ...

J2SE 5.0 (30 de septiembre de 2004)

  • Genéricos: proporciona seguridad de tipo de tiempo de compilación (estática) para colecciones y elimina la necesidad de la mayoría de los pronósticos (conversión de tipo).
  • Metadatos: también llamados anotaciones; permite que las construcciones de lenguaje, como clases y métodos, se etiqueten con datos adicionales, que luego pueden procesarse mediante utilidades que reconocen los metadatos.
  • Autoboxing / unboxing: conversiones automáticas entre tipos primitivos (como int) y clases de envoltorios primitivos (como Integer).
  • Enumeraciones: la palabra clave enum crea una lista de valores ordenada y de tipo seguro (como Day.MONDAY, Day.TUESDAY, etc.). Anteriormente, esto solo podía lograrse con enteros constantes sin tipos o clases construidas manualmente (patrón de enumeración con tipos seguros).
  • Swing: Nueva apariencia personalizable, llamada sintetizador.
  • Varargs: el último parámetro de un método ahora se puede declarar usando un nombre de tipo seguido de tres puntos (por ejemplo, texto de dibujo vacío (cadena ... líneas)). En el código de llamada se puede usar cualquier número de parámetros de ese tipo y luego se colocan en una matriz para pasar al método, o alternativamente, el código de llamada puede pasar una matriz de ese tipo.
  • Mejorado para cada bucle: la sintaxis del bucle for se extiende con una sintaxis especial para iterar sobre cada miembro de una matriz o cualquier Iterable, como las clases de Colección estándar, utilizando una construcción de la forma:

Java SE 6 (11 de diciembre de 2006)

  • Se ha eliminado el soporte para versiones anteriores de Win9x. De manera no oficial, Java 6 Update 7 es la última versión de Java que funciona para estas versiones de Windows. Se cree que esto se debe a los cambios principales en la Actualización 10.
  • Compatibilidad con el lenguaje de scripting: API genérica para una integración estrecha con los lenguajes de script, y la integración de Mozilla JavaScript Rhino incorporada
  • Mejoras de rendimiento dramáticas para la plataforma central y Swing.
  • Soporte mejorado del servicio web a través de JAX-WS
  • compatibilidad con JDBC 4.0.
  • API del compilador de Java: una API que permite a un programa de Java seleccionar e invocar un compilador de Java mediante programación.
  • Actualización de JAXB a la versión 2.0: incluye la integración de un analizador StAX.
  • Soporte para anotaciones conectables
  • Muchas mejoras en la GUI, como la integración de SwingWorker en la API, la clasificación y el filtrado de tablas, y el doble búfer de Swing (eliminando el efecto de la zona gris).
  • Las mejoras de JVM incluyen: sincronización y optimizaciones del rendimiento del compilador, nuevos algoritmos y actualizaciones a los algoritmos existentes de recolección de basura, y el rendimiento de inicio de la aplicación.

Eso es todo. Java SE 7.0 parece más interesante pero aún no se ha publicado.

Teniendo en cuenta la cantidad de nuevas funciones de lenguaje y API que se han agregado a C # en los últimos 4 años, estoy bastante sorprendido. ¿Qué está pasando en Sun / Oracle?

    
respondido por el sheikhjabootie 06.12.2010 - 14:27
fuente

Lea otras preguntas en las etiquetas