Visão Geral do Suporte a JDK 7 no NetBeans IDE

O NetBeans IDE suporta as novas funcionalidades de linguagem Java 7, como o operador diamante, strings em switch, multicatch etc. Quando você usa esses construtores em seu código, o IDE os reconhece, oferece classes corretas na funcionalidade autocompletar código, destaca erros corretamente e permite corrigir a sintaxe automaticamente. Portanto, o NetBeans IDE ajuda você a escrever código compatível com a Especificação de Linguagem Java, Java SE 7 Edition.

Neste tutorial, você aprende como o IDE trata as construções do idioma Java 7.

Conteúdo

O conteúdo desta página se aplica ao NetBeans IDE 6.8, 6.9, 7.4 e 8.0

Para concluir este tutorial, você precisa do software e dos recursos apresentados na tabela a seguir.

Software ou Recurso Versão Necessária
NetBeans IDE versão 7.4 ou 8.0
JDK (Java Development Kit) versão 7 ou 8

Garantindo que o JDK 7 esteja Registrado no NetBeans IDE

Para verificar se o JDK 7 está registrado no NetBeans IDE:

  1. No IDE, selecione Ferramentas > Plataformas Java no menu principal.
  2. Certifique-se de que o JDK 1.7 tenha sido escolhido na lista de Plataformas da caixa de diálogo Gerenciador de Plataformas Java.

    Plataforma Java Registrada

  3. Clique em Fechar.

Verificando a Configuração do Projeto

Para verificar se seu projeto está configurado para usar o JDK registrado para compilação, execução e depuração:

  1. Crie um projeto Java escolhendo Arquivo > Novo Projeto e selecionando Aplicação Java como o tipo de projeto.
  2. Clique em Próximo.
  3. Digite SwitchTest como nome do projeto e especifique sua localização.
  4. Clique em Finalizar.
  5. Na janela Projetos, clique com o botão direito do mouse no nó do projeto SwitchTest e selecione Propriedades > Bibliotecas. Nesta guia, certifique-se de que JDK 1.7 esteja selecionado na lista de Plataformas Java.

    JDK 7 selecionado como o formato do alvo

  6. Alterne para a guia Códigos-fonte da janela Propriedades do Projeto e certifique-se de que JDK 7 tenha sido escolhido como o formato do Código-fonte/Binário.

    JDK 7 selecionado como o formato do código-fonte

  7. Clique em OK para fechar a caixa de diálogo Propriedades do Projeto. Seu projeto está configurado para reconhecer os recursos do idioma do Java 7.

Usando Novos Construtores de Linguagem do JDK 7: Instrução de Alternância

O JDK 7 traz uma série de novas funcionalidades e melhorias em diferentes áreas, incluindo internacionalização, E/S e rede, segurança etc. A melhor forma de ilustrar o suporte ao JDK 7 pelo Editor Java do IDE é demonstrando algumas das alterações de linguagem introduzidas pelo Projeto Coin.

Uma dessas alterações é um "String em uma alternância". Nas versões anteriores do Java, o argumento de switch só podia ser um dos seguintes tipos de dados primitivos: byte, short, char, int ou enum. A partir do JDK 7, é possível usar argumentos do tipo String na expressão de uma instrução switch.

  1. Abra SwitchTest.java e adicione o código a seguir. Essa pequena amostra exibe códigos RGB para várias cores.
    Com o JDK 7, a variável color pode ser uma String.
    package switchtest;
    
        public class SwitchTest {
    
        public static void main(String[] args) {
    
            String color = "red";
            String colorRGB;
            switch (color.toLowerCase()) {
                case "black": colorRGB = "000000"; break;
                case "red": colorRGB = "ff0000"; break;
                case "green": colorRGB = "008000"; break;
                case "blue": colorRGB = "0000ff"; break;
                default: colorRGB = "Invalid color"; break;
            }
            System.out.println(colorRGB);
            }
        }
    

    Se o código colado for incorretamente colado no editor, pressione Alt-Shift-F para reformatar.

  2. Na janela Projetos, clique com o botão direito do mouse no nó do projeto e selecione Executar Arquivo. Você verá a saída da aplicação, que é o código RGB para a cor vermelha.
    Você pode ver que a construção foi bem-sucedida e que a aplicação funciona quando a plataforma de destino e o formato do código-fonte são JDK 7.

    Saída da execução do projeto

  3. Vamos reverter para o uso do JDK 6 e testar como a aplicação é compilada com o compilador do JDK 6.
    Na janela Projetos, clique com o botão direito do mouse no nó do projeto e selecione Propriedades. Na categoria Códigos-fontes, defina o Formato Código-fonte/Binário para JDK 6 e clique em OK.
    Você pode ver imediatamente que o parser do JDK6 não reconhece a sintaxe. A compilação falha por causa do tipo de variável incompatível.

    Erro

  4. Agora, vamos reescrever o código usando a instrução if-then-else, em vez de switch, como segue:
    package switchtest;
    
        public class SwitchTest {
    
        public static void main(String[] args) {
    
            String color = "red";
            String colorRGB;
            if (color.equals("black")) {
                colorRGB = "000000";
            } else if (color.equals("red")) {
                colorRGB = "ff0000";
            } else if (color.equals("green")) {
                colorRGB = "008000";
            } else if (color.equals("blue")) { 
                colorRGB = "0000ff";
            } else {
                colorRGB = "Invalid color";
            }
            System.out.println(colorRGB);
            }
        }
    
    Com o JDK 7 no formato de Código-fonte/Binário, o IDE reconhece tais casos e oferece a opção de convertê-los para switch, conforme mostrado na figura abaixo.

    Converter para alternar dica

    Clique na dica e o construtor if-then-else será automaticamente convertido para exatamente o mesmo switch que tínhamos antes.

Suporte a JDK 7: Mais Exemplos

Para demonstrar como o Editor Java do IDE reconhece e automaticamente corrige o código para que seja compatível com a especificação de linguagem do JDK 7, vamos usar um snippet de código simulado, que não tem finalidade, mas contém todas as grandes melhorias da linguagem.

Ao percorrer esse snippet de código simulado e aplicar as dicas do editor, você verá os exemplos a seguir de como:

  • Tirar vantagem da inferência automática de tipo, quando o compilador Java consegue inferir o tipo de uma instância genérica sem a necessidade de especificá-la explicitamente. O operador diamante é usado para sinalizar o caso de inferência de tipo.
  • Usar o tratamento aprimorado de exceção, ou multi-catch, quando um bloco catch pode ser usado para vários tipos de exceções.
  • Usar a nova sintaxe das instruções de fechamento de funcionalidades, introduzida pela funcionalidade de gerenciamento automático de funcionalidades.
  1. Substitua o código anterior da aplicação no mesmo arquivo SwitchTest.java pelo seguinte código:
    package switchtest;
    
    
    import java.io.FileInputStream;
    import java.lang.reflect.Method;
    import java.io.IOException;
    import java.lang.reflect.InvocationTargetException;
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    
    public class SwitchTest {
    
        public void test() throws IOException {
            List<String> list = new ArrayList<String>();
            HashMap<String, Integer> map = new HashMap<String, Integer>();
            HashMap<String, Integer> map2 = new HashMap<String, Integer>();
            String a = "ehlo";
    
            try {
                Method m = Object.class.getMethod("toString");
                m.invoke(this);
            } catch(NoSuchMethodException e) {
                e.printStackTrace();
            } catch(InvocationTargetException e) {
                e.printStackTrace();
            } catch(IllegalAccessException e) {
                e.printStackTrace();
            }
    
            FileInputStream in = null;
            try {
                in = new FileInputStream("foo.txt");
    
                int k;
                while ((k = in.read()) != -1) {
                    System.out.write(k);
                }
            } finally {
                if (in != null) {
                    in.close();
                }
            }
        }
    }
     
  2. Observe que o IDE exibe diversas dicas, como mostrado acima neste tutorial, de como é possível otimizar seu código para a especificação JDK 7. Basta clicar em cada dica e selecionar a ação sugerida.
  3. Finalmente, depois de aceitar todas as sugestões, você deverá ter o código compatível com JDK 7 mostrado abaixo.

    Snippet de código convertido


Consulte Também

Para obter mais informações sobre o JDK 7 e o NetBeans IDE, consulte:

Para obter mais informações sobre o desenvolvimento de aplicações Java no NetBeans IDE, veja:

get support for the NetBeans

Support


By use of this website, you agree to the NetBeans Policies and Terms of Use. © 2013, Oracle Corporation and/or its affiliates. Sponsored by Oracle logo