Академический Документы
Профессиональный Документы
Культура Документы
Secretria da Educao Maria Izolda Cela de Arruda Coelho Secretrio Adjunto Maurcio Holanda Maia
Assessora Institucional do Gabinete da Seduc Cristiane Carvalho Holanda Coordenadora de Desenvolvimento da Escola Maria da Conceio vila de Misquita Vins Coordenadora da Educao Profissional SEDUC Thereza Maria de Castro Paes Barreto
ndice
Apresentao...............................................................................................................................6 Lio 1.........................................................................................................................................9 1. Objetivos.................................................................................................................................9 2. Explorando o Java...................................................................................................................9 2.1. Um pouco da histria...........................................................................................................9 2.2. O que uma tecnologia JAVA?............................................................................................9 2.2.1. Uma linguagem de programao......................................................................................9 2.2.2. Um ambiente de desenvolvimento..................................................................................10 2.2.3. Um ambiente de aplicao..............................................................................................10 2.2.4. Um ambiente de distribuio..........................................................................................10 2.3. Algumas Caractersticas do JAVA......................................................................................10 2.3.1. Mquina Virtual Java......................................................................................................10 2.3.2. Garbage Collection..........................................................................................................11 2.3.3. Segurana de cdigo.......................................................................................................11 2.4. Fases do Java programa.....................................................................................................11 3. Primeiro Programa Java........................................................................................................12 3.1. Utilizando a Console e um editor de texto.........................................................................12 3.2. Erros...................................................................................................................................15 3.2.1 Erros de Sintaxe...............................................................................................................15 3.2.2 Erros em tempo de execuo (Erros de run-time)............................................................16 4. Usando NetBeans..................................................................................................................16 5. Exerccios..............................................................................................................................24 5.1 Melhorando o Hello World!................................................................................................24 5.2. A rvore.............................................................................................................................24 Lio 2.......................................................................................................................................26 1. Objetivos...............................................................................................................................26 2. Entendendo meu primeiro programa em Java.......................................................................26 3. Comentrios em Java............................................................................................................27 3.1. Comentrio de linha...........................................................................................................27 3.2. Comentrio de bloco..........................................................................................................28 3.3. Comentrio estilo Javadoc.................................................................................................28 4. Instrues e Bloco em Java...................................................................................................28 5. Identificadores em Java.........................................................................................................30 6. Palavras-chave em Java........................................................................................................30 7. Tipos de Dados em Java........................................................................................................31 7.1. Boolean..............................................................................................................................31 7.2. Character............................................................................................................................31 7.3. Integer................................................................................................................................31 7.4. Float-Point..........................................................................................................................31 8. Tipos de Dados Primitivos....................................................................................................32 8.1. Lgico................................................................................................................................32 8.2. Inteiro.................................................................................................................................32 8.3. Inteiro Longo......................................................................................................................33 8.4. Nmero Fracionrio...........................................................................................................33 9. Variveis................................................................................................................................34 9.1. Declarando e inicializando Variveis.................................................................................34 9.1. Declarando e inicializando Variveis.................................................................................34 9.2. Exibindo o valor de uma Varivel......................................................................................35
Informtica - Programao Orientada a Objetos I 1
9.3. System.out.println( ) e System.out.print( ).........................................................................35 9.4. Referncia de Variveis e Valor das Variveis...................................................................36 10. Operadores..........................................................................................................................36 11. Operadores de Incremento e Decremento...........................................................................39 12. Operadores Relacionais.......................................................................................................40 13. Operadores Lgicos............................................................................................................42 13.1. && (e lgico) e & (e binrio)..........................................................................................42 13.2. || ( ou lgico) e | ( ou binrio)...........................................................................................43 13.3. ^ (ou exclusivo binrio)...................................................................................................45 13.4. ! (negao)........................................................................................................................46 14. Operador Condicional ( ?: )................................................................................................46 15. Precedncia de Operadores.................................................................................................47 16. Exerccios............................................................................................................................48 16.1. Declarar e mostrar variveis............................................................................................49 16.2. Obter a mdia entre trs nmeros....................................................................................49 16.3. Exibir o maior valor.........................................................................................................49 16.4. Precedncia de operadores...............................................................................................49 Lio 3.......................................................................................................................................51 1. Objetivos...............................................................................................................................51 2. BufferedReader para capturar dados.....................................................................................51 3. Classe Scanner para capturar dados......................................................................................53 4. Utilizando a JOptionPane para receber dados.......................................................................54 5. Exerccios..............................................................................................................................55 5.1. As 3 palavras (verso Console)..........................................................................................55 5.2. As 3 palavras (verso Interface Grfica)............................................................................55 1. Objetivos...............................................................................................................................57 2. Estruturas de controle de deciso..........................................................................................57 2.1. Declarao if......................................................................................................................57 2.2. Declarao if-else...............................................................................................................58 2.3. Declarao if-else-if...........................................................................................................60 2.4. Erros comuns na utilizao da declarao if......................................................................61 2.6. Exemplo para switch..........................................................................................................64 3. Estruturas de controle de repetio.......................................................................................64 3.1. Declarao while................................................................................................................64 3.2. Declarao do-while..........................................................................................................66 3.3. Declarao for....................................................................................................................67 4. Declaraes de Interrupo...................................................................................................68 4.1. Declarao break................................................................................................................69 4.1.1. Declarao unlabeled break............................................................................................69 4.1.2. Declarao labeled break................................................................................................69 4.2. Declarao continue...........................................................................................................70 4.2.1. Declarao unlabeled continue.......................................................................................70 4.2.2. Declarao labeled continue...........................................................................................70 4.3. Declarao return...............................................................................................................71 5. Exerccios..............................................................................................................................71 5.1. Notas..................................................................................................................................71 5.2. Nmero por Extenso..........................................................................................................72 5.3. Cem vezes..........................................................................................................................72 5.4. Potncias............................................................................................................................72 Lio 5.......................................................................................................................................73
Informtica - Programao Orientada a Objetos I 2
1. Objetivos...............................................................................................................................73 2. Introduo a Array................................................................................................................73 3. Declarando Array..................................................................................................................73 4. Acessando um elemento do Array.........................................................................................74 5. Tamanho do Array.................................................................................................................76 6. Arrays Multidimensionais.....................................................................................................76 7. Exerccios..............................................................................................................................77 7.1. Dias da semana...................................................................................................................77 7.2. Maior nmero.....................................................................................................................77 7.3. Entradas de agenda telefnica............................................................................................77 Lio 6.......................................................................................................................................79 1. Objetivos...............................................................................................................................79 2. Argumentos de linha de comando.........................................................................................79 2. Argumentos de linha de comando.........................................................................................79 3. Argumentos de linha de comando no NetBeans...................................................................80 4. Exerccios..............................................................................................................................85 4.1. Argumentos de Exibio....................................................................................................85 4.2. Operaes aritmticas........................................................................................................85 Lio 7.......................................................................................................................................86 1. Objetivos...............................................................................................................................86 2. Introduo Programao Orientada a Objeto.....................................................................86 3. Classes e Objetos..................................................................................................................87 3.1. Diferenas entre Classes e Objetos....................................................................................87 3.2. Encapsulamento.................................................................................................................87 3.3. Atributos e Mtodos de Classe...........................................................................................88 3.4 Instncia de Classe..............................................................................................................88 4. Mtodos.................................................................................................................................89 4.1. O que so mtodos e porque usar mtodos?......................................................................89 4.2. Chamando Mtodos de Objeto e Enviando Argumentos...................................................89 4.3. Envio de Argumentos para Mtodos..................................................................................90 4.3.1. Envio por valor................................................................................................................90 4.3.2. Envio por referncia........................................................................................................91 4.4. Chamando mtodos estticos.............................................................................................92 4.5. Escopo de um atributo........................................................................................................93 5. Casting, Converso e Comparao de Objetos.....................................................................95 5.1. Casting de Tipos Primitivos...............................................................................................95 5.2. Casting de Objetos.............................................................................................................96 5.3. Convertendo Tipos Primitivos para Objetos e Vice-Versa.................................................97 5.4. Comparando Objetos..........................................................................................................98 5.5. Determinando a Classe de um Objeto..............................................................................100 6. Exerccios............................................................................................................................101 6.1. Definindo termos..............................................................................................................101 6.2. Java Scavenger Hunt........................................................................................................101 Lio 8.....................................................................................................................................103 1. Objetivos.............................................................................................................................103 2. Definindo nossas classes.....................................................................................................103 3. Declarando Atributos..........................................................................................................104 3.1. Atributos de Objeto..........................................................................................................105 3.2. Atributos de Classe ou Atributos Estticos......................................................................106 4. Declarando Mtodos...........................................................................................................106
Informtica - Programao Orientada a Objetos I 3
4.1. Mtodos assessores..........................................................................................................107 4.2 Mtodos Modificadores....................................................................................................108 4.3. Mltiplos comandos return..............................................................................................108 4.4. Mtodos estticos.............................................................................................................109 4.5. Exemplo de Cdigo Fonte para a classe StudentRecord..................................................109 5. this.......................................................................................................................................111 6. Overloading de Mtodos.....................................................................................................111 7. Declarando Construtores.....................................................................................................113 7.1. Construtor Padro (default)..............................................................................................113 7.2. Overloading de Construtores............................................................................................113 7.3. Usando Construtores........................................................................................................114 7.4. Utilizando o this()............................................................................................................115 8. Pacotes.................................................................................................................................116 8.1. Importando Pacotes..........................................................................................................116 8.2. Criando pacotes................................................................................................................116 8.3. Definindo a varivel de ambiente CLASSPATH.............................................................117 9. Modificadores de Acesso....................................................................................................118 9.1. Acesso padro...................................................................................................................118 9.2. Acesso pblico.................................................................................................................118 9.3. Acesso protegido..............................................................................................................119 9.4. Acesso particular..............................................................................................................119 10. Exerccios..........................................................................................................................119 10.1. Registro de Agenda........................................................................................................119 10.2. Agenda...........................................................................................................................120 Lio 9.....................................................................................................................................121 1. Objetivos.............................................................................................................................121 2. Herana...............................................................................................................................121 2.1. Definindo Superclasses e Subclasses...............................................................................121 2.2. super.................................................................................................................................123 2.3. Override de Mtodos........................................................................................................124 2.4. Mtodos final e Classes final...........................................................................................125 4. Mtodos...............................................................................................................................125 3. Polimorfismo.......................................................................................................................125 4. Classes Abstratas.................................................................................................................127 5. Interfaces.............................................................................................................................129 5.1. Porque utilizar Interfaces?...............................................................................................129 5.2. Interface vs. Classe Abstrata............................................................................................129 5.3. Interface vs. Classe..........................................................................................................129 5.4. Criando Interfaces............................................................................................................130 5.5. Relacionamento de uma Interface para uma Classe.........................................................131 5.6. Herana entre Interfaces...................................................................................................132 6. Exerccios............................................................................................................................132 6.1. Estendendo StudentRecord..............................................................................................132 6.2. A classe abstrata Shape....................................................................................................132 Lio 10...................................................................................................................................133 1. Objetivos.............................................................................................................................133 2. O que so Excees (Exception)?.......................................................................................133 3. Tratando Excees..............................................................................................................133 4. Exerccios............................................................................................................................135 4.1. Capturando Excees 1....................................................................................................135
Informtica - Programao Orientada a Objetos I 4
4.2. Capturando Excees 2....................................................................................................136 Apndice A..............................................................................................................................137 1. Objetivos.............................................................................................................................137 2. Instalando Java no Ubuntu Dapper.....................................................................................137 3. Instalando Java no Windows...............................................................................................138 4. Instalando NetBeans no Ubuntu Dapper.............................................................................139 5. Instalando NetBeans no Windows......................................................................................139
Apresentao
Autor Florence Tiu Balagtas Equipe Joyce Avestro Florence Balagtas Rommel Feria Reginald Hutcherson Rebecca Ong John Paul Petines Sang Shin Raghavan Srinivas Matthew Thompson Necessidades para os Exerccios
Sistemas Operacionais Suportados NetBeans IDE 5.5 para os seguintes sistemas operacionais:
Microsoft Windows XP Profissional SP2 ou superior Mac OS X 10.4.5 ou superior Red Hat Fedora Core 3 Solaris 10 Operating System (SPARC e x86/x64 Platform Edition)
Solaris 8 OS (SPARC e x86/x64 Platform Edition) e Solaris 9 OS (SPARC e x86/x64 Platform Edition) Vrias outras distribuies Linux
Configurao Mnima de Hardware Nota: IDE NetBeans com resoluo de tela em 1024x768 pixel Sistema Operacional Processador Memria HD Livre Microsoft Windows 500 MHz Intel Pentium III workstation ou equivalente 512 MB 850 MB Linux 500 MHz Intel Pentium III workstation ou equivalente 512 MB 450 MB Solaris OS (SPARC) UltraSPARC II 450 MHz 512 MB 450 MB Solaris OS (x86/x64 Platform Edition) AMD Opteron 100 Srie 1.8 GHz 512 MB 450 MB Mac OS X PowerPC G4 512 MB 450 MB Configurao Recomendada de Hardware Sistema Operacional Processador Memria HD Livre Microsoft Windows 1.4 GHz Intel Pentium III workstation ou equivalente 1 GB 1 GB Linux 1.4 GHz Intel Pentium III workstation ou equivalente 1 GB 850 MB Solaris OS (SPARC) UltraSPARC IIIi 1 GHz 1 GB 850 MB Solaris OS (x86/x64 Platform Edition) AMD Opteron 100 Series 1.8 GHz 1 GB 850 MB Mac OS X PowerPC G5 1 GB 850 MB Requerimentos de Software NetBeans Enterprise Pack 5.5 executando sobre Java 2 Platform Standard Edition Development Kit 5.0 ou superior (JDK 5.0, verso 1.5.0_01 ou superior), contemplando a Java Runtime Environment, ferramentas de desenvolvimento para compilar, depurar, e executar aplicaes escritas em linguagem Java. Sun Java System Application Server Platform Edition 9. Para Solaris, Windows, e Linux, os arquivos da JDK podem ser obtidos para sua plataforma em http://java.sun.com/j2se/1.5.0/download.html Para Mac OS X, Java 2 Plataform Standard Edition (J2SE) 5.0 Release 4, pode ser obtida diretamente da Apple's Developer Connection, no endereo: http://developer.apple.com/java ( necessrio registrar o download da JDK). Para mais informaes: http://www.netbeans.org/community/releases/55/relnotes.html
Antonio Jose R. Alves Ramos Aurlio Soares Neto Bruno da Silva Bonfim Bruno dos Santos Miranda Bruno Ferreira Rodrigues Carlos Alberto Vitorino de Almeida Carlos Alexandre de Sene Carlos Andr Noronha de Sousa Carlos Eduardo Veras Neves Cleber Ferreira de Sousa Cleyton Artur Soares Urani Cristiano Borges Ferreira Cristiano de Siqueira Pires Derlon Vandri Aliendres Fabiano Eduardo de Oliveira Fbio Bombonato Fernando Antonio Mota Trinta Flvio Alves Gomes Francisco das Chagas Francisco Marcio da Silva Gilson Moreno Costa Givailson de Souza Neves Gustavo Henrique Castellano Hebert Julio Gonalves de Paula Heraldo Conceio Domingues
Jos Augusto Martins Nieviadonski Jos Leonardo Borges de Melo Jos Ricardo Carneiro Kleberth Bezerra G. dos Santos Lafaiete de S Guimares Leandro Silva de Morais Leonardo Leopoldo do Nascimento Leonardo Pereira dos Santos Leonardo Rangel de Melo Filardi Lucas Mauricio Castro e Martins Luciana Rocha de Oliveira Lus Carlos Andr Lus Octvio Jorge V. Lima Luiz Fernandes de Oliveira Junior Luiz Victor de Andrade Lima Manoel Cotts de Queiroz Marcello Sandi Pinheiro Marcelo Ortolan Pazzetto Marco Aurlio Martins Bessa Marcos Vinicius de Toledo Maria Carolina Ferreira da Silva Massimiliano Giroldi Mauricio Azevedo Gamarra Mauricio da Silva Marinho Mauro Cardoso Mortoni
Reyderson Magela dos Reis Ricardo Ferreira Rodrigues Ricardo Ulrich Bomfim Robson de Oliveira Cunha Rodrigo Pereira Machado Rodrigo Rosa Miranda Corra Rodrigo Vaez Ronie Dotzlaw Rosely Moreira de Jesus Seire Pareja Sergio Pomerancblum Silvio Sznifer Suzana da Costa Oliveira Tsio Vasconcelos da Silveira Thiago Magela Rodrigues Dias Tiago Gimenez Ribeiro Vanderlei Carvalho Rodrigues Pinto Vanessa dos Santos Almeida Vast Mendes da Silva Rocha Wagner Eliezer Roncoletta Nolyanne Peixoto Brasil Vieira Paulo Afonso Corra Paulo Jos Lemos Costa Paulo Oliveira Sampaio Reis
Auxiliadores especiais
Reviso Geral do texto para os seguintes Pases: Brasil Tiago Flach Guin Bissau Alfredo C, Bunene Sisse e Buon Olossato Quebi ONG Asas de Socorro
Coordenao do DFJUG
Daniel de Oliveira JU GLeader responsvel pelos acordos de parcerias Luci Campos - Idealizadora do DFJUG responsvel pelo apoio social Fernando Anselmo - Coordenador responsvel pelo processo de traduo e reviso, disponibilizao dos materiais e insero de novos mdulos Regina Mariani - Coordenadora responsvel pela parte jurdica Rodrigo Nunes - Coordenador responsvel pela parte multimdia Srgio Gomes Veloso - Coordenador responsvel pelo ambiente (Moodle)
Agradecimento Especial
Lio 1 1. Objetivos
Nesta seo, vamos discutir os componentes bsicos de um computador, tanto em relao a hardware como a software. Tambm veremos uma pequena introduo sobre linguagens de programao e sobre o ciclo de vida do desenvolvimento. Por fim, mostraremos os diferentes sistemas numricos e as converses entre eles. Ao final desta lio, o estudante ser capaz de: Identificar os diferentes componentes de um computador. Conhecer as linguagens de programao e suas categorias. Entender o ciclo de vida de desenvolvimento de programas e aplic-lo na soluo de problemas. Conhecer os diferentes sistemas numricos e as converses entre eles.
2. Explorando o Java
2.1. Um pouco da histria
Java foi criado em 1991 por James Gosling da Sun Microsystems. Inicialmente chamada OAK(Carvalho), em homenagem uma rvore de janela do Gosling, seu nome foi mudado para Javadevido a existncia de uma linguagem com o nome OAK.
Figura 1: James Gosling criador do Java
A motivao original do Java era a necessidade de uma linguagem independente de plataformaque podia ser utilizada em vrios produtos eletrnicos, tais como torradeiras e refrigeradores. Um dos primeiros projetos desenvolvidos utilizando Java era um controle remoto pessoal chamado *7 (Star Seven). Ao mesmo tempo, a World Wide Web e a Internet foram ganhando popularidade. Gosling achava que a linguagem Java poderia ser usada para programao da Internet.
O bytecode uma linguagem de mquina especial que pode ser entendida pela Mquina Virtual Java (JVM). O bytecode independente de qualquer hardware de computador particular. Assim, qualquer computador com o interpretador Java pode executar um programa Java compilado, no importando em que tipo de computador o programa foi compilado.
plos de editores de texto que podem ser utilizados: bloco de notas, vi, emacs, etc.Esses arquivos so armazenados no disco rgido com a extenso .java.
Aps o programa Java ter sido criado e salvo, compile o programa utilizando o Compilador Java. A sada desse processo um arquivo de bytecode com extenso .class. O arquivo .class ento lido pelo Interpretador Java que converte os bytecodes em linguagem de mquina do computador que se est usando.
Neste exemplo utilizaremos um simples editor de texto, que pode ser o gedit do Linux ou o notepad do Windows, para editar o cdigo fonte. Em seguida ser necessrio abrir uma janela terminal para compilar e executar os programas. Passo 1: executar um editor de texto
Accessories Text Editor. Para iniciar um editor de texto no Windows selecione Start Programs Accessories Notepad.
Para iniciar um editor de texto no Linux selecione Applications Passo 2: Abrir a janela de console Para abrir o terminal no Linux, selecione Applications minal no Windows, selecione Start boto OK.
Accessories Terminal.
Passo 3: Escrever as instrues utilizando o Editor de Texto Digite as seguintes instrues no editor de textos: public class Hello { /** * Meu primeiro programa Java */ public static void main(String[] args) { // Mostra na tela o texto "Hello world" System.out.println("Hello world!"); } } Passo 4: Salvar o programa Java Chamaremos o programa de "Hello.java" e o colocaremos em uma pasta denominada "myJavaPrograms". Caso esta pasta no tenha sido criada, retorne janela de terminal aberta e insira as seguintes instrues: Para o Linux: $ md myJavaPrograms Para o Windows: C:\> md myJavaPrograms Retorne ao Editor de textos e salve o programa. Para abrir a caixa de dilogo salvar selecione aopo "File" localizada na barra de menus e depois clique na opo "Save". Selecione a nova pasta cria-
da como myJavaPrograms para entrar nela. A pasta deve estar vazia porque ainda no salvamos nada dentro dela. Na caixa de texto "Name", digite o nome do programa (Hello.java), e depois clique no boto salvar. ATENO: Para o Notepad no Windows, mude o Tipo para "All Files" (em Save as Type). Aps salvar o arquivo observe que o ttulo da janela mudou de "Untitled" para "Hello.java", caso deseje alterar novamente o arquivo basta edit-lo e depois salv-lo novamente clicando em File
Save.
Passo 5: Entrar na pasta que contm o programa O prximo passo deve ser o de compilar o programa. Inicialmente, precisamos entrar na pasta que o contm. Retorne janela do terminal. Em Linux: Normalmente, quando abrimos uma janela terminal, ela vai diretamente para sua pasta home (identificada por $). Para ver o que tem dentro do diretrio digite ls (LS em minscula, significando "List Sources") e pressione ENTER. Isso far com que sejam listados os arquivos e pastas da pasta home. Verifique a existncia de uma pasta chamada "myJavaPrograms", criada a pouco, sendo esta olocal em que foi salvo o programa "Hello.java". Mudaremos o contexto para esta pasta. Para entrar nesta pasta devemos utilizar o comando: cd [nome da pasta]. O comando "cd" significa "Change Directory". Digitaremos: $ cd myJavaPrograms Agora que estamos dentro da pasta onde o arquivo do programa est, poderemos ento compil-lo. Certifique-se de que o arquivo est realmente dentro desta, executando o comando ls (LS em minscula) novamente. Em Windows: Normalmente, quando abrimos uma janela terminal ela vai diretamente para sua pasta raiz (identificada por C:\). Para conhecer o contedo do diretrio digite dir (significando "directory") e pressione ENTER. Isso far com que sejam listados os arquivos e pastas da pasta principal. Verifique a existncia de uma pasta chamada "myJavaPrograms", criada a pouco, sendo esta o local em que foi salvo o programa "Hello.java". Mudaremos o contexto para esta pasta. Para entrar nesta pasta devemos utilizar o comando: cd [nome da pasta]. O comando "cd" significa "Change Directory". Digitaremos: C:\>cd myJavaPrograms
Agora que estamos dentro da pasta onde o arquivo do programa est, poderemos ento compil-lo. Certifique-se de que o arquivo est realmente dentro desta, executando o comando dir novamente. Passo 6: Compilar o programa Para compilar o programa, utilizamos o comando: javac [Nome do Arquivo]. Ou seja: javac Hello.java Durante a compilao, criado o arquivo: [Nome do Arquivo].class, neste caso, Hello.class, que contm o cdigo em linguagem de mquina (chamado de bytecode). Passo 7: Executar o programa Assumindo que no ocorreu problemas na compilao (caso tenha ocorrido qualquer problema refaa os passos realizados), estamos prontos para executar o programa. Para executar o programa, utilizamos o comando: java [nome do arquivo sem a extenso]. No caso do exemplo, digite: java Hello Veremos na mesma tela, em que foi executado o comando, a seguinte mensagem: Hello world!
3.2. Erros
Vimos um pequeno programa Java, geralmente no encontraremos qualquer problema para compilar e executar esses programas, entretanto nem sempre este o caso, como mencionamos na primeira parte deste curso, ocasionalmente encontramos erros durante esse processo. Como mencionamos antes, h dois tipos de erros: o primeiro pode ocorrer durante a compilao, chamado de erro de sintaxe, o segundo pode ocorrer durante a execuo, chamado runtime error.
Vamos retornar ao exemplo, o programa Hello.java. Intencionalmente, escreveremos a palavrachave "static" de forma errada e omitiremos o ponto-e-vrgula em uma instruo e a deixaremos errada. public class Hello { /** * Meu primeiro programa Java */ public statict void main(String[] args) { // A linha abaixo foi retirado o ; System.out.println("Hello world!") } } Salve o programa e execute os passos necessrios para compil-lo. Observe a mensagem de erro gerada ao se tentar compilar novamente o programa: Hello.java:6: <identifier> expected public statict void main(String[] args) { ^ Hello.java:10: ';' expected } ^ 1 error A primeira mensagem de erro sugere que existe um erro na linha 6 do programa apontado para apalavra void, entretanto esta palavra est correta. O erro na palavra anterior statict que deveser digitada como static. A segunda mensagem de erro sugere que faltou um ponto-e-vrgula na linha 10, entretanto, esta contm simplesmente o comando de fechar o bloco do mtodo main. O erro est exatamente na linha anterior. Como regra, ao encontrar muitas mensagens de erros devemos corrigir o primeiro erro da lista e tente novamente compilar o programa. Deste modo reduziremos o nmero total de mensagens de erro dramaticamente, pois podem existir o que chamamos de erros derivados, ou seja, um erro que tem por causa a instruo anterior.
4. Usando NetBeans
Construmos o programa sem utilizar nenhum recurso sofisticado, iremos aprender como fazertodo o processo da seo anterior utilizando uma IDE. Nesta parte da lio utilizaremos o NetBeans que um Ambiente de Desenvolvimento Integrado (IDE - Integrated Development Environment).
Um ambiente de desenvolvimento integrado um software aplicativo que possui uma interface construtora, um editor de texto, um editor de cdigo, um compilador e/ou interpretador e umdepurador. Passo 1 : executar o NetBeans Existem duas formas de executar o NetBeans: a primeira utilizando a linha de comandos de uma janela terminal e segunda selecionar o cone de atalho encontrado na janela da rea de trabalho. Para executar o NetBeans por intermdio da linha de comando, abra uma janela terminal (Os passos para abrir a janela terminal foram discutidos anteriormente) e digite:
Para o Windows, este comando deve ser executado na pasta em que o NetBeans foi instalado, por exemplo: C:\Program Files\netbeans-5.5\bin>netbeans A segunda maneira de executar o NetBeans clicando no cone de atalho encontrado na rea de trabalho do computador. Depois de abrir a IDE NetBeans ser mostrada a interface grfica GUI, conforme Figura 3:
Clique em File New Project, depois de fazer isso, uma janela de dilogo aparecer. Neste momento deve-se clicar em "Java Application" e em seguida clicar no boto "Next >".
Troque o local da aplicao clicando no boto "Browse...". Aparecer uma janela de dilogo para localizao do diretrio. D um clique duplo no seu diretrio home.
O contedo da raiz do diretrio ser apresentado. D um clique duplo no diretrio MYJAVAPROGRAMS e depois d um clique no boto "Open".
Veja que a localizao do projeto mudou para /home/florence/MYJAVAPROGRAMS. Finalmente, no campo "Create Main Class", digite "Hello", que ser o nome da classe principal, e em seguida clique no boto "Finish".
Passo 3: escrever os detalhes do programa Antes de escrever o programa descreveremos a janela principal. Como mostrado na figura 8, automaticamente, o NetBeans cria um cdigo bsico para o programa Java. Poderemos adicionar as declaraes neste cdigo gerado. No lado esquerdo da janela visualizamos uma lista de pastas e arquivos que o NetBeans gerou antes de criar o projeto. Tudo se encontra dentro da sua pasta MYJAVAPROGRAMS, onde foi configurado o local do projeto. No lado direito, visualizamos o cdigo gerado.
Modifique o cdigo gerado pelo NetBeans, por hora ignoraremos as outras partes das instrues discutindo os detalhes destas posteriormente. Insira a seguinte instruo: System.out.println("Hello world!"); Isto significa que voc deseja que seja mostrada a mensagem "Hello world!" na sada padro do computador, em seguida seja feito um salto de linha. Poderamos substituir esta instruo por duas equivalentes: System.out.print("Hello"); System.out.println(" world!"); O mtodo print() faz com que no seja provocado o salto de linha, utilizaremos para este exemplo a primeira instruo. Insira esta instruo aps a linha de comentrio (que ser desprezada pelo compilador): //TODO code application logic here.
Passo 4 : compilar o projeto Para compilar o programa, a partir do Menu Principal selecione Build Build Main Project, ou utilize a tecla de atalho F11, ou utilize o boto de atalho para compilar o cdigo.
Passo 5: Executar o projeto Para executar o programa, clique em Run Run Main Project, ou utilize a tecla de atalho F6, ouutilize o boto de atalho para executar o programa.
5. Exerccios
5.1 Melhorando o Hello World!
Utilizando o NetBeans crie uma classe chamada [SeuNome], o programa dever mostrar comoresultado a mensagem: Welcome to Java Programming [SeuNome]!!!
5.2. A rvore
Utilizando o NetBeans, crie uma classe chamada TheTree. O programa dever mostrar asseguintes linhas na sada: I think that I shall never see, [Eu acho que nunca verei,] a poem as lovely as a tree. [um poema to adorvel quanto uma rvore.] A tree whose hungry mouth is pressed [Uma rvore cuja boca faminta pressionada] Against the Earths sweet flowing breast. [Contra a Terra fluindo em seu seio docemente.]
Lio 2 1. Objetivos
Nesta lio iremos discutir um pouco da histria de Java e o que a tecnologia Java. Tambm iremos discutir as fases de um programa Java. Ao final desta lio, o estudante ser capaz de: Descrever as caractersticas da tecnologia Java como a JVM - Mquina Virtual Java, Garbage Collection e segurana do cdigo; Descrever as diferentes fases de um programa Java.
As prximas 3 linhas indicam um comentrio em Java. Um comentrio uma explicao do programador usada na documentao de uma parte do cdigo. Este comentrio no propriamente uma parte do cdigo, usado apenas para fins de documentao do programa. uma boa prtica de programao adicionar comentrios relevantes ao cdigo. /** * Meu primeiro programa em Java */ Um comentrio pode ser indicado pelos delimitadores /* e */. Qualquer coisa entre estes delimitadores ignorado pelo compilador Java e tratado como comentrio. A prxima linha, public static void main(String[] args) { que tambm pode ser escrita da seguinte forma: public static void main(String[] args) { indica o nome de um mtodo no programa que o mtodo principal main. O mtodo main o ponto de partida para qualquer programa feito em Java. Todo e qualquer programa escrito em Java, com exceo de Applets, inicia com o mtodo main. Certifique-se de que a assinatura do mtodo (conforme descrita acima) est correta. A linha seguinte tambm um comentrio em Java, // exibe a mensagem "Hello world" na tela At agora, j aprendemos duas maneiras de fazer comentrios em Java. Uma posicionar o comentrio entre /* e */, e a outra colocar // antes do comentrio. A linha de instruo abaixo, System.out.println("Hello world!"); escreve o texto "Hello World!" na tela. O comando System.out.println( ), escreve na sadapadro do computador o texto situado entre aspas duplas. As ltimas duas linhas, que contm somente uma chave em cada, simbolizam, respectivamente, o fechamento do mtodo main e da classe.
Dicas de programao :
1. Os programas em Java devem sempre conter a terminao .java no nome do arquivo. 2. O nome do arquivo deve sempre ser idntico ao nome da classe pblica. Ento, por exemplo, se o nome da classe pblica Hello o arquivo dever ser salvo com o nome: Hello.java. 3. Inserir comentrios sobre o que a classe ou mtodo realiza, isso facilitar o entendimento de quem posteriormente ler o programa, incluindo o prprio autor.
3. Comentrios em Java
Comentrios so notas escritas pelo programador para fins de documentao. Estas notas no fazem parte do programa e no afetam o fluxo de controle. Java suporta trs tipos de comentrios: comen-
trio de linha estilo C++, comentrio de bloco estilo C e um comentrio estilo Javadoc (utilizado compor a documentao do programa).
System.out.println("Hello world"); Um bloco formado por uma ou mais instrues agrupadas entre chaves indicando que formam uma s unidade. Blocos podem ser organizados em estruturas aninhadas indefinidamente. Qualquer quantidade de espaos em branco permitida. Um exemplo de bloco pode ser: public static void main(String[] args) { System.out.print("Hello "); System.out.println("world"); Dicas de programao: 1. Na criao de blocos, a chave que indica o incio pode ser colocada ao final da linha anterior ao bloco, como no exemplo: public static void main(String [] args) { ou na prxima linha, como em: public static void main(String [] args) { 2. uma boa prtica de programao organizar as instrues que sero colocadas apso incio de um bloco, como por exemplo: public static void main(String [] args) { System.out.print("Hello "); System.out.println("world"); }
5. Identificadores em Java
Identificadores so representaes de nomes de variveis, mtodos, classes, etc. Exemplos de identificadores podem ser: Hello, main, System, out. O compilador Java difere as letras maisculas de minsculas (case-sensitive). Isto significa que o identificador Hello no o mesmo que hello. Os identificadores em Java devem comear com uma letra, um underscore _, ou um sinal de cifro $. As letras podem estar tanto em maisculo quanto em minsculo. Os caracteres subseqentes podem usar nmeros de 0 a 9. Os identificadores no podem ter nomes iguais s palavras-chave ou palavras reservadas do Java, como: class, public, void, int, etc. Discutiremos mais sobre estas palavras mais tarde. Dicas de programao: 1. Para nomes de classes, a primeira letra deve ser maiscula. Nomes de mtodos ou variveis devem comear com letra minscula. Por exemplo: ExemploDeNomeDeUmaClasse exemploDeNomeDeUmMetodo 2. No caso de identificadores com mais de uma palavra, a primeira letra de cada palavra, com exceo da primeira, deve vir em maisculo. Por exemplo: charArray fileNumber - className 3. Evite o uso de undescores no incio de um identificador. Por exemplo: _NomeDeClasse.
6. Palavras-chave em Java
Palavras-chave so identificadores que, em Java, foram pr-definidas para propsitos especficos. No se pode usar esses identificadores como nomes de variveis, mtodos, classes, etc. A seguir, temos a lista com as palavras-chave em Java.
Ao longo dos tpicos seguintes, iremos abordar os significados destas palavras-chave e comoso usadas nos programas em Java.
Nota: true, false e null no so palavras-chave, porm, so palavras-reservadas, e, da mesma maneira, no permitido seu uso na atribuio a nomes de variveis, mtodos ou classes.
7.1. Boolean
Um dado boolean poder assumir somente dois valores: true ou false.
7.2. Character
Os characters so representaes da tabela Unicode. Um smbolo da tabela Unicode um valor de 16 bits que pode substituir os smbolos da tabela ASCII (que possuem 8 bits). A tabela Unicode permite a insero de smbolos especiais ou de outros idiomas. Para representar um caractere usam-se aspas simples. Por exemplo, a letra "a" ser representada como 'a'. Para representar caracteres especiais, usa-se a "\" seguido pelo cdigo do caractere especial. Por exemplo, '\n' para o caractere de nova linha, '\'' representar o character ' (aspas simples) e '\u0061' representao Unicode do smbolo 'a'.
7.3. Integer
Os dados do tipo integer vm em diferentes formatos: decimal (base 10), hexadecimal (base 16), e octal (base 8). Ao usar estes diferentes tipos de dados Integer nos programas necessrio seguir algumas notaes preestabelecidas. Para dados decimais no existe notao, basta escrever o nmero. Os nmeros hexadecimais devero ser precedidos por "0x" ou "0X". E os octais devero ser precedidos por "0". Por exemplo, considere o nmero 12. Sua representao em decimal apenas o nmero 12, sem nenhuma notao adicional, enquanto que sua representao em hexadecimal 0xC (pois o nmero 12 em hexadecimal representado pela letra C), e em octal ele representado por 014. O valor padro para tipos de dados Integer o tipo int. Um int um valor, com sinal, de 32 bits. Em alguns casos pode ser necessrio forar o dado Integer a ser do tipo long, para fazer isso basta colocar a letra "l" (L minscula) ou "L" aps o nmero. Um dado do tipo long um valor com sinal de 64 bits. Falaremos mais sobre os tipos de dados mais tarde.
7.4. Float-Point
Os tipos de float-point representam dados Integer com parte fracionria. Um exemplo o nmero 3.1415 (lembrando que o padro ingls utiliza o "." como divisor da parte fracionria). Esses tipos podem ser expressos em notao cientfica ou padro. Um exemplo de notao padro o nmero 583.45 enquanto que em notao cientfica ele seria representado por 5.8345e2. O valor padro para um dado ponto-flutuante o double, que um valor de 64 bits. Se for necessrio usar um nmero com uma preciso menor (32 bits) usa-se o float, que finalizado pela letra "f" ou "F" acrescida ao nmero em questo, por exemplo, 583.45f.
8.1. Lgico
O tipo boolean pode representar dois estados: true (verdadeiro) ou false (falso). Um exemplo : boolean resultado = true; No exemplo demonstrado acima, declarado um atributo chamado resultado do tipo boolean e atribudo a este o valor verdadeiro.
8.2. Inteiro
Os inteiros em Java podem ser representados em 5 formas, como j foi visto, e estas so: decimal, octal, hexadecimal, ASCII e Unicode. Como por exemplo: 2 // valor 2 em decimal 077 // 0 indica que ele est representado em octal. 0xBACC // 0x indica que ele est representado em hexadecimal. 'a' // representao ASCII '\u0061' // representao Unicode
O dado do tipo char um inteiro especial, sendo exclusivamente positivo e representa um nico Unicode. Ele deve ser, obrigatoriamente, colocado entre aspas simples (''). Sua representao como inteiro pode ser confusa para o iniciante, entretanto, o tempo e a prtica faro com que se acostume com este tipo. Por exemplo: char c = 97; // representa o smbolo 'a' byte b = 'a'; // em inteiro representa o nmero 97 possvel definir para qualquer inteiro nas formas mostradas. O que difere o tipo char dosdemais inteiros que a sua sada sempre ser mostrada como um valor ASCII. Enquanto que os inteiros sero sempre mostrados por nmeros decimais. Por exemplo: char c = 97; byte b = 'a'; System.out.println("char = " + c + " - byte = " + b); Resultar: char = a - byte = 97 Um cuidado deve ser tomado quanto aos inteiros: qualquer operao efetuada entre eles ter sempre como resultado um tipo int. Por exemplo: byte b1 = 1; byte b2 = 2; byte resultado = b1 + b2; Esta instruo final causar um erro de compilao, devendo ser modificada para: int resultado = b1 + b2;
Dicas de programao:
1. Para declarar um nmero como sendo um long prefervel usar L maisculo, pois, se este estiver em minsculo, pode ser difcil distingu-lo do dgito 1.
9. Variveis
Uma varivel um espao na memria usado para armazenar o estado de um objeto.Uma varivel deve ter um nome e um tipo. O tipo da varivel indica o tipo de dado que ela pode conter. O nome das variveis deve seguir as mesmas regras de nomenclatura que os identificadores.
nota: os valores colocados entre < > so obrigatrios, enquanto que os valores contidos entre [ ] so opcionais.
Aqui vemos um exemplo de programa que declara e inicializa algumas variveis: public class VariableSamples { public static void main( String[] args ){ // declara uma varivel com nome result e tipo boolean boolean result; // declara uma varivel com nome option e tipo char char option; // atribui o smbolo C para a varivel option = 'C'; // declara uma varivel com nome grade e tipo double // e a inicializa com o valor 0.0 double grade = 0.0; } } Dicas de programao: 1. sempre prefervel que se inicialize uma varivel assim que ela for declarada. 2. Use nomes com significado para suas variveis. Se usar uma varivel para armazenar a nota de um aluno, declare-a com o nome 'nota' e no simplesmente com uma letra aleatria 'x'. 3. prefervel declarar uma varivel por linha, do que vrias na mesma linha. Por exemplo: int variavel1; int variavel2; E no: int variavel1, variavel2;
A varivel (do tipo int) num o dado o atual valor contido por ela e, a referncia da varivel (do tipo string) nome somente armazenado o endereo de memria que contm o valor da varivel.
10. Operadores
Em Java temos diferentes tipos de operadores. Existem operadores aritmticos, operadores relacionais, operadores lgicos e operadores condicionais. Estes operadores obedecem a uma ordem de precedncia para que o compilador saiba qual operao executar primeiro, no caso de uma sentena possuir grande variedade destes.
public class ArithmeticDemo { public static void main(String[] args) { // alguns nmeros int i = 37; int j = 42; double x = 27.475; double y = 7.22; System.out.println("Variables values..."); System.out.println(" i = " + i); System.out.println(" j = " + j); System.out.println(" x = " + x);
System.out.println(" y = " + y); // adio dos nmeros System.out.println("Adding..."); System.out.println(" i + j = " + (i + j)); System.out.println(" x + y = " + (x + y)); // subtrao dos nmeros System.out.println("Subtracting..."); System.out.println(" i - j = " + (i - j)); System.out.println(" x - y = " + (x - y)); // multiplicao dos nmeros System.out.println("Multiplying..."); System.out.println(" i * j = " + (i * j)); System.out.println(" x * y = " + (x * y)); // diviso dos nmeros System.out.println("Dividing..."); System.out.println(" i / j = " + (i / j)); System.out.println(" x / y = " + (x / y)); // resto da diviso System.out.println("Comuting the remainder..."); System.out.println(" i % j = " + (i % j)); System.out.println(" x % y = " + (x % y)); // misturando operaes System.out.println("Mixing types..."); System.out.println(" j + y = " + (j + y)); System.out.println(" i * x = " + (i * x)); } }
Subtracting... i - j = -5 x - y = 20.255 Multiplying... i * j = 1554 x * y = 198.37 Dividing... i/j=0 x / y = 3.8054 Comuting the remainder... i % j = 37 x % y = 5.815 Mixing types... j + y = 49.22 i * x = 1016.58
Nota: Quando um nmero de tipo inteiro e um outro de nmero fracionrio so usados numa nica operao, o resultado ser dado pela varivel de maior tipo, no caso, valor de nmero fracionrio. O nmero inteiro implicitamente convertido para o nmero fracionrio antes da operao ter incio.
count++;
Como visto na tabela acima, os operadores de incremento e decremento podem ser usadostanto antes como aps o operando. E sua utilizao depender disso. Quando usado antes do operando, provoca acrscimo ou decrscimo de seu valor antes da avaliao da expresso em que ele aparece. Por exemplo:
public class RelationalDemo { public static void main(String[] args) { // alguns nmeros int i = 37; int j = 42; int k = 42; System.out.println("Variables values..."); System.out.println(" i = " + i); System.out.println(" j = " + j); System.out.println(" k = " + k); // maior que System.out.println("Greater than..."); System.out.println(" i > j = " + (i > j)); //false System.out.println(" j > i = " + (j > i)); //true System.out.println(" k > j = " + (k > j)); //false // maior ou igual a System.out.println("Greater than or equal to..."); System.out.println(" i >= j = " + (i >= j)); //false System.out.println(" j >= i = " + (j >= i)); //true System.out.println(" k >= j = " + (k >= j)); //true // menor que System.out.println("Less than..."); System.out.println(" i < j = " + (i < j)); //true System.out.println(" j < i = " + (j < i)); //false System.out.println(" k < j = " + (k < j)); //false // menor ou igual a System.out.println("Less than or equal to..."); System.out.println(" i <= j = " + (i <= j)); //true System.out.println(" j <= i = " + (j <= i)); //false System.out.println(" k <= j = " + (k <= j)); //true // igual a System.out.println("Equal to..."); System.out.println(" i == j = " + (i == j)); //false System.out.println(" k == j = " + (k == j)); //true // diferente System.out.println("Not equal to..."); System.out.println(" i != j = " + (i != j)); //true System.out.println(" k != j = " + (k != j)); //false
} }
A seguir temos a sada deste programa: Variables values...
i = 37 j = 42 k = 42
Greater than...
i == j = false k == j = true
Not equal to...
i != j = true k != j = false
x1 op x2
Onde x1 e x2 podem ser expresses, variveis ou constantes lgicas, e op pode tanto ser &&, &, ||, | ou ^.
A diferena bsica do operador && para & que o && suporta uma avaliao de curto-circuito (ou avaliao parcial), enquanto que o & no. O que isso significa? Dado o exemplo:
public class TestAND { public static void main( String[] args ) { int i = 0; int j = 10; boolean test = false; // demonstrao do operador && test = (i > 10) && (j++ > 9); System.out.println(i); System.out.println(j); System.out.println(test); // demonstrao do operador & test = (i > 10) & (j++ > 9); System.out.println(i); System.out.println(j);
A diferena bsica entre os operadores || e |, que, semelhante ao operador &&, o || tambm suporta a avaliao parcial. O que isso significa? Dada a expresso,
exp1 || exp2
o operador ou lgico ir avaliar a expresso exp1, e, imediatamente, retornar um valorlgico true para toda a expresso se a primeira parte for avaliada como verdadeira. Se a expresso exp1 resultar em verdadeira a segunda parte exp2 nunca ser avaliada, pois o valor final da expresso ser true independentemente do resultado da segunda expresso. O programa a seguir, mostra a utilizao destes operadores:
public class TestOR { public static void main( String[] args ){ int i = 0; int j = 10; boolean test = false; // demonstrao do operador ||
test = (i < 10) || (j++ > 9); System.out.println(i); System.out.println(j); System.out.println(test); // demonstrao do operador | test = (i < 10) | (j++ > 9); System.out.println(i); System.out.println(j); System.out.println(test);
} }
0 10 true 0 11 true
Note que a expresso j++ nunca ser avaliada na instruo que usa o operador ||, pois a primeira parte da expresso (i<10) j retorna true como valor final da expresso.
O resultado de uma expresso usando o operador ou exclusivo binrio ter um valor true somente se uma das expresses for verdadeira e a outra falsa. Note que ambos os operandos so necessariamente avaliados pelo operador ^. O programa a seguir, mostra a utilizao deste operador:
public class TestXOR { public static void main( String[] args ){ boolean val1 = true; boolean val2 = true;
} }
System.out.println(val1 ^ val2); val1 = false; val2 = true; System.out.println(val1 ^ val2); val1 = false; val2 = false; System.out.println(val1 ^ val2); val1 = true; val2 = false; System.out.println(val1 ^ val2);
13.4. ! (negao)
O operador de negao inverte o resultado lgico de uma expresso, varivel ou constante, ou seja, o que era verdadeiro ser falso e vice-versa. O programa a seguir, mostra a utilizao deste operador:
public class TestNOT { public static void main( String[] args ){ boolean val1 = true; boolean val2 = false; System.out.println(!val1); System.out.println(!val2); } }
Como resultado, o programa produzir a seguinte sada:
false true
exp1?exp2:exp3
Onde exp1 uma expresso lgica que deve retornar true ou false. Se o valor de exp1 for verdadeiro, ento, o resultado ser a expresso exp2, caso contrrio, o resultado ser exp3. O programa a seguir, mostra a utilizao deste operador:
public class ConditionalOperator { public static void main( String[] args ){ String status = ""; int grade = 80; //status do aluno status = (grade >= 60)?"Passed":"Fail"; //print status System.out.println( status );
} }
Passed
Veremos na Figura 2 um fluxograma que demonstra como o operador condicional funciona.
public class ConditionalOperator { public static void main( String[] args ){ int score = 0; char answer = 'a'; score = (answer == 'a') ? 10 : 0; System.out.println("Score = " + score ); } }
Como resultado, o programa produzir a seguinte sada:
Score = 10
Ta-
No caso de dois operadores com mesmo nvel de precedncia, ter prioridade o que estivermais esquerda da expresso. Dada uma expresso complexa como:
6%2*5+4/2+88-10
O ideal seria fazer uso de parnteses para reescrev-la de maneira mais clara:
((6%2)*5)+(4/2)+88-10
Dicas de programao: 1. Para evitar confuso na avaliao de suas expresses matemticas, deixe-as o mais simples possvel e use parnteses.
16. Exerccios
16.1. Declarar e mostrar variveis
Dada a tabela abaixo, declare as variveis que se seguem de acordo com seus tipos correspondentes e valores iniciais. Exiba o nomes e valor das variveis.
number = 10 letter = a result = true str = hello 16.2. Obter a mdia entre trs nmeros
Crie um programa que obtenha a mdia de 3 nmeros. Considere o valor para os trs nmeroscomo sendo 10, 20 e 45. O resultado esperado do exerccio :
nmero 1 com o valor 10 nmero 2 com o valor 20 nmero 3 com o valor 45 A mdia 25 16.3. Exibir o maior valor
Dados trs nmeros, crie um programa que exiba na tela o maior dentre os nmeros informados. Use o operador ?: que j foi estudado nesta sesso ( dica: ser necessrio utilizar dois operadores ?: para se chegar ao resultado). Por exemplo, dados os nmeros 10, 23 e 5, o resultado esperado do exerccio deve ser:
nmero 1 com o valor 10 nmero 2 com o valor 23 nmero 3 com o valor 5 O maior nmero 23 16.4. Precedncia de operadores
Dadas as expresses abaixo, reescreva-as utilizando parnteses de acordo com a forma comoelas so interpretadas pelo compilador.
1. a / b ^ c ^ d e + f g * h + i 2. 3 * 10 *2 / 15 2 + 4 ^ 2 ^ 2
3. r ^ s * t / u v + w ^ x y++
Lio 3 1. Objetivos
Agora que j estudamos alguns conceitos bsicos e escrevemos alguns cdigos simples, vamos fazer as aplicaes ficarem mais interativas comeando com a captura de dados digitados pelo usurio. Nesta lio, discutiremos trs modos de obter dados de entrada (input). O primeiro atravs do uso da classe BufferedReader do pacote java.util; o segundo, atravs do uso da nova classe Scanner no mesmo pacote; e, por fim, envolveremos a utilizao da interface grfica utilizando JOptionPane. Ao final desta lio, o estudante ser capaz de:
Criar cdigos para a captura de dados pelo teclado. Usar a classe BufferedReader para captura, atravs de uma janela de console, dos dados digitados
no teclado. Utilizar a classe Scanner para captura, atravs de uma janela de console, dos dados digitados no teclado. Utilizar a classe JOptionPane para captura, atravs da uma interface grfica, dos dados digitados no teclado.
try { name = dataIn.readLine(); } catch (IOException e) { System.out.println("Error!"); } System.out.println("Hello " + name +"!"); } } Faremos uma anlise deste programa linha por linha: import java.io.BufferedReader; import java.io.InputStreamReader; import java.io.IOException; Estas linhas acima mostram que estamos utilizando as classes BufferedReader, InputStreamReader e IOException cada qual dentro do pacote java.io. Essas APIs ou Interfaces de Programao de Aplicaes (Application Programming Interface) contm centenas de classes pr-definidas que se pode usar nos programas. Essas classes so organizadas dentro do que chamamos de pacotes. Pacotes contm classes que se relacionam com um determinado propsito. No exemplo, o pacote java.io contm as classes que permitem capturar dados de entrada e sada. Estas linhas poderiam ser reescritas da seguinte forma: import java.io.*; que importar todas as classes encontradas no pacote java.io, deste modo possvel utilizar todas classes desse pacote no programa. As prximas linhas: public class GetInputFromKeyboard { public static void main( String[] args ) { j foram discutidas na lio anterior. Isso significa que declaramos uma classe nomeada GetInputFromKeyboard e, em seguida, iniciamos o mtodo principal (main). Na instruo: BufferedReader dataIn = new BufferedReader(new InputStreamReader(System.in)); declaramos a varivel dataIn do tipo BufferedReader. No se preocupe com o significado da sintaxe, pois ser abordado mais frente. A seguir, declaramos a varivel name do tipo String: String name = ""; na qual armazenaremos a entrada de dados digitada pelo usurio. Note que foi inicializada como uma String vazia "". uma boa prtica de programao inicializar as variveis quando declaradas. Na prxima instruo, solicitamos que o usurio escreva um nome: System.out.print("Please Enter Your Name:");
As seguinte linhas definem um bloco try-catch: try { name = dataIn.readLine(); } catch (IOException e) { System.out.println("Error!"); } que asseguram, caso ocorram excees sero tratadas. Falaremos sobre o tratamento de excees na ltima parte deste curso. Por hora, necessrio adicionar essas linhas para utilizar o mtodo readLine() e receber a entrada de dados do usurio. Em seguida: name = dataIn.readLine(); capturamos a entrada dos dados digitados pelo usurio e as enviamos para a varivel String criada anteriormente. A informao guardada na varivel name. Como ltima instruo: System.out.println("Hello " + name + "!"); montamos a mensagem final para cumprimentar o usurio.
Definimos uma varivel, denominada sc, que ser criada a partir da classe Scanner e direcionada para a entrada padro: Scanner sc = new Scanner(System.in); De forma semelhante, mostramos uma mensagem solicitando informao do usurio: System.out.println("Please Enter Your Name:"); Utilizamos a varivel sc para chamarmos o mtodo que far o recebimento dos dados digitados: String name = sc.nextLine(); A classe Scanner possui diversos mtodos que podem ser utilizados para realizar este servio. Os principais mtodos que podemos utilizar, neste caso, so: Mtodo next() nextInt() nextByte() nextLong() nextFloat() nextDouble() Finalidade Aguarda uma Aguarda uma Aguarda uma Aguarda uma Aguarda uma Aguarda uma entrada entrada entrada entrada entrada entrada em em em em em em formato formato formato formato formato formato String Inteiro Inteiro Inteiro Longo Nmero Fracionrio Nmero Fracionrio
Por fim, mostramos o resultado e encerramos o mtodo main e a classe: System.out.println("Hello " + name +"!"); } }
A primeira instruo: import javax.swing.JOptionPane; mostra que estamos importando a classe JOptionPane do pacote javax.swing. Poderamos, de forma semelhante, escrever estas instrues do seguinte modo: import javax.swing.*; A instruo seguinte: name = JOptionPane.showInputDialog("Please enter your name"); cria uma caixa de entrada que exibir um dilogo com uma mensagem, um campo de texto para receber os dados do usurio e um boto OK, conforme mostrado na figura 1. O resultado ser armazenado na varivel do tipo String name. Na prxima instruo, criamos uma mensagem de cumprimento, que ficar armazenada na varivel msg: String msg = "Hello " + name + "!"; Finalizando a classe, exibiremos uma janela de dilogo que conter a mensagem e o boto de OK, conforme mostrado na figura 3. JOptionPane.showMessageDialog(null, msg);
5. Exerccios
5.1. As 3 palavras (verso Console)
Utilizando a classe BufferedReader ou Scanner, capture trs palavras digitadas pelo usurio e mostre-as como uma nica frase na mesma linha. Por exemplo:
Lio 4
1. Objetivos
Nas lies anteriores, foram mostrados programas seqenciais, onde as instrues foram executadas uma aps a outra de forma fixa. Nesta lio, discutiremos estruturas de controle que permitem mudar a ordem na qual as instrues so executadas. Ao final desta lio, o estudante ser capaz de:
Usar estruturas de controle de deciso (if e switch) que permitem a seleo de partes especficas do cdigo para execuo Usar estruturas de controle de repetio (while, do-while e for) que permitem a repetio da execuo de partes especficas do cdigo Usar declaraes de interrupo (break, continue e return) que permitem o redirecionamento do fluxo do programa
2.1. Declarao if
A declarao if especifica que uma instruo ou bloco de instrues seja executado se, esomente se, uma expresso lgica for verdadeira. A declarao if possui a seguinte forma: if (expresso_lgica) instruo; ou: if (expresso_lgica) { instruo1; instruo2 ... } onde, expresso_lgica representa uma expresso ou varivel lgica.
If
Por exemplo, dado o trecho de cdigo: int grade = 68; if (grade > 60) System.out.println("Congratulations!"); ou: int grade = 68; if (grade > 60) { System.out.println("Congratulations!"); System.out.println("You passed!"); }
Dicas de programao:
1. Expresso lgica uma declarao que possui um valor lgico. Isso significa que a execuo desta expresso deve resultar em um valor true ou false. 2. Coloque as instrues de forma que elas faam parte do bloco if. Por exemplo: if (expresso_lgica) { // instruo1; // instruo2; }
if (expresso_lgica) instruo_caso_verdadeiro; else instruo_caso_falso; Tambm podemos escrev-la na forma abaixo: if (expresso_lgica) { instruo_caso_verdadeiro1; instruo_caso_verdadeiro2; ... } else { instruo_caso_falso1; instruo_caso_falso2; ... } Por exemplo, dado o trecho de cdigo: int grade = 68; if (grade > 60) System.out.println("Congratulations! You passed!"); else System.out.println("Sorry you failed"); ou: int grade = 68; if (grade > 60) { System.out.print("Congratulations! "); System.out.println("You passed!"); } else { System.out.print("Sorry "); System.out.println("you failed"); }
Dicas de programao:
1. Para evitar confuso, sempre coloque a instruo ou instrues contidas no bloco if ou if-else entre chaves {}. 2. Pode-se ter declaraes if-else dentro de declaraes if-else, por exemplo: if (expresso_lgica) { if (expresso_lgica) { ... } else { ... } } else { ... }
Observe um exemplo da declarao if-else-if no seguinte trecho de cdigo: public class Grade { public static void main( String[] args ) { double grade = 92.0; if (grade >= 90) { System.out.println("Excellent!"); } else if((grade < 90) && (grade >= 80)) { System.out.println("Good job!"); } else if((grade < 80) && (grade >= 60)) { System.out.println("Study harder!"); } else { System.out.println("Sorry, you failed."); } } }
a varivel number no tem valor lgico. 2. Usar = (sinal de atribuio) em vez de == (sinal de igualdade) para comparao. Por exemplo: // ERRADO int number = 0; if (number = 0) { // algumas instrues aqui } 3. Escrever elseif em vez de else if. // ERRADO int number = 0; if (number == 0) // algumas } elseif (number // algumas }
Se nenhum dos valores case for satisfeito, o bloco default ser executado. Este um bloco opcional. O bloco default no obrigatrio na declarao switch.
Notas:
1. Ao contrrio da declarao if, mltiplas instrues so executadas sem a necessidade das chaves que determinam o incio e trmino de bloco {}. 2. Quando um case for selecionado, todas as instrues vinculadas ao case sero executadas. Alm disso, as instrues dos case seguintes tambm sero executadas. 3. Para prevenir que o programa execute instrues dos outros case subseqentes, utilizamos a declarao break aps a ltima instruo de cada case.
Dicas de Programao:
1. A deciso entre usar uma declarao if ou switch subjetiva. O programador pode decidir com base na facilidade de entendimento do cdigo, entre outros fatores. 2. Uma declarao if pode ser usada para decises relacionadas a conjuntos, escalas de variveis ou condies, enquanto que a declarao switch pode ser utilizada para situaes que envolvam varivel do tipo inteiro. Tambm necessrio que o valor de cada clusula case seja nico.
Compile e execute o programa acima e veremos que o resultado ser: Sorry, you failed. pois a varivel grade possui o valor 92 e nenhuma das opes case atende a essa condio. Note que para o caso de intervalos a declarao if-else-if mais indicada.
As instrues contidas dentro do bloco while so executadas repetidas vezes enquanto o valorde expresso_lgica for verdadeira. Por exemplo, dado o trecho de cdigo:
int i = 4; while (i > 0){ System.out.print(i); i--; } O cdigo acima ir imprimir 4321 na tela. Se a linha contendo a instruo i-- for removida,teremos uma repetio infinita, ou seja, um cdigo que no termina. Portanto, ao usar laos while, ou qualquer outra estrutura de controle de repetio, tenha a certeza de utilizar uma estrutura de repetio que encerre em algum momento. Abaixo, temos outros exemplos de declaraes while: Exemplo 1: int x = 0; while (x<10) { System.out.println(x); x++; } Exemplo 2: // lao infinito while (true) System.out.println("hello"); Exemplo 3: // a instruo do lao no ser executada while (false) System.out.println("hello");
Inicialmente, as instrues dentro do lao do-while so executadas. Ento, a condio naexpresso_lgica avaliada. Se for verdadeira, as instrues dentro do lao do-while sero executadas novamente. A diferena entre uma declarao while e do-while que, no lao while, a avaliao da expresso lgica feita antes de se executarem as instrues nele contidas enquanto que, no lao do-while, primeiro se executam as instrues e depois realiza-se a avaliao da expresso lgica, ou seja, as instrues dentro em um lao do-while so executadas pelo menos uma vez. Abaixo, temos alguns exemplos que usam a declarao do-while: Exemplo 1: int x = 0; do { System.out.println(x); x++; } while (x<10); Este exemplo ter 0123456789 escrito na tela. Exemplo 2: // lao infinito do { System.out.println("hello"); } while(true); Este exemplo mostrar a palavra hello escrita na tela infinitas vezes. Exemplo 3: // Um lao executado uma vez do System.out.println(hello); while (false); Este exemplo mostrar a palavra hello escrita na tela uma nica vez.
Dicas de programao:
1. Erro comum de programao ao utilizar o lao do-while esquecer o ponto-evrgula (;) aps a declarao while. do { ... } while (boolean_expression) // ERRADO -> faltou ; 2. Como visto para a declarao while, tenha certeza que a declarao do-while poder terminar em algum momento.
A declarao for possui a seguinte forma: for (declarao_inicial; expresso_lgica; salto) { instruo1; instruo2; ... } onde:
declarao_inicial inicializa uma varivel para o lao expresso_lgica compara a varivel do lao com um valor limite salto atualiza a varivel do lao
Um exemplo para a declarao for : for (int i = 0; i < 10; i++) { System.out.print(i); } Neste exemplo, uma varivel i, do tipo int, inicializada com o valor zero. A expresso lgica "i menor que 10" avaliada. Se for verdadeira, ento a instruo dentro do lao executada. Aps
isso, a expresso i ter seu valor adicionado em 1 e, novamente, a condio lgica ser avaliada. Este processo continuar at que a condio lgica tenha o valor falso. Este mesmo exemplo, utilizando a declarao while, mostrado abaixo: int i = 0; while (i < 10) { System.out.print(i); i++; }
4. Declaraes de Interrupo
Declaraes de interrupo permitem que redirecionemos o fluxo de controle do programa. A linguagem Java possui trs declaraes de interrupo. So elas: break, continue e return.
Neste exemplo, se a String Yza for encontrada, a declarao for ser interrompida e o controle do programa ser transferido para a prxima instruo abaixo da declarao for. 4.1.2. Declarao labeled break A forma labeled de uma declarao break encerra o processamento de um lao que identificado por um label especificado na declarao break. Um label, em linguagem Java, definido colocando-se um nome seguido de dois-pontos, como por exemplo: teste: esta linha indica que temos um label com o nome teste. O programa a seguir realiza uma pesquisa de um determinado valor em um array bidimensional. Dois laos so criados para percorrer este array. Quando o valor encontrado, um labeled break termina a execuo do lao interno e retorna o controle para o lao mais externo.
int[][] numbers = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}; int searchNum = 5; boolean foundNum = false; searchLabel: for (int i=0; i<numbers.length; i++) { for (int j=0; j<numbers[i].length; j++) { if (searchNum == numbers[i][j]) { foundNum = true; break searchLabel; } } // final do lao j } // final do lao i if (foundNum) { System.out.println(searchNum + " found!"); } else { System.out.println(searchNum + " not found!"); }
A declarao break, ao terminar a declarao for, no transfere o controle do programa aofinal de seu lao, controlado pela varivel j. O controle do programa segue imediatamente para a declarao for marcada com o label, neste caso, interrompendo o lao controlado pela varivel i.
A forma labeled da declarao continue interrompe a repetio atual de um lao e salta para a repetio exterior marcada com o label indicado. outerLoop: for (int i=0; i<5; i++) { for (int j=0; j<5; j++) { System.out.println("Inside for(j) loop"); // mensagem1 if (j == 2) continue outerLoop; } System.out.println("Inside for(i) loop"); // mensagem2 } Neste exemplo, a mensagem 2 nunca ser mostrada, pois a declarao continue outerloop interromper este lao cada vez que j atingir o valor 2 do lao interno.
5. Exerccios
5.1. Notas
Obtenha do usurio trs notas de exame e calcule a mdia dessas notas. Reproduza a mdia dos trs exames. Junto com a mdia, mostre tambm um :-) no resultado se a mdia for maior ou igual a 60; caso contrrio mostre :-( Faa duas verses deste programa:
1. Use a classe BufferedReader (ou a classe Scanner) para obter as notas do usurio, e System.out para mostrar o resultado. 2. Use JOptionPane para obter as notas do usurio e para mostrar o resultado.
5.4. Potncias
Receba como entrada um nmero e um expoente. Calcule este nmero elevado ao expoente. Faa trs verses deste programa: 1. Use uma declarao while para resolver este problema 2. Use uma declarao do-while para resolver este problema 3. Use uma declarao for para resolver este problema
Lio 5 1. Objetivos
Nesta lio, abordaremos Array em Java. Primeiro, definiremos o que array e, ento, discutiremos como declar-los e us-los. Ao final desta lio, o estudante ser capaz de:
Declarar e criar array Acessar elementos de um array Determinar o nmero de elementos de um array Declarar e criar array multidimensional
2. Introduo a Array
Em lies anteriores, discutimos como declarar diferentes variveis usando os tipos de dados primitivos. Na declarao de variveis, freqentemente utilizamos um identificador ou um nome e um tipo de dados. Para se utilizar uma varivel, deve-se cham-la pelo nome que a identifica. Por exemplo, temos trs variveis do tipo int com diferentes identificadores para cada varivel: int number1; int number2; int number3; number1 = 1; number2 = 2; number3 = 3; Como se v, inicializar e utilizar variveis pode torna-se uma tarefa tediosa, especialmente se elas forem utilizadas para o mesmo objetivo. Em Java, e em outras linguagens de programao, pode-se utilizar uma varivel para armazenar e manipular uma lista de dados com maior eficincia. Este tipo de varivel chamado de array. Um array armazena mltiplos itens de um mesmo tipo de dado em um bloco contnuo de memria, dividindo-o em certa quantidade de posies. Imagine um array como uma varivel esticada que tem um nome que a identifica e que pode conter mais de um valor para esta mesma varivel.
3. Declarando Array
Array precisa ser declarados como qualquer varivel. Ao declarar um array, defina o tipo de dados deste seguido por colchetes [] e pelo nome que o identifica. Por exemplo: int [] ages; ou colocando os colchetes depois do identificador. Por exemplo: int ages[]; Depois da declarao, precisamos criar o array e especificar seu tamanho. Este processo chamado de construo (a palavra, em orientao a objetos, para a criao de objetos). Para se construir um objeto, precisamos utilizar um construtor. Por exemplo:
// declarao int ages[]; // construindo ages = new int[100]; ou, pode ser escrito como: // declarar e construir int ages[] = new int[100]; No exemplo, a declarao diz ao compilador Java que o identificador ages ser usado comoum nome de um array contendo inteiros, usadopara criar, ou construir, um novo array contendo 100 elementos. Em vez de utilizar uma nova linha de instruo para construir um array, tambm possvel automaticamente declarar, construir e adicionar um valor uma nica vez. Exemplos: // criando um array de valores lgicos em uma // results. Este array contm 4 elementos que // inicializados com os valores {true, false, boolean results[] ={ true, false, true, false varivel so true, false} };
// criando um array de 4 variveis double inicializados // com os valores {100, 90, 80, 75}; double []grades = {100, 90, 80, 75}; // criando um array de Strings com identificador days e // tambm j inicializado. Este array contm 7 elementos String days[] = {"Mon","Tue","Wed","Thu","Fri","Sat","Sun"}; Uma vez que tenha sido inicializado, o tamanho de um array no pode ser modificado, pois armazenado em um bloco contnuo de memria.
Para acessar um elemento do array, ou parte de um array, utiliza-se um nmero inteirochamado de ndice.Um ndice atribudo para cada membro de um array, permitindo ao programa e ao programador acessar os valores individualmente quando necessrio. Os nmeros dos ndices so sempre inteiros. Eles comeam com zero e progridem seqencialmente por todas as posies at o fim do array. Lembre-se que os elementos dentro do array possuem ndice de 0 a tamanhoDoArray-1. Por exemplo, dado o array ages que declaramos anteriormente, temos: // atribuir 10 ao primeiro elemento do array ages[0] = 10; // imprimir o ltimo elemento do array System.out.print(ages[99]); Lembre-se que o array, uma vez declarado e construdo, ter o valor de cada membro inicializado automaticamente. Conforme a seguinte tabela:
Tipo primitivo boolean byte, short e int char long float double
Entretanto, tipos de dados por referncia, como as Strings, no sero inicializados caracteres em branco ou com uma string vazia "", sero inicializados com o valor null. Deste modo, o ideal preencher os elementos do arrays de forma explcita antes de utiliz-los. A manipulao de objetos nulos pode causar a desagradvel surpresa de uma exceo do tipo NullPointerException, por exemplo, ao tentar executar algum mtodo da classe String, conforme o exemplo a seguir: public class ArraySample { public static void main(String[] args){ String [] nulls = new String[2]; System.out.print(nulls[0]); // Linha correta, mostra null System.out.print(nulls[1].trim()); // Causa erro } }
O cdigo abaixo utiliza uma declarao for para mostrar todos os elementos de um array. public class ArraySample { public static void main(String[] args){ int[] ages = new int[100]; for (int i = 0; i < 100; i++) { System.out.print(ages[i]); } } }
Dicas de programao:
1. Normalmente, melhor inicializar, ou instanciar, um array logo aps declar-lo. Por exemplo, a instruo: int []arr = new int[100]; prefervel, ao invs de: int [] arr; arr = new int[100]; 2. Os elementos de um array de n elementos tem ndices de 0 a n-1. Note que no existe o elemento arr[n]. A tentativa de acesso a este elemento causar uma exceo do tipo ArrayIndexOutOfBoundsException, pois o ndice deve ser at n-1. 3. No possvel modificar o tamanho de um array.
5. Tamanho do Array
Para se obter o nmero de elementos de um array, pode-se utilizar o atributo length. O atributo length de um array retorna seu tamanho, ou seja, a quantidade de elementos. utilizado como no cdigo abaixo: nomeArray.length Por exemplo, dado o cdigo anterior, podemos reescrev-lo como: public class ArraySample { public static void main (String[] args) { int[] ages = new int[100]; for (int i = 0; i < ages.length; i++) { System.out.print(ages[i]); } } }
Dicas de programao:
1. Quando criar laos com for para o processamento de um array, utilize o campo length como argumento da expresso lgica. Isto ir permitir ao lao ajustarse, automaticamente para tamanhos de diferentes arrays. 2. Declare o tamanho dos arrays utilizando variveis do tipo constante para facilitar alteraes posteriores. Por exemplo: final int ARRAY_SIZE = 1000; // declarando uma constante ... int[] ages = new int[ARRAY_SIZE];
6. Arrays Multidimensionais
Arrays multidimensionais so implementados como arrays dentro de arrays. So declarados ao atribuir um novo conjunto de colchetes depois do nome do array. Por exemplo: // array inteiro de 512 x 128 elementos int [][] twoD = new int[512][128]; // array de caracteres de 8 x 16 x 24 char [][][] threeD = new char[8][16][24]; // array de String de 4 linhas x 2 colunas String [][] dogs = {{"terry", "brown"}, {"Kristin", "white"}, {"toby", "gray"}, {"fido", "black"}}; Acessar um elemento em um array multidimensional semelhante a acessar elementos em um array de uma dimenso. Por exemplo, para acessar o primeiro elemento da primeira linha do array dogs, escreve-se: System.out.print(dogs[0][0]); Isso mostrar a String "terry" na sada padro. Caso queira mostrar todos os elementos deste array, escreve-se: for (int i = 0; i < dogs.length; i++) { for (int j = 0; j < dogs[i].length; j++) { System.out.print(dogs[i][j] + " "); } }
7. Exerccios
7.1. Dias da semana
Criar um array de Strings inicializado com os nomes dos sete dias da semana. Por exemplo: String days[] = {"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"}; Usando uma declarao while, imprima todo o contedo do array. Faa o mesmo para as declaraes do-while e for.
Dado o seguinte array multidimensional, que contm as entradas da agenda telefnica: String entry = {{"Florence", "735-1234", "Manila"}, {"Joyce", "983-3333", "Quezon City"}, {"Becca", "456-3322", "Manila"}}; mostre-as conforme o formato abaixo: Name : Florence Tel. # : 735-1234 Address: Manila Name : Joyce Tel. # : 983-3333 Address: Quezon City Name : Becca Tel. # : 456-3322 Address: Manila
Lio 6 1. Objetivos
Nesta lio, aprenderemos sobre como processar a entrada que vem da linha de comando usando argumentos passados para um programa feito em Java. Ao final desta lio, o estudante ser capaz de: Utilizar o argumento de linha de comando Receber dados enviados pelo usurio utilizando os argumentos de linha de comando Aprender como passar argumentos para os programas no NetBeans
if (args.length > 0) { firstArg = Integer.parseInt(args[0]); } parseInt dispara uma exceo do tipo NumberFormatException se o contedo do elemento arg[0] no for um nmero.
Dicas de programao:
1. Antes de usar os argumentos de linha de comando, observe a quantidade de argumentos passados para a aplicao. Deste modo, nenhuma exceo ser disparada.
D um clique com o boto direito do mouse no cone CommandLineExample, conformedestacado na Figura 1. Um menu aparecer, conforme a Figura 2. Selecione a opo "Properties".
Running Project.
Na caixa de texto dos argumentos, digite os argumentos que se quer passar para o programa. Neste caso, digitamos os argumentos 5 4 3 2 1. Pressione o boto OK.
Execute o projeto.
Como pode-se ver, a sada do projeto a quantidade de argumentos, que 5, e o primeiro argumento passado, que tambm 5.
4. Exerccios
4.1. Argumentos de Exibio
Utilizando os dados passados pelo usurio atravs dos argumentos de linha de comando, exiba os argumentos recebidos. Por exemplo, se o usurio digitar: java Hello world that is all o programa dever mostrar na tela: world that is all
se o usurio digitar: java ArithmeticOperation 20 4 o programa dever mostrar na tela: sum = 24 subtraction = 16 multiplication = 80 division = 5
Lio 7 1. Objetivos
Nesta lio, abordaremos alguns conceitos bsicos da Programao Orientada a Objetos ou POO. Mais adiante, discutiremos o conceito de classes e objetos e como usar as classes e seus membros. Comparao, converso e casting de objetos, tambm sero vistos. Por enquanto, o foco ser o uso das classes j definidas nas bibliotecas Java e, posteriormente, discutiremos como criar nossas prprias classes. Ao final desta lio, o estudante ser capaz de:
Explicar o que Programao Orientada a Objetos e alguns dos seus conceitos Diferenciar entre classes e objetos Diferenciar atributos e mtodos de objeto de atributos e mtodos de classe Explicar o que so mtodos, como invoc-los e como enviar argumentos Identificar o escopo de um atributo Realizar converses entre tipos de dados primitivos e entre objetos Comparar objetos e determinar suas classes
Leo
Com tais descries, os objetos do mundo fsico podem ser facilmente modelados como objetos de software usando as propriedades como atributos e os comportamentos como mtodos. Estes atributos e mtodos podem ser usados em softwares de jogos ou interativos para simular objetos do mundo real! Por exemplo, poderia ser um objeto de 'carro' numa competio de corrida ou um objeto de 'leo' num aplicativo educacional de zoologia para crianas.
3. Classes e Objetos
3.1. Diferenas entre Classes e Objetos
No mundo do computador, um objeto um componente de software cuja estrutura similar a um objeto no mundo real. Cada objeto composto por um conjunto de atributos (propriedades) que so as variveis que descrevem as caractersticas essenciais do objeto e, consiste tambm, num conjunto de mtodos (comportamentos) que descrevem como o objeto se comporta. Assim, um objeto uma coleo de atributos e mtodos relacionados. Os atributos e mtodos de um objeto Java so formalmente conhecidos como atributos e mtodos de objeto, para distinguir dos atributos e mtodos de classes, que sero discutidos mais adiante. A classe a estrutura fundamental na Programao Orientada a Objetos. Ela pode ser pensada como um gabarito, um prottipo ou, ainda, uma planta para a construo de um objeto. Ela consiste em dois tipos de elementos que so chamados atributos (ou propriedades) e mtodos. Atributos especificam os tipos de dados definidos pela classe, enquanto que os mtodos especificam as operaes. Um objeto uma instncia de uma classe. Para diferenciar entre classes e objetos, vamos examinar um exemplo. O que temos aqui uma classe Carro que pode ser usada pra definir diversos objetos do tipo carro. Na tabela mostrada abaixo, Carro A e Carro B so objetos da classe Carro. A classe tem os campos nmero da placa, cor, fabricante e velocidade que so preenchidos com os valores correspondentes do carro A e B. O carro tambm tem alguns mtodos: acelerar, virar e frear.
Quando construdos, cada objeto adquire um conjunto novo de estado. Entretanto, as implementaes dos mtodos so compartilhadas entre todos os objetos da mesma classe. As classes fornecem o benefcio do Reutilizao de Classes (ou seja, utilizar a mesma classe em vrios projetos). Os programadores de software podem reutilizar as classes vrias vezes para criar os objetos.
3.2. Encapsulamento
Encapsulamento um princpio que prope ocultar determinados elementos de uma classe das demais classes. Ao colocar uma proteo ao redor dos atributos e criar mtodos para prover o acesso a estes, desta forma estaremos prevenindo contra os efeitos colaterais indesejados que podem afetlos ao ter essas propriedades modificadas de forma inesperada. Podemos prevenir o acesso aos dados dos nossos objetos declarando que temos controle desse acesso. Aprenderemos mais sobre como Java implementa o encapsulamento quando discutirmos mais detalhadamente sobre as classes.
O operador new aloca a memria para o objeto e retorna uma referncia para essa alocao. Ao criar um objeto, invoca-se, na realidade, o construtor da classe. O construtor um mtodo onde todas as inicializaes do objeto so declaradas e possui o mesmo nome da classe.
4. Mtodos
4.1. O que so mtodos e porque usar mtodos?
Nos exemplos apresentados anteriormente, temos apenas um mtodo, o mtodo main(). Em Java, ns podemos definir vrios mtodos e podemos cham-los a partir de outros mtodos. Um mtodo um trecho de cdigo distinto que pode ser chamado por qualquer outro mtodo para realizar alguma funo especfica. Mtodos possuem as seguintes caractersticas:
Podem ou no retornar um valor; Podem aceitar ou no argumentos; Aps o mtodo encerrar sua execuo, o fluxo de controle retornado a quem o chamou.
O que necessrio para se criar mtodos? Porque no colocamos todas as instrues dentro de um grande mtodo? O foco destas questes chamado de decomposio. Conhecido o problema, ns o separamos em partes menores, que torna menos crtico o trabalho de escrever grandes classes.
Retorna o caractere especificado no ndice. Um ndice vai de 0 at length() - 1. O primeiro caractere da seqncia est no ndice 0, o seguinte, no ndice 1, e assim sucessivamente por todo o array. public boolean equalsIgnoreCase (String anotherString) Compara o contedo de duas Strings, ignorando maisculas e minsculas. Duas strings so consideradas iguais quando elas tm o mesmo tamanho e os caracteres das duas strings so iguais, sem considerar caixa alta ou baixa.
Usando os mtodos: String str1 = "Hello"; char x = str1.charAt(0); // retornar o caracter H // e o armazenar no atributo x String str2 = "hello"; // aqui ser retornado o valor booleano true boolean result = str1.equalsIgnoreCase(str2);
4.3.1. Envio por valor Quando ocorre um envio por valor, a chamada do mtodo faz uma cpia do valor do atributo e o reenvia como argumento. O mtodo chamado no modifica o valor original do argumento mesmo que estes valores sejam modificados durante operaes de clculo implementadas pelo mtodo. Por exemplo: public class TestPassByValue { public static void main( String[] args ){ int i = 10; //exibe o valor de i System.out.println( i ); //chama o mtodo test //envia i para o mtodo test test( i ); //exibe o valor de i no modificado System.out.println( i ); } public static void test( int j ){ //muda o valor do argumento j j = 33; } } No exemplo dado, o mtodo test foi chamado e o valor de i foi enviado como argumento. O valor de i copiado para o atributo do mtodo j. J que j o atributo modificado no mtodo test, no afetar o valor do atributo i, o que significa uma cpia diferente do atributo. Como padro, todo tipo primitivo, quando enviado para um mtodo, utiliza a forma de envio por valor. 4.3.2. Envio por referncia Quando ocorre um envio por referncia, a referncia de um objeto enviada para o mtodo chamado. Isto significa que o mtodo faz uma cpia da referncia do objeto enviado. Entretanto, diferentemente do que ocorre no envio por valor, o mtodo pode modificar o objeto para o qual a referncia est apontando. Mesmo que diferentes referncias sejam usadas nos mtodos, a localizao do dado para o qual ela aponta a mesma. Por exemplo: class TestPassByReference { public static void main(String[] args) { // criar um array de inteiros int []ages = {10, 11, 12}; // exibir os valores do array for (int i=0; i < ages.length; i++) { System.out.println( ages[i] ); } // chamar o mtodo test e enviar a // referncia para o array
test( ages ); // exibir os valores do array for (int i=0; i < ages.length; i++) { System.out.println(ages[i]); } } public static void test( int[] arr ){ // mudar os valores do array for (int i=0; i < arr.length; i++) { arr[i] = i + 50; } } }
Dicas de programao:
1. Um erro comum sobre envio por referncia acontece quando criamos ummtodo para fazer trocas (swap) usando referncia. Note que Java manipula objetos 'por referncia', entretanto enviase a referncia para um mtodo 'por valor'. Como conseqncia, no se escreve um mtodo padro para fazer troca de valores (swap) entre objetos.
Mtodos estticos so mtodos que podem ser invocados sem que um objeto tenha sido instanciado pela classe (sem utilizar a palavra-chave new). Mtodos estticos pertencem a classe como um todo e no ao objeto especifico da classe. Mtodos estticos so diferenciados dos mtodos de objeto pela declarao da palavra-chave static na definio do mtodo. Para chamar um mtodo esttico, digite: NomeClasse.nomeMtodoEsttico(argumentos); Alguns mtodos estticos, que j foram usados em nossos exemplos so: // Converter a String 10 em um atributo do tipo inteiro int i = Integer.parseInt("10"); // Retornar uma String representando um inteiro sem o sinal da // base 16 String hexEquivalent = Integer.toHexString(10);
O cdigo acima representa cinco escopos indicado pelas letras. Dados os atributos i, j, k, m e n, e os cinco escopos A, B, C, D e E, temos os seguintes escopos para cada atributo: O O O O O escopo escopo escopo escopo escopo do do do do do atributo atributo atributo atributo atributo i j k m n A. B. C. D. E.
Dado dois mtodos: main e test teremos o seguinte exemplo: class TestPassByReference { public static void main(String[] args) { // criar um array de inteiros int []ages = {10, 11, 12}; //exibir os valores do array for (int i=0; i < ages.length; i++){ System.out.println( ages[i] ); } // chamar o mtodo test e enviar a referncia para o array test(ages); //exibe novamente os valores do array for (int i = 0; i < ages.length; i++) { System.out.println( ages[i] ); } } public static void test(int[] arr) { // modificar os valores do array for (int i = 0; i < arr.length; i++) { arr[i] = i + 50; } } }
Para o mtodo main, os escopos dos atributos so: ages[] - escopo A i em B - escopo B i em C escopo C E, no mtodo test, os escopos dos atributos so: arr[] - escopo D i em E - escopo E Quando atributos so declarados, o identificador deve ser nico no escopo. Isto significa que se voc tiver a seguinte declarao: { int test = 10; int test = 20; }
o compilador ir gerar um erro pois deve-se ter um nome nico para o atributos dentro do bloco. Entretanto, possvel ter atributos definidos com o mesmo nome, se no estiverem declarados no mesmo bloco. Por exemplo: public class TestBlock { int test = 10; public void test() { System.out.print(test); int test = 20; System.out.print(test); } public static void main(String[] args) { TestBlock testBlock = new TestBlock(); testBlock.test(); } } Quando a primeira instruo System.out.print for invocada, exibir o valor 10 contido na primeira declarao do atributo test. Na segunda instruo System.out.print, o valor 20 exibido, pois o valor do atributos test neste escopo.
Dicas de programao:
1. Evite ter atributos declarados com o mesmo nome dentro de um mtodo para no causar confuso.
(tipoDado)valor onde: tipoDado o nome do tipo de dado para o qual se quer converter o valor valor um valor que se quer converter. Por exemplo: double valDouble = 10.12; int valInt = (int)valDouble; //converte valDouble para o tipo int double x = 10.2; int y = 2; int result = (int)(x/y); //converte o resultado da operao para int Outro exemplo quando desejamos fazer um casting de um valor do tipo int para char. Um caractere pode ser usado como int porque para cada caractere existe um correspondente numrico que representa sua posio no conjunto de caracteres. O casting (char)65 ir produzir a sada 'A'. O cdigo numrico associado letra maiscula A 65, segundo o conjunto de caracteres ASCII. Por exemplo: char valChar = 'A'; System.out.print((int)valChar); //casting explcito produzir 65
Para usar objetos da superclasse onde uma subclasse esperada, necessrio fazer o casting explcito. Nenhuma informao ser perdida no casting, entretanto, ganhar todos os atributos e mtodos que a subclasse define. Para fazer o casting de um objeto para outro, utiliza-se a mesma operao utilizada com os tipos primitivos: Para fazer o casting: onde: nomeClasse o nome da classe destino objeto a referncia para o objeto origem que se quer converter Uma vez que casting cria uma referncia para o antigo objeto de nomeClasse; ele continua a existir depois do casting.
O exemplo a seguir realiza um casting de um objeto da classe VicePresident para um objeto da classe Employee. VicePresident uma subclasse de Employee com mais informaes, supondo que tenha sido definido que a classe VicePresident tem mais privilgios que um Employee. Employee emp = new Employee(); VicePresident veep = new VicePresident(); emp = veep; // casting no necessrio de baixo para cima veep = (VicePresident)emp; // necessita do casting explcito
Dicas de programao:
1. A classe Void representa vazio em Java. Deste modo, no existem motivos para ela ser usada na converso de valores primitivos e objetos. Ela um tratador para a palavra-chave void, que utilizada na assinatura de mtodos indicando que estes no retornam valor.
Uma exceo para esta regra so os operadores de igualdade: == (igual) e != (diferente). Quando aplicados a objetos, estes operadores no fazem o que se poderia supor. Ao invs de verificar se um objeto tem o mesmo valor de outro objeto, eles determinam se os dois objetos comparados pelo operador tm a mesma referncia. Por exemplo: String valor1 = new String; Integer dataCount = new Integer(7801); Para comparar objetos de uma classe e ter resultados apropriados, deve-se implementar e chamar mtodos especiais na sua classe. Um bom exemplo disso a classe String. possvel ter dois objetos String diferentes que contenham o mesmo valor. Caso se empregue o operador == para comparar objetos, estes sero considerados diferentes. Mesmo que seus contedos sejam iguais, eles no so o mesmo objeto. Para ver se dois objetos String tm o mesmo contedo, um mtodo chamado equals() utilizado. O mtodo compara cada caractere presente no contedo das Strings e retorna true se ambas strings tiverem o mesmo valor. O cdigo seguinte ilustra essa comparao, class EqualsTest { public static void main(String[] args) { String str1, str2; str1 = "Free the bound periodicals."; str2 = str1; System.out.println("String1: " + str1); System.out.println("String2: " + str2); System.out.println("Same object? " + (str1 == str2)); str2 = new String(str1); System.out.println("String1: " + str1); System.out.println("String2: " + str2); System.out.println("Same object? " + (str1 == str2)); System.out.println("Same value? " + str1.equals(str2)); } }
A sada dessa classe a seguinte: String1: Free the bound String2: Free the bound Same object? true String1: Free the bound String2: Free the bound Same object? false Same value? true periodicals. periodicals. periodicals. periodicals.
Vamos entender o processo envolvido. String str1, str2; str1 = "Free the bound periodicals."; str2 = str1;
A primeira parte dessa classe declara dois atributos (str1 e str2) e atribui a literal "Free the bound periodicals." a str1, e depois atribui esse valor a str2. Como visto anteriormente, str1 e str2 agora apontam para o mesmo objeto, e o teste de igualdade prova isso. Em seguida, temos a seguinte instruo: str2 = new String(str1); Na segunda parte da classe, cria-se um novo objeto String com o mesmo valor de str1 e faz-se a atribuio de str2 para esse novo objeto String. Agora temos dois diferentes tipos de objetos na str1 e str2, ambos com o mesmo contedo. Testando para ver se eles so o mesmo objeto usando o operador de igualdade obtemos a resposta esperada: false eles no so o mesmo objeto na memria. Utilizando o mtodo equals() recebemos a resposta esperada: true eles tem o mesmo contedo.
Dicas de programao:
1. Porque no se pode ter a mesma literal quando mudamos str2, a no ser quando utilizamos o new? Literais String so otimizadas em Java; se uma String criada utilizando uma literal e cria-se outra String com os mesmos caracteres, Java tem inteligncia suficiente para retornar apenas a posio em memria do primeiro objeto String criado. Ou seja, ambas strings se referem ao mesmoobjeto como se fosse um apelido. Para obrigar ao Java criar um novo objeto String, deve-se utilizar o operador new.
Existem duas maneiras de se descobrir a qual classe determinado objeto pertence: 1. Para obter o nome da classe: Utiliza-se o mtodo getClass() que retorna a classe do objeto (onde Class a classe em si). Esta, por sua vez, possui o mtodo chamado getName() que retorna o nome da classe. Por exemplo: String name = key.getClass().getName(); 2. Para testar se um objeto qualquer foi instanciado de uma determinada classe: Utiliza-se a palavra-chave instanceof. Esta palavra-chave possui dois operadores: a referncia para o objeto esquerda e o nome da classe direita. A expresso retorna um lgico dependendo se o objeto uma instncia da classe declarada ou qualquer uma de suas subclasses. Por exemplo: String ex1 = "Texas"; System.out.println(ex1 instanceof String); // retorna true String ex2; System.out.println(ex2 instanceof String); // retorna false
6. Exerccios
6.1. Definindo termos
Em suas palavras, defina os seguintes termos: 1. 2. 3. 4. 5. 6. 7. 8. Classe Objeto Instanciao Atributo de objeto Mtodo de objeto Atributo de classe ou atributos estticas Construtor Mtodo de classe ou mtodos estticos
Sua tarefa ajudar Pipoy a procurar as APIs. Voc deve informar as classes s quais os mtodos pertencem e como o mtodo deve ser declarado com um exemplo de uso deste. Por exemplo, se Pipoy quer saber qual o mtodo que converte uma String para int, sua resposta deve ser: Classe: Integer Declarao do Mtodo: public static int parseInt( String value ) Exemplo de Uso: String strValue = "100"; int value = Integer.parseInt( strValue ); Tenha certeza de que o fragmento de cdigo que voc escreveu em seu exemplo de uso compila e que produza o resultado correto. Enfim, no deixe Pipoy confuso. (Dica: Todos os mtodos esto no package java.lang). Caso haja mais de um mtodo para atender tarefa, utilize apenas um. Agora vamos iniciar a busca! Aqui esto alguns mtodos que Pipoy necessita: 1. Procure pelo mtodo que verifica se uma String termina com um determinado sufixo. Por exemplo, se a String dada "Hello", o mtodo deve retornar true se o sufixo informado "lo", e false se o sufixo for "alp". 2. Procure pelo mtodo que determina a representao do caractere para um dgito e base especficos. Por exemplo, se o dgito informado 15 e a base 16, o mtodo retornar o caractere 'F', uma vez que 'F' a representao hexadecimal para o nmero 15 em base 10. 3. Procure por um mtodo que retorna a parte inteira de um valor double. Por exemplo, se a entrada for 3.13, o mtodo deve retornar o valor 3. 4. Procure por um mtodo que determina se um certo caractere um dgito. Por exemplo, se a entrada for '3', retornar o valor true. 5. Procure por um mtodo que interrompe a execuo da Java Virtual Machine corrente.
Lio 8 1. Objetivos
Agora que j estudamos como usar as classes existentes na biblioteca de classes do Java, estudaremos como criar nossas prprias classes. Nesta lio, para facilmente entender como cri-las, realizaremos um exemplo de classe no qual adicionaremos dados e funcionalidades medida em que avanarmos no curso. Criaremos uma classe com informaes de um Estudante e com operaes necessrias para seu registro. Algumas observaes devem ser feitas quanto sintaxe que ser usada nesta e nas prximas sees: * - significa que pode haver nenhuma ou diversas ocorrncias na linha em que for aplicada <descrio> - indica a substituio deste trecho por um certo valor, ao invs de digit-lo como est [] - indica que esta parte opcional Ao final desta lio, o estudante ser capaz de: Criar nossas classes Declarar atributos e mtodos para as classes Usar o objeto this para acessar dados de instncia Utilizar overloading de mtodos Importar e criar pacotes Usar modificadores de acesso para controlar o acesso aos elementos de uma classe
Dicas de programao:
1. Lembre-se de que, para a declarao da classe, o nico modificador de acesso vlido o public. De uso exclusivo para a classe que possuir o mesmo nome do arquivo externo.
Nesta lio, criaremos uma classe que conter o registro de um estudante. Como j identificamos o objetivo da nossa classe, agora podemos nome-la. Um nome apropriado para nossa classe seria StudentRecord. Para definir nossa classe, escrevemos: public class StudentRecord { // adicionaremos mais cdigo aqui }
onde:
public modificador de acesso e significa que qualquer classe pode acessar esta class palavra-chave usada para criar uma classe StudentRecord identificador nico que identifica a classe
Dicas de programao:
1. Pense em nomes apropriados para a sua classe. No a chame simplesmente de classe XYZ ou qualquer outro nome aleatrio. 2. Os nomes de classes devem ser iniciadas por letra MAISCULA. 3. O nome do arquivo de sua classe obrigatoriamente possui o MESMO NOME da sua classe pblica.
3. Declarando Atributos
Para declarar um certo atributo para a nossa classe, escrevemos: <modificador>* <tipo> <nome> [= <valorInicial>]; onde: modificador tipo de modificador do atributo tipo tipo do atributo nome pode ser qualquer identificador vlido valorInicial valor inicial para o atributo
Relacionaremos a lista de atributos que um registro de estudante pode conter. Para cada informao, listaremos os tipos de dados apropriados que sero utilizados. Por exemplo, no seria ideal usar um tipo int para o nome do estudante ou String para a nota do estudante. Abaixo, por exemplo, temos algumas informaes que podemos adicionar ao registro do estudante: nome - String endereo - String idade - int nota de matemtica - double nota de ingls - double nota de cincias - double Futuramente, possvel adicionar mais informaes. Para este exemplo, utilizaremos somente estas.
public class StudentRecord { private String name; private String address; private int age; private double mathGrade; private double englishGrade; private double scienceGrade; } onde:
private significa que os atributos so acessveis apenas de dentro da classe. Outros objetos no podem acessar diretamente estes atributos.
Dicas de programao:
1. Declare todas os atributos de objeto na parte superior da declarao da classe. 2. Declare cada atributo em uma linha.
3. Atributos de objeto, assim como qualquer outro atributo devem iniciar com letra MINSCULA. 4. Use o tipo de dado apropriado para cada atributo declarado. 5. Declare atributos de objetos como private de modo que somente os mtodos da classe possam acess-los diretamente.
public class StudentRecord { // atributos de objeto declarados anteriormente private static int studentCount; }
usamos a palavra-chave static para indicar que um atributo esttico. Ento, nosso cdigo completo deve estar assim:
StudentRecord { String name; String address; int age; double mathGrade; double englishGrade; double scienceGrade; static int studentCount;
4. Declarando Mtodos
Antes de discutirmos quais mtodos que a nossa classe dever conter, vejamos a sintaxe geral usada para a declarao de mtodos.
<modificador> pode ser utilizado qualquer modificador de acesso <tipoRetorno> pode ser qualquer tipo de dado (incluindo void) <nome> pode ser qualquer identificador vlido <argumento> argumentos recebidos pelo mtodo separados por vrgulas. So definidos por: <tipoArgumento> <nomeArgumento>
seguinte erro de compilao ocorrer caso o mtodo e o atributo de retorno no tenham o mesmo tipo de dados: StudentRecord.java:14: incompatible types found : int required: java.lang.String return name; ^ 1 error Outro exemplo de um mtodo assessor o mtodo getAverage: public class StudentRecord { private String name; : : public double getAverage(){ double result = 0; result = (mathGrade+englishGrade+scienceGrade)/3; return result; } } O mtodo getAverage calcula a mdia das 3 notas e retorna o resultado.
name = temp; atribuir o contedo de temp para name e, portanto, alterar os dados dentro do atributo de objeto name. Mtodos modificadores no retornam valores. Entretanto, eles devem receber um argumento com o mesmo tipo do atributo no qual esto tratando.
Dicas de programao:
1. Nomes de mtodos devem iniciar com letra MINSCULA.
2. Nomes de mtodos devem conter verbos 3. Sempre faa documentao antes da declarao do mtodo. Use o estilo javadoc para isso.
public static void main( String[] args ){ // criar trs objetos para StudentRecord StudentRecord annaRecord = new StudentRecord(); StudentRecord beahRecord = new StudentRecord(); StudentRecord crisRecord = new StudentRecord(); / / enviar o nome dos estudantes annaRecord.setName("Anna"); beahRecord.setName("Beah"); crisRecord.setName("Cris"); // mostrar o nome de anna System.out.println(annaRecord.getName()); //mostrar o nmero de estudantes System.out.println("Count=" + StudentRecord.getStudentCount()); } } A sada desta classe : Anna Count = 0
5. this
O objeto this usado para acessar atributos de objeto ou mtodos da classe. Para entender isso melhor, tomemos o mtodo setAge como exemplo. Suponha que tenhamos o seguinte mtodo para setAge: public void setAge(int age){ age = age; // No uma boa prtica } O nome do argumento nesta declarao age, que tem o mesmo nome do atributo de objeto age. J que o argumento age a declarao mais prxima do mtodo, o valor do argumento age ser usado. Na instruo: age = age; estamos simplesmente associando o valor do argumento age para si mesmo! Isto no o que queremos que acontea no nosso cdigo. A fim de corrigir esse erro, usamos o objeto this. Para utilizar o objeto this, digitamos: this.<nomeDoAtributo> O ideal reescrever o nosso mtodo do seguinte modo: public void setAge(int age){ this.age = age; }
Este mtodo ir atribuir o valor do argumento age para a atributo de objeto age do objeto StudentRecord.
6. Overloading de Mtodos
Nas nossas classes, podemos necessitar de criar mtodos que tenham os mesmos nomes, mas que funcionem de maneira diferente dependendo dos argumentos que informamos. Esta capacidade chamada de overloading de mtodos. Overloading de mtodos permite que um mtodo com o mesmo nome, entretanto com diferentes argumentos, possa ter implementaes diferentes e retornar valores de diferentes tipos. Ao invs de inventar novos nomes todas as vezes, o overloading de mtodos pode ser utilizado quando a mesma operao tem implementaes diferentes. Por exemplo, na nossa classe StudentRecord, queremos ter um mtodo que mostre as informaes sobre o estudante. Entretanto, queremos que o mtodo print mostre dados diferentes dependendo dos argumentos que lhe informamos. Por exemplo, quando no enviamos qualquer argumento queremos que o mtodo print mostre o nome, endereo e idade do estudante. Quando passamos 3 valores double, queremos que o mtodo mostre o nome e as notas do estudante. Temos os seguintes mtodos dentro da nossa classe StudentRecord: public void print(){ System.out.println("Name:" + name); System.out.println("Address:" + address); System.out.println("Age:" + age); }
public void print(double eGrade, double mGrade, double sGrade) { System.out.println("Name:" + name); System.out.println("Math Grade:" + mGrade); System.out.println("English Grade:" + eGrade); System.out.println("Science Grade:" + sGrade); }
Quando tentamos chamar estes mtodos no mtodo main, criado para a classe StudantRecordExample: public static void main(String[] args) { StudentRecord annaRecord = new StudentRecord(); annaRecord.setName("Anna"); annaRecord.setAddress("Philippines"); annaRecord.setAge(15);
annaRecord.setMathGrade(80); annaRecord.setEnglishGrade(95.5); annaRecord.setScienceGrade(100); // overloading de mtodos annaRecord.print(); annaRecord.print( annaRecord.getEnglishGrade(), annaRecord.getMathGrade(), annaRecord.getScienceGrade()); } teremos a sada para a primeira chamada ao mtodo print: Name:Anna Address:Philippines Age:15 e, em seguida, a sada para a segunda chamada ao mtodo print: Name:Anna Math Grade:80.0 English Grade:95.5 Science Grade:100.0 Lembre-se sempre que mtodos overload possuem as seguintes propriedades: 1. o mesmo nome 2. argumentos diferentes 3. tipo do retorno igual ou diferente
7. Declarando Construtores
Discutimos anteriormente o conceito de construtores. Construtores so importantes na criao de um objeto. um mtodo onde so colocadas todas as inicializaes. A seguir, temos as propriedades de um construtor: 1. Possuem o mesmo nome da classe 2. Construtor um mtodo, entretanto, somente as seguintes informaes podem ser colocadas no cabealho do construtor: Escopo ou identificador de acessibilidade (como public) Nome do construtor
Argumentos, caso necessrio 3. No retornam valor 4. So executados automaticamente na utilizao do operador new durante a instanciao da classe Para declarar um construtor, escrevemos: [modificador] <nomeClasse> (<argumento>*) { <instruo>* }
StudentRecord("Anna"); StudentRecord beahRecord = new StudentRecord("Beah", "Philippines"); StudentRecord crisRecord = new StudentRecord(80,90,100); // algum cdigo aqui } Antes de continuarmos, vamos retornar o atributo esttico studentCount que declaramos agora a pouco. O objetivo de studentCount contar o nmero de objetos que so instanciados com a classe StudentRecord. Ento, o que desejamos incrementar o valor de studentCount toda vez que um objeto da classe StudentRecord instanciado. Um bom local para modificar e incrementar o valor de studentCount nos construtores, pois so sempre chamados toda vez que um objeto instanciado. Por exemplo: public StudentRecord() { studentCount++; // adicionar um estudante } public StudentRecord(String name) { studentCount++; // adicionar um estudante this.name = name; } public StudentRecord(String name, String address) { studentCount++; // adicionar um estudante this.name = name; this.address = address; } public StudentRecord(double mGrade, double eGrade, double sGrade) { studentCount++; // adicionar um estudante mathGrade = mGrade; englishGrade = eGrade; scienceGrade = sGrade; }
H algum detalhes que devem ser lembrados na utilizao da chamada ao construtor por this(): 1. A chamada ao construtor DEVE SEMPRE OCORRER NA PRIMEIRA LINHA DE INSTRUO 2. UTILIZADO PARA A CHAMADA DE UM CONSTRUTOR. A chamada ao this() pode ser seguida por outras instrues. Como boa prtica de programao, ideal nunca construir mtodos que repitam as instrues. Buscamos a utilizao de overloading com o objetivo de evitarmos essa repetio. Deste modo, reescreveremos os construtores da classe StudentRecord para: public StudentRecord() { studentCount++; // adicionar um estudante } public StudentRecord(String name) { this(); this.name = name; } public StudentRecord(String name, String address) { this(name); this.address = address; } public StudentRecord(double mGrade, double eGrade, double sGrade) { this(); mathGrade = mGrade; englishGrade = eGrade; scienceGrade = sGrade; }
8. Pacotes
So utilizados para agrupar classes e interfaces relacionadas em uma nica unidade (discutiremos interfaces mais tarde). Esta uma caracterstica poderosa que oferece um mecanismo para gerenciamento de um grande grupo de classes e interfaces e evita possveis conflitos de nome.
ou: import java.awt.*; A primeira linha de instruo importa especificamente a classe Color enquanto que a seguinte importa todas as classes do pacote java.awt. Outra maneira de importar classes de outros pacotes atravs da referncia explcita ao pacote. Isto feito utilizando-se o nome completo do pacote para declarao do objeto na classe: java.awt.Color color;
C:\schoolClasses>javac StudentRecord.java C:\schoolClasses>java StudentRecord Exception in thread "main" java.lang.NoClassDefFoundError: StudentRecord (wrong name: schoolClasses/StudentRecord)
at at at at at at at at at at at at
java.lang.ClassLoader.defineClass1(Native Method) java.lang.ClassLoader.defineClass(Unknown Source) java.security.SecureClassLoader.defineClass(Unknown Source) java.net.URLClassLoader.defineClass(Unknown Source) java.net.URLClassLoader.access$100(Unknown Source) java.net.URLClassLoader$1.run(Unknown Source) java.security.AccessController.doPrivileged(Native Method) java.net.URLClassLoader.findClass(Unknown Source) java.lang.ClassLoader.loadClass(Unknown Source) sun.misc.Launcher$AppClassLoader.loadClass(Unknown Source) java.lang.ClassLoader.loadClass(Unknown Source) java.lang.ClassLoader.loadClassInternal(Unknown Source)
Surge o erro NoClassDefFoundError, que significa que o Java desconhece onde procurar por esta classe. A razo disso que a sua classe StudentRecord pertence a um pacote denominado schoolClasses. Se desejamos executar esta classe, teremos que dizer ao Java o seu nome completo schoolClasses.StudentRecord. Tambm teremos que dizer JVM onde procurar pelos nossos pacotes, que, neste caso, no C:\. Para fazer isso, devemos definir a varivel classpath. Para definir a varivel classpath no Windows, digitamos o seguinte na linha de comando: C:\schoolClasses>set classpath=C:\ onde C:\ o diretrio onde colocamos os pacotes. Aps definir a varivel classpath, poderemos executar a nossa classe em qualquer pasta, digitando: C:\schoolClasses>java schoolClasses.StudentRecord Para sistemas baseados no Unix, /usr/local/myClasses, escrevemos: suponha que as nossas classes estejam no diretrio
export classpath=/usr/local/myClasses Observe que possvel definir a varivel classpath em qualquer lugar. possvel definir mais de um local de pesquisa; basta separ-los por ponto-evrgula (no Windows) e dois-pontos (nos sistemas baseados em Unix). Por exemplo: set classpath=C:\myClasses;D:\;E:\MyPrograms\Java e para sistemas baseados no Unix: export classpath=/usr/local/java:/usr/myClasses
9. Modificadores de Acesso
Quando estamos criando as nossas classes e definindo as suas propriedades e mtodos, queremos implementar algum tipo de restrio para se acessar esses dados. Por exemplo, ao necessitar que um certo atributo seja modificado apenas pelos mtodos dentro da classe, possvel esconder isso dos outros objetos que estejam usando a sua classe. Para implementar isso, no Java, temos os modificadores de acesso. Existem quatro diferentes tipos de modificadores de acesso: public, private, protected e default. Os trs primeiros modificadores so escritos explicitamente no cdigo para indicar o acesso, para o tipo default, no se utiliza nenhuma palavra-chave.
O atributo de objeto name e o mtodo getName() podem ser acessados por outros objetos, desde que o objetos pertenam ao mesmo pacote da classe StudentRecord.
Dicas de programao:
1. Normalmente, os atributos de objeto de uma classe devem ser declarados particulares e a classe pode fornecer mtodos assessores e modificadores para estes.
10. Exerccios
10.1. Registro de Agenda
Sua tarefa criar uma classe que contenha um Registro de Agenda. A tabela 1 descreve as informaes que um Registro de Agenda deve conter:
Tabela 1: Atributos e Descries dos Atributos Crie os seguintes mtodos: 1. Fornea todos os mtodos assessores e modificadores necessrios para todos os atributos.
2. Construtores.
10.2. Agenda
Crie uma classe Agenda que possa conter entradas de objetos tipo Registro de Agenda (utilize a classe criada no primeiro exerccio). Devem ser oferecidos os seguintes mtodos para a agenda: 1. 2. 3. 4. Adicionar registro Excluir registro Visualizar registros Modificar um registro
Lio 9 1. Objetivos
Nesta lio ser discutido como uma classe pode herdar as propriedades de outra classe jexistente. Uma classe que faz isso chamada de subclasse, e sua classe pai chamada de superclasse. Ser tambm discutida a aplicao automtica dos mtodos de cada objeto, independente da subclasse deste. Esta propriedade conhecida como polimorfismo. E, por ltimo, discutiremos sobre interfaces, que ajudam a reduzir no esforo de programao. Ao final desta lio, o estudante ser capaz de: Definir superclasses e subclasses Criar override de mtodos das superclasses Criar mtodos final e classes final
2. Herana
Todas as classes, incluindo as que compem a API Java, so subclasses da classe Object. Um exemplo de hierarquia de classes mostrado com a figura 1. A partir de uma determinada classe, qualquer classe acima desta na hierarquia de classes conhecida como uma superclasse (ou classe Pai). Enquanto que qualquer classe abaixo na hierarquia de classes conhecia como uma subclasse (ou classe Filho).
Herana um dos principais princpios em orientao a objeto. Um comportamento (mtodo) definido e codificado uma nica vez em uma nica classe e este comportamento herdado por todas suas subclasses. Uma subclasse precisa apenas implementar as diferenas em relao a sua classe pai, ou seja, adaptar-se ao meio em que vive.
public class Person { protected String name; protected String address; /** * Construtor Padro */ public Person(){ System.out.println("Inside Person:Constructor"); name = ""; address = ""; } /** * Construtor com 2 parmetros */ public Person( String name, String address ){ this.name = name; this.address = address; } /** * Mtodos modificadores e acessores */ public String getName(){ return name; } public String getAddress(){ return address; } public void setName( String name ){ this.name = name; } public void setAddress( String add ){ this.address = add; } } Os atributos name e address so declarados como protected. A razo de termos feito isto que queremos que estes atributos sejam acessveis s subclasses dessa classe. Se a declararmos com o modificador private, as subclasses no estaro aptas a us-los. Todas as propriedades de uma superclasse que so declaradas como public, protected e default podem ser acessadas por suas subclasses. Vamos criar outra classe chamada Student. E, como um estudante tambm uma pessoa, conclumos que iremos estender a classe Person, ento, poderemos herdar todas as propriedades existntes na classe Person. Para isto, escrevemos: public class Student extends Person { public Student(){ System.out.println("Inside Student:Constructor"); //Algum cdigo aqui } // Algum cdigo aqui
Quando a classe Student for instanciada, o construtor padro da superclasse Person invocado implicitamente para fazer as inicializaes necessrias. Aps isso, as instrues dentro do construtor da subclasse so executadas. Para ilustrar, considere o seguinte cdigo: public static void main( String[] args ){ Student anna = new Student(); }
No cdigo, criamos um objeto da classe Student. O resultado da execuo deste programa : Inside Person:Constructor Inside Student:Constructor
2.2. super
Uma subclasse pode, explicitamente, chamar um construtor de sua superclasse imediata. Isso feito utilizando uma chamada ao objeto super. Uma chamada ao super no construtor de uma subclasse ir resultar na execuo de um construtor especfico da superclasse baseado nos argumentos passados. Por exemplo, dada a seguinte instruo para a classe Student: public Student(){ super( "SomeName", "SomeAddress" ); System.out.println("Inside Student:Constructor"); } Este cdigo chama o segundo construtor de sua superclasse imediata (a classe Person) e a executa. Outro cdigo de exemplo mostrado abaixo: public Student(){ super(); System.out.println("Inside Student:Constructor"); } Este cdigo chama o construtor padro de sua superclasse imediata (a classe Person) e o executa. Devemos relembrar, quando usamos uma chamada ao objeto super: 1. A instruo super() DEVE SER A PRIMEIRA INSTRUO EM UM CONSTRUTOR.
2. As instrues this() e super() no podem ocorrer simultaneamente no mesmo construtor. O objeto super uma referncia aos membros da superclasse (assim como o objeto this da sua prpria classe). Por exemplo: public Student() { super.name = "person name"; // Nome da classe pai this.name = "student name"; // Nome da classe atual }
Supondo que tenhamos a seguinte implementao para o mtodo getName da superclasse Person: public class Person { ... public String getName(){ System.out.println("Parent: getName"); return name; } ... } Para realizar um polimorfismo por override no mtodo getName da subclasse Student, escrevemos: public class Student extends Person { ... public String getName(){ System.out.println("Student: getName"); return name; } ... } Ento, quando invocarmos o mtodo getName de um objeto da classe Student, o mtodo chamado ser o de Student, e a sada ser: Student: getName possvel chamar o mtodo getName da superclasse, basta para isso: public class Student extends Person { ... public String getName() { super.getName(); System.out.println("Student: getName");
return name; } ... } Inserimos uma chamada ao objeto super e a sada ser: Parent: getName Student: getName
3. Polimorfismo
Considerando a classe pai Person e a subclasse Student do exemplo anterior, adicionaremos outra subclasse a Person, que se chamar Employee. Abaixo est a hierarquia de classes que ilustra o cenrio:
Podemos criar uma referncia do tipo da superclasse para a subclasse. Por exemplo: public static main( String[] args ) { Person ref; Student studentObject = new Student(); Employee employeeObject = new Employee(); ref = studentObject; //Person ref: ponteiro para um Student // algum cdigo aqui } Supondo que tenhamos um mtodo getName em nossa superclasse Person, iremos realizar uma modificao deste nas subclasses Student e Employee: public class Person { public String getName(){ System.out.println("Person Name:" + name); return name; } } public class Student extends Person { public String getName(){ System.out.println("Student Name:" + name); return name; } } public class Employee extends Person { public String getName(){ System.out.println("Employee Name:" + name); return name; } } Voltando ao mtodo main, quando tentamos chamar o mtodo getName da referncia ref do tipo Person, o mtodo getName do objeto Student ser chamado. Agora, se atribuirmos ref ao objeto Employee, o mtodo getName de Employee ser chamado. public static main(String[] args) { Person ref; Student studentObject = new Student(); Employee employeeObject = new Employee(); ref = studentObject; //ponteiro de referncia para um Student
String temp = ref.getName(); //getName de Student chamado System.out.println(temp); ref = employeeObject; // ponteiro de referncia Person para um // objeto Employee String temp = ref.getName(); // getName de Employee // classe chamada System.out.println(temp); } A capacidade de uma referncia mudar de comportamento de acordo com o objeto a que se refere chamada de polimorfismo. O polimorfismo permite que mltiplos objetos de diferentes subclasses sejam tratados como objetos de uma nica superclasse, e que automaticamente sejam selecionados os mtodos adequados a serem aplicados a um objeto em particular, baseado na subclasse a que ele pertena. Outro exemplo que demonstra o polimorfismo realizado ao passar uma referncia a mtodos. Supondo que exista um mtodo esttico printInformation que recebe como parmetro um objeto do tipo Person, pode-se passar uma referncia do tipo Employee e do tipo Student, porque so subclasses do tipo Person. public static main(String[] args) { Student studentObject = new Student(); Employee employeeObject = new Employee(); printInformation(studentObject); printInformation(employeeObject); } public static printInformation(Person p){ ... }
4. Classes Abstratas
Para criar mtodos em classes devemos, necessariamente, saber qual o seu comportamento. Entretanto, em muitos casos no sabemos como estes mtodos se comportaro na classe que estamos criando, e, por mera questo de padronizao, desejamos que as classes que herdem desta classe possuam, obrigatoriamente, estes mtodos. Por exemplo, queremos criar uma superclasse chamada LivingThing. Esta classe tem certos mtodos como breath, sleep e walk. Entretanto, existem tantos mtodos nesta superclasse que no podemos generalizar este comportamento. Tome por exemplo, o mtodo walk (andar). Nem todos os seres vivos andam da mesma maneira. Tomando os humanos como exemplo, os humanos andam sobre duas pernas, enquanto que outros seres vivos como os ces andam sobre quatro. Entretanto, existem muitas caractersticas que os seres vivos tm em comum, isto o que ns queremos ao criar uma superclasse geral.
Para realizarmos isto, teremos que criar uma superclasse que possua alguns mtodos com implementaes e outros no. Este tipo de classe chamada de classe abstrata. Uma classe abstrata uma classe que no pode gerar um objeto. Freqentemente aparece no topo de uma hierarquia de classes no modelo de programao orientada a objetos. Os mtodos nas classes abstratas que no tm implementao so chamados de mtodos abstratos. Para criar um mtodo abstrato, apenas escreva a assinatura do mtodo sem o corpo e use a palavra-chave abstract. Por exemplo:
public abstract void someMethod(); Agora, vamos criar um exemplo de classe abstrata: public abstract class LivingThing { public void breath(){ System.out.println("Living Thing breathing..."); } public void eat(){ System.out.println("Living Thing eating..."); } /** * mtodo abstrato walk * Queremos que este mtodo seja criado pela * subclasse de LivingThing */ public abstract void walk(); } Quando uma classe estende a classe abstrata LivingThing, ela obrigada a implementar o mtodo abstrato walk. Por exemplo: public class Human extends LivingThing { public void walk(){ System.out.println("Human walks..."); }
Se a classe Human no implementar o mtodo walk, ser mostrada a seguinte mensagem de erro de compilao: Human.java:1: Human is not abstract and does not override abstract method walk() in LivingThing public class Human extends LivingThing ^ 1 error Dicas de programao: 1. Use classes abstratas para definir muitos tipos de comportamentos no topo de uma hierarquia de classes de programao orientada a objetos. Use suas subclasses para prover detalhes de implementao da classe abstrata.
5. Interfaces
Uma interface um tipo especial de classe que contm unicamente mtodos abstratos ou atributos finais. Interfaces, por natureza, so abstratas. Interfaces definem um padro e o caminho pblico para especificao do comportamento de classes. Permitem que classes, independente de sua localizao na estrutura hierrquica, implementem comportamentos comuns.
Outra razo para se utilizar interfaces na programao de objetos revelar uma interface de programao de objeto sem revelar essas classes. Como veremos mais adiante, podemos utilizar uma interface como tipo de dados. Finalmente, precisamos utilizar interfaces como mecanismo alternativo para herana mltipla, que permite s classes em ter mais de uma superclasse. A herana mltipla no est implementada em Java.
Para implementar esta interface, usaremos a palavra chave "implements". Por exemplo: /** * Esta classe define um segmento de linha */ public class Line implements Relation { private double x1; private double x2; private double y1; private double y2; public Line(double x1, double x2, double y1, double y2) { this.x1 = x1; this.x2 = x2; this.y2 = y2; this.y1 = y1; } public double getLength(){ double length = Math.sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1)); return length; } public boolean isGreater( Object a, Object b){ double aLen = ((Line)a).getLength(); double bLen = ((Line)b).getLength(); return (aLen > bLen); } public boolean isLess( Object a, Object b){ double aLen = ((Line)a).getLength(); double bLen = ((Line)b).getLength(); return (aLen < bLen); } public boolean isEqual( Object a, Object b){ double aLen = ((Line)a).getLength(); double bLen = ((Line)b).getLength(); return (aLen == bLen); } } Quando a classe implementa uma interface, deve-se implementar todos os mtodos desta, caso contrrio ser mostrado o erro: Line.java:4: Line is not abstract and does not override abstract method isGreater(java.lang.Object,java.lang.Object) in Relation public class Line implements Relation ^ 1 error
Dicas de programao:
1. Use interface para criar uma definio padro de mtodos em classes diferentes. Uma vez que o conjunto de definies de mtodos criado, e pode ser escrito um mtodo simples para manipular todas as classes que implementam a interface.
6. Exerccios
6.1. Estendendo StudentRecord
Neste exerccio, queremos criar um registro mais especializado de Student que contm informaes adicionais sobre um estudante de Cincia da Computao. Sua tarefa estender a classe StudentRecord que foi implementada nas lies anteriores e acrescentar atributos e mtodos que so necessrios para um registro de um estudante de Cincia da Computao. Utilize override para modificar alguns mtodos da superclasse StudentRecord, caso seja necessrio.
Lio 10 1. Objetivos
Nesta lio, iremos aprender uma tcnica utilizada em Java para tratar condies incomuns que interrompem a operao normal da classe. Esta tcnica chamada de tratamento de exceo. Ao final desta lio, o estudante ser capaz de:
Definir o que so excees Tratar excees utilizando try-catch-finally
3. Tratando Excees
Para tratar excees em Java utilizamos a declarao try-catch-finally. O que devemos fazer para proteger as instrues passveis de gerar uma exceo, inser-las dentro deste bloco. A forma geral de um try-catch-finally : try{ // escreva as instrues passveis de gerar uma exceo // neste bloco catch (<exceptionType1> <varName1>){ // escreva a ao que o seu programa far caso ocorra // uma exceo de um determinado . . . catch (<exceptionTypen> <varNamen>){ // escreva a ao que o seu programa far caso ocorra // uma exceo de um determinado tipo finally { // escreva a ao que o seu programa executar caso ocorra // ou no um erro ou exceo
} }
} Excees geradas durante a execuo do bloco try podem ser detectadas e tratadas num bloco catch. O cdigo no bloco finally sempre executado, ocorrendo ou no a exceo.
ambos.
Cada bloco catch define o tratamento de uma exceo. O cabealho do bloco catch recebe somente um argumento, que a exceo (Exception)
que este bloco pretende tratar. A exceo deve ser da classe Throwable ou de uma de suas subclasses. Para um melhor entendimento, observe a figura 1 que demonstra o fluxo seguido pelo trycatch-finally:
Figura 1: Fluxo em um try-catch-finally Tomemos, por exemplo, uma classe que imprime o segundo argumento passado atravs da linha de comandos. Supondo que no h verificao no cdigo para o nmero de argumentos. public class ExceptionExample { public static void main( String[] args ) { System.out.println(args[1]); System.out.println("Finish"); } }
Ao executar esta classe sem informar nenhum argumento e, ao tentar acessar diretamente, conforme o exemplo descrito, o segundo argumento args[1], uma exceo obtida que interromper a execuo normal do programa, e a seguinte mensagem ser mostrada: Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 1 at ExceptionExample.main(ExceptionExample.java:5) Para prevenir que isto ocorra, podemos colocar o cdigo dentro de um bloco try-catch. O bloco finally opcional. Neste exemplo, no utilizaremos o bloco finally. public class ExceptionExample{ public static void main( String[] args ){ try { System.out.println( args[1] ); } catch (ArrayIndexOutOfBoundsException exp) { System.out.println("Exception caught!"); } System.out.println("Finish"); } } Assim, quando tentarmos rodar o programa novamente sem a informao dos argumentos, a sada trataria a exceo e o fluxo do programa no seria interrompido, mostrando o resultado: Exception caught! Finish
4. Exerccios
4.1. Capturando Excees 1
Dada a seguinte classe: public class TestException { public static void main(String[] args) { for (int i=0; true; i++) { System.out.println("args["+i+"]="+ args[i]); } System.out.println("Quiting..."); } }
Compile e rode a classe TestException. E como sada ser: java TestExceptions one two three args[0]=one args[1]=two args[2]=three Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3 at TestExceptions.main(1.java:4)
Modifique a classe TestException para tratar esta exceo. A sada depois do tratamento da exceo dever ser: java TestExceptions one two three args[0]=one args[1]=two args[2]=three Exception caught: java.lang.ArrayIndexOutOfBoundsException: 3 Quiting...
Passo 2: Antes de executar o instalador, assegure-se de que o arquivo seja um executvel. Para tanto, pressione o boto direito do mouse no cone do instalador, e em seguida selecione Properties. Selecione na aba Permissions, e ento marque a opo Execute. Feche a janela. Passo 3: Duplo-clique no arquivo jdk-1_5_0_07-linux-i586.bin. A caixa de dilogo abaixo ser mostrada. Pressione o boto Run in Terminal. No console ser mostrado o contrato de licena do software. Pressione ENTER at ser mostrada a pergunta: Do you agree to the above license terms? [yes or no]. Caso concorde com os termos apresentados digite a palavra yes e pressione a tecla ENTER. Aguarde que o instalador termine de descompactar e instale o Java. Passo 4: Devemos um caminho de pesquisa a fim de permitir a execuo de comandos java em qualquer local. Para isto, entraremos na pasta /usr/local/bin. Digitando: cd /usr/local/bin Para criar os links simblicos para os comandos, tecle: sudo ln -s /usr/java/jdk1.5.0_07/bin/* .
Passo 2: Para executar o instalador, duplo-clique no cone. A caixa de dilogo do instalador J2SE ser mostrada com o contrato. Selecione a opo I accept the terms in the license agreement caso concorde com os termos apresentados e pressione o boto Next >.
Esta prxima janela define o que ser instalado. Pressione o boto Next > para continuar a instalao. O processo de instalao poder demorar um pouco, ao trmino a seguinte janela ser mostrada, pressione o boto Finish para completar a instalao.
Passo 4: A fim de possibilitar a execuo do NetBeans a partir de qualquer pasta no computador, precisamos criar um caminho de pesquisa. Para isso, entramos na pasta :/usr/local/bin. com o comando: cd /usr/local/bin Crie um caminho de pesquisa para o NetBeans, digitando: sudo ln -s /usr/java/netbeans-5.5 . possvel executar o NetBeans a partir de qualquer pasta, digitando: netbeans &
Hino Nacional
Ouviram do Ipiranga as margens plcidas De um povo herico o brado retumbante, E o sol da liberdade, em raios flgidos, Brilhou no cu da ptria nesse instante. Se o penhor dessa igualdade Conseguimos conquistar com brao forte, Em teu seio, liberdade, Desafia o nosso peito a prpria morte! Ptria amada, Idolatrada, Salve! Salve! Brasil, um sonho intenso, um raio vvido De amor e de esperana terra desce, Se em teu formoso cu, risonho e lmpido, A imagem do Cruzeiro resplandece. Gigante pela prpria natureza, s belo, s forte, impvido colosso, E o teu futuro espelha essa grandeza. Terra adorada, Entre outras mil, s tu, Brasil, Ptria amada! Dos filhos deste solo s me gentil, Ptria amada,Brasil! Deitado eternamente em bero esplndido, Ao som do mar e luz do cu profundo, Fulguras, Brasil, floro da Amrica, Iluminado ao sol do Novo Mundo! Do que a terra, mais garrida, Teus risonhos, lindos campos tm mais flores; "Nossos bosques tm mais vida", "Nossa vida" no teu seio "mais amores." Ptria amada, Idolatrada, Salve! Salve! Brasil, de amor eterno seja smbolo O lbaro que ostentas estrelado, E diga o verde-louro dessa flmula - "Paz no futuro e glria no passado." Mas, se ergues da justia a clava forte, Vers que um filho teu no foge luta, Nem teme, quem te adora, a prpria morte. Terra adorada, Entre outras mil, s tu, Brasil, Ptria amada! Dos filhos deste solo s me gentil, Ptria amada, Brasil!