Aiutami a recuperare ciò che mi è mancato da Java 1.4.2 [chiuso]

14

Sto per iniziare la mia prima carriera professionale come sviluppatore di software, e probabilmente scriverò un sacco di codice Java. Non so molto su cosa specificatamente scriverò, e inoltre, ho interessi abbastanza ampi riguardo al codice comunque.

Per motivi che non valevano la pena di discutere, il mio ultimo stage mi ha permesso di programmare solo gli SDK di Java 1.3 e 1.4. Inoltre, la mia formazione universitaria si è concentrata principalmente su algoritmi, strutture dati e altre teorie, non su funzionalità linguistiche o librerie.

Quindi, tenendo presente quanto sopra, quali caratteristiche, classi, ecc. nella versione attuale di Java (quale numero ci troviamo adesso, comunque?) varrebbe il mio tempo per leggere e perché? Cosa mi è mancato dal 1.4.2 che rende la tua vita di programmatore più semplice?

Esempi e storie di come hai scoperto un particolare pacchetto o alcuni di essi e metterli in pratica sarebbe anche fantastico.

    
posta DGH 06.12.2010 - 07:34
fonte

10 risposte

15

Le modifiche che considero più importanti sono:

  • Generics (e.g. typed collections, like Set)

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

  • Autoboxing/unboxing (automatically convert between types like Integer to int and vice versa)

  • Typesafe enums (enum is now a keyword, types can be created out of enums)

  • Varargs (for printf() function, allows variable number of arguments)

  • Static import (can now import static methods of a class, such as java.lang.Math)

  • Annotations

  • java.util.concurrent (Demonstrates java's concurrency)

Leggi anche A cosa stai mirando Java , per ottenere una migliore comprensione di ciascuna delle tre versioni.

    
risposta data 06.12.2010 - 10:34
fonte
10

Il singolo cambiamento più importante nella tua vita di programmazione quotidiana è l'introduzione di generici che molto probabilmente saranno usati in ogni nuovo modulo che ti verrà chiesto di scrivere, ed è una nuova confusa sintassi.

Generics è il meccanismo che consente ad es. un List per contenere stringhe invece di oggetti nudi, in cui il compilatore impone che un elemento da inserire nell'elenco sia una stringa e sa che quando si ottiene un elemento da un elenco si tratta di una stringa.

Questo rende i programmi migliori quando si evita il cast esplicito del runtime per il tipo di destinazione (che è una fonte frequente di errori se si sbaglia) e l'IDE può aiutarti a fare tutto il lavoro sporco perché sa molto di più su il tuo codice piuttosto che quando era solo un elenco di oggetti.

Joshua Bloch ha scritto una buona introduzione a Generics, che è disponibile come capitolo di esempio su link

    
risposta data 06.12.2010 - 08:39
fonte
6

Autoboxing è una bella funzionalità introdotta con Java 5. Proprio come in C # il compilatore ora effettua una conversione automatica tra i tipi primitivi (base) e le corrispondenti classi wrapper oggetto (int in Integer ecc) e di nuovo indietro. Questo rende il lavoro con le Collezioni Java molto meno doloroso.

Anche il ciclo

For-each era nuovo in Java 5, penso. Rende più semplice l'iterazione su array (e raccolte), poiché elimina gran parte della solita confusione che coinvolge l'impostazione e la gestione di una variabile di indice o iteratori. Ad esempio:

void myMethod(Collection<myObjectType> c) {
    for (myObjectType o : c)
        o.foo();
}
    
risposta data 06.12.2010 - 09:13
fonte
6

Enums , per sostituire le statiche e le costanti finali e aiutarti a rimuovere i riferimenti alle stringhe e ai numeri magici. Un esempio tratto da brave persone in 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();
    }
}

e

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));
    }
    
risposta data 06.12.2010 - 11:36
fonte
6

java.util.concurrent è stato introdotto in 1.5. La migliore risorsa per imparare è (probabilmente) il libro Java Concurrency in Practice . La concorrenza IMHO è il vantaggio competitivo più importante di Java rispetto a qualsiasi altra cosa, quindi vale sicuramente la pena saperlo.

    
risposta data 06.12.2010 - 11:27
fonte
4

Bene, StringBuilder mi ha aiutato ad accelerare il mio programma. È un equivalente di StringBuffer senza sicurezza thread.

    
risposta data 06.12.2010 - 13:12
fonte
4

Aiuterò classificando la risposta utile di @ykombinator. La sua lista è una lista degli elementi che userete quotidianamente mentre fate lo sviluppo java "generale".

Basso impatto e bassa difficoltà:

  • Avanzato per loop (per (String s: set) {...})
  • Autoboxing / unboxing (converti automaticamente tra tipi come Integer in int e viceversa)
  • Vararg (per la funzione printf (), consente il numero variabile di argomenti)
  • Import statico (ora puoi importare metodi statici di una classe, come java.lang.Math)

Impatto elevato e difficoltà media:

  • Esecuzioni tipefe (enum è ora una parola chiave, i tipi possono essere creati da enumerazioni)

Impatto elevato e alta difficoltà:

  • NOTE
  • Generics

Basso impatto e alta difficoltà (verrà utilizzato solo se non si esegue il threading avanzato)

  • java.util.concurrent (dimostra la concorrenza di java)

Suggerirei quindi di leggere i documenti / aiuto su pezzi a basso impatto e difficilmente accessibili - sono facili da imparare. Dedica un po 'di tempo a Annotazioni e Generiche - le annotazioni sono molto utili e i generici possono diventare piuttosto complicati.

Guarda il nuovo contenuto della concorrenza solo se hai bisogno di fare il threading.

    
risposta data 06.12.2010 - 14:38
fonte
4

Dato che non posso commentare perché ho meno di 50 lascerò una risposta. È già stato citato ma lo ripeterò di nuovo: Annotazioni! Questo tipo di metadati è diventato la cosa più importante nei miei anni di esperienza in Java. Ben usato come alcuni framework, rende il codice molto più conciso e pulito. Ad esempio, le annotazioni possono:

  • Converti un oggetto in un'entità @Entity
  • Converti un metodo in un servizio REST @GET
  • Spiega che un metodo non restituirà mai null @nullull
  • Imposta un oggetto su un campo per l'iniezione delle dipendenze @inject

E ovviamente puoi creare le tue annotazioni e sapere se un metodo, una classe o un campo sono annotati usando il reflection.

    
risposta data 06.12.2010 - 15:59
fonte
3

Imparare con l'esempio funziona per me

Ecco un rapido esempio di Java 6 idiomatico

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

  }
}

Non preoccuparti di Java5, è deprecato rispetto a Java6.

Passaggio successivo, annotazioni. Questi definiscono solo aspetti del codice che consentono ai lettori di annotazioni di compilare per te la configurazione di boilerplate. Considera un semplice servizio Web che utilizza la specifica JAX-RS (comprende URI RESTful). Non vuoi preoccuparti di fare tutto il brutto WSDL e fare incubi con Axis2, ecc., Vuoi un risultato veloce. Bene, fai questo:

// 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 po 'di magia di configurazione nel tuo web.xml sei fuori. Se stai costruendo con Maven e hai configurato il plugin Jetty, il tuo progetto avrà il suo piccolo web server subito pronto all'uso (non dovrai giocherellare con JBoss o Tomcat per te) e il codice sopra risponderà agli URI del forma:

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

Lavoro fatto.

    
risposta data 06.12.2010 - 11:25
fonte
3

Wow è stato un tuffo nel passato! Non uso Java da 4 anni - e nulla è cambiato in quel momento!

C'è un elenco di funzionalità per versione , ma ecco l'importante (plagiato ovviamente) ...

J2SE 5.0 (30 settembre 2004)

  • Generics: fornisce sicurezza del tipo (statico) in fase di compilazione per le raccolte ed elimina la necessità della maggior parte dei typecasts (conversione del tipo).
  • Metadati: chiamate anche annotazioni; consente ai costrutti del linguaggio come classi e metodi di essere taggati con dati aggiuntivi, che possono quindi essere elaborati da utilità che supportano la metadati.
  • Autoboxing / unboxing: conversioni automatiche tra tipi primitivi (come int) e classi wrapper primitive (come Integer).
  • Enumerazioni: la parola chiave enum crea un elenco di valori tipicamente ordinato, di valori (come Day.MONDAY, Day.TUESDAY, ecc.). In precedenza ciò poteva essere ottenuto solo da numeri interi costanti non tipizzati o classi costruite manualmente (pattern enumerato tipicamente).
  • Oscillazione: nuovo aspetto e sensazione personalizzabili, chiamato synth.
  • Vararg: l'ultimo parametro di un metodo può ora essere dichiarato usando un nome di tipo seguito da tre punti (ad esempio void drawtext (String ... lines)). Nel codice chiamante può essere utilizzato un numero qualsiasi di parametri di quel tipo e vengono quindi inseriti in una matrice da passare al metodo, o in alternativa il codice chiamante può passare una matrice di quel tipo.
  • Avanzato per ogni ciclo: la sintassi del ciclo for viene estesa con una sintassi speciale per iterare su ciascun membro di un array o di qualsiasi Iterable, come le classi Collection standard, utilizzando un costrutto del modulo:

Java SE 6 (11 dicembre 2006)

  • Supporto per versioni Win9x meno recenti. Non ufficialmente Java 6 Update 7 è l'ultima versione di Java mostrata per funzionare su queste versioni di Windows. Si ritiene che ciò sia dovuto alle principali modifiche apportate all'aggiornamento 10.
  • Supporto per lo scripting della lingua: API generiche per una stretta integrazione con i linguaggi di scripting e integrazione Mozon JavaScript Rhino integrata
  • Drammatici miglioramenti delle prestazioni per la piattaforma principale e Swing.
  • Supporto del servizio Web migliorato tramite JAX-WS
  • Supporto JDBC 4.0.
  • API Java Compiler un'API che consente a un programma Java di selezionare e richiamare un compilatore Java a livello di codice.
  • Aggiornamento di JAXB alla versione 2.0: compresa l'integrazione di un parser StAX.
  • Supporto per annotazioni collegabili
  • Molti miglioramenti della GUI, come l'integrazione di SwingWorker nell'API, l'ordinamento e il filtraggio delle tabelle e il doppio buffering di Swing vero (eliminazione dell'effetto area grigia).
  • I miglioramenti di JVM includono: sincronizzazione e ottimizzazioni delle prestazioni del compilatore, nuovi algoritmi e aggiornamenti agli algoritmi di garbage collection esistenti e prestazioni di avvio delle applicazioni.

Questo è tutto. Java SE 7.0 sembra più interessante ma non ancora rilasciato.

Considerando quante nuove funzionalità linguistiche e API sono state aggiunte a C # negli ultimi 4 anni, sono piuttosto sorpreso. Cosa succede a Sun / Oracle?

    
risposta data 06.12.2010 - 14:27
fonte

Leggi altre domande sui tag