Ajuda-me a recuperar o que perdi desde o Java 1.4.2 [fechado]

14

Estou prestes a começar minha primeira carreira profissional como desenvolvedor de software, e provavelmente vou escrever muito código Java. Eu não sei muito sobre o que especificamente vou escrever e, além disso, tenho interesses bastante amplos quando se trata de codificar de qualquer maneira.

Por razões que não valem a pena discutir, meu último estágio me fez codificar apenas os SDKs Java 1.3 e 1.4. Além disso, minha formação universitária tem se concentrado principalmente em algoritmos, estruturas de dados e outras teorias, não em recursos de linguagem ou bibliotecas.

Então, com o acima em mente, quais recursos, classes, etc. na versão atual do Java (que número estamos agora, afinal?) valeriam meu tempo para ler e por quê? O que eu perdi desde 1.4.2 que facilita sua vida como programador?

Exemplos e histórias de como você descobriu um pacote em particular ou algo assim e o colocou em uso também seriam ótimos.

    
por DGH 06.12.2010 / 07:34
fonte

10 respostas

15

As alterações que considero mais importantes são:

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

Leia também Que tipo de Java você está buscando? , para entender melhor de cada uma das três versões.

    
por 06.12.2010 / 10:34
fonte
10

A mudança mais importante no seu dia-a-dia para a programação da vida é a introdução de genéricos que provavelmente serão usados em cada novo módulo que você será solicitado a escrever, e é um novo e confuso sintaxe.

Genéricos é o mecanismo que permite, por exemplo um List para conter strings ao invés de objetos naked, onde o compilador impõe que um item a ser colocado na lista é uma String, e sabe que quando você pega um item fora de uma lista é uma String.

Isso faz com que programas melhores evitem a conversão explícita do tempo de execução para o tipo de destino (que é uma fonte freqüente de erros se você errar) e o IDE pode ajudá-lo a fazer todo o trabalho sujo, pois sabe muito mais sobre seu código do que quando era apenas uma lista de objetos.

Joshua Bloch escreveu uma boa introdução ao Generics, que está disponível como capítulo de amostra no link

    
por 06.12.2010 / 08:39
fonte
6

Autoboxing é um bom recurso introduzido com o Java 5. Assim como em C #, o compilador agora faz uma conversão automática entre os tipos primitivos (básicos) e suas classes correspondentes (int para Integer etc) e de volta. Isso faz com que trabalhar com o Java Collections seja menos doloroso.

O loop

For-each também era novo no Java 5, eu acho. Ele torna a iteração sobre matrizes (e coleções) mais fácil, porque elimina grande parte da confusão usual envolvendo a configuração e o gerenciamento de uma variável de índice ou iteradores. Por exemplo:

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

Enums , para substituir estática final e constantes e ajudá-lo a remover referências a strings e números mágicos. Um exemplo tirado das pessoas boas em sol / 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));
    }
    
por 06.12.2010 / 11:36
fonte
6

java.util.concurrent foi introduzido em 1.5. O melhor recurso para aprender é (provavelmente) o livro Java Concurrency in Practice . A concorrência IMHO é a vantagem competitiva mais importante do Java em comparação com qualquer outra coisa, então definitivamente vale a pena conhecer bem.

    
por 06.12.2010 / 11:27
fonte
4

Bem, o StringBuilder ajudou-me a acelerar o meu programa. É um equivalente do StringBuffer sem segurança do thread.

    
por 06.12.2010 / 13:12
fonte
4

Vou ajudar categorizando a resposta útil do @ykombinator. Sua lista é uma lista dos elementos que você usará diariamente enquanto faz o desenvolvimento java "geral".

Baixo impacto e baixa dificuldade:

  • Aperfeiçoado para loop (para (String s: set) {...})
  • Autoboxing / unboxing (converter automaticamente entre tipos como Integer para int e vice-versa)
  • Varargs (para a função printf (), permite número variável de argumentos)
  • Importação estática (agora pode importar métodos estáticos de uma classe, como java.lang.Math)

Alto impacto e dificuldade média:

  • Enumerações de tipos seguros (enum agora é uma palavra-chave, tipos podem ser criados a partir de enums)

Alto impacto e alta dificuldade:

  • Anotações
  • Genéricos

Baixo impacto e alta dificuldade (só será usado a menos que você faça um thread avançado)

  • java.util.concurrent (demonstra a simultaneidade do java)

Eu sugiro, portanto, que você leia os documentos / ajuda sobre peças difíceis de baixo impacto - elas são fáceis de aprender. Gastar um pouco de tempo em Anotações e Genéricos - as anotações são muito úteis, e os genéricos podem ficar bastante complicados.

Analise apenas o novo conteúdo de simultaneidade se precisar fazer o threading.

    
por 06.12.2010 / 14:38
fonte
4

Como não posso comentar porque estou abaixo de 50, deixo uma resposta. Já foi mencionado, mas vou repeti-lo novamente: Anotações! Esse tipo de metadado se tornou a coisa mais importante em meus anos de experiência em Java. É bem usado como alguns frameworks faz o código muito mais conciso e limpo. Por exemplo, as anotações podem:

  • Converta um objeto em uma entidade @Entity
  • Converta um método em um serviço REST @GET
  • Explique que um método nunca retornará null @nonnull
  • Defina um objeto como um campo para injeção de dependência @inject

E, claro, você pode criar suas próprias anotações e saber se um método, uma classe ou um campo é anotado usando a reflexão.

    
por 06.12.2010 / 15:59
fonte
3

Aprender por exemplo funciona para mim

Aqui está um exemplo rápido do idiomático Java 6

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

  }
}

Não se preocupe com o Java5, ele está obsoleto em relação ao Java6.

Próximo passo, anotações. Estes apenas definem aspectos para o seu código que permitem que os leitores de anotações preencham a configuração padronizada para você. Considere um serviço da web simples que use a especificação JAX-RS (ele entende URIs RESTful). Você não quer se incomodar em fazer todo o desagradável WSDL e se preocupar com o Axis2 etc, você quer um resultado rápido. Certo, faça isso:

// 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. Com um pouco de magia de configuração no seu web.xml você está fora. Se você está construindo com o Maven e tem o plugin do Jetty configurado, seu projeto terá seu próprio servidor web pronto para uso (sem mexer no JBoss ou no Tomcat para você), e o código acima responderá aos URIs do formulário:

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

Trabalho feito.

    
por 06.12.2010 / 11:25
fonte
3

Uau, isso foi uma explosão do passado! Eu não uso Java há 4 anos - e nada mudou nesse tempo!

Há uma lista de recursos por versão , mas aqui está a parte importante (plagiado claro) ...

J2SE 5.0 (30 de setembro de 2004)

  • Genéricos: fornece segurança do tipo em tempo de compilação (estática) para coleções e elimina a necessidade da maioria das tipologias (conversão de tipos).
  • Metadados: também chamados de anotações; permite que construções de linguagem, como classes e métodos, sejam marcadas com dados adicionais, que podem ser processados por utilitários com reconhecimento de metadados.
  • Autoboxing / unboxing: conversões automáticas entre tipos primitivos (como int) e classes wrapper primitivas (como Integer).
  • Enumerações: A palavra-chave enum cria uma lista ordenada de valores segura (como Day.MONDAY, Day.TUESDAY, etc.). Anteriormente, isso só podia ser alcançado por números inteiros constantes diferentes de tipos ou classes construídas manualmente (padrão de enumeração typesafe).
  • Swing: nova aparência e toque personalizáveis, chamada synth.
  • Varargs: O último parâmetro de um método agora pode ser declarado usando um nome de tipo seguido por três pontos (por exemplo, drawtext vazio (String ... linhas)). No código de chamada, qualquer número de parâmetros desse tipo pode ser usado e, em seguida, eles são colocados em uma matriz a ser passada para o método ou, alternativamente, o código de chamada pode transmitir uma matriz desse tipo.
  • Aprimorado para cada loop: A sintaxe do loop for estendida com uma sintaxe especial para iterar sobre cada membro de uma matriz ou qualquer Iterable, como as classes da Coleção padrão, usando uma construção do formulário:

Java SE 6 (11 de dezembro de 2006)

  • Suporte para versões mais antigas do Win9x descartadas. Extra-oficialmente, o Java 6 Update 7 é a última versão do Java mostrada para funcionar nessas versões do Windows. Acredita-se que isso se deva às grandes mudanças na Atualização 10.
  • Suporte à linguagem de script: API genérica para integração com linguagens de script e integração integrada de rinoceronte Mozilla JavaScript
  • Melhorias dramáticas no desempenho da plataforma principal e Swing.
  • Suporte aprimorado ao serviço da Web por meio do JAX-WS
  • Suporte ao JDBC 4.0.
  • Java Compiler API, uma API que permite que um programa Java selecione e invoque um compilador Java programaticamente.
  • Atualização do JAXB para a versão 2.0: Incluindo integração de um analisador StAX.
  • Suporte para anotações conectáveis
  • Muitos aprimoramentos da GUI, como a integração do SwingWorker na API, a classificação e a filtragem de tabelas e o verdadeiro buffer duplo Swing (eliminando o efeito de área cinza).
  • Os aprimoramentos da JVM incluem: otimizações de desempenho de sincronização e compilador, novos algoritmos e atualizações para algoritmos de coleta de lixo existentes e desempenho de inicialização do aplicativo.

É sobre isso. O Java SE 7.0 parece mais interessante, mas ainda não foi lançado.

Considerando quantos novos recursos de linguagem e APIs foram adicionados ao C # nos últimos 4 anos, estou bastante surpreso. O que está acontecendo na Sun / Oracle?

    
por 06.12.2010 / 14:27
fonte