Trilha do aprendizado do desenvolvimento geral em JavaO que é um aplicativo Java SE?É um aplicativo desenvolvido na Plataforma Java, Standard Edition (Java SE). Os mesmos aplicativos Java SE não

modificados podem ser executados praticamente em qualquer computador, qualquer que seja o sistema operacional,

como Microsoft Windows, Solaris, Linux ou Mac OS X. O segredo dessa portabilidade do aplicativo é o Java Runtime

Environment, que está disponível gratuitamente para a maioria dos sistemas operacionais, incluindo os acima

mencionados.

Além de ser uma plataforma para aplicativos de área de trabalho em várias plataformas, a Java SE é a base de outras

tecnologias, como a Plataforma Java, Enterprise Edition. Também é possível criar códigos que forneçam lógica secundária

para aplicativos da Web e empresariais.

Primeiros passosTutorial de início rápido de Java

Tutoriais e artigosDesenvolvendo aplicativos Java

Visão geral do suporte a JDK 7 no NetBeans IDE

Empacotamento e distribuição de aplicativos Java Desktop

Desenvolvendo aplicativos Java gerais

Criando, importando e configurando projetos Java

Configuração de Projetos de formato livre avançados

Suporte aos processadores de anotação no NetBeans IDE

o Parte I: utilizando o Project Lombok

o Parte II: utilizando processadores de anotação personalizados próprios

Ajuda para codificação no Editor Java do NetBeans IDE

Refatoração com Inspecionar e Transformar no editor Java do NetBeans IDE

Importando projetos do Eclipse para o NetBeans IDE

Cartão de atalhos de teclado

Construindo, depurando e testando

Usando o depurador visual de erros no NetBeans IDE

Habilitando o Java Web Start no NetBeans IDE

Usar o NetBeans IDE para unir arquivos JAR em um único arquivo JAR

Escrevendo testes JUnit

Depurando aplicativos multissegmentados

Maven

Melhores práticas do Maven

Criando um aplicativo Maven Swing usando Hibernate

Criando perfil do código-fonte

Introdução à criação de perfil de aplicativos Java

ScreencastsDemonstração: Recurso de inspeção e refatoração de transformação no NetBeans IDE 7.1

Demonstração: suporte do NetBeans IDE para o JDK 7

Demonstração: Recursos do Projeto Coin do JDK 7 no NetBeans IDE 7.0 (

Demonstração: trabalhando com dependências Maven

Demonstração: detecção de bloqueio usando o depurador do NetBeans

Demonstração: etapa visual em ação no depurador do NetBeans

Demonstração: usando o avaliador de partes do código no depurador do NetBeans

Demonstração: depuração multissegmentada

Documentos de contribuição da comunidadeIntegração do ANTLR sem aprender Ant

Adicionando uma tela de splash a um aplicativo Java

Lista completa de palavras-chave de macro para o editor Java do NetBeans

na Dzone).

Configurando o Netbeans para gerar um arquivo JAR distribuível usando o OneJAR

Configurar o NetBeans usando arquivos em lote

Refatoração simplificada

Personalizando a aparência do Netbeans IDE

Outros recursosPerguntas frequentes dos usuários do NetBeans:

o Sistema de projeto geral

o Compilação e construção

Usando pontos de criação de perfil

Criação de perfil avançada: Teoria em prática

Estudo de caso do NetBeans Profiler

Linguagens de script

Introdução ao Groovy

Monitoramento e gerenciamento de JMX

Primeiros passos com o monitoramento de Java Management Extensions (JMX)

Adicionando instrumentação JMX a um aplicativo Java

Desenvolvendo um gerenciador JMX e conectando a um agente JMX remoto

o Projeto de forma livre

o Depurando

o Criação de perfil

o Editando

MySQL e Java - Recursos

Seminários Web sob demanda sobre o MySQL

Aprendendo Java: recursos

o Introdução ao Java do JavaPassion

o Os tutoriais Java

Suporte aos processadores de anotação no NetBeans IDEAmostra contribuída por Jesse Glick.

Conteúdo

Introdução

Mapa das opções javac e comandos IDE

Utilizando projeto Lombok para anotações do usuário

Utilizando processador de anotações personalizado no IDE

Consulte também

Esse tutorial de duas partes demonstra como é possível anexar processadores de anotação a um projeto e utilizá-los

enquanto estiver trabalhando no código no IDE. O NetBeans possui suporte incorporado a processadores de anotações

personalizados. Agora é possível especificar convenientemente processadores de anotação para serem executados com o

projeto e visualizar os resultados do processo de anotação diretamente no editor Java através do autocompletar código e

navegação.

A primeira parte do tutorial exibe a utilização do processador de anotação de terceiros, Projeto Lombok, no NetBeans IDE.

A segunda parte do tutorial fornece explicações sobre como adicionar um processador de anotação de autoescrita em um

projeto. O código amostra para essa parte do tutorial é contribuído por Jesse Glick.

Para concluir este tutorial, são necessários dos seguintes recursos e softwares.

Software ou recurso Versão necessária

NetBeans IDE 6.9, 7.0, 7.1

Java Development Kit (JDK) versão 6

Observações:

O suporte a processadores de anotações personalizadas foi adicionado na versão 6.9 do IDE NetBeans. Este tutorial não

funcionará com versões anteriores do IDE.

IntroduçãoAnotações são mecanismos da linguagem de programação Java que são utilizados para manter metadados sobre os

elementos do aplicativo. Anotações mantêm metainformações sobre como os elementos anotados devem ser

processados pelo compilador, durante uma implementação ou tempo de execução. Em outras palavras, anotações são

comentários do código que podem ser processadas por outros programas e ferramentas.

É possível utilizar anotações personalizadas para realizar uma variedade de tarefas: marcar partes do aplicativo (por

exemplo, a informação de direitos autorais, métodos de teste, etc.), gerar código automaticamente, analisar as opções de

linha de comando, desenvolver serviços da Web, e outros. As informações sobre como anotações personalizadas devem

ser processadas são passadas para o compilador Java através dos processadores de anotação personalizados. JSR

269 implementado em JDK 6 fornece uma API original para processadores de anotação escrita. É possível escrever seu

próprio processador de anotação personalizado ou utilizar as soluções de terceiros.

Para informações iniciais sobre anotações no JDK 6, consulte os recursos a seguir:

Documentação Java SE - Anotações

Tutorial Java SE - Anotações

Na prática, anotações são mais utilizadas combinadas com Java Persistence API (JPA), que é parte da especificação Java

EE e algumas outras tecnologias, como o JAXB (Java Architecture para ligação XML). Utilizando JPA, classes Java podem

ser anotadas como entidades que mais tarde podem ser persistidas em um dispositivos de armazenamento. Para

desenvolver aplicativos com base JPA, é conveniente para utilizar estruturas como por exemplo o EclipseLink, que é

agrupado com o IDE. Como ponto inicial para mais informações sobre escrever aplicativos com base JPA no NetBeans IDE,

consulte Iniciar com aplicativos Java EE 6.

Mapa das opções do javac e comandos IDE para processamento de anotaçãoComo mencionado acima, no Java SE 6 javac, o processamento de anotação foi incorporada como funcionalidade

integrada do compilador Java. O compilador localiza automaticamente processadores de anotação por padrão como

caminho de classe de usuário (a menos que o processamento de anotação estiver desabilitado explicitamente). Além

disso, o caminho de busca ou o caminho para processadores de anotação particular podem ser especificados utilizando

opções javac. Na tabela abaixo, é possível visualizar um mapa das opções javac relacionado ao processamento de

anotação e os comandos correspondentes no IDE. Para mais informações sobre opções javac no JDK 6, consulte javac -

Compilador da linguagem de programação Java.

Observação. No IDE, as opções de processamento de anotações de todos os aplicativos Java, com exceção de

aplicativos da plataforma NetBeans, são especificadas na janela Propriedades do projeto. Para abrir a janela Propriedades

do projeto, clique com o botão direito do mouse em seu projeto e selecione Propriedades.

Opções Java 6

javacComando IDE Descrição

-processor

Propriedades do projeto >

Construção > Compilação >

campo Processadores de

anotação.

Especifique um nome completo

qualificado do processador de

anotação no campo Processador

de anotação.

Especifique explicitamente o processador de anotação para

executar. Esta opção elimina a necessidade de criar arquivos de

configuração do serviço do provedor

(META-INF/services/javax.annotation.processing.Processor)

-proc:none

Propriedades do projeto >

Construção > Compilação >

habilitar a caixa de verificação

Habilitar processamento de

anotação

Quando a caixa de verificação

estiver desabilitada, o projeto é

compilado sem qualquer

processamento de anotação.

A compilação continua sem qualquer processamento de anotação.

O mecanismo de descoberta do processador de anotação não é

utilizando durante a compilação.

-

processorpathPropriedades do projeto >

Bibliotecas > guia Processador

Especifique o caminho para um

Especifica onde localizar processadores de anotação; se essa

opção não for oferecida, o caminho da classe é localizado por

projeto IDE, biblioteca ou um

arquivo Jar que contém um

processador de anotação. Utilize

esta opção se um processador de

anotação e anotações são

empacotados em arquivos JAR

separados.

processadores (veja abaixo).

-classpath

Propriedades do projeto >

Bibliotecas > guia Compilador

Especifique o caminho para um

projeto IDE, biblioteca ou um

arquivo Jar que contém um

processador de anotação e

declarações de anotação. Utilize

esta opção se um processador de

anotação e anotações são

empacotados em um único

arquivo JAR.

Especifica onde localizar arquivos de classe de usuário e

(opcionalmente) processadores de anotação e arquivos código-

fonte. Esse caminho é localizado para processadores de anotação

se o -processorpath não for especificado.

-Akey[=value]

Propriedades do projeto >

Construção > Compilação >

campo Opções do processador

Adicione opções que devem ser

passadas para o processador de

anotação associado ao projeto.

Esse valor é opcional.

(Opcional) Opções para passar para o processador de anotação.

 

Próximas etapasLeia as partes a seguir do tutorial para aprender como utilizar anotações no IDE.

Parte I: Utilizando projeto Lombok para anotações personalizadas

Parte II: Utilizando próprio processador de anotação personalizado no IDE

Suporte aos processadores de anotação no NetBeans IDE, Parte I: Utilizando o projeto Lombok

Conteúdo

Introdução

Mapa das opções javac e comandos IDE

Utilizando projeto Lombok para anotações personalizadas

o Criando um novo projeto Java

o Habilitando anotações personalizadas para o projeto

o Escrevendo uma aplicação com a utilização de anotações personalizadas Lombok

Utilizando processadores próprios de anotação personalizado no IDE

Consulte também

Para demonstrar como as anotações personalizadas funcionam dentro do NetBeans IDE, vamos usar o Projeto Lombok,

que fornece uma forma conveniente de gerar automaticamente diversos elementos de código Java, tais como getters,

setters, construtores e outros. Para maiores informações sobre os recursos, visite owebsite do projeto Lombok.

Entretanto, tenha em mente que o projeto Lombok inclui alguns recursos que podem não funcionar em todos os

ambientes de desenvolvimento.

Para concluir este tutorial, você precisa dos seguintes recursos e softwares.

Software ou recurso Versão necessária

NetBeans IDE 6.9, 7.0, 7.1

Java Development Kit (JDK) versão 6

Observações:

O suporte a processadores de anotações personalizadas foi adicionado na versão 6.9 do IDE NetBeans. Este tutorial não

funcionará com versões anteriores do IDE.

Criando um novo projeto JavaNeste exercício você cria um projeto Java simples e uma classe denominada MyBooks.java que demonstra as

anotações em ação. .

1. Escolha Arquivo > Novo projeto e selecione Aplicativo Java como o tipo de projeto.

2. Na página Nome e localização do assistente do Novo projeto, digite TestAnn como nome do projeto.

3. Digite testann.TestBooks no campo Criar classe principal para substituir o nome padrão da classe. Clique em

Terminar.

" class="margin-around b-all">captura de tela do assistente Novo Projeto

package

testann; public class MyBooks { private int year; //fields private String title; private String author; }

4. Coloque o ponteiro do mouse na declaração da classe e pressione Ctrl-Espaço para criar o suporte de conclusão

de código no editor.

5. Selecione MyBooks (int year, String title, String author) - generate na lista de conclusão de

código para gerar um construtor para MyBooks.java.

6. Salve as alterações.

Habilitando anotações personalizadas (lombok.jar) para o projetoNeste exercício, você irá modificar a janela de propriedades do projeto para adicionar um biblioteca à classpath do

projeto e ativar o processamento de anotações no editor.

1. Efetue o download do arquivo lombok.jar e salve no sistema.

2. Clique com o botão direito no nó do projeto TestAnn e escolha Propriedades.

3. Selecione a categoria Bibliotecas na caixa de diálogo Propriedades do projeto.

4. Clique em Add JAR/Pasta na aba Compilar e localize o arquivo lombok.jar baixado.

Os recursos adicionados na guia Compilação correspondem à opção -classpath do compilador Java.

Como lombok.jar é um arquivo JAR único que contém definições de anotação e processadores de anotações. É

recomendado adicioná-lo à classpath do projeto, que é a aba Compilação.

5. Escolha a categoria Compilação na janela Propriedades do projeto.

6. Confirme que a caixa de seleção Ativar o processamento de anotações esteja selecionada (ela é selecionada por

padrão) e selecione a caixa de seleção Ativar o processamento de anotações no editor.

A caixa de verificação Habilitar processamento de anotação ativa o processamento de anotação ao construir e

compilar o projeto. Se a caixa de seleção não estiver selecionada, a opção -proc:none é passada para o

compilador Java e a compilação ocorre sem qualquer processamento de anotações. Então, se deseja processar

anotações no código, a caixa de verificação Habilitar processamento de anotação deve estar selecionada.

Ao selecionar a caixa de seleção, Ativar o processamento de anotações no editor, o processamento de anotações

ficará visível no editor. Quaisquer artefatos adicionais que forem gerados por processadores de anotações

(classes, métodos, campos, etc.) ficam visíveis no editor IDE e disponíveis para a conclusão de código, no

Navegador, Ir para tipo, Localizar usos e outros.

7. Clique em OK na janela Propriedades do projeto e retorne para o arquivo MyBooks.java.

Caso você expanda o nó Bibliotecas na janela Projetos, verá que a lombok.jar está agora listada como uma biblioteca

do projeto.

Escrevendo uma aplicação com a utilização de anotações personalizadas Lombok

1. No arquivo MyBooks.java, digite @Data antes de declarar a classe MyBooks. @Data é uma anotação que gera

o código clichê para classes Java: getters para todos os campos, setters para todos os campos não-finais e

o toString apropriado, equals e implementações hashCode que envolvem os campos da classe.

Para aprender mais sobre quais anotações são suportadas pelo projeto Lombok, consulte a Visão geral dos

recursos do Lombok.

2. Clique na dica na margem direita do editor e adicione importar para lombok.Data.

O código resultante no Editor deve ser parecido com o exemplo abaixo.

package testann;

import lombok.Data;

@Data

public class MyBooks {

private int year; //fields

private String title;

private String author;

public MyBooks(int year, String title, String author) {

this.year = year;

this.title = title;

this.author = author;

}

}

Observe que artefatos de código necessários, como getters, setters, toString, etc., têm sido gerados e é possível

visualizá-los na janela do Navegador. A anotação @Data gera todos os códigos clichês que são necessários para

uma classe típica.

É possível também invocar a janela de autocompletar código (Ctrl-Espaço) e ver que os artefatos gerados estão

disponíveis para pegá-los. Agora, veremos que o projeto compila e os artefatos gerados podem ser chamados de

outras partes do programa.

3. Abra o arquivo Testbook.java com o método main e crie um novo objeto da classe MyBooks.

4. package testann;5.6. public class TestBooks {7.8. public static void main(String[] args) {9.10. MyBooks books = new MyBooks(2009, "My Beautiful Dream", "John

Smith");11. }

}12.Adicione o seguinte código para imprimir os valores da variável books.

Para voltar os valores, chamamos os métodos getter que são autogerados por lombok.jar. Enquanto estiver digitando, observe que os artefatos autogerados estão disponíveis da janela de autocompletar código.package testann;public class TestBooks { public static void main(String[] args) { MyBooks books = new MyBooks(2009, "My Beautiful Dream", "John Smith"); System.out.println("Year: " + books.getYear() + ", Title: " + books.getTitle() + ", Author: " + books.getAuthor()); }}

13.Salve as alterações.

14.Clique com o botão direito do mouse no nó na janela Projetos e selecione Executar

(F6).

Quando você executa o aplicativo, deverá ver a seguinte saída que mostra que o

aplicativo foi compilado com êxito.

Você pode ver que os artefatos gerados pelo processador de anotação Lombok estão acessíveis de outras partes do programa.

Próxima etapa Parte II: Utilizando próprio processador de anotação personalizado

no IDE

Suporte aos processadores de anotação no NetBeans IDE, Parte II: Usando processadores próprios personalizados de anotação no IDEContribuição de Jesse Glick, redigido e mantido por Irina Filippova

Conteúdo

Introdução

Mapa de opções javac e comandos IDE

Usando o projeto Lombok para anotações personalizadas

Usando processadores personalizados próprios de anotação no IDE

o Definindo uma anotação e criando um processador de anotação

o Usando o processador de anotação

Consulte também

Nesta seção do tutorial, você aprenderá aprender como adicionar um processador de anotação personalizado de redação

própria em um projeto no IDE. Este tutorial não lhe ensina como redigir um processador de anotação. Ele explica como

adicioná-lo em um projeto NetBeans IDE.

O aplicativo de amostra usado nesta seção foi criado por Jesse Glick e publicado como uma entrada de FAQ para as

versões anteriores do IDE.

O processador de anotação usando como exemplo gera uma classe principal para a classe anotada. A classe principal

gerada também contém um método que é chamado da classe anotada. Siga as instruções abaixo sobre como criar e

adicionar um processador personalizado de anotação em um projeto do IDE.

Para concluir este tutorial, você precisa dos seguintes recursos e softwares.

Software ou recurso Versão necessária

NetBeans IDE 6.9, 7.0, 7.1

Java Development Kit (JDK) versão 6

Observações:

O suporte a processadores de anotações personalizadas foi adicionado na versão 6.9 do IDE NetBeans. Este tutorial não

funcionará com versões anteriores do IDE.

Definindo uma anotação e criando um processador de anotaçãoNeste exercício, você criará um projeto de biblioteca de classes.

1. Escolha Arquivo > Novo projeto e selecione o projeto de Bibliotecas de classes Java na categoria Java. Clique em

Próximo.

2. Digite AnnProcessor como nome do projeto e especifique uma localização para o projeto. Clique em Terminar.

Ao clicar em Terminar, o IDE cria o projeto de biblioteca de classes e lista o projeto na janela Projetos.

3. Clique com o botão direito do mouse no nó do projeto AnnProcessor na janela Projetos e escolha Propriedades.

4. Na categoria Códigos-fonte, confirme se JDK 6 está especificado como o formato de código-fonte/binário.

5. Selecione a aba Bibliotecas e confirme se a plataforma Java está definida como JDK 6. Clique em OK para fechar

a janela Propriedades do projeto.

Neste exercício, você criará dois pacotes Java e uma classe Java em cada um destes pacotes.

1. Crie um pacote Java denominado ann clicando no nó Pacotes de código-fonte sob o nó do projeto AnnProcessor e

escolha Novo > Pacote Java. Digite ann como o nome do pacote e clique em Terminar.

2. Repita a etapa anterior e crie um pacote Java denominado proc.

Após ter criado os dois pacotes Java, a estrutura do projeto deverá ser similar à seguinte imagem.

3. Clique com o botão direito do mouse no pacote Java ann e selecione Nova > Classe Java.

4. Digite Handleable para o nome da classe. Clique em Terminar.

5. Modifique o novo arquivo Handleable.java para fazer as alterações a seguir. Salve o arquivo.

6. package ann;

7.

8. public @interface Handleable {

9.

}

É assim que as anotações são declaradas, de forma muito similar a uma declaração de interface. A diferença é

que a palavra-chave interface precisa ser precedida por um sinal at(@). Essa anotação é

denominada Handleable.

Informações adicionais: nas declarações de anotação, você também pode especificar parâmetros adicionais,

por exemplo, que tipos de elementos podem ser anotados, ou seja, classes ou métodos. Faça isso

adicionando @Target(value = {ElementType.TYPE}) para classes e @Target(value =

{ElementType.METHOD). Portanto, a declaração de anotação se torna também anotada com meta-

annotations.

Agora precisamos adicionar um código para que o processador de anotação processe a anotação Handleable.

10. Clique com o botão direito do mouse no pacote proc e selecione Nova > Classe Java.

11. Digite HandleableProcessor para o nome da classe. Clique em Terminar.

12. Modifique a classe HandleableProcessor.java para adicionar o código a seguir. Salve as alterações.

13.package proc;

14.

15.import ann.Handleable;

16.import java.io.IOException;

17.import java.io.PrintWriter;

18.import java.io.Writer;

19.import java.util.Set;

20.import javax.annotation.processing.AbstractProcessor;

21.import javax.annotation.processing.RoundEnvironment;

22.import javax.annotation.processing.SupportedAnnotationTypes;

23.import javax.annotation.processing.SupportedSourceVersion;

24.import javax.lang.model.SourceVersion;

25.import javax.lang.model.element.Element;

26.import javax.lang.model.element.ElementKind;

27.import javax.lang.model.element.TypeElement;

28.import javax.lang.model.type.TypeMirror;

29.import javax.tools.Diagnostic;

30.import javax.tools.JavaFileObject;

31.

32.@SupportedAnnotationTypes("ann.Handleable")

33.@SupportedSourceVersion(SourceVersion.RELEASE_6)

34.public class HandleableProcessor extends AbstractProcessor {

35.

36. /** public for ServiceLoader */

37. public HandleableProcessor() {

38. }

39.

40. public boolean process(Set annotations,

41. RoundEnvironment roundEnv) {

42. for (Element e : roundEnv.getElementsAnnotatedWith(Handleable.class)) {

43. if (e.getKind() != ElementKind.FIELD) {

44. processingEnv.getMessager().printMessage(

45. Diagnostic.Kind.WARNING,

46. "Not a field", e);

47. continue;

48. }

49. String name = capitalize(e.getSimpleName().toString());

50. TypeElement clazz = (TypeElement) e.getEnclosingElement();

51. try {

52. JavaFileObject f = processingEnv.getFiler().

53. createSourceFile(clazz.getQualifiedName() + "Extras");

54. processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE,

55. "Creating " + f.toUri());

56. Writer w = f.openWriter();

57. try {

58. PrintWriter pw = new PrintWriter(w);

59. pw.println("package "

60. + clazz.getEnclosingElement().getSimpleName() + ";");

61. pw.println("public abstract class "

62. + clazz.getSimpleName() + "Extras {");

63. pw.println(" protected " + clazz.getSimpleName()

64. + "Extras() {}");

65. TypeMirror type = e.asType();

66. pw.println(" /** Handle something. */");

67. pw.println(" protected final void handle" + name

68. + "(" + type + " value) {");

69. pw.println(" System.out.println(value);");

70. pw.println(" }");

71. pw.println("}");

72. pw.flush();

73. } finally {

74. w.close();

75. }

76. } catch (IOException x) {

77. processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR,

78. x.toString());

79. }

80. }

81. return true;

82. }

83.

84. private static String capitalize(String name) {

85. char[] c = name.toCharArray();

86. c[0] = Character.toUpperCase(c[0]);

87. return new String(c);

88. }

}

Vamos examinar mais de perto as partes principais que compõem o código para o processador de anotações

(observe que, por conveniência, somente partes do código são fornecidas).

Primeiro, você especifica os tipos de anotações que o processador de anotações suporta

(usando @SupportedAnnotationTypes) e a versão dos arquivos de código-fonte que são suportados

(usando @SupportedSourceVersion); nesse caso, a versão é JDK 6: 

@SupportedAnnotationTypes("ann.Handleable")

@SupportedSourceVersion(SourceVersion.RELEASE_6)

A seguir, declare uma classe pública para o processador que estenda a classe AbstractProcessor do

pacote javax.annotation.processing. AbstractProcessor é a superclasse padrão para processadores

de anotação concretos, que contém os métodos necessários para processar anotações.

public class HandleableProcessor extends AbstractProcessor {

...

}

Você agora precisa fornecer um construtor público para a classe.

public class HandleableProcessor extends AbstractProcessor {

public HandleableProcessor() {

}

...

}

A seguir, chame o método de process() da classe AbstractProcessor principal. Através deste método, as

anotações disponíveis para processamento são fornecidas. Além disso, este método contém informações sobre o

ciclo de processamento.

public class HandleableProcessor extends AbstractProcessor {

...

public boolean process(Set annotations,

RoundEnvironment roundEnv) {

...

}

}

A lógica do processador de anotação está contida dentro do método process() da

classe AbstractProcessor. Observe que, por meio de AbstractProcessor, você também acessa a

interface ProcessingEnvironment, que permite que os processadores de anotação usem diversos recursos

úteis, como um Filer (um manipulador de arquivamento que permite que os processadores de anotação criem

novos arquivos) e um Messager (um meio pelo qual os processadores de anotação reportam erros).

public class HandleableProcessor extends AbstractProcessor {

...

public boolean process(Set annotations,

RoundEnvironment roundEnv) {

//For each element annotated with the Handleable annotation

for (Element e : roundEnv.getElementsAnnotatedWith(Handleable.class)) {

//Check if the type of the annotated element is not a field. Se for,

retorne um erro.

if (e.getKind() != ElementKind.FIELD) {

processingEnv.getMessager().printMessage(

Diagnostic.Kind.WARNING,

"Não é um campo", e);

continue;

}

//Define the following variables: name and clazz.

String name = capitalize(e.getSimpleName().toString());

TypeElement clazz = (TypeElement) e.getEnclosingElement();

//Generate a source file with a specified class name.

try {

JavaFileObject f = processingEnv.getFiler().

createSourceFile(clazz.getQualifiedName() + "Extras");

processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE,

"Creating " + f.toUri());

Writer w = f.openWriter();

Adicione as linhas seguintes ao arquivo : try

{

PrintWriter pw = new PrintWriter(w);

pw.println("package "

+ clazz.getEnclosingElement().getSimpleName() + ";");

pw.println("public abstract class "

+ clazz.getSimpleName() + "Extras {");

pw.println(" protected " + clazz.getSimpleName()

+ "Extras() {}");

TypeMirror type = e.asType();

pw.println(" /** Handle something. */");

pw.println(" protected final void handle" + name

+ "(" + type + " value) {");

pw.println(" System.out.println(value);");

pw.println(" }");

pw.println("}");

pw.flush();

} finally {

w.close();

}

} catch (IOException x) {

processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR,

x.toString());

}

}

return true;

}

...

}

O último bloco neste código declara o método capitalize que é usado para colocar em maiúscula o nome do

elemento anotado.

public class HandleableProcessor extends AbstractProcessor {

...

private static String capitalize(String name) {

char[] c = name.toCharArray();

c[0] = Character.toUpperCase(c[0]);

return new String(c);

}

}

89. Compile o projeto clicando com o botão direito do mouse no projeto AnnProcessor e escolhendo Compilar.

Usando o processador de anotação no IDENesta seção, você criará um projeto de aplicativo Java no qual o processador de anotações será usado.

1. Escolha Arquivo > Novo projeto e selecione o tipo de projeto aplicativo Java na categoria Java. Clique em

Próximo.

2. Na página Nome e localização, digite Demo como o nome do projeto e especifique o local do projeto.

3. Digite demo.Main no campo Criar classe principal. Clique em Terminar.

4. Abra a janela Propriedades do projeto e confirme se o JDK 6 está selecionado como o formato de

código-fonte/binário no painel Código-fonte e que a plataforma Java esteja definida como JDK 6 no painel

Bibliotecas.

5. Modifique a classe Main.java para adicionar o código a seguir. Salve as alterações.

6. package demo;

7.

8. import ann.Handleable;

9.

10.public class Main extends MainExtras {

11.

12. @Handleable

13. private String stuff;

14.

15. public static void main(String[] args) {

16. new Main().handleStuff("hello");

17. }

}

O código contém os seguintes elementos:

o declaração de importação para o processador personalizado de anotação ann.Handleable

o a classe pública Main que estende a classe MainExtras (MainExtras deveria ser gerada por seu processador

de anotação durante a compilação)

o um campo privado denominado stuff que é anotado com a anotação @Handleable

o o método main que chama o método handleStuff, declarado na classe MainExtras automaticamente gerada

Em nosso exemplo simples, o método handleStuff somente imprime o valor atual. Você pode modificar este

método para executar outras tarefas.

Após salvar o código Main.java, você verá que o IDE relata diversos erros de compilação. Isso acontece porque

o processador de anotação ainda não foi adicionado no projeto.

18. Clique com o botão direito do mouse no nó do projeto Demo na janela Projetos, escolha Propriedades e, a seguir,

selecione a categoria Bibliotecas na janela Propriedades.

19. Na aba Compilar, clique em Adicionar projeto e localize o projeto AnnProcessor.

A aba Compilar corresponde a opção -classpath do compilador Java. Como o processador de anotação é um

arquivo JAR único que contém a definição da anotação e o processador de anotação, ele deve ser adicionado na

classpath do projeto, que é a aba Compilar.

20. Selecione a categoria Compilar na janela Propriedades e selecione as caixas de seleção Ativar o processamento

de anotações e Ativar o processamento de anotações no editor.

21. Especifique o processador de anotações a ser executado clicando no botão Adicionar próximo à área de texto

Processadores de anotações e digite proc.HandleableProcessor no campo Processador de anotações FQN. 

A categoria Compilar na janela Propriedades deve se parecer com a imagem a seguir.

22. Clique em OK na janela Propriedades.

Observação. No arquivo Main.java, você ainda poderá ver erros de compilação. Isso é porque o IDE ainda não

pode localizar o arquivo MainExtras.java que declara o métodohandleStuff. O

arquivo MainExtras.java será gerado após você desenvolver o projeto Demo pela primeira vez. Se Compilar

ao salvar estiver ativado para seu projeto, o IDE compilou o projeto quando você salvou o Main.java.

23. Clique com o botão direito do mouse no projeto Demo e escolha Compilar.

Após compilar o projeto, se você examinar os projetos na janela Projetos, poderá agora ver um novo

nó Códigos-fonte gerados com o arquivo demo/MainExtras.java.

Caso você reveja o conteúdo do arquivo MainExtras.java gerado, verá que o processador de anotações gerou

a classe MainExtras com o método handleStuff. O métodohandleStuff é aquele chamado a partir do

arquivo Main.java anotado.

package demo;

public abstract class MainExtras {

protected MainExtras() {}

/** Handle something. */

protected final void handleStuff(java.lang.String value) {

System.out.println(value);

}

}

24. Clique com o botão direito do mouse no projeto Demo e escolha Executar.

Quando você clicar em Executar, deverá ver o seguinte na janela Saída. O projeto Demo é compilado e imprime a

mensagem.

Envie-nos seus comentários

Veja tambémConsulte os seguintes recursos para obter mais informações sobre anotações em aplicativos Java:

Documentação do Java SE - Anotações

Tutorial do Java SE - Anotações

Compilador do Java: Opções de processamento de anotação

Weblog de Joseph D. Darcy's Weblog  - dicas úteis sobre a especificação JSR-269

Oracle Technology Network Downloads de software Documentação

Pesquisar

AnotaçõesMuitas APIs requerem uma grande quantidade de código clichê. Por exemplo, para escrever um JAX-RPC serviço Web, você deve fornecer uma interface emparelhado e implementação. Esse clichê pode ser gerado automaticamente por uma ferramenta que o programa foi "decorado" com anotações indicando que os métodos eram acessíveis remotamente.

Outras APIs requerem arquivos "lado" para ser mantida em paralelo com os programas. Por exemplo JavaBeans requer um BeanInfo classe para ser mantida em paralelo com um feijão, e Enterprise JavaBeans (EJB) requer um descritor de implantação .Seria mais conveniente e menos propenso a erros, se as informações contidas nestes arquivos secundários foram mantidos como anotações no próprio programa.

A plataforma Java sempre teve vários ad mecanismos de anotação hoc. Por exemplo, o passageiro é um modificador de anotação ad hoc, indicando que um campo deve ser ignorado pelo subsistema de serialização, eo @ deprecated tag javadoc é uma anotação ad hoc indicando que o método não deve mais ser utilizado. A partir da versão 5.0, a plataforma tem uma anotação de propósito geral (também conhecido como metadados ) facilidade que permite que você definir e usar seus próprios tipos de anotações. A instalação consiste em uma sintaxe para declarar tipos de anotações, uma sintaxe para declarações de anotação, APIs para anotações de leitura, uma representação arquivo de classe para anotações, e uma ferramenta de processamento de anotação .

Anotações não afetam diretamente a semântica do programa, mas afetam a forma como os programas são tratados por ferramentas e bibliotecas, que por sua vez pode afetar a semântica do programa em execução. As anotações podem ser lidos de arquivos-fonte, arquivos de classe, ou reflexiva em tempo de execução.

Anotações complementar tags javadoc. Em geral, se a marcação visa prejudicar ou produzir uma documentação, que provavelmente deve ser um tag javadoc, caso contrário, deve ser uma anotação.

Programadores de aplicativos típicos nunca terá que se definir um tipo de anotação, mas-lo não é difícil de fazê-lo. Declarações de tipo de anotação são semelhantes às declarações de interface normais. Um sinal de arroba-( @ ) precede o interface depalavra-chave. Cada declaração de método define um elemento do tipo de anotações. Declarações de método não deve ter quaisquer parâmetros ou um throws cláusula. Os tipos de retorno estão restritos a primitivos, de Cordas , Classe e enums , anotações, e matrizes de os tipos precedentes. Os métodos podem ter valores padrão . Aqui está um exemplo de declaração de tipo anotação:

/ ** * Descreve a Solicitação-Para o realce-(RFE), que conduziram * Para a presença do elemento de API anotada. * /public @ interface de RequestForEnhancement { int id (); Sinopse String (); String padrão engenheiro () "[não atribuído]"; Data String () default "[não implementado]"; }

Uma vez que um tipo de anotação é definida, você pode usá-lo para anotar declarações. Uma anotação é um tipo especial de modificador, e pode ser utilizado em qualquer lugar que outros modificadores (tais como público , estática , ou definitiva ) pode ser usado. Por convenção, anotações precedem outros modificadores. Anotações consistem em um sinal de arroba ( @ ) seguido por um tipo de anotação e uma lista entre parênteses de elemento de pares de valores. Os valores devem ser tempo de compilação-constantes. Aqui está uma declaração de método com uma anotação correspondente ao tipo de anotação declaradas acima:

@ RequestForEnhancement ( id = 2868724, sinopse = "Ativar o tempo de viagem", engenheiro = "Mr. Peabody", data = "4/1/3007")travelThroughTime public static void (Data destino) {... }

Um tipo de anotação com nenhum elemento é considerado um marcador tipo de anotação, por exemplo:/ ** * Indica que a especificação do elemento API anotada * São preliminares e sujeitos a alterações.

* /@ interface pública preliminar {}É permitido omitir os parênteses em anotações de marcação, como mostrado abaixo:@ Preliminar public class timetravel {... }Em anotações com um único elemento, o elemento deve ser chamado valor , como mostrado abaixo:/ ** * Associa um aviso de copyright com o elemento API anotada. * /@ Copyright pública de interface { Cadeia de valor ();}É permitido omitir o nome do elemento e sinal de igual ( = ) em uma anotação de elemento único elemento cujo nome é o valor , como mostrado abaixo:@ Copyright ("2002 Sistemas de Propulsão Yoyodyne")OscillationOverthruster public class {... }Para unir tudo isso, vamos construir um framework de teste simples anotação-based. Primeiro precisamos de um tipo de anotação marcador para indicar que um método é um método de teste e deve ser executado pela ferramenta de teste:importar java.lang.annotation *.;

/ ** * Indica que o método é anotada um método de teste. * Esta anotação deve ser usado somente em métodos estáticos sem parâmetros. * /@ Retention (RetentionPolicy.RUNTIME)@ Target (ElementType.METHOD)público Teste interface @ {}Note-se que a declaração de tipo de anotação é em si anotada. Tais anotações são chamados meta-anotações . O primeiro ( @ Retention (RetentionPolicy.RUNTIME) ) indica que as anotações com este tipo devem ser mantidas pela VM para que eles possam ser lidos reflexivamente em tempo de execução. A segunda ( @ Target (ElementType.METHOD) ) indica que este tipo de anotação pode ser utilizado para anotar declarações método só.

Aqui está um programa de exemplo, alguns de cujos métodos são anotados com a interface acima:

public class Foo { @ Test m1 public static void () {} public static void m2 () {} @ Test m3 public static void () { throw new RuntimeException ("Boom"); } m4 public static void () {} @ Test public static void m5 () {} m6 public static void () {} @ Test public static void m7 () { throw new RuntimeException ("Crash"); } public static void m8 () {}}

Aqui está a ferramenta de teste:importar java.Lang.reflect *.;

públicas RunTests classe { public static void main (String [] args) throws Exception { int passou = 0, falhou = 0; for (Method m:. Class.forName (args [0]) GetMethods ()) { if ( m.isAnnotationPresent (Test.class) ) { try { m.invoke (null); passou + +; } Catch (Throwable ex) { System.out.printf ("Teste% s falhou:% s% n", m, ex.getCause ()); falhou + +; } } } System.out.printf ("Passed:% d, Falha% d% n", passou, não); }}

A ferramenta leva o nome da classe como um argumento de linha de comando e itera sobre todos os métodos da classe chamada de tentar chamar cada método que é anotado com o teste tipo de anotação (definida acima). A consulta reflexivo para descobrir se um método tem um teste de anotação é destaque em verde. Se uma invocação de método de teste gera uma exceção, o teste é considerado como tendo falhado, e um relatório de falha é impresso. Finalmente, um resumo é impresso mostrando o número de testes que passados e falhou. Aqui é o que parece quando você executar a ferramenta de teste sobre o Foo programa (acima):$ Java RunTests FooVazio teste public static Foo.m3 () falhou: java.lang.RuntimeException: Boom Teste public static void Foo.m7 () falhou: java.lang.RuntimeException: Crash Passado: 2, Falha 2Embora esta ferramenta de teste é claramente um brinquedo, ele demonstra o poder de anotações e pode ser facilmente estendido para superar suas limitações.

Tecnologia Java

Copyright © 1993, 2011, Oracle e / ou dos seus afiliados. Todos os direitos reservados.

Fale Conosco

Pesquisa   Gabarito

 Não sabe por onde começar? Veja Caminhos de Aprendizagem

Conteúdo Tutorial

Recursos TutorialVer o Tutoriais Java Online (Actualizado 2012/06/14 ).

Blog Os Tutoriais Java ' tem novidades e atualizações sobre os tutoriais Java SE.

Descarregue a última versão do Java pacote Tutoriais .

Em forma de livroBaixar arquivos de ebook .

O Tutorial Java Edition, Quarta.Amazon.com .

Errata para o Tutorial Java, quarta edição.

Outros recursosDesenvolvedor Java SE Guias

Documentação da API

JavaFX Documentação 2,0

O Java EE 6 Tutorial

Documentação do NetBeans ™

A Oracle Formação e Certificação ProfissionalJava Certificação e Formação

Oracle University

SoftwareO Java Development Kit (JDK) para Java SE 7.

NetBeans IDE

Java EE SDK

Os tutoriais de Java são guias práticos para programadores que desejam usar a linguagem de programação Java para criar aplicativos. Eles incluem centenas de completo, exemplos de trabalho, e dezenas de lições. Grupos de aulas relacionados são organizados em "trilhas".

Os tutoriais de Java principalmente descrever os recursos em Java SE 7. Para melhores resultados, baixar JDK 7 .

O que há de novo

Os tutoriais de Java são continuamente atualizados para acompanhar as mudanças para a plataforma Java e para incorporar o feedback dos nossos leitores. Atualizações recentes incluem as seguintes características:

O Generics lição foi totalmente reformulado. A lição atualizada tem informações mais completas sobre a programação com os genéricos, incluindo orientações para uso de wildcards e restrições sobre os medicamentos genéricos , e uma página de captura Wildcard e Métodos auxiliar .

Os tutoriais de Java já estão disponíveis em dois formatos de ebook:o mobi arquivos ebook para Kindle. Para melhores resultados, recomendamos a

visualização on the Fire Kindle ou Kindle DX.o ePub arquivos ebook para iPad, Nook, e eReaders outros que apóiam

o ePub formato.

Cada ebook contém uma trilha única. Você pode baixar trilhas através do link no "em forma de livro" caixa à direita. Para obter melhores resultados quando se vêem blocos de código pré-formatadas, ajustar a orientação vertical / horizontal e tamanho da fonte do dispositivo para ativar a área de visualização possível.

A Preparação para a Certificação Java Programmer Idioma lição foi reformulado. Os objectivos para cada exame de certificação Java SE 7 estão listados e são fornecidos links para páginas de tutoriais relevantes.

Trails abordando os fundamentos

Estas trilhas estão disponíveis em forma de livro como O Tutorial Java, Quarta Edição . Para comprar este livro, consulte a caixa à direita.

Introdução - Uma introdução à tecnologia Java e lições sobre a instalação do Java de desenvolvimento de software e usá-lo para criar um programa simples.

Aprender a linguagem Java - Lições que descrevem os conceitos essenciais e as características da linguagem de programação Java.

Essenciais Classes Java - Lições sobre exceções, entrada básica / saída, a simultaneidade, expressões regulares, e ao ambiente da plataforma.

Coleções - Lições sobre o uso e prorroga o Java Collections Framework. Balanço - Uma introdução ao Swing GUI toolkit, com uma visão geral dos recursos e um

catálogo visual dos componentes. Veja abaixo um tutorial mais abrangente sobre o Swing.

Implantação - Como empacotar aplicações e applets usando arquivos JAR, e implantá-los usando o Java Web Start e do Java Plug-in.

Preparação para a Certificação Java Programming Language - Lista de treinamento e recursos disponíveis do tutorial.

Criação de interfaces gráficas

Criando uma GUI com Swing - Uma introdução abrangente para criação de GUI na plataforma Java.

Criando um GUI JavaFX - Uma coleção de tutoriais JavaFX.

Trails especializados e Lições

Estas trilhas e aulas estão disponíveis apenas como páginas da web.

Networking personalizado - Uma introdução aos recursos da plataforma Java redes poderosas.

O Mecanismo de Extensão - Como fazer APIs personalizado disponível para todos os aplicativos em execução na plataforma Java.

Full-Screen API Modo Exclusivo - Como escrever aplicativos que utilizam de forma mais completa de hardware do usuário gráfica.

Genéricos - um aprimoramento do sistema de tipo que apóia as operações em objetos de vários tipos, fornecendo em tempo de compilação segurança de tipo. Note que essa lição é para usuários avançados. A linguagem Java contém uma trilha Generics lição de que é recomendado para iniciantes.

Internacionalização - Uma introdução à concepção de software para que ele possa ser facilmente adaptado (localizado) para vários idiomas e regiões.

JavaBeans - A tecnologia da plataforma Java do componente. JDBC Database Access - Apresenta uma API para a conectividade entre as aplicações Java

e uma grande variedade de bases de dados e fontes de dados. JMX - Java Management Extensions fornece um modo padrão de gestão de recursos tais

como aplicações, dispositivos e serviços.

JNDI - Java Naming and Directory Interface permite acessar a Naming and Directory Service, tais como DNS e LDAP.

JAXP - Apresenta a API Java para XML Processing (JAXP) 1.4 tecnologia. JAXB - Apresenta a arquitetura Java para XML Binding tecnologia (JAXB). RMI - Remote Method Invocation A API permite que um objeto para invocar métodos de

um objeto executando em outra máquina virtual Java. Reflexão - Uma API que representa ("reflete" a) as classes, interfaces e objetos no atual

Java Virtual Machine. Segurança - os recursos da plataforma Java que ajudam a proteger aplicações de

software malicioso. Som - Uma API para reproduzir dados de som de aplicações. Gráficos 2D - Como mostrar e imprimir gráficos 2D em aplicações. Sockets Direct Protocol - Como habilitar o protocolo Sockets Direct para aproveitar

InfiniBand.

O uso deste página (http://docs.oracle.com/javase/tutorial (Última Atualização 2012/06/14 )) e todo o material em páginas sob o título "Java Tutoriais O" banner está sujeito a estes avisos legais .

Sobre a Oracle | Oracle Technology Network | Termos de Serviço | Acessibilidade da Documentação

Copyright © 1995, 2012 Oracle Corporation e / ou

suas afiliadas. Todos os direitos reservados.

Original text

The objectives for each Java SE 7 certification exam are listed and links are provided to relevant tutorial pages.

Contribute a better translation

Baixar Ebooks   download JDK   Pesquisar Java Tutoriais   Esconder TOC

Orientados a Objetos Conceitos de programação

O que é um objeto?

O que é uma classe?

O que é Herança?

O que é uma Interface?

O que é um pacote?

Perguntas e Exercícios

Página Inicial > Aprender a linguagem Java

«Anterior  •  Trail  •  Próximo »

Lição: Conceitos programação orientada a objeto

Se você nunca usou uma linguagem de programação orientada a objeto antes, você precisa aprender alguns conceitos básicos antes de começar a escrever qualquer código. Esta lição irá apresentá-lo a objetos, classes, herança, interfaces e pacotes. Cada discussão se concentra em como esses conceitos se relacionam com o mundo real, oferecendo, simultaneamente, uma introdução à sintaxe da linguagem de programação Java.

O que é um objeto?

Um objeto é um pacote de software do estado relacionado e comportamento. Objetos de software são frequentemente usadas para modelar os objetos do mundo real que você encontra na vida cotidiana. Esta lição explica como o estado e comportamento são representados dentro de um objeto, introduz o conceito de encapsulamento de dados, e explica os benefícios de projetar seu software desta maneira.

O que é uma classe?

Uma classe é um modelo ou protótipo a partir do qual os objetos são criados. Esta seção define uma classe que modela o estado eo comportamento de um objeto do mundo real. É intencionalmente incide sobre os princípios, mostrando como mesmo uma classe simples pode limpa modelo de estado e comportamento.

O que é Herança?

Herança fornece um mecanismo poderoso e natural para organizar e estruturar o seu software. Esta seção explica como as classes herdam o estado eo comportamento de suas superclasses, e explica como derivar uma classe de outra usando a sintaxe simples, desde que pela linguagem de programação Java.

O que é uma Interface?

Uma interface é um contrato entre uma classe e do mundo exterior. Quando uma classe implementa uma interface, que promete fornecer o comportamento publicado pela interface. Esta seção define uma interface simples e explica as mudanças necessárias para qualquer classe que implementa-lo.

O que é um pacote?

Um pacote é um namespace para organizando classes e interfaces de uma forma lógica. Colocar o código em pacotes torna grandes projetos de software mais fácil de gerenciar. Esta seção explica por que isso é útil, e apresenta-lhe o Application Programming Interface (API) fornecida pela plataforma Java.

Perguntas e Exercícios: Conceitos programação orientada a objeto

Utilize as perguntas e exercícios apresentados nesta seção para testar sua compreensão dos objetos, classes, herança, interfaces e pacotes.

«Anterior • Trail • Próximo »

Problemas com os exemplos? Tente compilar e executar o Exemplos: Perguntas Frequentes . Reclamações? Elogios? Sugestões? Dê-nos a sua opinião .

O uso deste página e todo o material em páginas sob o título "Java Tutoriais O" banner está sujeito a estes avisos legais .

Sobre a Oracle | Oracle Technology Network | Termos de Uso

Copyright © 1995, 2012 Oracle Corporation e / ou suas

afiliadas.Todos os direitos reservados.

O que é um objeto?

Objetos são fundamentais para compreender orientada a objetos de tecnologia. Olhe ao seu redor agora e você vai encontrar muitos exemplos de objetos do mundo real: seu cachorro, sua mesa, sua televisão, sua bicicleta.

Objetos do mundo real compartilham duas características: Todos eles têm estado e comportamento . Os cães têm estado (nome, cor, raça, fome) e comportamento (latindo, buscando, abanando a cauda). Bicicletas também tem estado (engrenagem atual, cadência, velocidade atual) e comportamento (mudança de velocidade, mudança de cadência, aplicando os travões).Identificar o estado eo comportamento de objetos do mundo real é uma ótima maneira de começar a pensar em termos de programação orientada a objeto.

Tome um minuto agora para observar os objetos do mundo real que estão em sua área imediata. Para cada objeto que você vê, pergunte-se duas perguntas: "Quais os possíveis estados pode ser este objeto dentro?" e "O possível comportamento pode executar esse objeto?". Certifique-se de anotar as suas observações. Ao fazer isso, você notará que os objetos do mundo real variam em complexidade; sua lâmpada de mesa pode ter apenas dois estados possíveis (e fora) e dois comportamentos possíveis (ligar, desligar), mas o seu rádio de mesa pode ter adicional estados (ligado, desligado, volume atual, estação atual) e comportamento (ligar, desligar, aumentar volume, diminuir volume, procurar, digitalizar e melodia). Você também pode perceber que alguns objetos, por sua vez, também irá conter outros objetos. Estas observações do mundo real, tudo se traduzirá no mundo da programação orientada a objeto.

Um objeto de software.

Objetos de software são conceitualmente semelhantes para objetos do mundo real: eles também consistem em comportamento do Estado e afins. Um objeto armazena seu estado emcampos (variáveis em algumas linguagens de programação) e expõe o seu comportamento através de métodos (funções em algumas linguagens de programação). Métodos operam sobre o estado interno de um objeto e servir como o principal mecanismo de objeto para objeto de comunicação. Escondendo estado interno e exigindo toda a interação a ser realizado através de métodos de um objeto é conhecido como encapsulamento de dados - um princípio fundamental da programação orientada a objeto.

Considere-se uma bicicleta, por exemplo:

Uma bicicleta modelado como um objeto de software.

Ao atribuir estado (velocidade atual, a cadência atual, e engrenagem de corrente) e fornecer métodos para mudar esse estado, o objeto permanece no controle de como o mundo exterior é permitido usá-lo. Por exemplo, se a bicicleta tem apenas 6 engrenagens, um método para alterar as engrenagens poderia rejeitar qualquer valor que é inferior a 1 ou superior a 6.

Agrupamento de código em objetos individuais de software fornece uma série de benefícios, incluindo:

1. Modularidade: O código fonte para um objeto pode ser escrito e mantido independentemente do código de fonte para outros objetos. Uma vez criado, um objeto pode ser facilmente passado ao redor dentro do sistema.

2. Esconder informação: Ao interagir apenas com os métodos de um objeto, os detalhes de sua implementação interna permanecem escondidos do mundo exterior.

3. Reutilização de código: Se um objeto já existe (talvez escrito por outro desenvolvedor de software), você pode usar esse objeto em seu programa. Isso permite que os especialistas para implementar / testar / depurar tarefa complexa, objetos específicos, que você pode confiar para ser executado em seu próprio código.

4. Capacidade de conexão e facilidade de depuração: Se um objeto particular torna-se problemático, você pode simplesmente removê-lo de sua aplicação e tomada em um objeto diferente como a sua substituição. Isto é análogo a correção de problemas mecânicos no mundo real. Se um parafuso quebra, você substitui -lo , não a máquina inteira.

«Anterior • Trail • Próximo »

O que é uma classe?

No mundo real, muitas vezes você vai encontrar muitos objetos individuais todos do mesmo tipo. Pode haver milhares de outras bicicletas existentes, todos da mesma marca e modelo.Cada bicicleta foi construído a partir do mesmo conjunto de plantas e, por conseguinte, contém os mesmos componentes. Em termos orientados a objetos, dizemos que a bicicleta é umexemplo da classe de objetos conhecida como bicicletas. A classe é o modelo a partir do qual objetos individuais são criados.

A seguir de bicicleta classe é uma possível implementação de uma bicicleta:

classe de bicicleta {

int cadência = 0; int velocidade = 0; int engrenagem = 1;

changeCadence void (int newValue) { cadência = newValue; }

vazio changeGear (int newValue) { artes = newValue; }

SpeedUp void (int incremento) { velocidade = velocidade de incremento +; }

applyBrakes void (int decremento) { velocidade = velocidade - decremento; }

printStates (void) { System.out.println ("cadência:" + cadência + "Velocidade:" + velocidade + "gear:" gear +); }

}

A sintaxe da linguagem de programação Java vai olhar novo para você, mas o projeto dessa classe é com base na discussão anterior de objetos em bicicleta. Os campos cadência ,velocidade e engrenagem representam o estado do objeto, e os métodos ( changeCadence , changeGear , aceleração , etc) definir sua interação com o mundo exterior.

Você deve ter notado que a bicicleta classe não contém um principal método. Isso porque não é um aplicativo completo, é apenas o modelo para bicicletas que podem ser usados em um aplicativo. A responsabilidade de criação e utilização de novas bicicleta objetos pertence a uma outra classe em seu aplicativo.

Aqui está uma BicycleDemo classe que cria duas separadas bicicleta objetos e invoca seus métodos:

BicycleDemo classe { public static void main (String [] args) {

/ / Cria duas diferentes / Objetos / bicicleta Bicicleta bike1 = bicicleta nova (); Bicicleta bike2 = bicicleta nova ();

/ / Chamar métodos em / / Esses objetos bike1.changeCadence (50); bike1.speedUp (10); bike1.changeGear (2); bike1.printStates ();

bike2.changeCadence (50); bike2.speedUp (10); bike2.changeGear (2); bike2.changeCadence (40); bike2.speedUp (10); bike2.changeGear (3); bike2.printStates (); }}

O resultado deste teste imprime a cadência final, velocidade e equipamento para as duas bicicletas:

cadência: 50 velocidade: 10 arte: 2cadência: 40 velocidade: 20 arte: 3

O que é Herança?

Diferentes tipos de objectos têm, frequentemente, uma certa quantidade em comum com o outro. Mountain bikes, bicicletas de estrada e bicicletas tandem, por exemplo, todos compartilham as características de bicicletas (velocidade atual, a cadência atual, a engrenagem de corrente). No entanto, cada um também define recursos adicionais que os tornam diferentes: bicicletas em tandem tem dois assentos e dois conjuntos de guidão; bicicletas de estrada têm guidão queda; algumas bicicletas de montanha têm um anel de corrente adicional, dando-lhes uma relação de marcha mais baixa.

Programação orientada a objetos permite que as classes herdam estado comumente utilizados e comportamento de outras classes. Neste exemplo, de bicicleta torna-se agora asuperclasse de MountainBike , Roadbike e TandemBike . Na linguagem de programação Java, cada classe é permitido ter uma superclasse direta, e cada superclasse tem o potencial para um número ilimitado de subclasses :

Uma hierarquia de classes de bicicletas.

A sintaxe para a criação de uma subclasse é simples. No início da sua declaração de classe, utilizar o estende palavra-chave, seguido do nome da classe a herdar:

classe MountainBike extends bicicleta {

/ / Novos campos e métodos que definem / / Uma bicicleta de montanha irá aqui

}

Isto dá MountainBike todos os mesmos campos e métodos como de bicicleta , mas permite que seu código para se concentrar exclusivamente nas características que o tornam único. Isso torna o código para suas subclasses fácil de ler. No entanto, você deve ter o cuidado de documentar corretamente o estado eo comportamento que cada superclasse define, uma vez que o código não aparece no arquivo de origem de cada subclasse.

«Anterior • Trail • Próximo »

O que é uma Interface?

Como você já aprendeu, objetos definir sua interação com o mundo exterior através dos métodos que eles expõem. Métodos de formar o objeto de interface com o mundo exterior; os botões na parte frontal do seu televisor, por exemplo, são a interface entre você e a fiação elétrica do outro lado do seu invólucro de plástico. Você pressiona o botão "Power" para ligar a televisão ligada e desligada.

Na sua forma mais comum, uma interface é um grupo de métodos relacionados com corpos vazios. O comportamento de uma bicicleta, se especificado como uma interface, pode aparecer como segue:

interface de bicicleta {

/ / Rotações das rodas por minuto changeCadence void (int newValue);

vazio changeGear (int newValue);

SpeedUp void (int incremento);

applyBrakes void (decremento int);}

Para implementar essa interface, o nome da sua classe mudaria (para uma determinada marca de bicicleta, por exemplo, como ACMEBicycle ), e você pode usar a implementos palavra-chave na declaração da classe:

ACMEBicycle classe implementa {bicicleta

/ Restante / desta classe / / Implementado como antes}

Implementação de uma interface permite que uma classe para se tornar mais formal sobre o comportamento que ela promete oferecer. Interfaces formar um contrato entre a classe eo mundo exterior, e este contrato é imposta em tempo de compilação, o compilador. Se sua classe alega a implementar uma interface, todos os métodos definidos por essa interface deve aparecer em seu código-fonte antes que a classe irá compilar com sucesso.

Nota:  Para realmente compilar o ACMEBicycle classe, você precisa adicionar o público palavra-chave para o início dos métodos de interface implementada. Você vai aprender as razões para esta tarde nas aulas sobre Classes e Objetos e Interfaces e Herança .

O que é um pacote?

Um pacote é um namespace que organiza um conjunto de classes relacionadas e interfaces. Conceitualmente você pode pensar de pacotes como sendo semelhante a pastas diferentes no seu computador. Você pode manter as páginas em HTML em uma pasta, imagens em si, e scripts ou aplicativos em outro. Como o software escrito na linguagem de programação Java pode ser composto por centenas ou milhares de aulas individuais, faz sentido manter as coisas organizadas, colocando as classes relacionadas e interfaces em pacotes.

A plataforma Java fornece uma biblioteca de classes enorme (um conjunto de pacotes) adequado para uso em seus próprios aplicativos. Esta biblioteca é conhecido como o "Application Programming Interface", ou "API" para breve. Seus pacotes representam as tarefas mais comumente associados com programação de propósito geral. Por exemplo, uma corda objeto contém o estado eo comportamento de cadeias de caracteres, um arquivo de objeto permite que um programador para criar, apagar, inspecionar, comparar ou modificar um arquivo no sistema de arquivos, um soquete objeto permite a criação e uso de soquetes de rede ; vários objetos GUI

controlar botões e caixas e mais alguma coisa relacionada a interfaces gráficas de usuário. Há literalmente milhares de classes para escolher. Isso permite que você, o programador, para se concentrar no design de sua aplicação em particular, ao invés da infra-estrutura necessária para que ele funcione.

A plataforma Java Specification API contém a listagem completa de todos os pacotes, interfaces, classes, campos e métodos fornecidos pela plataforma Java SE. Carregar a página em seu navegador e marcá-la. Como um programador, ele se tornará sua peça mais importante de documentação de referência.

Perguntas e Exercícios: Conceitos programação orientada a objeto

Perguntas

1. Objetos do mundo real contêm ___ e ___.2. Um objeto de estado do software é armazenado em ___.3. O comportamento de um objeto de software é exposta através de ___.4. Escondendo os dados internos do mundo exterior, e acessá-lo somente através de

métodos expostos publicamente é conhecida como ___ dados.5. Um projeto para um objeto de software é chamado de ___.6. Comportamento comum pode ser definido em um ___ e herdado em um ___ usando a

palavra-chave ___.7. Uma coleção de métodos sem implementação é chamada de ___.8. Um espaço de nomes que organiza classes e interfaces de funcionalidade é chamado de

___.9. A API termo significa ___?

Exercícios

1. Criar novas classes para cada objeto do mundo real que você observou no início desta trilha. Consulte a classe de bicicleta se você esquecer a sintaxe necessária.

2. Para cada nova classe que você criou acima, crie uma interface que define o

Respostas para Perguntas e Exercícios: Conceitos programação orientada a objeto

Respostas às perguntas

1. Objetos do mundo real contêm estado e comportamento .2. Um objeto de estado do software é armazenado em campos .3. O comportamento de um objeto de software é exposta através de métodos .4. Escondendo os dados internos do mundo exterior, e acessá-lo somente através de

métodos expostos publicamente é conhecido como dados de encapsulamento .5. Um projeto para um objeto de software é chamado de classe .6. Comportamento comum pode ser definida em uma superclasse e herdada em

uma subclasse usando o estende palavra-chave.7. Uma coleção de métodos sem implementação é chamado de Interface .

8. Um espaço de nomes que organiza classes e interfaces de funcionalidade é chamado de pacote .

9. A API termo significa Application Programming Interface .

Respostas aos exercícios

1. Suas respostas vão variar de acordo com os objetos do mundo real que você está modelando.

2. Suas respostas irão variar aqui também, mas a mensagem de erro especificamente listar os métodos necessários que não foram implementadas.

Lição: Conceitos Básicos de Língua

Variáveis

Você já aprendeu que os objetos armazenar seu estado em campos. No entanto, a linguagem de programação Java também usa a "variável" termo bem. Esta seção discute essa relação, além de variáveis regras de nomeação e convenções, tipos de dados básicos (tipos primitivos, cadeias de caracteres e matrizes), os valores padrão e literais.

Operadores

Esta seção descreve os operadores da linguagem de programação Java. Apresenta os operadores mais comumente usados em primeiro lugar, e os operadores menos comumente usados passado. Cada discussão inclui exemplos de código que você pode compilar e executar.

Expressões, declarações e Blocos

Os operadores podem ser usados em expressões de construção, que calculam os valores, as expressões são os principais componentes de declarações; declarações podem ser agrupadas em blocos. Esta seção aborda expressões, declarações, e os blocos usando um código exemplo que você já viu.

Demonstração dos Fluxos de Controle

Esta seção descreve as instruções de controle de fluxo suportados pela linguagem de programação Java. Abrange as declarações de tomada de decisões, looping, e ramificação que permitem que seus programas para condicionalmente executar blocos particulares de código.

Variáveis

Como você aprendeu na lição anterior, um objeto armazena seu estado em campos .

int cadência = 0;int velocidade = 0;int engrenagem = 1;

A ? O que é um objeto de discussão introduziu-lhe os campos, mas você provavelmente tem ainda algumas perguntas, tais como: Quais são as regras e convenções para nomear um campo? Além int , o que outros tipos de dados existem? Não os campos têm de ser inicializadas quando são declaradas? São campos atribuído um valor padrão se não forem explicitamente inicializado? Vamos explorar as respostas a essas perguntas desta lição, mas antes de nós,

existem algumas distinções técnicas que você deve primeiro se tornar conscientes.Na linguagem de programação Java, os termos "campo" e "variável" são ambos usados, esta é uma fonte comum de confusão entre os novos desenvolvedores, já que ambos muitas vezes parecem se referir à mesma coisa.

A linguagem de programação Java define os seguintes tipos de variáveis:

Variáveis de instância (campos não-static) Tecnicamente falando, objetos armazenar seus estados individuais em "campos não-static", isto é, campos declarados sem aestática palavra-chave. Non-estáticos campos são também conhecidos como variáveis de instância porque os seus valores são únicos para cada exemplo de uma classe (a cada objecto, por outras palavras); o currentSpeed de uma bicicleta é independente do currentSpeed de outro.

Variáveis de classe (campos estáticos) A variável de classe é qualquer campo declarado com a estática modificador; diz ao compilador que há exatamente uma cópia dessa variável na existência, independentemente de quantas vezes a classe foi instanciada. Um campo que define o número de engrenagens para um determinado tipo de bicicleta poderia ser marcado como static pois conceitualmente o mesmo número de marchas será aplicável a todas as instâncias. Os códigos numGears static int = 6; criaria um campo estático. Além disso, a palavra-chave final, pode ser adicionado para indicar que o número de velocidades nunca irá mudar.

Variáveis locais similares à forma como um objeto armazena seu estado em campos, um método, muitas vezes, armazenar seu estado temporário em variáveis locais . A sintaxe para declarar uma variável local é semelhante ao declarar um campo (por exemplo, int count = 0; ). Não há nenhuma palavra-chave especial que designa uma variável como local; que a determinação vem inteiramente a partir do local em que a variável é declarada - que está entre as chaves de abertura e encerramento de um método. Como tal, as variáveis locais são visíveis apenas com os métodos em que são declarados, eles não são acessíveis a partir do resto da classe.

Parâmetros Você já viu exemplos de parâmetros, tanto na bicicleta e na classe principal método do "Olá Mundo!" aplicação. Lembre-se que a assinatura para o principalmétodo é public static void main (String [] args) . Aqui, o args variável é o parâmetro para este método. A coisa importante a lembrar é que os parâmetros são sempre classificados como "variáveis" não "campos". Isso se aplica a outros parâmetros aceitar construções como bem (como construtores e manipuladores de exceção) que você vai aprender mais tarde no tutorial.

Dito isto, o restante deste tutorial usa as seguintes diretrizes gerais quando se discute campos e variáveis. Se estamos a falar de "campos em geral" (excluindo variáveis locais e parâmetros), podemos simplesmente dizer "campos". Se a discussão se aplica a "todas as anteriores", podemos simplesmente dizer "Variáveis". Se o contexto exige uma distinção, vamos usar termos específicos (campo estático, as variáveis locais, etc), conforme apropriado. Você também pode ocasionalmente ver o "membro" termo usado também. Campos de um tipo, métodos e tipos aninhados são chamados coletivamente de seus membros .

Nomeando

Toda linguagem de programação tem seu próprio conjunto de regras e convenções para os tipos de nomes que você está autorizado a usar, ea linguagem de programação Java não é diferente. As regras e convenções para nomear suas variáveis podem ser resumidas como segue:

Os nomes de variáveis são case-sensitive. Nome de uma variável pode ser qualquer identificador legal - uma seqüência ilimitada de comprimento de letras Unicode e dígitos, começando com uma letra, o cifrão " $ ", ou o caractere sublinhado" _ ". A convenção, entretanto, é sempre começar seus nomes de variáveis com uma letra, e não " $ "ou" _ ".Além disso, o cifrão, por convenção, nunca é usada em tudo. Você pode encontrar algumas situações onde gerados automaticamente nomes irão conter o cifrão, mas seus nomes de variáveis devem sempre evitar usá-lo. Uma convenção semelhante existe para o caractere de sublinhado, enquanto é tecnicamente legal para começar o nome da sua variável com "_ ", essa prática é desencorajada. Espaço em branco não é permitido.

Os caracteres subseqüentes podem ser letras, dígitos, sinais de dólar, ou caracteres de sublinhado. Convenções (e bom senso) se aplicam a esta regra também. Ao escolher um nome para as variáveis, utilizar palavras completas, em vez de abreviaturas. Se o fizer, fará o seu código mais fácil de ler e compreender. Em muitos casos, que também irá fazer o seu código de auto-documentação; campos nomeados cadência , velocidade , e artes , por exemplo, são muito mais intuitivo do que as versões abreviadas, como s , c , e g .Também tenha em mente que o nome escolhido não deve ser uma palavra-chave ou palavra reservada .

Se o nome escolhido é composto por apenas uma palavra, soletrar essa palavra em todas as letras minúsculas. Se ele consiste de mais de uma palavra, capitalizar a primeira letra de cada palavra subseqüente. Os nomes gearRatio e currentGear são excelentes exemplos da presente Convenção. Se a variável armazena um valor constante, como estáticas NUM_GEARS final int = 6 , as mudanças de convenções ligeiramente, capitalizando cada letra e separando as palavras subseqüentes com o caractere sublinhado. Por convenção, o caractere sublinhado nunca é usada em outros lugares.

Tipos de dados primitivos

A linguagem de programação Java é estaticamente-digitada, o que significa que todas as variáveis devem primeiro ser declarado, antes de poderem ser utilizados. Trata-se de declarar o tipo da variável eo nome, como você já viu:

int engrenagem = 1;

Se o fizer, diz que seu programa um campo chamado "engrenagem" existe, contém dados numéricos, e tem um valor inicial de "1". A variável tipo de dados determina os valores que ele possa conter, além das operações que podem ser executadas nele. Além de int , a linguagem de programação Java suporta sete outros tipos de dados primitivos . Um tipo primitivo é pré-definido pela linguagem e é chamado por uma palavra reservada. Os valores primitivos não compartilham estado com outros valores primitivos. Os oito tipos primitivos de dados suportados pela linguagem de programação Java são:

byte : O byte é um tipo de dados de 8 bits assinado dois do complemento inteiro. Tem um valor mínimo de -128 e um valor máximo de 127 (inclusive). O byte tipo de dados pode ser útil para salvar a memória em grandes matrizes , onde as economias de memória realmente importa. Eles podem também ser utilizados no lugar de int onde os seus limites de ajudar a clarificar o seu código; o facto de que uma gama variável é limitada pode servir como uma forma de documentação.

curto : O curta é um tipo de dados 16-bit número inteiro assinado complemento de dois. Tem um valor mínimo de -32.768 e um valor máximo de 32.767 (inclusive). Tal como acontece com byte , as mesmas diretrizes se aplicam: você pode usar um curta para economizar memória em grandes conjuntos, em situações em que as economias de memória realmente importa.

int : A int tipo de dados é um inteiro de 32 bits assinado complemento de dois. Tem um valor mínimo de -2.147.483.648 e um valor máximo de 2.147.483.647 (inclusive). Para valores inteiros, este tipo de dados é geralmente a opção padrão a menos que haja uma razão (como o acima) para escolher outra coisa. Este tipo de dados provavelmente será grande o suficiente para os números de seu programa vai usar, mas se você precisar de uma ampla gama de valores, use longo vez.

tempo : O tempo é um tipo de dados de 64 bits assinado dois do complemento inteiro. Tem um valor mínimo de -9.223.372.036.854.775.808 e um valor máximo de 9.223.372.036.854.775.807 (inclusive). Utilize este tipo de dados quando você precisa de um intervalo de valores mais amplos do que aqueles fornecidos pelo int .

flutuador : O flutuador tipo de dados é um único-precisão de 32 bits ponto flutuante IEEE 754. Sua gama de valores está além do escopo desta discussão, mas é especificado nos tipos de ponto flutuante, formatos e valores seção da especificação da linguagem Java. Tal como acontece com as recomendações para byte e curto , use uma bóia (em vez de duas vezes ), se você precisa para economizar memória em grandes conjuntos de números de ponto flutuante. Este tipo de dados nunca deve ser usado para valores precisos, como moeda. Para isso, você precisará usar o java.math.BigDecimal classe em vez. números e strings cobre BigDecimal e outras classes úteis fornecidos pela plataforma Java.

dupla : A dupla é um tipo de dados de precisão dupla de 64 bits ponto flutuante IEEE 754. Sua gama de valores está além do escopo desta discussão, mas é especificado nostipos de ponto flutuante, formatos e valores seção da especificação da linguagem Java. Para valores decimais, este tipo de dados é geralmente a opção padrão. Como mencionado acima, este tipo de dados nunca deve ser usado para valores precisos, tais como moeda.

boolean : O boolean tipo de dados tem apenas dois valores possíveis: verdadeiro e falso . Utilize este tipo de dados para bandeiras simples que rastreiam as condições verdadeiro / falso. Este tipo de dados representa um bit de informação, mas o seu "tamanho" não é algo que está definido com precisão.

caractere : O caractere tipo de dados é um personagem único 16-bit Unicode. Tem um valor mínimo de '\ u0000' (ou 0) e um valor máximo de '\ uFFFF' (ou 65.535 inclusive).

Além dos oito tipos primitivos de dados listados acima, a linguagem de programação Java também fornece suporte especial para cadeias de caracteres através da java.lang.String classe.Encerrando a seqüência de caracteres dentro de aspas duplas irá criar automaticamente uma nova cadeia objeto, por exemplo, String s = "isto é uma string"; . corda objetos são imutáveis , o que significa que uma vez criado, seus valores não podem ser alterados. A seqüência de classes não é tecnicamente um tipo de dados primitivo,

mas considerando o apoio especial que lhe é dado pela linguagem, você provavelmente tendem a pensar nele como tal. Você aprenderá mais sobre a cadeia de classe em objetos de dados simples

Valores Padrão

Nem sempre é necessário atribuir um valor quando um campo está declarado. Campos que são declarados, mas não inicializado será definido como um padrão razoável pelo compilador.De um modo geral, este padrão será zero ou nula , dependendo do tipo de dados. Baseando-se esses valores implícitos, no entanto, é geralmente considerado um estilo de programação ruim.

O gráfico a seguir resume os valores padrão para os tipos de dados acima.

Tipo de dados Valor padrão (para os campos)

byte 0

curto 0

int 0

longo 0L

flutuar 0.0f

dobrar 0.0d

caractere '\ U0000'

String (ou qualquer objeto) nulo

boolean falso

As variáveis locais são um pouco diferentes, o compilador nunca atribui um valor padrão para uma variável local não inicializada. Se você não puder inicializar a variável local onde ela é declarada, certifique-se de atribuir um valor antes de tentar usá-lo. Acessar uma variável local não inicializada irá resultar em um erro de tempo de compilação.

Literais

Você deve ter notado que a nova palavra-chave não é usado quando inicializar uma variável de um tipo primitivo. Tipos primitivos são tipos especiais de dados incorporadas ao idioma, pois eles não são objetos criados a partir de uma classe. Um literal é a representação de código fonte de um valor fixo; literais são representados diretamente em seu código sem a necessidade de computação. Como mostrado abaixo, é possível atribuir um literal para uma variável de um tipo primitivo:

resultado boolean = true;caractere capitalC = 'C';byte b = 100;

curto s = 10000;int i = 100000;

Integer literais

Um literal inteiro é do tipo longo , se ele termina com a letra L ou l , caso contrário ele é do tipo int . É recomendável que você usar a letra maiúscula L porque a letra minúscula l é difícil distinguir o dígito 1 .

Valores dos tipos integrais byte , curto , int , e muito pode ser criado a partir de int literais. Valores do tipo longas que ultrapassam a faixa de int pode ser criado a partir delongas literais. Literais inteiros podem ser expressos por estes sistemas numéricos:

Decimal: Base 10, cujos dígitos é composto pelos números 0 a 9, este é o sistema de número que você usa todos os dias

Hexadecimal: Base 16, cujos dígitos composto pelos números de 0 a 9 e as letras A até F Binário: Base 2, cujos dígitos é composto dos números 0 e 1 (você pode criar literais

binários em Java SE 7 e posteriores)

Para programação de propósito geral, o sistema decimal é provável que seja o sistema único número que você vai usar. No entanto, se você precisa usar um outro sistema numérico, o exemplo a seguir mostra a sintaxe correta. O prefixo 0x indica hexadecimal e 0b indica binário:

/ / O número 26, em decimalint decVal = 26;/ / O número 26, em hexadecimalint hexVal = 0x1A;/ / O número 26, em binárioint binVal = 0b11010;

De ponto flutuante Literais

Um literal de ponto flutuante é do tipo flutuante se termina com a letra F ou F , caso contrário, seu tipo é duplo e, opcionalmente, pode terminar com a letra D ou d .

Os tipos de ponto flutuante ( bóia e dupla ) também pode ser expressa usando E ou E (para a notação científica), F ou F (32-bit flutuante literal) e D ou d (64-bit dupla literal, este é o padrão e por convenção é omitido).

d1 duplas = 123,4;/ / Mesmo valor que d1, mas em notação científicadobrar d2 = 1.234e2;flutuar f1 = 123.4f;

Literais de caracteres e String

Literais dos tipos de char e string podem conter qualquer caractere Unicode (UTF-16) caracteres. Se o seu editor e sistema de arquivos permitirem, você pode usar esses caracteres diretamente em seu código. Se não, você pode usar um "escape Unicode", tais como '\ u0108' (capital C com circunflexo) ou "S \ u00ED Se \ u00F1or" (Señor Sí em espanhol).Sempre use 'aspas simples' para de char literais e "aspas" para cordas literais. Seqüências de escape Unicode pode ser usado em outro lugar em um programa (como em nomes de campo, por exemplo), não apenas no de char ou string literais.

A linguagem de programação Java também suporta algumas sequências de escape especiais para de char e string literais: \ b (backspace), \ t (tab), \ n (line feed), \ f (form feed),\ r (retorno de carro), \ " (aspas duplas), \ ' (aspas simples), e \ \ (barra invertida).

Há também uma especial nula literal que pode ser usado como um valor para qualquer tipo de referência. nulo pode ser atribuído a qualquer variável, excepto variáveis de tipos primitivas. Há pouco você pode fazer com um nulo valor além do teste para a sua presença. Portanto, nula é frequentemente usado em programas como um marcador para indicar que um objeto não está disponível.

Finalmente, há também um tipo especial de literal chamado de classe literal , formado por tirar um nome de tipo e acrescentando " classe ". , por exemplo, String.class . Este se refere ao objeto (do tipo Classe ), que representa o próprio tipo.

Usando o caractere de sublinhado literais numéricos

Em Java SE 7 e depois, qualquer número de caracteres de sublinhado ( _ ) pode aparecer em qualquer lugar entre dígitos em um literal numérico. Este recurso permite, por exemplo. para separar grupos de dígitos em literais numéricos, o que pode melhorar a legibilidade do seu código.

Por exemplo, se seu código contém números com muitos dígitos, você pode usar um caractere de sublinhado para separar dígitos em grupos de três, da mesma forma como você usaria um sinal de pontuação como uma vírgula ou um espaço, como um separador.

O exemplo a seguir mostra outras maneiras que você pode usar o sublinhado em literais numéricos:

longo creditCardNumber = 1234_5678_9012_3456L;longo socialSecurityNumber = 999_99_9999L;flutuar pi = 3.14_15F;hexBytes longos = 0xFF_EC_DE_5E;longo hexWords = 0xCAFE_BABE;longo maxLong = 0x7fff_ffff_ffff_ffffL;nybbles bytes = 0b0010_0101;bytes = 0b11010010_01101001_10010100_10010010;

Você pode colocar ressalta apenas entre os dígitos, você não pode colocar sublinhados nos seguintes locais:

No início ou no final de um número Adjacente a um ponto decimal em um literal de ponto flutuante Antes de um F ou L sufixo Nas posições onde uma seqüência de dígitos é esperado

Os seguintes exemplos demonstram válidos e inválidos sublinhado colocações (que são destaque) em literais numéricos:

/ / inválido: não pode colocar sublinha / / ao lado de um ponto decimalflutuar PI1 = 3_.1415F;/ / inválido: não pode colocar sublinha / / ao lado de um ponto decimal

flutuar pi2 = 3._1415F;/ / inválido: não pode colocar sublinha / / antes de um sufixo Llongo socialSecurityNumber1 = 999_99_9999_L;

/ / Este é um identificador, não / / A literal numéricoint x1 = _52;/ / OK (literal decimal)int x2 = 5_2;/ / inválido: não pode colocar sublinha / / No final de um literalint x3 = 52_;/ / OK (literal decimal)int x4 = 5_______2;

/ / inválido: não pode colocar sublinha / / no prefixo 0x radixint x5 = 0_x52;/ / inválido: não pode colocar sublinhados / / , no início de um númeroint x6 = 0x_52;/ / OK (literal hexadecimal)int x7 = 0x5_2; / / inválido: não pode colocar sublinhados / / no final de um númeroint x8 = 0x52_;

Baixar Ebooks   download JDK   Pesquisar Java Tutoriais   Esconder TOC

Noções básicas de linguagem

Variáveis

Tipos de dados primitivos

Arrays

Resumo das Variáveis

Perguntas e Exercícios

Operadores

Operadores aritméticos, atribuição e Unário

Operadores de igualdade, Relacional e Condicional

Bitwise e Operadores Bit Shift

Resumo dos Operadores

Perguntas e Exercícios

Expressões, declarações e Blocos

Perguntas e Exercícios

Demonstração dos Fluxos de Controle

As Demonstrações if-then e if-then-else

A Declaração de interruptor

O tempo e fazer ao mesmo tempo, Demonstrações

A Declaração para

Ramificação Demonstrações

Resumo das Demonstrações de Fluxo de Controle

Perguntas e Exercícios

Página Inicial > Aprendizagem da Língua Java > Linguagem Basics

«Anterior  •  Trail  •  Próximo »

Arrays

Uma matriz é um objeto de recipiente que contém um número fixo de valores de um único tipo. O comprimento de uma matriz é estabelecida quando a matriz é criada. Após a criação, seu comprimento é fixo. Você já viu um exemplo de matrizes já, no principal método do "Olá Mundo!" aplicação. Esta seção discute matrizes em maior detalhe.

Uma matriz de dez elementos

Cada item em uma matriz é chamado de elemento , e cada elemento é acessado pela numérica índice . Como mostrado na ilustração acima, a numeração começa com 0. O elemento 9, por exemplo, seria, portanto, ser acessada no índice 8.

O programa a seguir, ArrayDemo , cria um array de inteiros, coloca alguns valores nela, e imprime cada valor à saída padrão.

ArrayDemo classe { public static void main (String [] args) { / / Declara um array de inteiros int [] meuArray;

/ / Aloca memória para 10 inteiros meuArray = new int [10];

/ / Inicializa o primeiro elemento meuArray [0] = 100; / / Inicializa o segundo elemento meuArray [1] = 200; / / Etc meuArray [2] = 300; meuArray [3] = 400; meuArray [4] = 500; meuArray [5] = 600; meuArray [6] = 700; meuArray [7] = 800; meuArray [8] = 900; meuArray [9] = 1000;

System.out.println ("elemento no índice 0:" + MeuArray [0]); System.out.println ("Elemento no índice 1:" + MeuArray [1]); System.out.println ("Elemento no índice 2:" + MeuArray [2]); System.out.println ("Elemento no índice 3:" + MeuArray [3]); System.out.println ("Elemento no índice 4:" + MeuArray [4]); System.out.println ("Elemento no índice 5:" + MeuArray [5]); System.out.println ("Elemento no índice 6:" + MeuArray [6]); System.out.println ("Elemento no índice 7:" + MeuArray [7]); System.out.println ("Elemento no índice 8:" + MeuArray [8]); System.out.println ("Elemento no índice 9:" + MeuArray [9]); }}

A saída deste programa é:

Elemento no índice 0: 100Elemento no índice 1: 200Elemento no índice 2: 300Elemento no índice 3: 400Elemento no índice 4: 500Elemento no índice 5: 600Elemento no índice 6: 700Elemento no índice 7: 800Elemento no índice 8: 900Elemento no índice 9: 1000

Em uma situação de programação do mundo real, você provavelmente usa um dos suportados construções de looping para percorrer cada elemento da matriz, em vez de escrever cada linha individualmente como mostrado acima. No entanto, este exemplo ilustra claramente a sintaxe de matriz. Você vai aprender sobre as várias construções de loop ( para , enquanto , edo-while ) no fluxo de controle de seção.

Declarando uma variável para fazer referência a uma matriz

O programa acima declara meuArray com a seguinte linha de código:

/ / Declara um array de inteirosint [] meuArray;

Como declarações para variáveis de outros tipos, uma declaração de matriz tem dois componentes: tipo do array eo nome da matriz. Tipo de um array é escrito como tipo [] , ondetipo é o tipo de dados dos elementos contidos; os colchetes são símbolos especiais que indicam que esta variável contém uma matriz. O tamanho da matriz não é parte do seu tipo (razão pela qual os suportes são vazio). O nome de um array pode ser o que quiser, desde que ele segue as regras e convenções, como discutido anteriormente na nomenclatura seção. Tal como acontece com variáveis de outros tipos, a declaração não chega a criar uma matriz - ele simplesmente diz ao compilador que esta variável irá conter uma matriz do tipo especificado.

Da mesma forma, você pode declarar arrays de outros tipos:

byte [] anArrayOfBytes;curto [] anArrayOfShorts;tempo [] anArrayOfLongs;float [] anArrayOfFloats;double [] anArrayOfDoubles;boolean [] anArrayOfBooleans;char [] anArrayOfChars;String [] anArrayOfStrings;

Você também pode colocar os colchetes após o nome da matriz:

/ / Dessa forma é desencorajadoanArrayOfFloats float [];

No entanto, a convenção desencoraja esta forma, os suportes de identificar o tipo de matriz e deve aparecer com a designação do tipo.

Criando, inicializando, e acessando um Array

Uma maneira de criar uma matriz é com o novo operador. A próxima instrução no ArrayDemo programa aloca um array com memória suficiente para dez elementos inteiros e atribui a matriz para o meuArray variável.

/ / Cria um array de inteirosmeuArray = new int [10];

Se esta declaração faltasse, o compilador imprimiria um erro como o seguinte, ea compilação falharia:

ArrayDemo.java: 4: meuArray variável não pode ter sido inicializado.

As próximas linhas atribuem valores para cada elemento da matriz:

meuArray [0] = 100; elemento / / inicializa o primeiromeuArray [1] = 200; / / inicializa o segundo elementomeuArray [2] = 300; / / etc

Cada elemento da matriz é acessado por seu índice numérico:

System.out.println ("Elemento 1 no índice 0:" + meuArray [0]);System.out.println ("Elemento 2 no índice 1:" + meuArray [1]);System.out.println ("Elemento 3 no índice 2:" + meuArray [2]);

Alternativamente, você pode usar a sintaxe de atalho para criar e inicializar um array:

int [] = {meuArray 100, 200, 300, 400, 500, 600, 700, 800, 900, 1000};

Aqui, o comprimento da matriz é determinada pelo número de valores fornecidos entre { e } .

Você pode também declarar um array de arrays (também conhecido como um multidimensional matriz) usando dois ou mais conjuntos de colchetes, como String [] [] nomes .Cada elemento, por conseguinte, deve ser acedida por um número correspondente de valores de índice.

Na linguagem de programação Java, um array multidimensional é simplesmente um array cujos componentes são, elas próprias matrizes. Isso é diferente de matrizes em C ou Fortran. Uma consequência disto é que as linhas são permitidos para variar em comprimento, como mostrado no seguinte MultiDimArrayDemo programa:

MultiDimArrayDemo classe { public static void main (String [] args) { String [] [] nomes = { {"Mr.", "Sra.", "Ms."}, {"Smith", "Jones"} }; / / Mr. Smith System.out.println (nomes [0] [0] + nomes [1] [0]); / / Ms. Jones System.out.println (nomes [0] [2] + nomes [1] [1]); }}

A saída deste programa é:

Mr. SmithMs. Jones

Finalmente, você pode usar o built-in comprimento propriedade para determinar o tamanho de qualquer matriz. O código

System.out.println (anArray.length);

irá imprimir o tamanho da matriz para a saída padrão.

Arrays Copiando

O Sistema de classe tem um arraycopy método que você pode usar de forma eficiente copiar dados de um array para outro:

arraycopy public static void (Object src, int srcPos, Objeto dest, int destPos, int length)

Os dois objetos argumentos especificar a matriz para copiar a partir da matriz e copiar para . Os três int argumentos especificam a posição inicial na matriz de origem, a posição de partida na matriz de destino, eo número de elementos da matriz para copiar.

O programa a seguir, ArrayCopyDemo , declara um array de de char elementos, soletrando a palavra "descafeinado". Ele usa arraycopy para copiar uma subsequência de componentes de matriz em uma segunda matriz:

ArrayCopyDemo classe { public static void main (String [] args) { char [] = {CopyFrom 'd', 'e', 'c', 'a', 'f', 'f', 'e',

'I', 'n', 'a', 't', 'e', 'd'}; char [] copyTo = new char [7];

System.arraycopy (CopyFrom, 2, copyTo, 0, 7); System.out.println (new String (copyTo)); }}

A saída deste programa é:

cafeína

«Anterior • Trail • Próximo »

Problemas com os exemplos? Tente compilar e executar o Exemplos: Perguntas Frequentes . Reclamações? Elogios? Sugestões? Dê-nos a sua opinião .

O uso deste página e todo o material em páginas sob o título "Java Tutoriais O" banner está sujeito a estes avisos legais .

Sobre a Oracle | Oracle Technology Network | Termos de Uso

Copyright © 1995, 2012 Oracle Corporation e / ou suas

afiliadas.Todos os direitos reservados.

Resumo das Variáveis

A linguagem de programação Java usa os dois "campos" e "Variáveis", como parte de sua terminologia. Variáveis de instância (campos não-static) são únicos para cada instância de uma classe. Variáveis de classe (campos estáticos) são campos declarados com a estática modificador, há exatamente uma cópia de uma variável de classe, independentemente de quantas vezes a classe foi instanciada. As variáveis locais armazenar o estado temporário dentro de um método. Os parâmetros são variáveis que fornecem informações adicionais para um método, ambas as variáveis locais e parâmetros são sempre classificados como "variáveis" (não "campos"). Ao nomear os seus campos ou variáveis, existem regras e convenções que você deve (ou deve) seguir.

Os oito tipos de dados primitivos são: byte, short, int, float, long, double, boolean e char. O java.lang.String classe representa as cadeias de caracteres. O compilador irá atribuir um valor padrão razoável para campos dos tipos acima, para as variáveis locais, um valor padrão nunca é atribuído. Um literal é a representação de código fonte de um valor fixo. Uma matriz é um objeto de recipiente que contém um número fixo de valores de um único tipo. O comprimento de uma matriz é estabelecida quando a matriz é criada. Após a criação, seu comprimento é fixo.

«Anterior • Trail • Próximo »

Perguntas e Exercícios: Variáveis

Perguntas

1. A "variável de instância" termo é outro nome para ___.2. A variável "classe" termo é outro nome para ___.3. Uma variável local armazena estado temporário, que é declarada dentro de um ___.4. Uma variável declarada dentro do parêntese de abertura e fechamento de uma

assinatura do método é chamado de ____.5. Quais são os oito tipos primitivos de dados suportados pela linguagem de programação

Java?6. Cadeias de caracteres são representados pela classe ___.7. Um ___ é um objeto de recipiente que contém um número fixo de valores de um único

tipo.

Exercícios

1. Crie um pequeno programa que define alguns campos. Tente criar alguns nomes de campo ilegais e ver que tipo de erro o compilador produz. Use as regras de nomeação e convenções como um guia.

2. No programa que você criou no Exercício 1, tente deixar os campos não inicializado e imprimir seus valores. Tente o mesmo com uma variável local e ver que tipo de erros do compilador que você pode produzir. Familiarizar-se com erros de compilador comum irá torná-lo mais fácil de reconhecer os erros em seu código.

Respostas para Perguntas e Exercícios: Variáveis

Respostas às perguntas

1. A "variável de instância" termo é outro nome para não-estático campo .2. A variável "classe" termo é outro nome para campo estático .3. Uma variável local armazena estado temporário, que é declarada dentro de

um método .4. Uma variável declarada dentro do parêntese de abertura e fechamento de um método é

chamado de parâmetro .5. Quais são os oito tipos primitivos de dados suportados pela linguagem de programação

Java? byte, short, int, char, float, long, double, boolean,6. Cadeias de caracteres são representados pela classe java.lang.String .7. Uma matriz é um objeto de recipiente que contém um número fixo de valores de um

único tipo.

Respostas aos exercícios

1. Crie um pequeno programa que define alguns campos. Tente criar alguns nomes de campo ilegais e ver que tipo de erro o compilador produz. Use as regras de nomeação e convenções como um guia.

Não há uma única resposta correta aqui. Os resultados irão variar dependendo do seu código.

2. No programa que você criou no Exercício 1, tente deixar os campos não inicializado e imprimir seus valores. Tente o mesmo com uma variável local e ver que tipo de erros do compilador que você pode produzir.Familiarizar-se com erros de compilador comum irá torná-lo mais fácil de reconhecer os erros em seu código.

Novamente, não há uma única resposta correta para este exercício. Os resultados irão variar dependendo do seu código.

Operadores

Agora que você já aprendeu como declarar e inicializar variáveis, você provavelmente quer saber como fazer algo com eles. Aprender os operadores da linguagem de programação Java é um bom lugar para começar. Operadores são símbolos especiais que realizam operações específicas em um, dois ou três operandos , e, em seguida, retornar um resultado.

À medida que exploramos os operadores da linguagem de programação Java, pode ser útil para você saber de antemão que os operadores têm a maior prioridade. Os operadores na tabela a seguir são listadas de acordo com a ordem de precedência. Quanto mais próximo da parte superior da mesa de um operador aparece, maior a sua precedência. Os operadores com maior precedência são avaliados antes dos operadores com precedência relativamente menor. Operadores na mesma linha têm a mesma precedência. Quando os operadores de precedência igual aparecem na mesma expressão, uma regra deve governar, que é avaliada em primeiro lugar. Todos os operadores binários, exceto para os operadores de atribuição são avaliados da esquerda para a direita; operadores de atribuição são avaliados direita para a esquerda.

Precedência dos operadores

Operadores Precedência

postfix expr + + expr -

unário + + expr - expr + expr - expr ~!

multiplicativo *% /

aditivo + -

deslocar << >>>>>

relacional <> <=> = Instanceof

igualdade ! == =

AND bit a bit &

bit a bit exclusivo OU ^

bit a bit, inclusive, ou |

E lógico &&

OU lógico | |

ternário ? :

atribuição = + = - = * = / =% = & = ^ = | = << = >> = >>> =

Na programação de propósito geral, alguns operadores tendem a aparecer com mais freqüência do que outros, por exemplo, o operador de atribuição " = "é muito mais comum do que o operador de deslocamento à direita não assinado" >>> ". Com isso em mente, a seguinte discussão centra-se em primeiro lugar os operadores que você está mais sujeito a usar em uma base regular, e termina focando aqueles que são menos comuns. Cada discussão é acompanhada por código de exemplo que você pode compilar e executar. Estudar a sua saída irá ajudar a reforçar o que você acabou de aprender.

Operadores aritméticos, atribuição e Unário

O operador de atribuição simples

Um dos operadores mais comuns que você encontrará é o operador de atribuição simples " = ". Você viu este operador na classe de bicicleta, que atribui o valor de seu direito de o operando à sua esquerda:

int cadência = 0; int velocidade = 0; int engrenagem = 1;

Este operador pode também ser usado em objectos para atribuir referências de objeto , como discutido em Criando Objectos .

Os operadores aritméticos

A linguagem de programação Java fornece aos operadores que executam adição, subtração, multiplicação e divisão. Há uma boa chance de você reconhecê-los pelos seus homólogos em matemática básica. O único símbolo que pode parecer novo para você é " % ", que divide um operando por outro e retorna o resto como seu resultado.

+ Operador aditivo (também usada para Concatenação de String)- Operador de subtração* Operador de multiplicaçãoOperador / divisãoOperador de resto%

O programa a seguir, ArithmeticDemo , testa os operadores aritméticos.

ArithmeticDemo classe {

public static void main (String [] args) { / / Resultado é agora 3 int resultado = 1 + 2; System.out.println (resultado);

/ / Resultado é agora 2 resultado = resultado - 1; System.out.println (resultado);

/ / Resultado é agora 4 resultado = resultado * 2; System.out.println (resultado);

/ / Resultado é agora 2 resultado = resultado / 2; System.out.println (resultado);

/ / Resultado é agora 10 resultado = resultado + 8; / / Resultado é agora 3 resultado =% resultado 7; System.out.println (resultado); }}

Você também pode combinar os operadores aritméticos com o operador de atribuição simples de criar atribuições compostas . Por exemplo, x + = 1; e x = x 1; tanto incremento o valor de x em 1.

A + operador pode também ser utilizado para a concatenação (unir) duas cadeias em conjunto, como mostrado no seguinte ConcatDemo programa:

ConcatDemo classe { public static void main (String [] args) { FirstString String = "Isto é"; Cordas secondString = "A string concatenada."; Cordas thirdString = firstString + secondString; System.out.println (thirdString); }}

Até o final deste programa, a variável thirdString contém "Esta é uma string concatenada.", que é impressa na saída padrão.

Os operadores unários

Os operadores unários requer apenas um operando; que realizar várias operações, tais como incrementar / decrementar um valor por um, negando uma expressão, ou invertendo o valor de um booleano.

+ Operador mais unário; indica valor positivo (os números são positiva, sem isso, no entanto)- Operador menos unário; nega uma expressão

+ + Operador de incremento; incrementos um valor de 1- Operador de decremento; decréscimos um valor de 1! Operador de complemento lógico; inverte o valor de um booleano

O programa a seguir, UnaryDemo , testa os operadores unários:

UnaryDemo classe {

public static void main (String [] args) { / / Resultado é agora de 1 int resultado = 1; System.out.println (resultado); / / 0 resultado é agora resultado -; System.out.println (resultado); / / Resultado é agora de 1 resultado + +; System.out.println (resultado); / / Resultado é agora -1 resultado = resultado; System.out.println (resultado); boolean sucesso = false; / / False System.out.println (sucesso); / / True System.out.println (sucesso!); }}

Os operadores de incremento / decremento pode ser aplicado antes (prefixo) ou depois (postfix) o operando. O código resultado + +; e + + resultado; serão ambos fim emresultado sendo incrementado de um. A única diferença é que a versão de prefixo ( + + resultado ) avalia que o valor incrementado, enquanto a versão postfix ( resultado + + ) avalia que o valor original. Se você está apenas executando um simples incremento / decremento, isso realmente não importa qual versão que você escolher. Mas se você usar este operador, em parte, de uma expressão maior, o que você escolher pode fazer uma diferença significativa.

O programa a seguir, PrePostDemo , ilustra o prefixo / postfix operador de incremento unário:

PrePostDemo classe { public static void main (String [] args) { int i = 3; i + +; / / Imprime 4 System.out.println (i); + + I; / / Imprime 5 System.out.println (i); / / Imprime 6 System.out.println (+ + i); / / Imprime 6 System.out.println (i + +); / / Imprime 7 System.out.println (i); }}

Operadores de igualdade, Relacional e Condicional

A igualdade e operadores relacionais

A igualdade e operadores relacionais determinar se um operando é maior do que, a menos que, igual a, ou não igual a outra operando. A maioria desses operadores será, provavelmente, parece familiar para você também. Tenha em mente que você deve usar " == ", não" = ", ao testar se dois valores primitivos são iguais.

== Igual para! = Não igual a> Maior> = Maior do que ou igual a<Inferior<= Menos de ou igual a

O programa a seguir, ComparisonDemo , testa os operadores de comparação:

ComparisonDemo classe {

public static void main (String [] args) { int valor1 = 1; int valor2 = 2; if (valor1 == valor2) System.out.println ("valor1 == valor2"); if (valor1! = valor2) System.out.println ("valor1 = valor2"); if (valor1> valor2) System.out.println ("valor1> valor2"); if (valor1 <valor2) System.out.println ("valor1 <valor2"); if (valor1 <valor2 =) System.out.println ("valor1 <= valor2"); }}

Saída:

valor1! = valor2valor1 <valor2valor1 <= valor2

Os operadores condicionais

Os && e | | operadores executar condicional-E e condicional OU operações em duas expressões Boolean. Estes operadores apresentam "curto-circuito" comportamento, o que significa que o segundo operando é avaliado somente se necessário.

Condicional &&-E| | Condicional-OR

O programa a seguir, ConditionalDemo1 , testa esses operadores:

ConditionalDemo1 classe {

public static void main (String [] args) { int valor1 = 1; int valor2 = 2;

if ((valor1 == 1) && (valor2 == 2)) System.out.println ("valor1 é 1 e valor2 é 2"); if ((valor1 == 1) | | (valor2 == 1)) System.out.println ("valor1 valor2 é 1 ou é 1"); }}

Outro operador condicional é :? , que pode ser pensado como uma abreviação para um if-then-else declaração (discutido no Controle de Fluxo de Demonstrações desta lição). Este operador é também conhecido como o operador ternário porque utiliza três operandos. No exemplo a seguir, este operador deve ser lido como: "Se someCondition é verdade , atribuir o valor de valor1 para resultar Caso contrário, atribuir o valor de. valor2 a resultar . "

O programa a seguir, ConditionalDemo2 , testa a : operador:

ConditionalDemo2 classe {

public static void main (String [] args) { int valor1 = 1; int valor2 = 2; int resultado; someCondition boolean = true; resultar someCondition =? valor1: valor2;

System.out.println (resultado); }}

Porque someCondition é verdade, este programa imprime "1" para a tela. Use a : operador em vez de um if-then-else if faz seu código mais legível, por exemplo, quando as expressões são compactos e sem efeitos colaterais (como atribuições).

O Tipo de Operador de comparação instanceof

O instanceof operador compara um objeto para um tipo especificado. Você pode usá-lo para testar se um objeto é uma instância de uma classe, uma instância de uma subclasse, ou uma instância de uma classe que implementa uma interface específica.

O programa a seguir, InstanceofDemo , define uma classe pai (chamado pai ), uma interface simples (chamado MyInterface ), e uma classe filha (chamada Criança ) que herda do pai e implementa a interface.

InstanceofDemo classe { public static void main (String [] args) {

Obj1 Pai Pai = new (); Pai obj2 Criança = new ();

System.out.println ("Parent obj1 instanceof:" + (Parent instanceof obj1)); System.out.println ("Criança instanceof obj1:" + (Criança instanceof obj1)); System.out.println ("obj1 MyInterface instanceof:" + (Obj1 instanceof MyInterface)); System.out.println ("obj2 Parent instanceof:" + (Obj2 Parent instanceof)); System.out.println ("obj2 Criança instanceof:"

+ (Obj2 Criança instanceof)); System.out.println ("obj2 instanceof MyInterface:" + (Obj2 instanceof MyInterface)); }}

Pais de classe {}Criança classe estende MyInterface Parent implementos {}interface de MyInterface {}

Saída:

Pai obj1 instanceof: trueCriança obj1 instanceof: falseobj1 instanceof MyInterface: falseobj2 Parent instanceof: trueobj2 Criança instanceof: trueobj2 instanceof MyInterface: true

Ao usar o instanceof operador, tenha em mente que nulo não é uma instância de qualquer coisa.

Bitwise e Operadores Bit Shift

A linguagem de programação Java também oferece aos operadores que executam operações de deslocamento bit a bit e bit em tipos integrais. Os operadores discutidas nesta seção são menos utilizados. Assim, sua cobertura é breve, a intenção é simplesmente torná-lo consciente de que esses operadores existir.

O unário complemento bit a bit operador " ~ "inverte um padrão de bits, que pode ser aplicado a qualquer um dos tipos integrais, fazendo todos os" 0 "a" 1 "e cada" 1 "a" 0 ". Por exemplo, um byte de 8 bits contém, aplicando este operador para um valor cujo bit padrão é "00000000" mudaria o seu padrão de "11111111".

O deslocamento para a esquerda assinado operador " << "muda um padrão de bits para a esquerda, e o operador de deslocamento assinado direita" >> "muda um padrão de bits para a direita. O padrão de bits é dado pelo operando da esquerda, eo número de posições para deslocar pelos operando à direita. A direita não assinado mudança operador " >>> "muda um zero na posição mais à esquerda, enquanto a posição mais à esquerda, após ">>" depende de extensão de sinal.

O bit a bit e operador executa uma operação AND bit a bit.

O bit a bit ^ operador executa uma operação bit a bit OU exclusivo.

O bit a bit | operador executa uma operação OR bit a bit inclusiva.

O programa a seguir, BitDemo , usa o bit a bit E operador para imprimir o número "2" para a saída padrão.

BitDemo classe { public static void main (String [] args) { int bitmask = 0x000F; int val = 0x2222; / / Imprime "2" System.out.println (val & bitmask);

}}

Resumo dos Operadores

A seguinte referência rápida resume os operadores suportados pela linguagem de programação Java.

Operador de Atribuição Simples= Operador de atribuição simples

Operadores AritméticosOperador + Aditivo (também usado para concatenação de String)- Operador de subtração* Operador de multiplicaçãoOperador / DivisãoOperador Restante%

Operadores unários+ Operador mais unário; indica valor positivo (os números são positiva, sem isso, no entanto)- Operador menos unário; nega uma expressão+ + Operador de incremento; incrementos um valor de 1- Operador de decremento; decréscimos um valor de 1! Operador de complemento lógico; inverte o valor de um booleano

Igualdade e operadores relacionais== Igual a! = Não igual a> Maior que> = Maior do que ou igual a<Menor que<= Menos do que ou igual a

Operadores CondicionaisCondicional &&-E| | Condicional-OR?: Ternário taquigrafia (para if-then-else declaração)

Operador de comparação de tipoinstanceof Compara um objeto para um tipo especificado

Bitwise e Operadores Bit Shift~ Unário bit a bit complementoAssinado << desvio à esquerdaAssinado direito >> mudar>>> Mudança Unsigned direito& AND bit a bit^ Bitwise OU exclusivo| Inclusive Bitwise OR

Perguntas e Exercícios: Operadores

Perguntas

1. Considere o seguinte trecho de código.2. arrayOfInts [j]> arrayOfInts [j +1]

Quais os operadores que o código contém?

3. Considere o seguinte trecho de código.4. int i = 10;5. int n = i + + 5%;

a. Quais são os valores de i e n depois que o código é executado?b. Quais são os valores finais de i e n , se em vez de usar o operador de incremento

postfix ( i + + ), você usa a versão de prefixo ( + + i) )?6. Para inverter o valor de um booleano , operador que você usaria?7. Que operador é usado para comparar dois valores, = ou == ?8. Explicar o seguinte amostra de código: someCondition = resultado? valor1: valor2;

Exercícios

1. Altere o programa seguinte para usar atribuições compostas:2. ArithmeticDemo classe {3.4. public static void main (String [] args) {5. 6. int resultado = 1 + 2 / / resultado é agora 37. System.out.println (resultado);8.9. resultado = resultado - 1; / result / agora é 210. System.out.println (resultado);11.12. result = result * 2; / result / agora é 413. System.out.println (resultado);14.15. resultado = resultado / 2; / result / agora é 216. System.out.println (resultado);17.18. resultado = resultado + 8; / / result é agora 1019. result = result 7%; / / resultado é agora 320. System.out.println (resultado);21. }22. }23.

24.No programa seguinte, explicar por que o valor "6" é impresso duas vezes em uma linha:25. PrePostDemo classe {26. public static void main (String [] args) {27. int i = 3;28. i + +;29. System.out.println (i) / / "4"30. + + I; 31. System.out.println (i) / / "5"32. System.out.println (+ + i) / / "6"33. System.out.println (i + +) / / "6"34. System.out.println (i) / / "7"35. }

}

Respostas para Perguntas e Exercícios: Operadores

Respostas às perguntas

1. Considere o seguinte trecho de código:2. arrayOfInts [j]> arrayOfInts [j +1]

Pergunta: Quais os operadores que o código contém? Resposta: > , +

3. Considere o seguinte trecho de código:4. int i = 10;5. int n = i + + 5%;

a. Pergunta: Quais são os valores de i e n depois que o código é executado? Resposta: i é 11, e n é 0.

b. Pergunta: Quais são os valores finais de i e n , se em vez de usar o operador de incremento postfix ( i + + ), você usa a versão de prefixo ( + + i) )? Resposta: i é 11, e n é 1.

6. Pergunta: Para inverter o valor de um booleano , operador que você usaria? Resposta: O operador de complemento lógico! "".

7. Pergunta : Qual o operador é usado para comparar dois valores, = ou == ? Resposta: A == operador é usado para comparação, e = é usado para atribuição.

8. Pergunta: Explique a seguinte amostra de código: result = someCondition? valor1: valor2; 

Resposta: Este código deve ser lido como: "Se someCondition é verdade , atribuir o valor de valor1 a resultar . Caso contrário, atribuir o valor de valor2 a resultar . "

Exercícios

1. Altere o programa seguinte para usar atribuições compostas:2. ArithmeticDemo classe {3.4. public static void main (String [] args) {5. 6. int resultado = 1 + 2 / / resultado é agora 37. System.out.println (resultado);8.9. resultado = resultado - 1; / result / agora é 210. System.out.println (resultado);11.12. result = result * 2; / result / agora é 413. System.out.println (resultado);14.15. resultado = resultado / 2; / result / agora é 216. System.out.println (resultado);17.18. resultado = resultado + 8; / / result é agora 1019. result = result 7%; / / resultado é agora 320. System.out.println (resultado);21.

22. }23. }

Aqui está uma solução:

ArithmeticDemo classe {

public static void main (String [] args) { int resultado = 3; System.out.println (resultado);

resultado - = 1; / / resultado é agora 2 System.out.println (resultado);

resultado * = 2; / / resultado é agora 4 System.out.println (resultado);

resultado / = 2; / result / agora é 2 System.out.println (resultado);

resultado + = 8; / / result é agora 10 % resultado = 7; / / resultado é agora 3 System.out.println (resultado);

}}

24.No programa seguinte, explicar por que o valor "6" é impresso duas vezes em uma linha:25. PrePostDemo classe {26. public static void main (String [] args) {27. int i = 3;28. i + +;29. System.out.println (i) / / "4"30. + + I; 31. System.out.println (i) / / "5"32. System.out.println (+ + i) / / "6"33. System.out.println (i + +) / / "6"34. System.out.println (i) / / "7"35. }36. }

O código System.out.println (+ + i); avalia a 6, porque a versão de prefixo + + avalia que o valor incrementado. A próxima linha, System.out.println (i + +); avaliada como o valor atual (6), e então incrementa por um. Assim, "7" não são impressos até a próxima linha.

Expressões, declarações e Blocos

Agora que você compreende as variáveis e operadores, é hora de aprender sobre expressões e declarações , e blocos . Os operadores podem ser usados em expressões de construção, que calculam os valores, as expressões são os principais componentes de declarações; declarações podem ser agrupadas em blocos.

Expressões

Uma expressão é uma construção feita de variáveis, operadores, e invocações de métodos, que são construídos de acordo com a sintaxe da linguagem, que resulta em um valor único.Você já viu exemplos de expressões, ilustrados em negrito abaixo:

int cadência = 0 ; meuArray [0] = 100 ; System.out.println ( "Elemento 1 no índice 0:" + meuArray [0] );

int resultado = 1 + 2 ; / / result é agora 3 if ( valor1 == valor2 ) System.out.println ( "valor1 == valor2" );

O tipo de dados do valor retornado por uma expressão depende dos elementos utilizados na expressão. A expressão de cadência = 0 retorna um int porque o operador de atribuição retorna um valor do mesmo tipo de dados como seu operando à esquerda, neste caso, a cadência é um int . Como você pode ver em outras expressões, uma expressão pode retornar outros tipos de valores, bem como, tais como boolean ou string .

A linguagem de programação Java permite construir expressões compostas de várias expressões menores, desde que o tipo de dados exigida por uma parte da expressão corresponde ao tipo de dados do outro. Aqui está um exemplo de uma expressão composta:

1 * 2 * 3

Neste exemplo particular, a ordem em que a expressão é avaliada não é importante porque o resultado da multiplicação é independente da ordem; o resultado é sempre o mesmo, não importa em que ordem de aplicar as multiplicações. No entanto, isso não é verdade de todas as expressões. Por exemplo, a expressão seguinte dá resultados diferentes, dependendo se realizar a adição ou a operação de divisão primeira:

x + y / 100 / / ambígua

Você pode especificar exatamente como uma expressão será avaliada usando parênteses equilibrada: (e). Por exemplo, para fazer a expressão inequívoca anterior, você poderia escrever o seguinte:

(X + y) / 100 / / inequívoca, recomenda

Se você não indicar explicitamente a ordem para as operações a serem executadas, a ordem é determinada pela precedência atribuída aos operadores no uso dentro da expressão. Os operadores que têm uma maior precedência são avaliados primeiro. Por exemplo, o operador de divisão tem uma precedência maior do que o operador de adição. Portanto, as duas declarações seguintes são equivalentes:

x + y / 100

x + (y / 100) / / inequívoca, recomendado

Ao escrever expressões compostas, ser explícito e indicar com parênteses que os operadores devem ser avaliados primeiro. Esta prática torna o código mais fácil de ler e manter.

Demonstrações

As afirmações são equivalente a frases em línguas naturais. Uma instrução forma uma unidade completa de execução. Os seguintes tipos de expressões podem ser feitas em uma declaração que encerra a expressão com um ponto e vírgula ( ; ).

Expressões de atribuição Qualquer uso de + + ou - Invocações de método Criação de expressões Object

Tais declarações são chamados de declarações de expressão . Aqui estão alguns exemplos de declarações de expressão.

/ Cessão / declaraçãoaValue = 8933.234;/ / Incrementa declaraçãoaValue + +;/ Instrução de chamada / métodoSystem.out.println ("Olá Mundo!");Declaração de criação / objeto /Bicicleta myBike = new Bicicleta ();

Para além das declarações de expressão, há dois outros tipos de declarações: declaração de declarações e demonstrativos de controle de fluxo . Uma instrução de declaraçãodeclara uma variável. Você já viu muitos exemplos de instruções de declaração já:

/ Declaração / declaraçãodobrar aValue = 8933.234;

Finalmente, as declarações de controle de fluxo regular a ordem na qual os comandos são executados. Você vai aprender sobre as declarações de controle de fluxo na próxima seção,Demonstração dos Fluxos de Controle

Blocos

Um bloco é um grupo de zero ou mais instruções entre chaves equilibradas e podem ser usados em qualquer lugar uma única instrução é permitido. O seguinte exemplo, BlockDemo , ilustra o uso de blocos:

BlockDemo classe { public static void main (String [] args) { condição boolean = true; if (condição) { / / começam bloco 1 System.out.println ("Condição é verdadeira."); } / bloco final / um else { / / começa o bloco 2 System.out.println ("Condição é falsa."); } / bloco final / 2 }}

Perguntas e Exercícios: Expressões, Demonstrações e Blocos

Perguntas

1. Os operadores podem ser usados na construção de ___, que calcular valores.2. As expressões são os principais componentes de ___.3. As declarações podem ser agrupadas em ___.4. O trecho de código a seguir é um exemplo de uma expressão ___.5. 1 * 2 * 3

6. As afirmações são equivalente a frases em línguas naturais, mas em vez de terminar com um período, uma instrução termina com um ___.

7. Um bloco é um grupo de zero ou mais instruções entre ___ equilibrada e pode ser usado em qualquer lugar uma única instrução é permitido.

Exercícios

Identificar os seguintes tipos de declarações de expressão:

aValue = 8933.234; aValue + +; System.out.println ("Olá Mundo!"); Bicicleta myBike = new Bicicleta ();

Respostas para Perguntas e Exercícios: Expressões, Demonstrações e Blocos

Perguntas

1. Os operadores podem ser utilizados na construção de expressões , que calcular valores.2. As expressões são os principais componentes de declarações .3. As declarações podem ser agrupadas em blocos .4. O trecho de código a seguir é um exemplo de um composto de expressão.5. 1 * 2 * 3

6. As afirmações são equivalente a frases em línguas naturais, mas em vez de terminar com um período, uma instrução termina com um ponto e vírgula .

7. Um bloco é um grupo de zero ou mais declarações equilibradas entre chaves e pode ser usado em qualquer lugar uma única instrução é permitido.

Exercícios

Identificar os seguintes tipos de declarações de expressão:

aValue = 8933.234; declaração / cessão / aValue + + / / incremento declaração System.out.println ("Olá Mundo!"); instrução de chamada / / método Bicicleta myBike = bicicleta nova (); declaração criação / objeto /

Demonstração dos Fluxos de Controle

As demonstrações dentro de arquivos de origem são geralmente executados de cima para baixo, na ordem em que aparecem. demonstrações de fluxo de controle , no entanto, acabar com o

fluxo de execução, empregando a tomada de decisão, looping, e ramificação, permitindo que o seu programa para condicionalmente executar determinado blocos de código. Esta seção descreve as declarações de tomada de decisão ( if-then , if-then-else , mudar ), as declarações de looping ( para , enquanto , ao mesmo tempo fazer- ), e as declarações de ramificação ( quebrar , continuar , voltar ) suportados pelo Java linguagem de programação.

As Demonstrações if-then e if-then-else

O if-then Declaração

O if-then declaração é a mais básica de todas as declarações de controle de fluxo. Ele diz que seu programa execute uma determinada seção de código apenas se um determinado teste avalia a verdade . Por exemplo, a bicicleta pode permitir a classe dos travões para diminuir a velocidade da bicicleta apenas se a bicicleta já está em movimento. Uma aplicação possível do applyBrakes método poderia ser como se segue:

applyBrakes (void) { / / A cláusula "se": bicicleta deve estar se movendo if (isMoving) { / / A cláusula "então": diminuir a velocidade atual currentSpeed -; }}

Se este teste avalia a falsos (o que significa que a bicicleta não estiver em movimento) saltos, controle para o fim do if-then declaração.

Além disso, as chaves de abertura e encerramento são opcionais, desde que a cláusula "então" contém apenas uma instrução:

applyBrakes (void) { / / O mesmo que acima, mas sem as chaves if (isMoving) currentSpeed -;}

Decidir quando a omitir as chaves é uma questão de gosto pessoal. Omitindo-los pode tornar o código mais frágil. Se uma segunda declaração é depois adicionada à cláusula "então", um erro comum seria esquecer de adicionar as chaves recém necessários. O compilador não pode pegar esse tipo de erro, você só vai obter os resultados errados.

O if-then-else Declaração

O if-then-else declaração fornece um caminho secundário de execução quando uma cláusula "se" é avaliada como false . Você pode usar um if-then-else declaração noapplyBrakes método para tomar alguma ação se os freios são aplicados quando a bicicleta não estiver em movimento. Neste caso, a ação é apenas mostrar uma mensagem de erro informando que a bicicleta já parou.

applyBrakes (void) { if (isMoving) { currentSpeed -; Else {} System.out.println ("A bicicleta tem" + "já parou!"); }

}

O programa seguinte, IfElseDemo , atribui um grau com base no valor de um índice de ensaio: um A para uma pontuação de 90% ou superior, um B para uma pontuação de 80% ou superior, e assim por diante.

IfElseDemo classe { public static void main (String [] args) {

int testscore = 76; grau char;

if (testscore> = 90) { grau = 'A'; } Else if (testscore> = 80) { grau = 'B'; } Else if (testscore> = 70) { grau = 'C'; } Else if (testscore> = 60) { grau = 'D'; Else {} grau = 'F'; } System.out.println ("Grau =" grau +); }}

A saída do programa é:

Grau = C

Você deve ter notado que o valor de testscore pode satisfazer mais de uma expressão na instrução composta: 76> = 70 e 76> = 60 . No entanto, uma vez que uma condição é satisfeita, as declarações apropriadas são executadas (grau = 'C' ;) e as restantes condições não são avaliados.

A Declaração de interruptor

Ao contrário de if-then e if-then-else declarações, o interruptor de instrução pode ter um número de caminhos de execução possíveis. Um interruptor trabalha com asbyte , curtas , de char , e int tipos de dados primitivos. Ele também trabalha com tipos enumerados (discutido em Tipos Enum ), a seqüência de classe, e algumas classes especiais que envolvem certos tipos primitivos: Character , Byte , curto , e Integer (discutido em números e strings ).

O seguinte exemplo de código, SwitchDemo , declara um int chamado mês cujo valor representa um mês. O código exibe o nome do mês, com base no valor de meses , utilizando ointerruptor de instrução.

public class {SwitchDemo public static void main (String [] args) {

int mes = 8; Cordas monthString; switch (mês) { case 1: monthString = "Janeiro"; quebrar; case 2: monthString = "Fevereiro";

quebrar; case 3: monthString = "Março"; quebrar; case 4: monthString = "Abril"; quebrar; case 5: monthString = "Maio"; quebrar; case 6: monthString = "Junho"; quebrar; case 7: monthString = "Julho"; quebrar; case 8: monthString = "Agosto"; quebrar; case 9: monthString = "Setembro"; quebrar; caso 10: monthString = "Outubro"; quebrar; caso 11: monthString = "Novembro"; quebrar; case 12: monthString = "Dezembro"; quebrar; default: monthString = "mês inválido"; quebrar; } System.out.println (monthString); }}

Neste caso, agosto é impresso na saída padrão.

O corpo de um interruptor de instrução é conhecido como um bloco de interruptor . Uma instrução no interruptor bloco pode ser marcado com um ou mais caso ou padrãoetiquetas. O interruptor de declaração avalia sua expressão, em seguida, executa todas as instruções que seguem a correspondência caso rótulo.

Você também pode exibir o nome do mês com if-then-else declarações:

int mes = 8;if (mes == 1) { System.out.println ("Janeiro");} Else if (mes == 2) { System.out.println ("Fevereiro");}... / / E assim por diante

Decidir se deve usar if-then-else declarações ou um interruptor afirmação é baseada em leitura ea expressão que a declaração está testando. Um if-then-else declaração pode testar expressões com base em faixas de valores ou condições, enquanto um interruptor testes expressões declaração com base apenas em um único inteiro, valor enumerado, ou de Cordas objeto.

Outro ponto de interesse é a quebra de declaração. Cada pausa declaração termina o fechamento interruptor comunicado. Fluxo de controle continua com a primeira declaração após o interruptor de bloqueio. Os quebra demonstrações são necessários porque sem eles, declarações em interruptor blocos cair através : Todas as instruções após a correspondência caso rótulo são executados em sequência, independentemente de a expressão de subsequentes caso rótulos, até uma quebra de instrução for encontrado. O programaSwitchDemoFallThrough mostra instruções em um interruptor de blocos que caem

completamente. O programa exibe o mês correspondente ao número inteiro mês e os meses que se seguem no ano:

SwitchDemoFallThrough public class {

public static void main (String args []) { <String> futureMonths java.util.ArrayList = novo <String> java.util.ArrayList ();

int mes = 8;

switch (mês) { case 1: futureMonths.add ("Janeiro"); case 2: futureMonths.add ("Fevereiro"); case 3: futureMonths.add ("Março"); case 4: futureMonths.add ("Abril"); case 5: futureMonths.add ("Maio"); case 6: futureMonths.add ("Junho"); case 7: futureMonths.add ("Julho"); case 8: futureMonths.add ("Agosto"); case 9: futureMonths.add ("Setembro"); caso 10: futureMonths.add ("Outubro"); caso 11: futureMonths.add ("Novembro"); case 12: futureMonths.add ("Dezembro"); quebrar; default: break; }

if (futureMonths.isEmpty ()) { System.out.println ("número do mês inválido"); Else {} para (MonthName String: futureMonths) { System.out.println (MonthName); } } }}

Esta é a saída a partir do código:

AgostoSetembroOutubroNovembroDezembro

Tecnicamente, a última pausa não é necessária porque o fluxo cai para fora do interruptor de declaração. Usando uma pausa é recomendado para que a modificação do código é mais fácil e menos propenso a erros. O padrão seção lida com todos os valores que não são explicitamente tratados por um dos casos seções.

O seguinte exemplo de código, SwitchDemo2 , mostra como uma declaração pode ter vários casos de rótulos. O exemplo de código calcula o número de dias em um determinado mês:

SwitchDemo2 classe { public static void main (String [] args) {

int mes = 2; int ano = 2000; int numDays = 0;

switch (mês) { case 1: case 3: case 5: case 7: case 8: case 10: case 12: numDays = 31; quebrar; case 4: case 6: case 9: case 11: numDays = 30; quebrar; case 2: if (((% ano 4 == 0) && ! (% Ano 100 == 0)) | | (% Ano 400 == 0)) numDays = 29; outro numDays = 28; quebrar; default: System.out.println ("mês inválido."); quebrar; } System.out.println ("Número de Dias =" + NumDays); }}

Esta é a saída a partir do código:

Número de dias = 29

Usando Seqüências em declarações switch

Em Java SE 7 e posterior, você pode usar uma corda objeto no interruptor expressão instrução. O exemplo seguinte código, StringSwitchDemo , exibe o número do mês com base no valor da cadeia chamado meses :

public class {StringSwitchDemo

getMonthNumber public static int (mês String) {

int monthNumber = 0;

if (mes == null) { voltar monthNumber; }

interruptor (month.toLowerCase ()) { caso "janeiro": monthNumber = 1; quebrar; caso, "fevereiro": monthNumber = 2; quebrar; caso "marcha": monthNumber = 3; quebrar; caso "abril": monthNumber = 4; quebrar; caso "pode": monthNumber = 5; quebrar;

caso "junho": monthNumber = 6; quebrar; caso "julho": monthNumber = 7; quebrar; caso, "agosto": monthNumber = 8; quebrar; caso "setembro": monthNumber = 9; quebrar; caso "outubro": monthNumber = 10; quebrar; caso "novembro": monthNumber = 11; quebrar; caso "dezembro": monthNumber = 12; quebrar; default: monthNumber = 0; quebrar; }

voltar monthNumber; }

public static void main (String [] args) {

Meses String = "Agosto";

int returnedMonthNumber = StringSwitchDemo.getMonthNumber (mês);

if (returnedMonthNumber == 0) { System.out.println ("mês inválido"); Else {} System.out.println (returnedMonthNumber); } }}

A saída desse código é 8 .

A cadeia no interruptor expressão é comparada com as expressões associados a cada caso rótulo como se o String.Equals método estavam a ser utilizados. Para que oStringSwitchDemo exemplo para aceitar qualquer meses, independentemente do caso, mes é convertido em minúsculas (com a toLowerCase método), e todas as cordas associados com os casos as etiquetas são em letras minúsculas.

Nota : Este exemplo verifica se a expressão no interruptor declaração é nula . Certifique-se que a expressão em qualquer interruptor declaração não é nulo para evitar umNullPointerException de ser lançada.

O tempo e fazer ao mesmo tempo, Demonstrações

O tempo declaração continuamente executa um bloco de instruções enquanto uma determinada condição é verdadeira . A sintaxe da linguagem pode ser expresso como:

while (expressão) { declaração (s)}

O tempo declaração avalia expressão , que deve retornar um boolean valor. Se a expressão for avaliada como verdadeira , o enquanto instrução é executada a declaração (s) notempo do bloco. O tempo continua testando a declaração de expressão e executar o seu bloco até que a expressão é avaliada como false . Usando o enquanto instrução para imprimir os valores de 1 a 10 pode ser realizado como no seguinte WhileDemo programa:

WhileDemo classe { public static void main (String [] args) { int count = 1; while (count <11) { System.out.println ("Count é:" + Count); count + +; } }}

Você pode implementar um loop infinito usando o enquanto instrução da seguinte forma:

while (true) { / / Seu código vai aqui}

A linguagem de programação Java também fornece uma do-enquanto afirmação, que pode ser expressa como se segue:

fazer { declaração (s)} While (expressão);

A diferença entre -enquanto que e enquanto é que -enquanto que avalia a sua expressão na parte inferior da alça em vez do topo. Portanto, as instruções dentro do OD bloco são sempre executadas pelo menos uma vez, como mostrado no seguinte DoWhileDemo programa:

DoWhileDemo classe { public static void main (String [] args) { int count = 1; fazer { System.out.println ("Count é:" + Count); count + +; } While (count <11); }}

A Declaração para

O para instrução fornece uma maneira compacta para repetir uma faixa de valores. Os programadores muitas vezes se referem a ele como o "loop para" por causa da maneira em que repetidamente faz um loop até uma determinada condição é satisfeita. A forma geral da para declaração pode ser expressa da seguinte forma:

for ( inicialização ; rescisão ; incremento {) declaração (ões)}

Ao utilizar esta versão do de declaração, tenha em mente que:

A inicialização expressão inicializa o laço; é executado uma vez, como o circuito começa.

Quando a rescisão expressão for avaliada como false , o loop termina. O incremento de expressão é invocado após cada iteração do loop, é perfeitamente

aceitável para esta expressão para incrementar ou diminuir um valor.

O programa a seguir, ForDemo , usa a forma geral da para declaração para imprimir os números 1 a 10 para a saída padrão:

ForDemo classe { public static void main (String [] args) { for (int i = 1; i <11; i + +) { System.out.println ("Count é:" + I); } }}

A saída deste programa é:

Count é: 1Conde é: 2Conde é: 3Count é: 4Conde é: 5Count é: 6Conde é: 7Conde é: 8Conde é: 9Count é: 10

Observe como o código declara uma variável dentro da expressão de inicialização. O âmbito da presente variável estende-se desde a sua declaração para o fim do bloco de regulada pelapara instrução, para que possa ser utilizado nas expressões de terminação e de incremento também. Se a variável que controla um por declaração não é necessária fora do circuito, é melhor declarar a variável na expressão de inicialização. Os nomes i , j , e k são muitas vezes utilizados para controlar de loops; declarando-os dentro da expressão de inicialização limita a sua vida útil e reduz os erros.

As três expressões da de laço são opcionais; um loop infinito pode ser criado como segue:

/ / Loop infinitopara (;;) { / / Seu código vai aqui}

O de declaração também tem outra forma projetada para iteração através Coleções e matrizes Este formulário é por vezes referido como o melhor de declaração, e

pode ser usado para fazer seus loops mais compacto e fácil de ler. Para demonstrar, considere a seguinte matriz, que contém os números 1 a 10:

int [] = {números 1,2,3,4,5,6,7,8,9,10};

O seguinte programa, EnhancedForDemo , usa o melhor para percorrer a matriz:

EnhancedForDemo classe { public static void main (String [] args) { int [] numbers = {1,2,3,4,5,6,7,8,9,10}; for (int item: números) { System.out.println ("Count é:" + Item); } }}

Neste exemplo, a variável de ponto mantém o valor de corrente a partir da matriz de números. A saída deste programa é o mesmo como antes:

Count é: 1Conde é: 2Conde é: 3Count é: 4Conde é: 5Count é: 6Conde é: 7Conde é: 8Conde é: 9Count é: 10

Nós recomendamos o uso dessa forma de o para instrução em vez da forma geral, sempre que possível.

Ramificação Demonstrações

A quebra de Declaração

A quebra de declaração tem duas formas: etiquetados e não etiquetados. Você viu a forma não marcada, na discussão anterior do interruptor de declaração. Você também pode usar um unlabeled pausa para terminar uma para , ao mesmo tempo , ou do-while loop, como mostrado no seguinte BreakDemo programa:

BreakDemo classe { public static void main (String [] args) {

int [] = arrayOfInts {32, 87, 3, 589, 12, 1076, 2000, 8, 622, 127}; int SearchFor = 12;

int i; boolean foundIt = false;

for (i = 0; i <arrayOfInts.length; i + +) { if (arrayOfInts [i] == SearchFor) { foundIt = true;

quebrar; } }

if (foundIt) { System.out.println ("Encontrado" + + SearchFor "no índice" + i); Else {} System.out.println (SearchFor + "não está na matriz"); } }}

Este programa procura o número 12 em uma matriz. A quebra de declaração, mostradas em negrito, termina a para loop quando esse valor for encontrado. Fluxo de controle, em seguida, transfere para a instrução após o para loop. Saída deste programa é:

Encontrado 12 no índice 4

Um não marcado pausa declaração termina o interior interruptor , para , ao mesmo tempo , ou do-while declaração, mas um rótulo pausa termina uma instrução externa. O programa seguinte, BreakWithLabelDemo , é semelhante ao programa anterior, mas usa aninhados para lacetes para pesquisar um valor em uma matriz bidimensional. Quando o valor for encontrado, uma marcada quebra termina o exterior para loop (identificado como "busca"):

BreakWithLabelDemo classe { public static void main (String [] args) {

int [] [] = {arrayOfInts {32, 87, 3, 589}, {12, 1076, 2000, 8}, {622, 127, 77, 955} }; int SearchFor = 12;

int i; Int J = 0; boolean foundIt = false;

pesquisa: for (i = 0; i <arrayOfInts.length; i + +) { for (j = 0; j <arrayOfInts [i] comprimento.; j + +) { if (arrayOfInts [i] [j] == SearchFor) { foundIt = true; quebrar pesquisa; } } }

if (foundIt) { System.out.println ("Encontrado" SearchFor + + "Em" + i + "," + j); Else {} System.out.println (SearchFor + "Não está na matriz"); } }}

Esta é a saída do programa.

Encontrado 12 a 1, 0

A quebra de declaração termina a instrução rotulada, mas não transfere o fluxo de controle para o rótulo. Fluxo de controle é transferido para a instrução imediatamente após a declaração rotulada (terminado).

O continue Declaração

O continue declaração pula a iteração atual de um para , ao mesmo tempo , ou do-while loop. A forma não marcada, salta para o final do corpo do laço mais interno e avalia obooleana expressão que controla o ciclo. O programa a seguir, ContinueDemo , os passos através de uma corda , contando as ocorrências da letra "p". Se o personagem atual não é ap, o continue declaração ignora o resto do circuito e segue para o próximo caractere. Se ele é um "p", o programa incrementa a contagem de carta.

ContinueDemo classe { public static void main (String [] args) {

Cordas Searchme = "Peter Piper pegou um" + "Peck de pimentas em conserva"; int max = searchMe.length (); int numPs = 0;

for (int i = 0; i <max; i + +) { / / Interessado apenas em p de if (searchMe.charAt (i)! = 'p') continuar;

/ / P processo de numPs + +; } System.out.println ("Encontrado" + numPs + "p é na cadeia."); }}

Aqui está a saída deste programa:

Encontrado 9 p na cadeia.

Para ver este efeito de forma mais clara, tente remover o continue declaração e recompilar. Quando você executar o programa novamente, a contagem será errado, dizendo que encontrou 35 p, em vez de 9.

A rotulado continuar declaração pula a iteração atual de um loop externo marcado com o rótulo dado. O programa de exemplo a seguir, ContinueWithLabelDemo , usa loops aninhados para procurar uma substring dentro de outra seqüência. Dois loops aninhados são necessários: um para iterar sobre a substring e uma para repetir a seqüência que está sendo pesquisada. O programa a seguir, ContinueWithLabelDemo , usa a forma rotulada de continuar a pular uma iteração no loop externo.

ContinueWithLabelDemo classe { public static void main (String [] args) {

Cordas Searchme = "Procure por um substring em mim"; Substring String = "sub";

boolean foundIt = false;

int max = searchMe.length () - substring.length ();

teste: for (int i = 0; i <= max; i + +) { int n = substring.length (); int j = i; int k = 0; while (n -! = 0) { if (searchMe.charAt (j + +) ! = Substring.charAt (k + +)) { continuar a testar; } } foundIt = true; quebrar teste; } System.out.println (foundIt? "Encontrei": "não encontrá-lo"); }}

Aqui é a saída desse programa.

Encontrei

O retorno Declaração

A última das declarações de ramificação é o retorno comunicado. Os de retorno sai de instrução do método atual, e fluxo de controle retorna para onde o método foi chamado. Oretorno declaração tem duas formas: uma que retorna um valor, e que não faz. Para retornar um valor, basta colocar o valor (ou uma expressão que calcula o valor) após o retornopalavra-chave.

retorno + + contar;

O tipo de dados do valor retornado deve corresponder ao tipo de valor de retorno do método declarado. Quando um método é declarado nulo , use o formulário de devolução que não retorna um valor.

voltar;

As Classes e Objetos de aula irá cobrir tudo o que você precisa saber sobre métodos de escrita.

Resumo das Demonstrações de Fluxo de Controle

O if-then declaração é a mais básica de todas as declarações de controle de fluxo. Ele diz que seu programa execute uma determinada seção de código apenas se um determinado teste avalia a verdade . O if-then-else declaração fornece um caminho secundário de execução quando uma cláusula "se" é avaliada como false . Ao contrário de if-then e if-then-else , o interruptor de declaração permite a qualquer número de caminhos de execução possíveis. O tempo e do-while declarações continuamente executar um bloco de instruções enquanto uma determinada condição é verdadeira . A diferença entre -enquanto que e enquanto é que -enquanto que avalia a sua expressão na parte inferior da alça em vez do topo. Portanto, as declarações dentro do do do bloco são sempre executados pelo menos uma

vez. O para instrução fornece uma maneira compacta para repetir uma faixa de valores.Tem duas formas, uma das quais foi projetado para loop através de coleções e matrizes.

Perguntas e Exercícios: Demonstração de Fluxo de Controle

Perguntas

1. A demonstração de fluxo de mais básico de controle suportados pela linguagem de programação Java é a declaração ___.

2. A declaração ___ permite a qualquer número de caminhos de execução possíveis.3. A instrução ___ é semelhante ao enquanto instrução, mas avalia a sua expressão no ___

do loop.4. Como você escreve um loop infinito usando o para declaração?5. Como você escreve um loop infinito usando o enquanto afirmação?

Exercícios

1. Considere o seguinte trecho de código.2. if (aNumber> = 0)3. if (aNumber == 0)4. System.out.println ("primeira string");5. mais System.out.println ("segunda corda");6. System.out.println ("terceira corda");

a. Qual a saída que você acha que o código irá produzir se aNumber é 3?b. Escreva um programa de teste que contém o trecho de código anterior;

fazer aNumber 3. O que é a saída do programa? É o que você previu? Explique por que a saída é o que é, em outras palavras, qual é o fluxo de controle para o trecho de código?

c. Usando apenas espaços e quebras de linha, reformatar o trecho de código para fazer o fluxo de controle fácil de entender.

d. Use chaves, {e}, para esclarecer melhor o código.

Confira suas respostas

Respostas para Perguntas e Exercícios: Demonstração de Fluxo de Controle

Respostas às perguntas

1. A demonstração de fluxo de mais básico de controle suportados pela linguagem de programação Java é a if-then declaração.

2. O interruptor de declaração permite a qualquer número de caminhos de execução possíveis.

3. O fazer enquanto- instrução é semelhante ao enquanto instrução, mas avalia a sua expressão na parte inferior do loop.

4. Pergunta: Como você escreve um loop infinito usando o para declaração?

Resposta:

para (;;) {

}

5. Pergunta: Como você escreve um loop infinito usando o enquanto afirmação?

Resposta:

while (true) {

}

Exercícios

1. Considere o seguinte trecho de código.2. if (aNumber> = 0)3. if (aNumber == 0)4. System.out.println ("primeira string");5. outro 6. System.out.println ("segunda corda");7. System.out.println ("terceira corda");

a. Exercício: Qual a saída que você acha que o código irá produzir se aNumber é 3?

Solução:

segunda cordaterceira corda

b. Exercício: Escrever um programa de teste que contém o trecho de código anterior; fazer aNumber 3. O que é a saída do programa? É o que você previu? Explique por que a saída é o que é. Em outras palavras, qual é o fluxo de controle para o trecho de código?

Solução: NestedIf

segunda cordaterceira corda

3 é maior do que ou igual a 0, de modo a execução avança para o segundo se nota. O segundo se ensaio instrução de falha porque 3 não é igual a 0. Assim, a pessoa executa cláusula (uma vez que está ligado ao segundo , se declaração). Assim, segunda seqüência é exibida. A final println é completamente fora de qualquer caso declaração, por isso sempre é executado, e, portanto, terceira corda é sempre exibido.

c. Exercício: Usando apenas espaços e quebras de linha, reformatar o trecho de código para fazer o fluxo de controle fácil de entender.

Solução:

if (aNumber> = 0) if (aNumber == 0)

System.out.println ("primeira string"); outro System.out.println ("segunda corda");

System.out.println ("terceira corda");

d. Exercício: Use chaves { e } de esclarecer ainda mais o código e reduzir a possibilidade de erros futuros mantenedores do código.

Solução:

if (aNumber> = 0) { if (aNumber == 0) { System.out.println ("primeira string"); Else {} System.out.println ("segunda corda"); }}

System.out.println ("terceira corda");

Resumo das Variáveis

A linguagem de programação Java usa os dois "campos" e "Variáveis", como parte de sua terminologia. Variáveis de instância (campos não-static) são únicos para cada instância de uma classe. Variáveis de classe (campos estáticos) são campos declarados com a estática modificador, há exatamente uma cópia de uma variável de classe, independentemente de quantas vezes a classe foi instanciada. As variáveis locais armazenar o estado temporário dentro de um método. Os parâmetros são variáveis que fornecem informações adicionais para um método, ambas as variáveis locais e parâmetros são sempre classificados como "variáveis" (não "campos"). Ao nomear os seus campos ou variáveis, existem regras e convenções que você deve (ou deve) seguir.

Os oito tipos de dados primitivos são: byte, short, int, float, long, double, boolean e char. O java.lang.String classe representa as cadeias de caracteres. O compilador irá atribuir um valor padrão razoável para campos dos tipos acima, para as variáveis locais, um valor padrão nunca é atribuído. Um literal é a representação de código fonte de um valor fixo. Uma matriz é um objeto de recipiente que contém um número fixo de valores de um único tipo. O comprimento de uma matriz é estabelecida quando a matriz é criada. Após a criação, seu comprimento é fixo.

«Anterior • Trail • Próximo »

Tutorial - Robocode em NetbeansIniciado por pedrotuga , 29 Jun 2007 12:34

Por favor inicie sessão para responder

13 respostas a este tópico

#1pedrotugaStack Overflow

Membro

7133 mensagens

Publicado 29 de Junho de 2007 - 12:34Já está o tutorial completo mas ainda podem ser limadas algumas arestas.Podem já seguir este tutorial. Dêm feedback sobre os pequenos scripts no fim pois ainda não os testei.

Este tutorial destina-se a quem joga robocode e pretende um ambiente de desenvolvimento mais expedito do que o editor que vem com o robocode. A grande vantagem é o acesso a documentação em tempo real.O IDE utilizado é o netbeans, este IDE é distribuido com o kit de desenvolvimento Java da sun. Quem tiver um ambiente de java diferente pode fazer download do netbeans no site do IDE: http://www.netbeans.org/index.html.

Depois de concluido este tutorial, se tudo tiver corrido conforme previsto, o netbenas mostrará a documentação do robcode desta forma:

clicar na imagem para ver imagem aumentada1.Abrir o netbeans e criar um novo projecto:File>newproject

2.Em categories escolher "general" e em projects escolher "java aplication" clicar em "next"

3.Escoher o nome para o projecto e a path. O nome do projecto será a pasta onde o vosso robot ficará, ainda não é o nome do robot, isso é mais a frente.Nessa mesma janela escolher tambem a path, tem que ser a localização da pasta de robots da vossa instalação do robocode. Por exemplo D:/robocode/robots no windows ou /home/eu/robocode/robots  em linux.Ainda nessa janela, des-selecionar a checkbox que diz: "create main" class.A outra checkbox pode ficar selecionada ou nao, é uma questão de preferencia. Se têm outro projecto a desenvolver no vosso IDE que usam com mais frequencia então é melhor não a selecionar.

4.clicar em "finish". O projecto aparecerá na arvore de projectos.

5.Agora que está o projecto criado, vamos dizer-lhe onde estao as bibliotecas do robocode. clicar com o botao direito em "libraries" e escolher "add jar/folder".

De seguida navega-se até à pasta do robocode, entra-se na subpasta "libs" e adicionam-se os tres jars que lá estão: robocode.jar roborumble.rar e codesize.rar. Estão as bibliotecas do robocode no projecto prontas a ser usadas. Ja podemos compilar através do netbeans, mas ainda falta adicionar a documentação.

6.Ir ao menu Tools>library manager. Uma vez aberto o gestor de bibliotecas vamos criar uma biblioteca nova para alojar a documentação. Clicar en "new library". Em library type escolher qualquer  coisa como "robolib", o library typer pode ser mesmo "class library".

7.Esta a biblioteca criada, vamos adicionar-lhe a documentação. Ainda no library manager, clicamos na biblioteca que acabámos de criar ( deve estar listada à esquerda como um "class library") e, em cada aba clicamos em "add jar/folder" e adicionamos os seguintes valores nas respectivas abas.

classpath -> PATH_TO/robocode/libssources -> PATH_TO/robocode/libsjavadoc -> PATH_TO/robocode/javadoc

Substituir PATH_TO pela path para a vossa instalação do robocode.

8.Na arvore do projecto que criamos inicialmente, clicamos com o botao direito em "libraries" no menu que aparece escolhemos "new library".

Aparece uma lista de todas as bibliotecas, selecionamos a biblioteca que acabámos de criar e clicamos em "add library".

9.Está quase, vamos criar um robot! Clicar com o botao direito sobre o nó do nosso projecto e escolher new > empty java file. Na janela que aparecer insiram o nome do vosso robot e estão prontos para trabalhar nele!

10.Já podemos escrever robôs e compilÁ-los, no entanto a pasta de destino dos nossos ficheiros é ainda pouco prática e quebra a restrição de comprimento nos nomes dos robots: para um robot ser reconhecido pelo robocode a path pode conter no máximo 12 caracteres.Para contornar este problema basta criar um pequenho script para copiar os ficheiros par a raíz do projecto. Utilizadores do windows podem criar um pequeno batchfile, quem usa linux, macos ou outro sistema operativo baseado em unix pode criar um pequeno shellscript.Aqui vai o código necessário para por dentro desses scripts:

windows batch file:Código :

copy -Y ./build/classes/packagename/*.class ./

salvar como .bat

shell script file:Código :

cp ./build/classes/packagename/*.class ./

salvar como .sh

substituir "packagename" pelo nome do vosso package, é aconselhado usar o mesmo package name para todos os robots para que este script os possa copiar todos.O script deve ser colocado na raíz do projecto criado pelo netbeans e corrido cada vez que o robot é compilado. Ter uma consola aberta só para correr este script não é má ideia, uma vez que o vamos ter que fazer com frequencia.

11. Só para finalizar fica uma nota a ter em atenção: apesar de estarmos a usar o netbeans não estamos a compilar um porjecto por completo. Esta tecnica usa as facilidade criadas pelo netbeans para o desenvolvimento de um projecto mas nunca chega a ser um projecto em si. como tal NUNCA devemos tentar compilar ou correr o projecto em si, se o fizermos receberemos uma mensagem de erro. Em vez disso cada

robot deve ser compilado individualmente premindo a tecla F9 ou clicando com o botao direito do rato e escolhendo a opção "compile file".De notar tambem que este projecto não tem main class. Um robot não é uma aplicação. A aplicação é o robocode em si, mas isso não compete ao jogador mexer.

Search:

Choose page language

Ajuda para codificação no Editor Java no NetBeans IDE: Um Guia de ReferênciaO propósito do ambiente de desenvolvimento integrado (IDE) é o de maximizar a produtividade e suportar o desenvolvimento racional a partir de uma ferramenta única. Este documento de referência descreve os recursos úteis para ajuda na codificação, opções de personalização, e capacidades de navegação do Editor Java do NetBeans IDE.

para aprender a usar os recursos de produtividade do editor.

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

O Editor Java no NetBeans ajuda a completar com rapidez e gerar código através do recursos de conclusão "inteligente"de código. Em um senso geral, a conclusão do código é muito útil quando você deseja preencher o código faltantes, examinar as opções disponíveis no contexto de seu aplicativo, e gerar blocos de código quando necessário. Consulte os exemplos abaixo de como usar a conclusão de código.

Ctlr-Espaço (ou escolha Fonte >Conclusão de código, no menu principal) para abrir a caixa de conclusão de código. Na medida em que você digitam a lista de sugestões diminui. As sugestões listadas incluem as que estão importadas em seu arquivo de origem e os símbolos do

java.lang.Para personalizar as configurações de conclusão de código, selecione Ferramentas > Opções > Editor > Conclusão de código.Por exemplo, você pode definir que a janela de conclusão de código apareça automaticamente ou somente quando necessária. Na aba Conclusão de código, selecione a caixa de seleção Janela suspensa de conclusão de código para chamar automaticamente esta janela quando estiver digitando determinados caracteres. O caractere padrão é ".", mas é possível adicionar seus próprios caracteres.Para adicionar caracteres que chamam a janela de conclusão de código, selecione Java na lista suspensa Linguagem, e digite seus caracteres no campo Acionadores automáticos suspensos para Java. A janela de conclusão de código aparecerá cada vez que você digita os caracteres especificados.Quando a caixa de seleção Janela suspensa automática de conclusão de código estiver desabilitada, será necessário pressionar Ctlr-Espaço cada vez que precisar usar a conclusão de código.

No NetBeans IDE, a conclusão de código Java é "inteligente", o que significa que as sugestões que sejam as mais relevantes para o contexto de seu código são exibidas no topo, acima da linha preta na janela de conclusão de código.No exemplo na esquerda, o editor sugere a inserção do

LinkedHashMap do pacotejava.util.Se as sugestões "inteligentes" não são as que você deseja usar,

Ctlr-Espaço novamente para visualizar a lista completa.

Use a conclusão de código (Ctlr-Espaço) para completar as palavras-chave em seu código. O editor analisa o contexto e sugere as palavras-chave mais relevantes.No exemplo na esquerda, a classe ColorChooserDemo estende a

JPanel. Você pode adicionar rapidamente a palavra-extends a partir dos itens sugeridos.

Quando você está adicionando um novo campo ou uma variável, use a conclusão de código (Ctlr-Espaço) para escolher um nome que coincida com seu tipo.Digite um prefixo para o novo nome, pressione Ctlr-Espaço e selecione o nome que deseja usar a partir da lista de sugestões.

O editor adivinha nos parâmetros para variáveis, métodos ou campos, e exibe as sugestões em uma caixa suspensa.Por exemplo, quando você seleciona um método na janela de conclusão de código que tem um ou mias argumentos, o Editor realça o primeiro argumento e exibe uma dica de ferramentas sugerindo o formato para este argumento. Para mover para o próximo argumento, pressione as

ouEnter.Você pode chamar as dicas de ferramenta com parâmetros de método ao

Ctlr-P (ou Fonte > Mostrar parâmetros de método) a qualquer momento.

Você pode usar a tecla Tab para rapidamente preencher os prefixos mais usados e sugestões únicas.Para verificar como funciona este recurso, tente digitar o seguinte:

System.out.i e espere pela conclusão do código mostrar todos os campos e métodos que iniciam com "i". Todas as sugestões serão relacionadas com "imprimir".

Pressione a tecla Tab e o editor automaticamente preenche o "imprimir". Você pode continuar e digita "E" e, após pressionar Tab, o "imprimirEm" será adicionado.

Na janela de conclusão de código, são usados ícones para distinguir diferente membros da linguagem Java. Consulte o Apêndice A no fim deste documento para ver o significados destes ícones.

Há diversas maneiras de trabalhar com instruções importadas. O Editor Java do IDE verifica constantemente seu código para o correto uso de instruções importadas e imediatamente avisa quando classes não-

Quando uma classe não-importada é encontrada, aparece a marca de na margem esquerda do IDE (esta margem também é denominada margem de glifo). Clique na marca de erro e escolha se a

importação faltante deve ser adicionada ou se a classe deve ser criada no pacote atual.Enquanto estiver digitando, pressione Ctrl-Shift-I (ou escolha Fonte > Corrigir importações, no menu) para adicionar todas as instruções faltantes de uma só vez.

Alt-Shift-I para adicionar uma importação somente para o tipo no qual o cursor está localizado.

Quando você seleciona uma classe na janela de conclusão de código, o Editor adiciona automaticamente um instrução importada pela ela, portanto, não é preciso se preocupar com isso.

Se houver instruções importadas não utilizadas em seu código, pressione a marca de aviso   na margem esquerda do editor e escolha remover uma importação não utilizada ou todas as importações não utilizadas. No Editor, as importações não utilizadas são sublinhadas (consulte a

Coloração semântica para obter detalhes).Para rapidamente ver se seu código contém importações não utilizadas ou faltantes, observe as linhas de erro na margem direita: linhas laranja marcam as importações faltantes ou não utilizadas.

superior

Ao trabalhar no Editor Java, você pode gerar partes de código de duas maneiras: usando a conclusão de código ou a partir da caixa de diálogo Geração de código. Vamos examinar mais de perto exemplos simples

Alt-Insert (ou escolha Fonte> Inserir código) em qualquer parte do Editor para inserir um construtor a partir da caixa Geração de código. A lista sugerida é ajustada para o contexto atual.No exemplo na esquerda, vamos gerar um construtor para a classe Sample.

Alt-Insert, selecione Construtor na caixa Geração de código, e especifique os campos que serão inicializados pelo construtor. O Editor irá gerar o construtor com os parâmetros especificados.No Editor Java do IDE, é possível gerar automaticamente diversos construtores e métodos inteiros, sobrepor e delegar métodos, adicionar propriedades, e mais.

Você também pode gerar código a partir da janela de conclusão de código. Neste exemplo, usamos a mesma parte do código como acima, para mostrar como você pode gerar código a partir da janela de conclusão de

Pressione Ctrl-Espaço para abrir a janela de conclusão de código e escolha o seguinte item:Sample(String name, int number) - gerar. O Editor irá gerar um construtor com os parâmetros especificados.Na janela de conclusão de código, os construtores que podem ser automaticamente gerados são marcados com o   e com a nota "gerar". Para obter mais explicações sobre os ícones e seus significados, consulte

início

Um modelo de código é uma parte predefinida de código que tem uma abreviação associada a si. Consulte os exemplos abaixo que mostram como usar modelos de código.

Os modelos de código são marcados com o   na janela de conclusão de

Você pode adotar um dos seguintes procedimentos:Selecione um modelo a partir da janela de conclusão de código e pressione Enter

Digite a abreviatura para este modelo e pressione a tecla que expande este modelo (por padrão,Tab).

No modelo expandido, as partes editáveis são exibidas como caixas azuis. Tab para passar através das partes que precisa editar.

Para personalizar os modelos de código:Escolha Ferramentas > Opções > Editor > Modelos de código.

Na lista suspensa Idioma , selecione Java (ou o idioma para o qual deseja criar um modelo de código). A lista de abreviaturas e modelos associados é

Use os botões Novo e Remover para adicionar ou remover modelo na lista. Para editar um modelo existente, selecione o modelo e edite o código no campo Texto expandido, abaixo na lista.

Escolha a tecla que será usada para expandir os modelos. A tecla padrão

este documento para saber mais sobre a sintaxe para escrever novos Modelos de código.Consulte também Modelos de código no NetBeans IDE para PHP.

Use os seguintes recursos que facilitam trabalhar com o Javadoc para seu código.

Coloque o cursor em um elemento e pressione Ctr-Shift-Espaço (ou escolha Fonte > Mostrar documentação). O Javadoc para este elemento é exibido em uma janela suspensa.No menu principal do IDE, clique em Janela > Outra > Javadoc, para abrir a janela Javadoc, na qual a documentação é automaticamente atualizada para a localização de seu cursor.

Coloque o cursor sobre um método ou classe que não tenha Javadoc, ", e pressione Enter.

O IDE cria uma estrutura de esqueleto para o comentário Javadoc preenchido com algum conteúdo. Caso tenha a janela do Javadoc aberta, você verá imediatamente as alterações enquanto estiver digitando.

O IDE exibe dicas quando o Javadoc está faltando ou identificadores Javadoc são necessários.Clique no ícone de bulbo na margem esquerda do editor para corrigir os erros do Javadoc.Caso não queira ver as dicas relacionadas com o Javadoc, escolha Ferramentas >Opções >Editor > Dicas, e desmarque a caixa de seleção Javadoc na lista de dicas que é exibida.

Usando a conclusão de código para identificadores JavadocA conclusão de código está disponível para identificadores Javadoc.Digite o símbolo "@" e espere até que a janela de conclusão de código seja aberta (dependendo de suas configurações, pode ser preciso

Ctlr-Espaço).

Para gerar o Javadoc para um projeto, escolha o item de menu Executar > Gerar Javadoc (ou clique com o botão direito do mouse na janela Projetos e escolha Gerar Javadoc). O IDE irá gerar o Javadoc e irá abri-lo em uma janela separada do navegador.No exemplo à esquerda, é possível visualizar um exemplo de saída do comando Gerar Javadoc. Se houverem alguns avisos ou erros, eles também são exibidos nesta janela.Para personalizar as opções de formatação do Javadoc, clique com o botão direito do mouse no projeto, escolha Propriedades, e abra o painel Documentação sob a categoria Build (somente disponível em projetos Java). Para obter informações sobre as opções neste painel, clique no botão Ajuda nesta janela.

Para identificar os lugares em seu código que precisam de comentários Javadoc e inserir com rapidez estes comentários, é possível usar a ferramenta Analisador de Javadoc disponível no Editor Java.Para analisar e corrigir os comentários Javadoc:

Selecione um projeto, um pacote, ou um arquivo individual, e escolha Ferramentas > Analisar Javadoc a partir do menu principal. A janela Analisador exibe sugestões para adicionar ou corrigir comentários Javadoc, dependendo do escopo de sua seleção.

Selecione uma ou diversas caixas de seleção onde gostaria de corrigir o Javadoc, e clique no botão Corrigir selecionados. 

Clique em Examinar problemas corrigidos e use as setas Acima e Abaixo para adicionar de fato seus comentários. Isso pode ser útil se você selecionou corrigir diversas instâncias de uma só vez e agora deseja revisar os stubs.

superior

Enquanto você está digitando, o Editor Java verifica seu código e fornece sugestões de como é possível corrigir os erros e navegar através do código. Os exemplos abaixo mostram os tipos de dicas que estão

Para os erros mais comuns de código, você pode ver as dicas na margem esquerda do Editor. As dicas são mostradas para muitos tipos de erros, como um campo e definições de variável faltando, problemas com importações, chaves, e outros. Clique no ícone de dica e selecione a correção a ser adicionada.As dicas são automaticamente exibidas por padrão. No entanto, caso deseje visualizar todas as dicas, escolha Fonte > Corrigir código (ou pressione Alt-Enter).Por exemplo, tente digitar "myBoolean=true". O Editor detecta que esta variável não está definida. Clique no ícone de dica e veja que o Editor sugere que você crie um campo, um parâmetro de método ou uma variável local. Selecionar

Você pode desejar limitar o número de categorias para as quais as dicas são exibidas. Para fazê-lo:1. Escolha Ferramentas > Opções > Editor > Dicas.

2. Na lista suspensa Linguagem, selecione Java e visualize uma lista de elementos para os quais dicas são exibidas (suas caixas de seleção estão selecionadas).

3. Para desabilitar dicas para algumas categorias, desmarque as caixas de seleção apropriadas.

Nota: na aba Dicas, também é possível desabilitar ou limitar o escopo das varreduras de dependência (opção Varredura de dependência). Estas etapas podem aprimorar significativamente o desempenho do IDE.O IDE detecta os erros de compilação em seu código-fonte Java ao localizar e recompilar classes que dependem do arquivo que você está editando (mesmo que estas dependências estão nos arquivos que não são abertos no editor). Quando um erro de compilação é encontrado, símbolos vermelhos são adicionados no arquivo de código-fonte, pacote ou nós do projeto. A varredura de dependência dentro de projetos pode consumir recursos e degradar o desempenho, especialmente se você estiver trabalhando em projetos grandes.Para aprimorar o desempenho do IDE, você pode adotar um dos seguintes procedimentos:Limite o escopo das varreduras de dependência para a raiz do código-fonte (pesquise por dependências somente na raiz do código-fonte onde a classe modificada está localizada) ou para o projeto atual.

Desative a varredura de dependência (escolha Propriedades do projeto > Build > Compilando, e cancele a seleção da opção Rastrear dependências Java). Neste caso, O IDE não efetua a varredura por dependências ou atualiza os símbolos de erro quando você modifica um arquivo.

É fácil circundar partes de seu código com diversas instruções, tais comofor, whileSelecione um bloco em seu código que deseja circundar com uma instrução e clique no ícone de bulbo na margem esquerda (ou pressione Alt-Enter). O Editor exibe uma lista de sugestões entre as quais é possível selecionar a instrução necessária.

Escolha Fonte > Formato, ou pressione Alt-Shift-F para formatar todo o arquivo ou uma seleção de código. O IDE formata o código de acordo com as configurações de formatação especificadas.Para personalizar as configurações de formatação para o código Java:

1. Escolha Ferramentas > Opções > Editor > Formatação.

2. Na lista suspensa Linguagem, selecione Java.

3. Na lista suspensa Categoria, selecione a categoria que deseja personalizar. Por exemplo, você pode personalizar o número de linhas em branco, o tamanho das tabulações e identações, estilo de mudança de linha, etc.

4. Modifique as regras para a categoria selecionada e visualize o resultado.

Por padrão, o IDE insere automaticamente pares de chaves, colchetes e aspas. Quando você digita uma chave de abertura e a seguir pressiona Enter, a chave de fechamento é automaticamente adicionadas. Para (, [, " e ', o Editor insere imediatamente um par coincidente.Se, por algum motivo, este recurso está desabilitado, habilite o mesmo como segue:

1. Escolha Ferramentas > Opções > Editor > Conclusão de código.

2. Selecione a caixa de seleção Inserir colchetes de fechamento automaticamente.

O Editor também realça os pares de chaves, colchetes e aspas coincidentes. Por exemplo, coloque o cursor antes de qualquer chave ou colchete e, e este tiver um par coincidente, ambos serão realçados em amarelo. Colchetes únicos de qualquer tipo são realçados em vermelho e a marca de erro é exibida na margem esquerda.Para personalizar as cores de realce, escolha Ferramentas > Opções > Fontes e Cores > Realce.

No Editor Java, é possível retrair e expandir com rapidez blocos de código, como a declaração de método, comentários Javadoc, instruções importadas, etc. Blocos retraíveis são mostrados com linhas cinzas e sinais de mais/menos junto a margem esquerda do Editor.A maneira mais fácil de retrair um bloco de código é a de clicar nas linhas cinzas com um caractere de sinal de menos na margem esquerda.

Para dobrar todos os blocos retraíveis em um arquivo, clique com o botão direito do mouse no Editor e escolha Dobras de código > Retrair todos, a partir do menu suspenso.

No menu suspenso Dobras de código > Retrair todos, é possível decidir retrair todos os comentários Javadoc ou todo o código Javadoc em um arquivo.

Você pode passar o mouse sobre os elementos dobrados para rever rapidamente as partes ocultas.

Para personalizar as opções de dobra de código:1. Escolha Ferramentas > Opções > Editor > Geral.

2. Para desabilitar a dobra de código, desmarque Usar dobra de código. Observe que a dobra de código é habilitada por padrão.

3. Selecione os blocos de código a serem retraídos por padrão quando você abre um arquivo.

No NetBeans IDE, escolha Ferramentas > Opções > Mapa de teclas, para personalizar os atalhos de teclado. Você pode fazer isso de diversas maneiras:Selecione um conjunto predefinido de atalhos de teclado, denominado Perfil.

Editar determinados atalhos de teclado.

É possível salvar conjuntos personalizados de seus atalhos como perfis. A seguir, é possível alternar de um perfil para outro para alterar com rapidez múltiplas configurações. Por exemplo, para criar um perfil personalizado de atalhos de teclado:

1. Na janela Opções > Mapa de teclas, clique em Gerenciar perfis.

2. Selecione o perfil que deseja usar como base para seu novo perfil e clique em Duplicar.

3. Insira o nome do novo perfil e clique em OK.

4. Assegure que o novo perfil está selecionado e modifique os atalhos que precisar.Para editar um atalho, clique duas vezes no campo Atalho ou clique no botão de elipse (...). Quando você pressiona a sequência de teclas, a sintaxe para as mesmas é adicionada. Se você deseja adicionar caracteres especiais , tais como Tab, Escape ou Enter, clique no botão de elipse (...) novamente e seleciona a tecla na janela suspensa.

5. Quando tiver terminado de editar, clique em OK na janela Opções.

Para localizar um atalho para um comando específico, digite o nome do comando no campo Pesquisar. Para localizar um comando pro uma combinação, insira o cursor no campo Pesquisar em atalhos e pressione a combinação de teclas de atalho. 

O Editor Java do IDE mostra elementos de código em cores distintas, com base na semântica de seu código. Com a coloração da semântica, torna-se mais fácil identificar diversos elementos em seu código. Além da coloração, o Editor Java realça elementos similares com uma determinada cor de plano de fundo. Portanto, você pode considerar o recurso de realce como uma alternativa ao comando Pesquisar, porque em combinação com linhas de erro, fornece uma rápida visão geral de onde os locais realçados estão localizados no arquivo.

Para personalizar as configurações de coloração de semântica para o Editor Java, escolha Ferramentas > Opções > Fontes e cores.O IDE fornece esquemas predefinidos de esquemas de coloração, denominados perfis. Você pode criar novos perfis com cores personalizadas e rapidamente alternar entre as mesmas.É muito conveniente salvar cores personalizadas em novos perfis. Por exemplo, execute os seguintes procedimentos:

1. Na janela Opções > Fontes e cores, clique em Duplicar junto a listas suspensa Perfil.

2. Insira o nome do novo perfil e clique em OK.

3. Assegure que o novo perfil está no momento selecionado e escolha Java na lista suspensa Linguagem.

4. Selecione a categoria para alterar a fonte, cor da fonte (primeiro plano), cor do plano de fundo, e os efeitos para esta categoria. Use a janela Visualizar para visualizar os resultados.

5. Clique em OK.

Nota: todas as configurações do NetBeans IDE e dos perfis são armazenadas no NetBeans userdira FAQ sobre como localizar o userdir para seu sistema operacional). Ao atualizar para versões mais recentes do NetBeans, é possível exportar as configurações antigas e importá-las na versão mais recente.Para exportar configurações IDE:

1. Na janela Opções (Ferramentas > Opções) clique em Exportar.

2. Especifique a localização e nome do arquivo ZIP que será criado.

3. Selecione as configurações que deseja exportar e clique em OK.

Para importar configurações IDE:1. Na janela Opções (Ferramentas > Opções) clique em Importar.

2. Especifique o arquivo ZIP com as configurações IDE ou o caminho para o userdir de uma versão anterior.

3. Selecione as configurações que deseja importar e clique em OK.

 

À esquerda, você pode ver um exemplo de um esquema de coloração. Dependendo de suas configurações personalizadas, suas cores podem parecer diferentes das mostradas na captura de tela.São usadas cores distintas para palavras-chave (azul), variáveis e campos (verde) e parâmetros (laranja).Referências aos métodos ou classes obsoletos são mostrados com tachados. Isso o alerta quando for escrever código que dependem de membros obsoletos.Membros não utilizados são sublinhados com uma linha ondulada cinza. Os comentários são exibidos em cinza. 

O IDE realça os usos do mesmo elemento, chaves coincidentes, pontos de saída do método, e pontos que causam exceção.Se você coloca o cursor sobre um elemento, como um campo ou variável, todos os usos deste elemento são realçados. Observe que as linhas de erro na margem direita do Editor indicam os usos deste elemento em todo o arquivo de código-fonte (consulte Linhas de erro). Clique na linha de erro para navegar com rapidez para a localização de uso desejada.Caso você decida renomear todas as instâncias realçadas, use o comando Renomeação instantânea (Ctrl-R ou escolha Refatorar > Renomear). 

O Editor Java fornece diversas maneiras para poder navegar através do código. Consulte abaixo para obter diversos exemplos que mostram os recursos de navegação do Editor Java.

As linhas de erro na margem direita do Editor fornecem uma visão geral rápida de todos os lugares marcados no arquivo atual: erros, avisos, dicas, ocorrências realçadas e anotações. Observe que a margem de linha de erro representa todo um arquivo, não apenas a parte que está no momento exibida no Editor. Usando linhas de erro, você pode identificar imediatamente se há erros ou avisos no arquivo sem ser preciso

Clique em uma linha de erro para saltar para a linha à qual a marca se refere.

Use os seguintes comandos "Ir para.." localizados sob o item de menu Navegar para saltar com rapidez para as localizações de destino.Ir para a declaração ( Ctrl-B, por padrão). Mantenha pressionada a tecla Ctrl e clique no uso de uma classe, método ou campo, para saltar para sua declaração. Você também pode colocar o cursor sobre o membro (uma classe, método ou campo) e escolher Navegar > Ir para a declaração, ou clicar com o botão direito do mouse e escolher Navegar > Ir para a declaração, no menu suspenso.

Ir para o código-fonte ( Cltr-Shift-B, por padrão). Mantenha pressionada a tecla Ctrl e clique no em uma classe, método ou campo, para saltar para o código-fonte, se este estiver disponível. Você também pode colocar o cursor sobre o membro (uma classe, método ou campo) e pressionar Ctrl-Shift-B ou escolher Navegar > Ir para o código-fonte, no menu principal.

Ir para tipo (Ctrl-O), Ir para arquivo (Alt-Shift-O) e Ir para símbolo (Ctrl-Alt-Shift-O)(classe, interface, anotação ou enum), arquivo ou símbolo para onde deseja saltar, use estes comandos e digite o nome na nova janela. Observe que você pode usar prefixos, acentos circunflexos e caracteres curinga.

Ir para linha (Ctrl-G). Insira o número da linha para a qual deseja saltar.

Para retornar com rapidez para sua última edição, mesmo se estiver em outro arquivo ou projeto, pressione Ctrl-Q ou use o botão para no canto superior esquerdo na barra de ferramentas do Editor Java. O último documento editado é aberto, e o cursor está sob a posição editada por último.

Há dois recursos bem úteis que permitem alternar entre arquivos abertos:Ir para o anterior (Alt-Esquerda) e Ir adiante (Alt-Direita). Para ir para o arquivo anteriormente editado ou mover adiante, escolha Navegar > Voltar ou Navegar > Adiante, ou pressione os botões correspondentes na barra de ferramentas do Editor (mostrados na figura). O arquivo é aberto é o cursor é colocado na localização de sua última edição. Quando você clica em um destes botões, poderá expandir a lista de arquivos recentes e clicar para navegar para qualquer um deles.

Alternando entre arquivos (Ctrl-Tab) Após pressionar Ctrl-Tab, todos os arquivos abertos são mostrados em uma janela suspensa. Mantenha pressionada a tecla Ctrl e pressione diversas vezes a tecla Tab para escolher o arquivo que deseja abrir.

Você pode usar indicadores para navegar com rapidez entre determinados lugares em seu código.Pressione Ctrl-Shift-M (ou clique com o botão direito do mouse na margem esquerda e escolha Indicador > Alternar indicador) para colocar um indicador na linha atual. A linha com indicador é mostrada com um ícone azul pequeno na margem esquerda (consulte a figura).Para remover o indicador, pressione Ctrl-Shift-M novamente.Para ir para o próximo indicador, pressione Ctrl-Shift-Ponto, para ir para o indicador anterior, pressione Ctrl-Shift-Vírgula.

A janela Navegador fornece vistas estruturadas do arquivo atualmente sendo trabalhado e permite navegar com rapidez entre diferentes partes do arquivo.Para abrir a janela Navegador, escolha Janela > Navegação > Navegador ou pressione Ctrl-7.Na janela Navegador, você pode fazer o seguinte:Escolher entre diferentes vistas: Membros, Padrões Bean, Árvores, Elementos, etc.

Clicar duas vezes em um elemento para saltar para a linha onde ela está definida.

Clicar com o botão direito do mouse e aplicar comandos, como Ir para o código-fonte, Localizar usos e Refatorar.

Aplicar filtros aos elementos exibidos no Navegador (use os botões na parte inferior).

Digitar o nome do elemento que deseja localizar (a janela navegador precisa estar ativa).

 

início

Pacote de construtor privado

Campo do construtor privado

Campo estático do campo privado

Método estático do pacote privado

    

Refatoração com Inspecionar e Transformar no editor Java do NetBeans IDEO editor Java do NetBeans IDE 7.1 apresenta um novo recurso de Inspetor e Transformar, que é a ferramenta Refatoração

para executar diversas inspeções e transformações de uma só vez em todos os escopos de arquivos selecionados. Ele

também permite que um usuário defina uma inspeção personalizada.

Neste tutorial, você aprenderá a executar uma revisão de código usando inspeções com refatoração e um conjunto

predefinido de inspeções, gerenciar configurações e criar inspeções personalizadas.

Conteúdo

Configurando o ambiente do tutorial

Executando inspeções

Usando configurações

o Converter para JDK 7

o Organizar importações

Gerenciando inspeções personalizadas

Resumo

Consulte também

RequisitosPara concluir este tutorial, você precisa dos seguintes recursos e softwares.

Software ou recurso Versão necessária

NetBeans IDE Versão 7.1

Java Development Kit (JDK) Versão 6 e superior

Configurando o ambiente do tutorialAlém do software necessário acima listado, você precisa descompactar o arquivo InspectTransform.zip na sua pasta de

projeto do NetBeans e abri-lo no NetBeans IDE como segue:

Executando inspeçõesA opção Inspeção única na caixa de diálogo Inspecionar e transformar (Refatorar > Inspecionar transformar) oferece uma

ampla variedade de inspeções relativas a determinadas transformações de refatoração. A lista completa de tias

operações está disponível na caixa de diálogo Gerenciar inspeções após clicar no botão Procurar a direita da Inspeção

única.

O campo Pesquisar permite verificar se uma inspeção necessária está disponível usando uma pesquisa por palavra-

chave. Por exemplo, há diversas inspeções encontradas quando operator é pesquisado por.

Cada inspeção é fornecida com uma descrição disponível no campo Descrição da caixa de diálogo Gerenciar inspeções ou

quando uma inspeção está sendo selecionada na lista suspensa Inspeção única mostrada na captura de tela abaixo.

Para executar uma inspeção a aplicar uma inspeção existente:

1. Na janela Projetos, selecione o arquivo Import.java.

2. Escolha Refatorar > Inspecionar e transformar no menu do IDE.

3. Na caixa de diálogo Inspecionar e transformar, selecione a opção Inspeção única e escolha a

inspeção Atribuição substituível pela atribuição do operador.

4. Clique em Inspecionar.

As alterações de refatoração sugeridas são exibidas no painel de visualização.

5. Clique em Efetuar a refatoração para aplicar as alterações, se necessário.

Clique aqui para visualizar em tela

cheia; Ctrl+Clique para download (3.2

MB).

início

Usando configuraçõesUm conjunto de refatorações agrupadas constituem a configuração que pode ser executada em seu escopo de interesse,

por exemplo, uma classe ou diversas classes, pacotes ou projetos. O IDE oferece as seguintes duas configurações

predefinidas:

Converter para JDK 7

Organizar importações

Converter para JDK 7A configuração Converter para JDK 7 disponível no IDE, por padrão incorpora tais operações de refatoração como o

uso do operador diamante, tentar com conversão de recursos, uso de multicatch e trocar para aplicativos String.

Nota: A lista de refatorações na configuração pode ser modificada na lista Inspeções da caixa de diálogo Gerenciar

inspeções, ao selecionar a cancelar a seleção de itens sob os nós JDK 1.5 e posteriores.

Para executar e aplicar o padrão de configuraçãoConverter para JDK 7:

1. Na janela Projetos, selecione o arquivo Import.java.

2. Escolha Refatorar > Inspecionar e transformar no menu do IDE.

3. Na caixa de diálogo Inspecionar e transformar, selecione a opção Configuração e escolha o conjunto de inspeções de Converter para JDK 7.

4. Clique em Inspecionar.

As alterações que convertem o código a sintaxe do JDK 7, são exibidas no painel

Visualizar.

5. Clique em Efetuar a refatoração para aplicar as alterações, se necessário.

Organizar importaçõesA configuração Organizar importações permite inspecionar a forma como estão organizadas as declarações de importação e refatorar o código, caso desejado. Por padrão, ela inclui uma inspeção única que verifica que as declarações de importação correspondem as regras de estilo do código especificado.Nota: Para configurar as regras de estilo do código para declarações de importação:

1. Escolha Ferramentas > Opções > > Editor > Formatando, na barra de ferramentas principal do IDE.

2. Selecione Java na lista suspensa Linguagens.

3. Selecione Importações na lista suspensa Categoria.

4. Especifique as opções disponíveis como necessário.

5. Clique em OK para salvar suas edições.

Para executar e aplicar o padrãoOrganizar importaçõesconfiguração:

1. Na janela Projetos, selecione o arquivo Import.java.

2. Escolha Refatorar > Inspecionar e transformar no menu do IDE.

3. Na caixa de diálogo Inspecionar e transformar, selecione a opção Configuração e escolha o item Organizar importações.

4. Clique em Inspecionar.O painel Visualizar exibe duas ocorrências propostas para a seção Importar no arquivo Imports.java, para torná-lo alinhado com as regras de estilo de código especificadas.

5. Clique em Efetuar a refatoração para aplicar as alterações, se necessário.

Clique aqui para visualizar em tela cheia; Ctrl+Clique para download (5.2 MB).

início

Gerenciando inspeções personalizadasUma inspeção personalizada pode ser criada para instruir o IDE sobre quais estruturas de código devem ser encontradas e como transformá-las.Nota: Para evitar de adicionar uma inspeção duplicada no IDE, escolha Refatorar > Inspecionar e transformar a partir do menu principal, clique em Gerenciar ou Procurar e, na caixa de diálogo Gerenciar inspeções, use o campo Pesquisar para procurar pela inspeção necessária antes de criar uma nova inspeção.Para criar uma inspeção personalizada:

1. Escolha Refatorar > Inspecionar e transformar no menu do IDE.

2. Na caixa de diálogo Inspecionar e transformar, clique em Gerenciar ou Procurar.

3. Na caixa de diálogo Gerenciar inspeções, clique em Nova.Um nó Personalizada > Inspeção é criado na lista Inspeções.

4. (Opcional) Clique com o botão direito do mouse em Inspecionar, escolha Renomear no menu suspenso, especifique o nome necessário para sua inspeção personalizada (por exemplo, MyCustomInspection) e pressione Enter.

5. Clique em Editar script. A área de texto Script é exibida.

6. Digite a descrição e o código da inspeção na área de texto Script ou clique em Abrir

no Editor e especifique o mesmo no arquivo MyCustomInspection.hint.

7. Clique em Salvar abaixo da área de texto Script ou pressione Ctrl-S no Editor para

salvar suas edições.

8. Clique em OK para fechar a caixa de diálogo Gerenciar inspeções ou feche o arquivo MyCustomInspection.hint no Editor.Sua inspeção personalizada está feita e pronta para ser aplicada.

Para executar a inspeção personalizada que você criou:1. Escolha Refatorar > Inspecionar e transformar no menu do IDE.

2. Na lista Inspeções da caixa de diálogo Inspecionar e transformar, especifique um arquivo, pacote ou projetos a serem inspecionados. Alternativamente, clique no botão na direita para abrir a caixa de diálogo Escopo personalizado, para especificar o código personalizado a ser inspecionado.

3. Selecione a opção Inspeção única e escolha a inspeção MyCustomInspection.

4. Clique em Inspecionar.As alterações de refatoração sugeridas são exibidas no painel de visualização.

5. Clique em Efetuar a refatoração para aplicar as alterações, se necessário.

Clique aqui para visualizar em tela cheia; Ctrl+Clique para download (1.7 MB).

início

ResumoEste tutorial cobre os usos mais frequentes do recurso Inspecionar e transformar. Observe que com a funcionalidade Inspecionar e Transformar, você também pode executar a refatoração personalizada no escopo do projeto, ou aplicar determinadas configurações de refatoração à diversos projetos abertos no IDE, etc..

Importando projetos do Eclipse para o NetBeans IDEConteúdo

Assistente de importação de projetos do Eclipse

Como funciona o Assistente de importação

Importando e configurando projetos

Construção e execução de um projeto

Arquivos de projetos do NetBeans

Considerações sobre o controle de versão

Ressincronizando um projeto

Resolvendo problemas de importação

Para concluir este tutorial, você precisa dos seguintes recursos e softwares.

Software ou recurso Versão necessária

NetBeans IDE versão 6.9 ou posterior

Java Development Kit (JDK) versão 6 ou 7

Assistente de importação de projetos do EclipseUm suporte aprimorado para a importação de projetos do Eclipse está disponível no NetBeans IDE. O assistente Importar

projeto do Eclipse permite que você use o NetBeans para trabalhar com projetos de área de trabalho Java e de aplicações

web criados no Eclipse e MyEclipse.

Após criar um projeto NetBeans a partir de um projeto Eclipse, você pode trabalhar das seguintes maneiras:

Usar o NetBeans em um projeto de equipe em que outros desenvolvedores usem o Eclipse.

Alternar entre o NetBeans e o Eclipse em um projeto.

Experimente o NetBeans em um projeto existente que tenha sido criado no Eclipse.

início

Como funciona o Assistente de importaçãoQuando você importa um projeto, o IDE analisa os metadados do projeto Eclipse e cria um projeto NetBeans com base

nesses metadados. A importação do projeto não impõe alterações na estrutura do projeto Eclipse, portanto isso não

interfere no modo em que o projeto funciona no Eclipse.

Depois de ter importado o projeto, você pode usar um dos IDEs do NetBeans e Eclipse, ou ambos, para editar, construir,

executar, depurar e criar o perfil do projeto. Se você fizer uma alteração de configuração no projeto Eclipse, você pode

sincronizar o projeto NetBeans novamente. Isso permite que você trabalhe em projetos no NetBeans mesmo se todos em

sua equipe estiverem trabalhand com o Eclipse. O caminho de construção que você define no Eclipse continua sendo o

caminho de construção mestre do projeto.

início

Importando e configurando projetosPara importar um projeto Eclipse no NetBeans:

1. Certifique-se de que você tenha uma cópia do projeto que deseja importar para seu sistema.

Normalmente, esse projeto já estaria em um espaço de trabalho do Eclipse em seu sistema.

2. Escolha Arquivo > Importar projeto > Projeto Eclipse.

3. Na página Localização do espaço de trabalho do assistente, selecione o botão de opção Importar projetos para o

espaço de trabalho e, em seguida, especifique a localização do espaço de

trabalho. 

4. Na página Projetos a importar, selecione os projetos que você deseja importar. Em seguida, selecione uma das

seguintes opções de armazenamento dos arquivos do projeto NetBeans:

o Armazenar dados do projeto NetBeans nas pastas do projeto Eclipse.O NetBeans adiciona pastas e

arquivos na pasta de nível superior do projeto original.

o Criar projetos NetBeans importados em um local separado. O NetBeans usa os códigos-fonte e bibliotecas

na pasta do projeto Eclipse original, mas cria uma pasta separada para armazenar os metadados do projeto

NetBeans e criar saídas.

Normalmente, é melhor armazenar os dados do projeto NetBeans dentro das pastas do projeto Eclipse. Na

maioria dos casos, isso significa que os metadados do projeto NetBeans irão se referir a códigos-fonte e

bibliotecas com os mesmos caminhos que são usados pelos metadados do Eclipse. Portanto, a extração do

projeto de um sistema de controle de versões em máquinas diferentes deve resultar em comportamento similar,

tanto no NetBeans quanto no Eclipse.

Veja Arquivos do projeto NetBeans a seguir para obter uma relação dos arquivos e pastas criados pelo NetBeans.

5. Na página Servidores, registre todos os servidores que seu projeto precisa com o IDE NetBeans. (Essa página não

é exibida se você não estiver importando aplicativos Web.)

Depois de ter concluído o assistente, as caixas de diálogo a seguir devem ser exibidas:

Problemas de importação. Esse diálogo oferece informações sobre as discrepâncias entre a estrutura do projeto no

Eclipse e no NetBeans e destaca as ações que você pode ter que tomar para corrigir as discrepâncias.

Você pode copiar as informações obtidas desse diálogo e colá-las em outro lugar para consultar posteriormente.

Na maioria dos casos, você usa a caixa de diálogo Propriedades do projeto para resolver esses problemas.

Veja Resolvendo problemas de importação para obter um guia para a solução dos problemas mais comuns.

Resolver problemas de referência. Essa caixa de diálogo alerta você sobre um problema de referência específico com

uma das bibliotecas de seu projeto. Você pode solucionar esse problema depois de fechar a caixa de diálogo clicando

com o botão direito do mouse no nó do projeot e escolhendo Resolver problemas de referências.

Resolver servidor ausente. Essa caixa de diálogo alerta você de que o projeto não foi capaz de encontrar um servidor

necessário. Você pode solucionar esse problema depois de fechar a caixa de diálogo clicando com o botão direito do

mouse no nó do projeto e escolhendo Resolver servidor ausente.

Depois de ter concluído o assistente e ter fechado algumas das caixas de diálogo informativas mostradas acima, os nós

dos projetos serão exibidos na janela Projetos.

Se houver referências nos metadados de seu projeto sobre servidores ou outros recursos que o NetBeans não consegue

resolver, o nó do projeto será exibido em vermelho. Você pode resolver essas referências imediatamente clicando com o

botão direito do mouse no nó do projeto e escolhendo Resolver problemas de referência e Resolver servidor ausente.

Para outros tipos de ajustes na configuração do projeto, você usa a caixa de diálogo Propriedades do projeto. Abra a caixa

de diálogo Propriedades do projeto clicando com o botão direito do mouse no nó do projeto e escolhendo Propriedades.

Para obter mais informações sobre a configuração de seu projeto, veja Configurando o classpath e outras configurações

do projeto no guia Criando, importando e configurando projetos Java.

início

Compilando e executando um projetoDepois de ter importado o projeto no NetBeans, você pode construir e executar o projeto. Todos os artefatos criados a

partir dos comandos construir e executar do NetBeans são criados nas pastas build e dist. O NetBeans não

sobrescreve a saída criada a partir de ações construir do Eclipse. Se o projeto Eclipse já tiver pastas build e dist, o

projeto NetBeans cria pastas chamadas nbbuild e nbdist e as utiliza para as saídas do comando construir.

A seguir, alguns dos comandos construir e executar disponíveis no menu Executar:

Executar projeto. Testa a execução do aplicativo no IDE.

Limpar e construir projeto. Exclui o conteúdo das pastas build (ou nbbuild) e dist (ou nbdist) e reconstrói todas

as saídas do projeto. Usa o script de construção do NetBeans. Similar ao comando Limpar no Eclipse.

Limpar. Exclui o conteúdo das pastas nbbuild e nbdist.

Construir. Reconstrói as saídas do projeto. Se o recurso Compilar ao salvar estiver habilitado, o comando Construir é

desabilitado. Veja a seção Compilar ao salvar do guia Criando, importando e configurando projetos Java.

Para obter mais informações sobre a construção e execução de seu aplicativo, bem como sobre a personalização do

processo de construção, veja Criando, importando e configurando projetos Java.

início

Arquivos do projeto NetBeansDepois de ter importado o projeto, você encontrará a pasta e os arquivos a seguir em seu sistema:

Arquivo build.xml ou arquivo nb-build.xml. O script de construção principal do NetBeans para o projeto. Você pode

personalizar esse script de acordo com as necessidades de seu projeto. Por padrão, esse arquivo é chamado

de build.xml. Se esse arquivo já existir na pasta do projeto, o script é chamado de nb-build.xml.

Pasta nbproject. Contém a maioria dos metadados do projeto NetBeans, incluindo recursos que são chamados pelo

script de construção principal do NetBeans. Se você marcar essa pasta e o arquivo build.xml ou nb-build.xml em

seu sistema de controle de versão, outros usuários poderão abrir o projeto no NetBeans. Essa pasta também contém a

pastaprivate, que contém dados específicos de seu sistema. Essa pasta não deve ser copiada para o sistema de

controle de versão, já que seu conteúdo irá variar entre os usuários. VejaConsiderações sobre o controle de versão a

seguir.

Pasta nbbuild. Quando você criar ou executar seu projeto no NetBeans, os códigos-fonte serão compilados nessa pasta.

Pasta nbdist. Quando você constrói seu projeto no NetBeans, as saídas distribuíveis do projeto são craidas e colocadas

nessa pasta. Tais saídas podem ser arquivos JAR e arquivos WAR.

início

Considerações sobre o controle de versãoSe o projeto foi copiado de um sistema de controle de de versão, as pastas build (ou nbbuild), dist (ou nbdist)

e nbproject/private não devem ser copiadas para esse sistema de controle de versão.

Se o projeto estiver sob os sistemas de controle de versão CVS, Subversion ou Mercurial, os arquivos "ignorar"

apropriados são criados ou atualizados para esses diretórios quando o projeto é importado.

Embora a pasta nbproject/private deva ser ignorada, a pasta nbproject deve ser copiada para o sistema de

controle de versão. A pasta nbproject contém metadados do projeto que permitem que outros usuários abram o

projeto no NetBeans sem ter que importar o projeto primeiro.

início

Ressincronizando um projetoO importador do projeto tem recursos de sincronização. Se o classpath no Eclipse tiver sido alterado desde que foi

importado inicialmente, você pode usar o recurso Sincronizar projetos do Eclipse novamente para atualizar o classpath no

projeto NetBeans correspondente.

A ressincronização do projeto é unidirecional, de projetos Ecilpse para projetos NetBeans. Se você fizer alterações na

estrutura do projeto no NetBeans, essas alterações não serão propagadas para o projeto Eclipse com o recurso de

ressincronização. Se você pretende manter tanto o projeto Eclipse quanto o NetBeans, use o projeto Eclipse como projeto

"mestre".

O IDe também ressincroniza os projetos automaticamente se as alterações na configuração do Eclipse forem inequívocas

e não exigirem sua intervenção. Essa ressincronização automática ocorre logo depois que você abre o projeto. Se a

ressincronização exigir sua intervenção, você precisa ressincronizar manualmente o projeto.

Para sincronizar novamente de modo manual os projetos NetBeans com projetos Eclipse:

Escolha Arquivo > Importar projeto > Ressincronizar projetos Eclipse.

Observações: quando você ressincronizar um projeto, a ressincronização é realizada em todos os projetos que você

importou do espaço de trabalho.

início

Resolvendo problemas de importaçãoQuando você importa um projeto no NetBeans, podem haver algumas coisas que não são automaticamente resolvidas no

NetBeans IDE. Para alguns desses problemas, um item do menu, como Resolver problema de servidor ausente, é exibido

no menu de contexto do projeto. Outros problemas podem ser resolvidos na caixa de diálogo Propriedades do projeto

referente ao projeto importado no NetBeans IDE.

Eis uma lista de problemas de importação comuns e suas soluções.

Mensagem do problema Solução

Resolver problema de servidor ausente

Clique com o botão direito do mouse no nó do projeto e escolha

Resolver problema de servidor ausente. Em seguida, navegue até o

arquivo ou pasta que contém o servidor.

Resolver problema de referência

Clique com o botão direito do mouse no nó do projeto e escolha

Resolver problema de referência. Em seguida, navegue até o

arquivo ou pasta que contém o recurso que é mencionado no

projeto.

A plataforma Eclipse para o projeto ProjectName não

pode ser usada. Ela é um JRE e o projeto NetBeans

requer um JDK. O NetBeans usará a plataforma

padrão.

Caso queira alterar a plataforma que o NetBeans usa para o

projeto, escolha Ferramentas > Plataformas e especifique uma

plataforma diferente.

O projeto Eclipse ProjecName afirma usar o JDK a

partir do diretório "{1}". Mas esse diretório não

existe. O NetBeans usará a plataforma padrão.

Caso queira alterar a plataforma que o NetBeans usa para o

projeto, escolha Ferramentas > Plataformas e especifique uma

plataforma diferente.

O NetBeans não oferece suporte a

inclusões/exclusões de código-fonte por raiz de

código-fonte como o Eclipse. Elas foram mescladas e

é recomendável que você as verifique no painel

Código-fonte das propriedades do projeto.

No NetBeans, inclusões e exclusões são declaradas em um local

para todo o projeto. Para verificar as inclusões e exclusões no

projeto NetBeans, clique com o botão direito do mouse no nó do

projeto e, na janela Projetos, escolha Propriedades. Na caixa de

diálogo Propriedades do projeto, selecione a aba Códigos-fonte e,

em seguida, clique no botão Inclusões/exclusões.

Falha na importação devido a .... Mais detalhes

podem ser encontrados no arquivo de log do IDE.

Você pode abrir o arquivo de registro do IDE escolhendo Visualizar

> Registro do IDE.

Tipo de projeto desconhecido, ele não pode ser

importado.

Você pode importar apenas os seguintes tipos de projeto Eclipse:

Projeto Java, Projeto Java de um arquivo Ant existente, Web

estática, Web dinâmica e Projeto JPA.

início

Envie-nos seus comentários

NetBeansForEclipseUsers

Conteúdo

[ esconder ]

1   NetBeans para usuários do Eclipse

2   Eclipse e NetBeans Matriz de recursos

3   Características Eclipse (que podem ou não estar em NetBeans)

4   Outra documentação

NetBeans para usuários do EclipseEsta página é dedicada inteiramente aos recursos do Eclipse para os usuários do Eclipse de comutação ou usando o NetBeans. Informações sobre esta página deve ser em 3 categorias:

1. ) A matriz característica que mostra a funcionalidade em Eclipse e NetBeans e como acessá-lo em Eclipse e NetBeans também. Contamos com os usuários do Eclipse para nos ajudar a obter esta informação e categoria 2 é o lugar onde eles podem adicionar suas características que gostariam de conhecer ou ter adicionado ao NetBeans.

2. ) A lista de recursos que não existem no NetBeans ou que não tenham ainda sido descoberto e colocar na matriz de categoria 1 .

3. ) Outros documentos nesta Wiki que está relacionado com Eclipse. Este mantém-los de ter que procurar em tantos lugares.

Eclipse e NetBeans Matriz de recursosCaracterística Eclipse NetBeans

Recursos do Editor

Sugestões Código: Implementar todos os métodos abstratos

Adicionar uma interface para uma classe.Uma lâmpada aparece que permite ao usuário de implementar os métodos abstratos

Funciona basicamente o mesmo. Uma anotação aparece no nome da classe. Clique onde a anotação é. A lâmpada aparece. Se a interface não tenha ainda sido importadas eo FQN não foi utilizado a primeira sugestão será para importar a classe. Uma vez importado a sugestão será a de implementar todos os métodos abstratos.

Ir para a implementação de um método de super

Uma seta para cima aparece ao lado de um método substituído. Clicando na seta para cima leva você para a implementação super.

Uma seta para cima aparece ao lado de um método substituído. Em NB 5.5 e versões anteriores clicando na seta para cima não tem efeito. Em RN 6.0 em que o levará para a implementação super. Em todas as versões há uma opção de menu de contexto Ir para Implementação / Superque está ligado por padrão para CTRL-B. O Navigator vista da janela de herança também podem ser usados para a mesma finalidade, mas é difícil de utilizar o teclado para operar.

Depuração

Atualizar o código durante a depuração

Código é recarregada durante uma sessão de depuração se uma classe se alterados e salvos. Existem algumas restrições (como não se pode mudar a assinatura do método, adicionar novos métodos, etc)

No NetBeans você tem que selecionar manualmente Run-> Aplicar alterações de código para compilar o arquivo aberto no editor e irá recarregar o código no depurador, sujeitos às mesmas restrições que Eclipse (assinatura do método, etc)

Mostrar uma lista de pontos de interrupção de todos os lugares, e deixe-me habilitar / desabilitar as específicas, sem ter que abrir o arquivo de

Use Janela / Abrir Perspectiva / Debug Use Janela / Depuração / Breakpoints

origem específico e encontrar a linha.

Capacidade de pairar sobre uma classe ou método e ter o javadoc para essa classe ou método ser exibido.

Você pode abrir a janela Javadoc, usandoWindow / Show View / Outros / Java / @ Javadoc

No menu de contexto disponível, mas você pode colocar o cursor em uma linha e pressione F4 ou clique no ícone de execução para cursor na barra de ferramentas

Características Eclipse (que podem ou não estar em NetBeans) Adicionar pasta de origem arbitrária ao projeto e / ou janela fontes de depuração para depuração que não faz parte do

projeto real e não será compilado

Para mostrar o javadoc de uma classe ou um método, quer abrir a janela javadoc (Janela-> Outros-> Javadoc) ou um pequeno truque: pressione CTRL + Espaço antes do último caractere do método de classe /.

Para copiar o nome completo de uma classe (ou mesmo o caminho completo de um arquivo), selecionando o nome da classe, botão direito do mouse e escolher "Copiar nome qualificado".

Outra documentação Importe seus projetos Eclipse para o NetBeans

EclipseToNetBeans

Migrando seus projetos Eclipse para o NetBeans- Desde 24 de outubro de 2007- Última actualização: 3 de setembro de 2008- Projeto de contato: Amit Kumar Saha- Projeto: Blog (velho) . Blog Novo .

Este docs comunidade sub-projeto é um esforço para permitir uma transição suave do Eclipse para o NetBeans. O desafio para nós, povos do NetBeans é que queremos que a sua curva de transição seja suave.

Não queremos que você aprenda coisas que vai pedir para você dedicar uma grande parte do seu tempo apenas para se acostumar com as características do NetBeans

Na medida do possível, queremos que ele seja não mais do que os passos 3-4 antes que você possa continuar a trabalhar com seus projetos Eclipse existentes no NetBeans

Esta página servirá como ponto de entrada para docs que irá mostrar como você pode migrar os existentes Eclipse para projetos NetBeans e continuar trabalhando com eles usando o NetBeans.Durante um período de tempo, iremos abordar projetos Eclipse de crescente complexidade, funcionalidade variada e, em seguida, 'porto' los ao NetBeans.

Nota1. Por favor, sinta-se livre para adicionar quaisquer documentos que você gostaria de ver.

2. Estes documentos utilizam

Eclipse "Europa", "Ganimedes"

NetBeans 6.5 (para versões anteriores do NetBeans verificar nesta página )

Para uma visão geral de fundo de projetos de importação, consulte: Guia de Importação Geral Eclipse para 6,5

Documentos Importar um Java Console projeto Eclipse para o NetBeans

Importar uma aplicação Java Web projeto Eclipse para o NetBeans

Ligações chave melhoradas Eclipse

Serviços Web com NetBeans para usuários do Eclipse

Importar projetos C do Eclipse para o NetBeans  (pós Blog)

Os documentos planejadas Capa "Ressincronizar Eclipse Projetos" característica que mantém automaticamente o NetBeans classpath do projeto em

sintonia com um Eclipse

Importar um projeto mais complexo Eclipse (tipos Misc itens classpath como bibliotecas, variáveis, etc)

Importar um Java Desktop (GUI) Swing-base do projeto Eclipse para o NetBeans

Importar um Java Desktop (GUI)-SWT (a ser investigado) Baseado projeto Eclipse para o NetBeans

Portando Eclipse Plug-ins para o NetBeans

Portar aplicativos SWT para Swing / Plataforma NetBeans

Interessado em escrever qualquer um dos documentos acima? Contacte-me!

Relacionado http://wiki.netbeans.org/EclipseProjectImportTesting~~V

Aprimorada Eclipse plugin importador projeto

NetBeans 6 está fora: Por que os desenvolvedores devem usá-lo?

Consultas, sugestões ou comentáriosContato: Amit Kumar Saha <amitksaha@netbeans.org> <amitsaha.in@gmail.com>