programação basica em java

Embed or link this publication

Description

apostila

Popular Pages


p. 1

Programação Básica em Java Apostila de Patrícia Augustin Jaques

[close]

p. 2

Programação Básica em Java Autoria: Patrícia Augustin Jaques - pjaques@unisinos.br Última atualização: Outubro de 2007. Nenhuma parte desta apostila pode ser utilizada ou reproduzida, em qualquer meio ou forma, seja mecânico ou eletrônico, fotocópia, gravação, ou outros, sem autorização, prévia, expressa e específica do Autor. Essa apostila está protegida pela licença Creative Communs. Você pode usá-la para seus estudos, mas não pode usá-la para fins comerciais ou modificá-la. Bons estudos em Java! Programação Básica em Java by Patrícia Augustin Jaques is licensed under a Creative Commons AtribuiçãoUso Não-Comercial-Vedada a Criação de Obras Derivadas 2.5 Brasil License. Meus agradecimentos a aluna Natali Silverio que me permitiu conhecer a licença Creative Commons. Um especial agradecimento ao aluno Leandro Medeiros que ajudou na revisão do texto. 2

[close]

p. 3

Programação Básica em Java Profa. Patrícia Augustin Jaques Sumário 1 Introdução à Linguagem Java ............................................................................................ 7 1.1 Características da Linguagem Java ...................................................................................................... 7 1.1.1 1.1.2 1.1.3 1.1.4 1.1.5 1.2.1 1.2.2 1.2.3 1.2.4 1.2.5 1.2.6 1.3.1 1.3.2 1.3.3 1.3.4 Parecida com C, C++: .................................................................................................................................... 7 Orientada a Objetos:....................................................................................................................................... 7 Compilada e Interpretada: .............................................................................................................................. 7 Segura: .......................................................................................................................................................... 8 Suporta concorrência: ..................................................................................................................................... 8 Instalando e configurando o ambiente de programação Java ............................................................................. 9 Onde encontro o ambiente de programação Java? ............................................................................................ 9 Versão Java 1.1.x ........................................................................................................................................... 9 Versão Java 1.2.x ........................................................................................................................................... 9 Outras opções .............................................................................................................................................. 10 Que ferramenta uso para criar os meus programas? ....................................................................................... 10 Passo a Passo............................................................................................................................................... 10 Que nome dar ao arquivo? ............................................................................................................................ 11 Compilando o código .................................................................................................................................... 11 Executando o programa HelloWorld ............................................................................................................... 11 1.2 O Ambiente de Programação Java ....................................................................................................... 9 1.3 O Primeiro Programa Java ................................................................................................................ 10 1.4 A Máquina Virtual Java ..................................................................................................................... 12 1.5 Exercícios ........................................................................................................................................ 13 1.4.1 O Ciclo de Vida de uma Máquina Virtual Java ................................................................................................. 12 2 Estruturas Fundamentais de Programação em Java ........................................................ 14 2.1 Espaço em Branco ........................................................................................................................... 14 2.2 Comentários em Java ....................................................................................................................... 14 2.3 Palavras-chave reservadas ................................................................................................................ 14 2.4 Identificadores................................................................................................................................. 15 2.5 Convenções para nomes de identificadores ........................................................................................ 15 2.5.1 Variáveis e métodos ...................................................................................................................................... 15 2.5.2 Constantes ................................................................................................................................................... 15 2.5.3 Classes ........................................................................................................................................................ 15 2.6 Declaração Import ........................................................................................................................... 15 2.7 Tipos Primitivos de Dados (Tipos Nativos de Dados) .......................................................................... 15 2.8 Conversões entre Tipos Numéricos .................................................................................................... 16 2.9 Declaração e Inicialização de Valores ................................................................................................. 17 2.10 Constantes .................................................................................................................................... 17 2.11 Operadores ................................................................................................................................... 17 2.11.1 2.11.2 2.11.3 2.11.4 2.11.5 2.11.6 2.12.1 2.12.2 2.12.3 2.12.4 2.12.5 2.12.6 2.12.7 Operadores Aritméticos ............................................................................................................................... 18 Operadores Relacionais ............................................................................................................................... 18 Operadores Lógicos .................................................................................................................................... 18 Operadores Bit-a-Bit ................................................................................................................................... 19 Operador if-then-else ternário ..................................................................................................................... 20 Precedência de Operadores ......................................................................................................................... 21 if-else......................................................................................................................................................... 21 switch ........................................................................................................................................................ 22 while .......................................................................................................................................................... 23 do-while ..................................................................................................................................................... 23 for ............................................................................................................................................................. 24 continue ..................................................................................................................................................... 24 break ......................................................................................................................................................... 25 2.12 Controle de Fluxo ........................................................................................................................... 21 2.13 Exercícios ...................................................................................................................................... 26 3

[close]

p. 4

Programação Básica em Java Profa. Patrícia Augustin Jaques 3 Fundamentos da Orientação a Objetos ............................................................................ 27 3.1 Classes e Objetos............................................................................................................................. 27 3.1.1 Variáveis ...................................................................................................................................................... 28 3.1.2 Métodos ....................................................................................................................................................... 28 3.1.3 Métodos Construtores ................................................................................................................................... 29 3.1.4 Finalização de um Objeto .............................................................................................................................. 30 3.1.5 Instanciando uma classe ............................................................................................................................... 30 3.1.6 Operador this ............................................................................................................................................... 30 3.1.7 Acessando métodos e variáveis de um objeto ................................................................................................. 30 3.2 Sobrecarga de Métodos (Overloading) ............................................................................................... 31 3.3 Passagem de Parâmetros em Java ..................................................................................................... 31 3.4 Visibilidade ...................................................................................................................................... 32 3.5 Herança .......................................................................................................................................... 33 3.6 Sobreposição (Overriding) ................................................................................................................ 34 3.7 O Modificador “final” ........................................................................................................................ 36 3.8 Classes Abstratas ............................................................................................................................. 36 3.9 Interfaces ....................................................................................................................................... 38 3.10 Inner Classes ................................................................................................................................. 39 3.11 Classes Anônimas (Anonymous Class) .............................................................................................. 40 3.12 Garbage Collection ......................................................................................................................... 41 3.13 Exercícios ...................................................................................................................................... 41 3.9.1 Utilizando as Interfaces ................................................................................................................................. 39 3.5.1 super ........................................................................................................................................................... 34 3.6.1 Dinamic Binding............................................................................................................................................ 35 4 Strings .............................................................................................................................. 44 4.1 Criando uma string .......................................................................................................................... 44 4.1.1 Criando uma string vazia:.............................................................................................................................. 44 4.1.2 Criando uma string a partir de um array de caracteres:................................................................................... 44 4.1.3 Criando uma String a partir de um array de bytes:.......................................................................................... 44 4.2 Substituição de Caracteres ................................................................................................................ 45 4.3 Concatenação de Strings .................................................................................................................. 45 4.4 Substring ........................................................................................................................................ 45 4.5 Alterando os caracteres de uma String para maiúsculo ........................................................................ 46 4.6 Alterando os caracteres de uma String para minúsculo ........................................................................ 46 4.7 Retirando espaços em branco ........................................................................................................... 46 4.8 Extração de Caractere ...................................................................................................................... 46 4.9 Comparação de Strings..................................................................................................................... 46 4.10 Tamanho de uma string .................................................................................................................. 47 4.11 Identificando a posição de caracteres ou substrings em uma String .................................................... 47 4.12 Ordem .......................................................................................................................................... 47 4.13 Conversões de tipos primitivos de dados para Strings ........................................................................ 48 4.14 Conversão de String para tipos primitivos: ........................................................................................ 48 4.15 As classes Wrappers ....................................................................................................................... 49 4.16 StringTokenizer .............................................................................................................................. 49 4.17 Exercícios ...................................................................................................................................... 49 5 Arrays ............................................................................................................................... 51 5.1 Criando um array ............................................................................................................................. 51 5.2 Inicializando arrays .......................................................................................................................... 51 5.3 Acessando um elemento de uma Array .............................................................................................. 52 5.4 Obtendo tamanho de um array ......................................................................................................... 53 4 5.2.1 Inicialização Default ...................................................................................................................................... 52

[close]

p. 5

Programação Básica em Java Profa. Patrícia Augustin Jaques 5.5 Copiando o conteúdo de um array para outro array ............................................................................ 53 5.6 Arrays Multidimensionais .................................................................................................................. 53 5.7 Array de Objetos.............................................................................................................................. 54 5.8 Exercícios ........................................................................................................................................ 54 5.6.1 Criando arrays multidimensionais ................................................................................................................... 53 5.6.2 Inicializando um array multidimensional ......................................................................................................... 53 6 Vector ............................................................................................................................... 55 6.1 Criando um Vector ........................................................................................................................... 55 6.2 Inserindo objetos em um Vector ....................................................................................................... 55 6.2.1 Inserindo um elemento em uma determinada posição..................................................................................... 55 6.2.2 Inserindo um elemento no final do Vector ...................................................................................................... 55 6.3 Verifica a existência de um elemento no Vector .................................................................................. 55 6.4 Retornando um elemento ................................................................................................................. 56 6.5 Retornado a posição de um elemento ................................................................................................ 56 6.6 Substituindo um objeto em uma determinada posição ......................................................................... 56 6.7 Removendo um elemento do Vector .................................................................................................. 56 6.8 Tamanho de um Vector .................................................................................................................... 56 6.9 Convertendo um Vector para array .................................................................................................... 56 6.10 Exercícios ...................................................................................................................................... 57 7 Gerando documentação HTML do código com javadoc .................................................... 58 8 Interfaces em Java – A biblioteca AWT ............................................................................ 60 8.1 Frame ............................................................................................................................................. 60 8.2 Gerenciadores de Layout .................................................................................................................. 61 8.2.1 8.2.2 8.2.3 8.2.4 8.2.5 8.2.6 FlowLayout................................................................................................................................................... 61 BorderLayout................................................................................................................................................ 62 GridLayout ................................................................................................................................................... 63 CardLayout................................................................................................................................................... 63 GridBagLayout .............................................................................................................................................. 64 Compreendendo os campos do GridBagConstraints ......................................................................................... 65 8.3 Dispondo Componentes sem Usar um Gerenciador de Layout .............................................................. 67 8.4 Panel .............................................................................................................................................. 68 8.5 O Modelo de Delegação de Eventos ................................................................................................... 69 8.6 Adaptadores .................................................................................................................................... 70 8.7 Label .............................................................................................................................................. 71 8.8 Definindo Fontes e Cores de Texto .................................................................................................... 71 8.9 Button ............................................................................................................................................ 73 8.10 Checkbox ...................................................................................................................................... 73 8.11 CheckboxGroup ............................................................................................................................. 74 8.12 Choice........................................................................................................................................... 74 8.13 Canvas .......................................................................................................................................... 75 8.14 TextField ....................................................................................................................................... 76 8.15 TextArea ....................................................................................................................................... 77 8.16 List 78 8.17 Dialog ........................................................................................................................................... 79 8.18 FileDialog ...................................................................................................................................... 80 8.19 ScroollPane ................................................................................................................................... 81 8.20 Menu ............................................................................................................................................ 82 8.21 CheckBoxMenuItem ....................................................................................................................... 83 8.20.1 Adicionando Atalhos para os Menus ............................................................................................................. 83 5

[close]

p. 6

Programação Básica em Java Profa. Patrícia Augustin Jaques 8.22 Imprimindo um Frame .................................................................................................................... 84 8.23 Exercícios ...................................................................................................................................... 85 9 Applets ............................................................................................................................. 87 9.1 Restrições de Segurança de um Applet .............................................................................................. 87 9.2 Hierarquia de Java ........................................................................................................................... 87 9.3 Carregando um Applet ..................................................................................................................... 88 9.4 O Ciclo de Vida de um Applet ............................................................................................................ 88 9.5 O primeiro exemplo de um applet...................................................................................................... 89 9.6 Criando programas Java aplicativos e applets ..................................................................................... 90 9.7 Exibindo Som e Imagem em um Applet.............................................................................................. 91 10 Interface Gráfica – Biblioteca Swing .............................................................................. 93 10.1 Determinando o Look-and-Feel de uma Interface Gráfica em Java ...................................................... 93 10.2 JFrame .......................................................................................................................................... 94 10.3 Capturando eventos nos componentes Swing ................................................................................... 96 10.4 Determinando o Layout Manager do Frame ...................................................................................... 96 10.5 JPanel ........................................................................................................................................... 97 10.6 JButton ......................................................................................................................................... 97 10.7 JLabel ........................................................................................................................................... 99 10.8 JTextField e JTextArea .................................................................................................................... 99 10.9 JCheckBox ................................................................................................................................... 100 10.10 JRadioButton ............................................................................................................................. 102 10.11 JComboBox................................................................................................................................ 104 10.12 JList .......................................................................................................................................... 104 10.13 Caixas de Diálogo (JDialog e JOptionPane) ................................................................................... 110 10.14 JDialog ...................................................................................................................................... 111 10.15 JFileChooser .............................................................................................................................. 113 10.16 Menu ........................................................................................................................................ 114 10.17 JApplet ...................................................................................................................................... 117 10.17.1 Applet Context ........................................................................................................................................ 119 10.12.1 ListModel ................................................................................................................................................ 106 10.12.2 ListCellRendering .................................................................................................................................... 109 10.13.1 JOptionPane ........................................................................................................................................... 110 10.6.1 Um exemplo simples de botão: .................................................................................................................... 97 10.6.2 Desenhando botões com Imagens: .............................................................................................................. 98 10.2.1 Capturando os eventos de fechar janela no JFrame ...................................................................................... 96 11 Endereços Úteis na Internet ......................................................................................... 122 12 Referências Bibliográficas ............................................................................................ 123 6

[close]

p. 7

Programação Básica em Java Profa. Patrícia Augustin Jaques 1 Introdução à Linguagem Java A linguagem Java surgiu em 1991 quando cientistas da Sun, liderados por Patrick Naughton e James Gosling, projetaram uma linguagem pequena para ser utilizada em eletrodomésticos em geral. O projeto se chamava “Green”. Como o pessoal da Sun vinha de uma geração UNIX, eles basearam a linguagem em C++ e ela foi chamada originalmente de “Oak”. Oak é um tipo de árvore e a linguagem foi assim denominada porque havia uma árvore deste tipo, a qual Gosling gostava de apreciar, e que podia ser vista da janela de sua sala na Sun. Porém, posteriormente, eles verificaram que Oak era o nome de uma linguagem de programação existente e, por isso, trocaram o nome para Java. O projeto Green passou os anos de 1993 e 1994 procurando uma empresa que quisesse comprar a sua tecnologia, mas não encontraram ninguém. Dizem que Patrick Naughton, uma das pessoas responsáveis pelo marketing, conseguiu acumular 300.000 milhas aéreas de bônus tentando vender a tecnologia Java. Enquanto isso a World Wide Web crescia mais e mais. A chave para a Web é o browser que recebe a página hipertexto e o converte para a tela. Então, para mostrar o poder de Java, Patrick Naughton e Jonathan Payne construíram o browser HotJava. Este browser reconhecia applets e, por isso, tinha uma máquina virtual Java embutida em si. Em 1995, a Netscape decidiu tornar a próxima versão do seu browser (versão 2.0) apta a reconhecer applets Java. A partir de então, todas as versões posteriores do Netscape, inclusive do Internet Explorer, reconhecem Java. 1.1 Características da Linguagem Java 1.1.1 Parecida com C, C++: A sintaxe da linguagem Java é muito semelhante a da linguagem C ou de C++. Logo, o programador que já conhece a linguagem C achará a transição para Java simples e fácil. A sintaxe de Java fornece uma versão mais limpa do que C++. ponteiros, estruturas, uniões e etc. Em Java não existe aritmética de 1.1.2 Orientada a Objetos: Java é uma linguagem voltada para a programação orientada a objetos e, por isso, todo o código está contido dentro de classes. Java suporta herança simples, mas não herança múltipla. A ausência de herança múltipla pode ser compensada pelo uso de herança e interfaces, onde uma classe herda o comportamento de sua superclasse além de oferecer uma implementação para uma ou mais interfaces. 1.1.3 Compilada e Interpretada: Todo programa Java é compilado e interpretado. Um programa em Java é compilado para um código composto por instruções chamadas de “bytecode”. O “bytecode” é um código de uma máquina virtual, chamada Máquina Virtual Java (Java Virtual Machine - JVM), idealizada pelos criadores da linguagem. Os bytecodes são independentes de plataforma e são interpretados pela JVM para serem executados no computador. 7

[close]

p. 8

Programação Básica em Java Profa. Patrícia Augustin Jaques Todo o interpretador Java ou browser que execute applets Java é uma implementação de uma Máquina Virtual Java. A JVM também pode ser implementada em hardware. Além da JVM, a plataforma Java é composta também pela Java Application Programming Interface (Java API). A API Java é uma grande coleção de componentes de software disponibilizados que fornecem muitas capacidades interessantes e úteis, tais como, componentes de interface gráfica, conexão via sockets, etc. A API Java é agrupada em bibliotecas (packages ou pacotes) de componentes relacionados. O código Java é compilado uma única vez, porém o programa é interpretado toda vez que for executado. Esse processo pode ser mais bem visualizado na figura a seguir. 1.1.4 Segura: A presença de coleta automática de lixo (Garbage Collection) evita erros comuns que os programadores cometem quando são obrigados a gerenciar diretamente a memória (C, C++, Pascal). A eliminação do uso de ponteiros, em favor do uso de vetores, objetos e outras estruturas substitutivas, traz benefícios em termos de segurança. O programador é proibido de obter acesso à memória que não pertence ao seu programa, além de não ter chances de cometer erros comuns tais como uso indevido de aritmética de ponteiros. A presença de mecanismos de tratamento de exceções torna as aplicações mais robustas, não permitindo que elas abortem, mesmo quando rodando sob condições anormais. 1.1.5 Suporta concorrência: Java suporta Multithreading que é a capacidade de um programa fazer mais de uma coisa ao mesmo tempo como, por exemplo, imprimir enquanto lê um fax. A linguagem permite a criação, de maneira fácil, de vários “threads” de execução, que eliminam o período de inatividade do processador executando concorrentemente ou tomando vantagem da execução paralela real em sistemas multiprocessadores. 8

[close]

p. 9

Programação Básica em Java Profa. Patrícia Augustin Jaques 1.2 O Ambiente de Programação Java 1.2.1 Instalando e configurando o ambiente de programação Java O ambiente de programação Java disponibilizado pela Sun é composto basicamente pelas seguintes ferramentas: Ferramenta java.exe javac.exe jdb.exe appletviewer.exe Descrição O interpretador Java que será usado para executar os aplicativos Java. O compilador Java que transforma programas fonte escritos em Java (.java) em bytecodes (.class). Java Language Debugger – permite visualizar a execução passo-a-passo. Ferramenta que permite visualizar e testar os applets sem a necessidade de um browser. Existem versões do ambiente Java para as plataformas mais conhecidas: Windows, Linux, UNIX e etc. Embora o código do Java seja portável, a Máquina Virtual Java é dependente de plataforma. Por isso, tenha sempre o cuidado de copiar o ambiente de programação compatível com o Sistema Operacional que você está usando. 1.2.2 Onde encontro o ambiente de programação Java? O ambiente de programação Java pode ser copiado da página da SUN http://java.sun.com/products/. Neste site você encontrará as últimas versões do ambiente de programação Java, bem como a documentação da biblioteca Java. A seguir, encontram-se instruções de como instalar este ambiente. 1.2.3 Versão Java 1.1.x Até a versão 1.1.x do Java, o ambiente de programação se chamava Java Development Kit (JDK) e quando instalado ficava armazenado no diretório JDK1.1.x. Para essa versão era necessário configurar algumas variáveis de ambientes (path e classpath) para uso adequado. No Windows 95 e 98, essas variáveis deveriam ser alteradas no arquivo autoexec.bat que se encontra localizado no diretório raiz do seu HD. As seguintes linhas de código deveriam ser adicionadas ao seu arquivo autoexec.bat para a versão 1.1.x do JDK: PATH=%path%;jdk1.1.x\bin set CLASSPATH=.;c:\jdk1.1.x\lib Na primeira linha é descrito o diretório em que as ferramentas Java (java, javac, etc) podem ser encontradas. O %path% é usado para as configurações anteriores de PATH não serem perdidas. A variável CLASSPATH (segunda linha) contém o diretório em que estão instaladas as bibliotecas Java. Sempre que declarar a variável CLASSPATH é importante colocar o ponto como um dos argumentos. Com isso você está definindo que o Java deve procurar por classes Java no diretório local. 1.2.4 Versão Java 1.2.x Atualmente o ambiente de programação Java encontra-se na versão 1.4.2 (junho de 2004). A partir da versão 1.2.x este ambiente passou a se chamar Java 2 Software Development Kit, Standard Edition (J2SE). 9

[close]

p. 10

Programação Básica em Java Profa. Patrícia Augustin Jaques A partir desta versão é necessário apenas configurar a variável de ambiente PATH. A localização das bibliotecas Java é encontrada automaticamente pela Máquina Virtual Java através do diretório fornecido no PATH. A variável PATH é definida no arquivo autoexec.bat da seguinte maneira: PATH=%PATH%;c:\jdk1.3\bin Se for necessário utilizar uma outra biblioteca além das bibliotecas padrões fornecidas com o Java2 SDK (por exemplo, servlets), é necessário que você a defina no CLASSPATH. 1.2.5 Outras opções A IBM disponibiliza gratuitamente na sua homepage http://oss.software.ibm.com/developerworks/projects/jikes o compilador Java IBM Jikes. Atualmente, o Jikes encontra-se na versão 1.21. Você vai observar que ele é bem mais rápido que o compilador javac da SUN. Vale a pena experimentar! Para o Jikes é importante definir a variável de ambiente classpath no arquivo autoexec.bat, além de copiar o jikes para o diretório bin onde foi instalado o jdk: PATH=%PATH%; c:\jdk1.3\bin set CLASSPATH=.;c:\jdk1.3\jre\lib\rt.jar 1.2.6 Que ferramenta uso para criar os meus programas? O código do programa Java que você criar pode ser digitado em qualquer editor de texto padrão como, por exemplo, o WordPad e o NotePad. Atualmente, existem alguns editores de texto específicos para criação de programas Java. O Kawa, por exemplo, é um shareware e pode ser copiado do site http://www.allaire.com/. Um outro bom editor que pode ser encontrado na versão freeware é o JCreator. Ele pode ser copiado do site http://www.jcreator.com. 1.3 O Primeiro Programa Java Neste capítulo vamos escrever, compilar e executar o tradicional aplicativo “Hello World”. O código deste programa será explicado posteriormente para que você possa começar a entender os fundamentos da programação Java. 1. 2. 3. 4. 5. 6. 7. 8. /* Meu programa Java */ public class HelloWorld { public static void main (String args[ ]) { System.out.println (“Hello, World!”); } // da rotina main } // da class 1.3.1 Passo a Passo Linha 2: public class HelloWorld 10

[close]

p. 11

Programação Básica em Java Profa. Patrícia Augustin Jaques Esta linha utiliza a palavra reservada class para declarar que uma nova classe será definida aqui. HelloWorld é o nome usado para identificar a classe. Toda a definição da classe, inclusive todo o código e os dados, estará entre a chave de abertura “{“ e a chave final “}” que se encontram nas linhas 5 e 8 deste exemplo. Linha 4: public static void main (String args[ ]) A linha 3 contém a declaração do método main. O método main é simplesmente um ponto de partida para o interpretador Java. É por onde será iniciada a execução. O método main deverá sempre ser declarado na forma acima. Linha 6: System.out.println (“Hello, World!”); Esta linha executa o método println do objeto out. Este objeto é uma instância da classe OutputStream e foi declarado como variável de classe (static) na classe System. Este método imprime na tela uma mensagem texto, no caso, “Hello, World!”. Por causa do modelo de objeto, uma saída simples de console é complicada para entender. Por isso, até aprofundarmos o conteúdo suficientemente, pense apenas em System.out.println como um método para impressão na tela (saída do console). 1.3.2 Que nome dar ao arquivo? Após digitar o código-fonte, você deve nomear o arquivo. Os arquivos que contém o código-fonte Java devem sempre ter a terminação “.java”. Geralmente, em Java, coloca-se uma classe dentro de cada arquivo. O arquivo conterá o mesmo nome da classe. Cuidado, o compilador Java diferencia letras maiúsculas de minúsculas, por isso, preste atenção quando for nomear o arquivo. Se você utilizar o modificador public para a classe, por exemplo, public class HelloWorld, o arquivo deve possuir o mesmo nome que a classe. Caso não utilize public, o arquivo pode ter outro nome. 1.3.3 Compilando o código Para compilar o código acima você deve digitar: C:\> javac HelloWorld.java O compilador é chamado pelo comando javac seguido do nome do arquivo sempre com a terminação “.java”. Ao ser compilado, se o código não possuir nenhum erro, será gerado um arquivo chamado HelloWorld.class composto por bytecodes. Esse programa é independente de plataforma e, por isso, o seu programa HelloWorld (.class) pode ser executado em qualquer sistema operacional que possua a JVM instalada. 1.3.4 Executando o programa HelloWorld Após a compilação do programa, em que foi gerado o arquivo HelloWorld.class, você pode executá-lo digitando o seguinte comando: C:\>java HelloWorld No código acima estamos chamando o interpretador Java (java.exe) para carregar a classe HelloWorld e executá-la. No comando de execução não se deve digitar a extensão do arquivo (.class). A seguinte saída será gerada para o programa acima: 11

[close]

p. 12

Programação Básica em Java Profa. Patrícia Augustin Jaques > Hello, World! 1.4 A Máquina Virtual Java Java Virtual Machine, em inglês). A Máquina Virtual Java é um computador abstrato definido por uma Quando trabalhamos com Java, um dos termos que mais ouvimos é “Maquina Virtual Java” (MVJ) (ou especificação. Para executar um programa Java, precisamos de uma implementação desta máquina virtual. Por exemplo, a Sun oferece uma implementação da MVJ que é o interpretador java.exe que vem juntamente com o ambiente de programação J2SDK. Mas, quando ouvimos falar de Java Virtual Machine, na verdade, o termo pode estar se referindo a 3 coisas diferentes (Venners, 2000): a especificação abstrata da MVJ; uma implementação concreta desta máquina virtual. No caso, por exemplo, o programa java (interpretador) que vem com o ambiente de programação da Sun (J2SDK). uma instância em tempo de execução (ou instância runtime). A especificação abstrata é um conceito descrito em detalhes no livro “The Java Virtual Machine Specification” (Lindholm et al., 1997) que define para os desenvolvedores de implementação de MVJ que características uma MVJ deve possuir. Implementações concretas existem para várias plataformas e podem vir de vários fornecedores. Elas também podem ser totalmente implementadas em software, ou ainda uma combinação de hardware e software. Por exemplo, o programa java.exe que vem no ambiente de programação fornecido pela SUN, o JSDK, é um exemplo de uma implementação da MVJ. Uma instância em tempo de execução é quando essa implementação da MVJ está rodando e executando uma aplicação. Por exemplo, quando o interpretador java.exe do JSDK está executando um programa Java. Toda a aplicação Java vai ser executada por uma instância da MVJ. 1.4.1 O Ciclo de Vida de uma Máquina Virtual Java Uma instância em tempo de execução (ou instância runtime) tem a função de executar uma aplicação Java. Quando uma aplicação Java inicia a sua execução, uma instância runtime nasce. Ela morre no momento em que a aplicação completa a sua execução. Se nós executarmos três aplicações Java iguais, usando a mesma implementação de MVJ e na mesma máquina, nós teremos 3 instâncias de MJV executando. Cada aplicação Java irá executar na sua própria MVJ. A instância da MVJ irá iniciar a execução de sua aplicação pelo método main ( ). O método main ( ) deve ter a seguinte assinatura: public static void main (String args[ ]) (como mostrado no exemplo listado na seção 1.3). Qualquer classe Java que contenha o método main() pode ser usada como ponto de partida para a execução de uma aplicação stand-alone Java. Nós temos que, de alguma maneira, fornecer a MVJ o nome da classe que contém o método main() por onde a MVJ irá iniciar a execução. Um exemplo real de implementação de MVJ é o programa java.exe do ambiente Java 2 SDK da Sun. Para dizer a esta MVJ que nós gostaríamos de executar a classe HelloWorld, nós digitamos o comando: C:\>java HelloWorld no prompt do DOS (Windows). O primeiro parâmetro (java) está indicando que o sistema operacional pode iniciar a execução da JVM do J2SDK. O segundo parâmetro é o nome da classe inicial. Esta classe deve conter o método main( ). A MVJ é formada por um subsistema que carrega classes (classloader) que é um mecanismo para carregar as classes e interfaces dado os seus nomes. Ele carrega tanto classes do programa Java criado pelo 12

[close]

p. 13

Programação Básica em Java Profa. Patrícia Augustin Jaques programador, também como classes da Java API. Apenas são carregadas as classes da Java API que são utilizadas pelo programa. A MVJ também possui uma máquina de execução (execution engine) que é um mecanismo responsável por executar as instruções Java (bytecodes) contidos nos métodos das classes carregadas. Em uma MVJ implementada em software, o tipo mais simples de execution engine apenas interpreta os bytecodes um por um. Um outro tipo de execution engine, que é mais rápida, é o compilador just-in-time (JIT). Um compilador JIT compila os bytecodes para código em máquina nativa na primeira vez que o método é executado. O código nativo é guardado em memória e, então, pode ser reusado na próxima vez que o método é invocado. Ele mantém em memória tanto os bytecodes como o código nativo, por isso, embora seja mais rápido, requer mais memória. Algumas vezes a JVM é chamada de interpretador já que, quando a MVJ é implementada em software, ela interpreta os bytecodes para executá-los. Porém, algumas MVJs usam técnicas diferentes, como é o caso dos compiladores JIT. Desta maneira, não é muito adequado chamar a MVJ de interpretador (Venners, 2000). 1.5 Exercícios Exercício 1 – Pede Argumento Faça um programa Java leia um argumento passado para a Máquina Virtual Java. O programa deve ser formado por uma única classe e contém apenas o método main ( ). A classe deve se chamar PedeArgumento e você passará o seu nome como argumento. Por exemplo, se o seu nome é Nicolas, você deve executar o programa através do seguinte comando: C:/> java PedeArgumento Nicolas E o programa deve exibir na tela como resultado: > Olá Nicolas! Dica: Todo o parâmetro passado para a MVJ é recebido pela array de String do método main(). Para acessar um argumento de uma array, forneça a posição da array que você deseja acessar. Por exemplo, como nós fornecemos apenas uma String ela estará na primeira posição da array que é zero: String nome = args [0]; Se você digitasse duas strings (por exemplo, o seu nome e sobrenome, seria necessário acessar as duas primeiras posições da array: 0 e 1). 13

[close]

p. 14

Programação Básica em Java Profa. Patrícia Augustin Jaques 2 Estruturas Fundamentais de Programação em Java 2.1 Espaço em Branco Java é uma linguagem de formato livre. Não é necessário endentar para que ela funcione corretamente. Por exemplo, o nosso programa HelloWorld poderia ser escrito da seguinte maneira: public class HelloWorld{public static void main (String a[ ] ) {System.out.println (“Oi, mundo!”);}} Devemos, porém, tomar cuidado para que haja pelo menos um espaço, Tab ou uma nova linha entre palavras que não estejam separadas por um operador ou separador. 2.2 Comentários em Java Os comentários em código-fonte Java podem ser de 3 tipos: de uma linha, de várias linhas e de documentação. Os comentários de uma linha começam com // (duas barras) e terminam no final da linha. Este tipo de comentário é útil para explicações de uma única linha de código. Nas linhas 7 e 8 do código exibido no início deste capítulo encontramos dois comentários desse tipo. O comentário de várias linhas é usado para comentários mais longos que uma linha e é iniciado com /* (barra-asterisco) e finalizado com */ (asterisco-barra). Tudo que houver entre /* e */ é considerado um comentário e, portanto, ignorado pelo compilador. Existe ainda o comentário de documentação que começa com /** (barra-asterisco-asterisco) e finaliza com */ (asterisco-barra). O uso da ferramenta JavaDoc para gerar documentação HTML vai ser explicado no capítulo 7 (página 58). 2.3 Palavras-chave reservadas As palavras-chave reservadas Java são usadas para identificar os tipos, modificadores e mecanismos de controle de fluxo. Essas palavras, juntamente com os operadores e separadores, formam a definição da linguagem Java. Elas não podem ser usadas como nome de variável, método ou classe. abstract case const else float if int null protected static throw var boolean cast continue extends for implements interface operator public super throws void break catch default false future import long outer rest switch transient volatile byte char do final generic inner native package return synchronized true while byvalue class double finally goto instanceof new private short this try 14

[close]

p. 15

Programação Básica em Java Profa. Patrícia Augustin Jaques 2.4 Identificadores Os identificadores são as palavras usadas para nomes de classes, métodos e variáveis. Um identificador pode ser qualquer seqüência de caracteres de letras maiúsculas e minúsculas, números e caracteres de sublinhado e símbolo de cifrão. Mas, tome os seguintes cuidados: Eles não podem começar com números para não serem identificados como literais numéricos; Java é sensível a maiúsculas e minúsculas, por isso o identificador Valor é diferente de valor. 2.5 Convenções para nomes de identificadores 2.5.1 Variáveis e métodos Segundo a convenção para identificadores Java, os métodos e variáveis devem ser nomeados com letras minúsculas. No caso do identificador ser formado por mais de um termo, o segundo termo e os termos seguintes devem iniciar com letra maiúscula. As variáveis são compostas por substantivos e adjetivos, enquanto que os nomes de métodos começam sempre com um verbo. Exemplos: hora, horaDoDia, valorCorrente, obterHoraDoDia(). 2.5.2 Constantes Para as variáveis finais, que representam constantes em Java, usa-se todo o nome em letras maiúsculas. Quando as constantes forem formadas por mais de um termo, usa-se sublinhado para separá-los. Os nomes de constantes Java são formados por substantivos e adjetivos. Exemplos: VALOR_P1, DIA_SEXTA, VERDE. 2.5.3 Classes Nomes de classes em Java são escritos em minúsculo com a primeira letra em maiúscula. Para os nomes compostos por mais de um termo, usa-se começar os termos seguintes com letra maiúscula. Os nomes de classes Java são formados por substantivos e adjetivos. Exemplos: InterfaceSimples, Interface. 2.6 Declaração Import Para utilizar os pacotes Java, usa-se a declaração de importação que define onde o compilador pode encontrar as classes destes pacotes. A declaração de importação (import) deve preceder a declaração de todas as classes. O compilador irá procurar por pacotes dentro dos diretórios especificados na variável de ambiente classpath. Um pacote pode ainda estar compactado dentro de um arquivo JAR. 2.7 Tipos Primitivos de Dados (Tipos Nativos de Dados) Java tem oito tipos simples de dados que podem ser classificados em quatro grupos: Inteiros: byte, short, int e long que são usados para números inteiros; Números de Ponto flutuante: float e double que correspondem aos números com precisão de fração. Caracteres: char. Valores lógicos: boolean que é um tipo especial usado para representar valores lógicos. 15

[close]

Comments

no comments yet