Apostila - Java objetos, Notas de estudo de Informática

Baixe Apostila - Java objetos e outras Notas de estudo em PDF para Informática, somente na Docsity!

Caelum

“Mata o tempo e matas a tua carreira” Bryan Forbes

Sobre a empresa

A Caelum atua no mercado desde 2002, desenvolvendo sistemas e prestando consultoria em diversas áreas, à luz sempre da plataforma Java. Foi fundada por profissionais que se encontraram no Brasil depois de uma experiência na Alemanha e Itália, desenvolvendo sistemas de grande porte com integração aos mais variados ERPs. Seus profissionais publicaram já diversos artigos nas revistas brasileiras de Java, assim como artigos em eventos acadêmicos, e são presença constante nos eventos da tecnologia. Em 2004 a Caelum criou uma gama de cursos que rapidamente ganharam grande reconhecimento no mercado. Os cursos foram elaborados por ex instrutores da Sun que queriam trazer mais dinamismo e aplicar as ferramentas e bibliotecas utilizadas no mercado, tais como Eclipse, Hibernate, Struts, e outras tecnlogias open source que não são abordadas pela Sun. O material utilizado foi inicialmente desenvolvido enquanto eram ministrados os cursos de verão de java da Universidade de São Paulo em janeiro de 2004 pelos instrutores da Caelum. Em 2006 a empresa foca seus projetos em três grandes áreas: sistemas de gerenciamento de conteúdo para portais, desenvolvimento de soluções de integração financeira e treinamento com intuito de formação.

Sobre a apostila

Esta é a apostila da Caelum que tem como intuito ensinar Java de uma maneira elegante, mostrando apenas o que é necessário no momento correto e poupando o leitor de assuntos que não costumam ser de seu interesse em determinadas fases do aprendizado. A Caelum espera que você aproveite esse material, e que ele possa ser de grande valia para auto didatas e estudantes. Todos os comentários, críticas e sugestões serão muito bem vindos. O material aqui contido pode ser publicamente distribuído desde que não seja alterado e seus créditos sejam mantidos. Ele não pode ser usado para ministrar qualquer curso, porém pode ser referência e material de apoio. Caso você esteja interessado em usá lo fins comerciais, entre em contato com a empresa. Atenção: Você pode verificar a data de última atualização da apostila no fim do índice. Nunca imprima a apostila que você receber de um amigo ou pegar por email, pois atualizamos constantemente esse material, quase que mensalmente. Vá até o nosso site e faça o download da última versão! www.caelum.com.br

• Capítulo 1: Como aprender Java......................................................................... Índice
  • 1.1 - O que é realmente importante?..............................................................
  • 1.2 - Sobre os exercícios.................................................................................
  • 1.3 - Tirando dúvidas.......................................................................................
  • 1.4 - Sobre os autores.....................................................................................
• Capítulo 2: O que é Java.....................................................................................
  • 2.1 - Java..........................................................................................................
  • 2.2 - Máquina Virtual......................................................................................
  • 2.3 - Java lento? Hotspot e JIT.........................................................................
  • 2.4 - Versões do Java... e a confusão do Java2................................................
  • 2.5 - JVM? JRE? JDK?
  • 2.6 - Onde usar e os objetivos do Java............................................................
  • 2.7 - Especificação versus implementação......................................................
  • 2.8 - Como o FJ11 está organizado.................................................................
  • 2.9 - Instalando o Java.....................................................................................
  • 2.10 - Compilando o primeiro programa.......................................................
  • 2.11 - Executando seu primeiro programa...................................................
  • 2.12 - O que aconteceu?................................................................................
  • 2.13 - E o bytecode?......................................................................................
  • 2.14 - Exercícios............................................................................................
  • 2.15 - O que pode dar errado?......................................................................
  • 2.16 - Um pouco mais....................................................................................
  • 2.17 - Exercícios............................................................................................
• Capítulo 3: Variáveis primitivas e Controle de fluxo........................................
  • 3.1 - Declarando e usando variáveis.............................................................
  • 3.2 - Tipos primitivos e valores.....................................................................
  • 3.3 - Exercícios..............................................................................................
  • 3.4 - Casting e promoção..............................................................................
  • 3.5 - O If-Else.................................................................................................
  • 3.6 - O While..................................................................................................
  • 3.7 - O For.....................................................................................................
  • 3.8 - Controlando loops.................................................................................
  • 3.9 - Escopo das variáveis.............................................................................
  • 3.10 - Um bloco dentro do outro...................................................................
  • 3.11 - Um pouco mais....................................................................................
  • 3.12 - Exercícios............................................................................................
  • 3.13 - Desafios...............................................................................................
• Capítulo 4: Orientação a objetos básica...........................................................
  • 4.1 - Motivação: problemas do paradigma procedural.................................
  • 4.2 - Criando um tipo....................................................................................
  • 4.3 - Uma classe em Java..............................................................................
  • 4.4 - Criando e usando um objeto.................................................................
  • 4.5 - Métodos
  • 4.6 - Métodos com retorno............................................................................
  • 4.7 - Objetos são acessados por referências.................................................
  • 4.8 - O método transfere().............................................................................
  • 4.9 - Continuando com atributos...................................................................
  • 4.10 - Para saber mais: Uma Fábrica de Carros...........................................
  • 4.11 - Um pouco mais.................................................................................... Caelum Java e Orientação a Objetos
  • 4.12 - Exercícios............................................................................................
  • 4.13 - Desafios...............................................................................................
  • 4.14 - Fixando o conhecimento.....................................................................
• Capítulo 5: Um pouco de arrays.......................................................................
  • 5.1 - O problema............................................................................................
  • 5.2 - Arrays de referências............................................................................
  • 5.3 - Percorrendo uma array.........................................................................
  • 5.4 - Percorrendo uma array no Java 5.0......................................................
  • 5.5 - Um pouco mais......................................................................................
  • 5.6 - Exercícios..............................................................................................
  • 5.7 - Desafios.................................................................................................
  • 5.8 - Testando o conhecimento......................................................................
• Capítulo 6: Modificadores de acesso e atributos de classe..............................
  • 6.1 - Controlando o acesso............................................................................
  • 6.2 - Encapsulamento....................................................................................
  • 6.3 - Getters e Setters...................................................................................
  • 6.4 - Construtores..........................................................................................
  • 6.5 - A necessidade de um construtor...........................................................
  • 6.6 - Atributos de classe................................................................................
  • 6.7 - Um pouco mais......................................................................................
  • 6.8 - Exercícios..............................................................................................
  • 6.9 - Desafios.................................................................................................
• Capítulo 7: Orientação a Objetos – herança, reescrita e polimorfismo............
  • 7.1 - Repetindo código?.................................................................................
  • 7.2 - Reescrita de método.............................................................................
  • 7.3 - Chamando o método reescrito..............................................................
  • 7.4 - Polimorfismo.........................................................................................
  • 7.5 - Um outro exemplo.................................................................................
  • 7.6 - Um pouco mais......................................................................................
  • 7.7 - Exercícios..............................................................................................
• Capítulo 8: Eclipse IDE.....................................................................................
  • 8.1 - O Eclipse...............................................................................................
  • 8.2 - Views e Perspective...............................................................................
  • 8.3 - Criando um projeto novo.......................................................................
  • 8.4 - Nossa classe Conta...............................................................................
  • 8.5 - Criando o main......................................................................................
  • 8.6 - Rodando o main....................................................................................
  • 8.7 - Pequenos truques..................................................................................
  • 8.8 - Exercícios..............................................................................................
• Capítulo 9: Orientação a Objetos – Classes Abstratas......................................
  • 9.1 - Repetindo mais código?........................................................................
  • 9.2 - Classe abstrata......................................................................................
  • 9.3 - Métodos abstratos.................................................................................
  • 9.4 - Um outro exemplo.................................................................................
  • 9.5 - Para saber mais.....................................................................................
  • 9.6 - Exercícios..............................................................................................
• Capítulo 10: Orientação à Objetos – Interfaces..............................................
  • 10.1 - Aumentando nosso exemplo..............................................................
  • 10.2 - Interfaces.......................................................................................... Caelum Java e Orientação a Objetos
  • 10.3 - Dificuldade no aprendizado de interfaces........................................
  • 10.4 - Exemplo interessante: conexões com o banco de dados..................
  • 10.5 - Um pouco mais..................................................................................
  • 10.6 - Exercícios..........................................................................................
• Capítulo 11: Exceções – Controlando os erros...............................................
  • 11.1 - Motivação..........................................................................................
  • 11.2 - Exercício para começar com os conceitos........................................
  • 11.3 - Exceções de Runtime mais comuns..................................................
  • 11.4 - Outro tipo de exceção: Checked Exceptions.....................................
  • 11.5 - Um pouco da grande famíla Throwable............................................
  • 11.6 - Mais de um erro................................................................................
  • 11.7 - Lançando exceções...........................................................................
  • 11.8 - Criando seu próprio tipo de exceção................................................
  • 11.9 - Para saber mais: finally.....................................................................
  • 11.10 - Um pouco mais................................................................................
  • 11.11 - Exercícios........................................................................................
  • 11.12 - Desafios...........................................................................................
• Capítulo 12: Pacotes – Organizando suas classes e bibliotecas.....................
  • 12.1 - Organização......................................................................................
  • 12.2 - Import...............................................................................................
  • 12.3 - Acesso aos atributos, construtores e métodos..................................
  • 12.4 - Usando o Eclipse com pacotes..........................................................
  • 12.5 - Exercícios..........................................................................................
• Capítulo 13: Ferramentas: jar e javadoc.........................................................
  • 13.1 - Arquivos, bibliotecas e versões.........................................................
  • 13.2 - Gerando o jar pelo Eclipse................................................................
  • 13.3 - Javadoc..............................................................................................
  • 13.4 - Gerando o Javadoc............................................................................
  • 13.5 - Classpath...........................................................................................
  • 13.6 - Exercícios..........................................................................................
• Capítulo 14: O pacote java.lang......................................................................
  • 14.1 - Pacote java.lang................................................................................
  • 14.2 - Um pouco sobre a classe System e Runtime....................................
  • 14.3 - java.lang.Object................................................................................
  • 14.4 - Casting de referências......................................................................
  • 14.5 - Integer e classes wrappers (box)......................................................
  • 14.6 - Autoboxing no Java 5.0.....................................................................
  • 14.7 - Métodos do java.lang.Object equals e toString................................
  • 14.8 - java.lang.String.................................................................................
  • 14.9 - java.lang.Math..................................................................................
  • 14.10 - Exercícios........................................................................................
  • 14.11 - Desafio............................................................................................
• Capítulo 15: Pacote java.io.............................................................................
  • 15.1 - Orientação a objeto...........................................................................
  • 15.2 - InputStream: lendo bytes
  • 15.3 - InputStreamReader: lendo chars......................................................
  • 15.4 - BufferedReader: lendo Strings.........................................................
  • 15.5 - Lendo Strings do teclado..................................................................
  • 15.6 - A analogia na saída........................................................................... Caelum Java e Orientação a Objetos
  • 15.7 - Uma maneira mais fácil: Scanner e PrintStream.............................
  • 15.8 - Um pouco mais..................................................................................
  • 15.9 - Exercícios..........................................................................................
• Capítulo 16: Collections framework...............................................................
  • de dados...................................................................................................... 16.1 - Motivação: Manipular arrays é trabalhoso, precisamos de estruturas
  • 16.2 - Listas: java.util.List...........................................................................
  • 16.3 - Listas no Java 5.0 com Generics.......................................................
  • 16.4 - Ordenação: Collections.sort..............................................................
  • 16.5 - Exercícios..........................................................................................
  • 16.6 - Conjunto: java.util.Set.......................................................................
  • 16.7 - Principais interfaces: java.util.Collection.........................................
  • 16.8 - Iterando sobre coleções: java.util.Iterator.......................................
  • 16.9 - Iterando coleções no java 5.0: enhanced for....................................
  • 16.10 - Mapas - java.util.Map......................................................................
  • 16.11 - Mapas no Java 5.0...........................................................................
  • 16.12 - Exercícios........................................................................................
  • 16.13 - Desafios...........................................................................................
• Capítulo 17: Threads.......................................................................................
  • 17.1 - Linhas de execução...........................................................................
  • 17.2 - Criando uma subclasse da classe Thread.........................................
  • 17.3 - Garbage Collector.............................................................................
  • 17.4 - Exercícios..........................................................................................
  • 17.5 - Para saber mais: Compartilhando objetos entre Threads.................
  • 17.6 - Vector e Hashtable............................................................................
  • 17.7 - Um pouco mais..................................................................................
• Capítulo 18: E agora?.....................................................................................
  • 18.1 - Exercício prático...............................................................................
  • 18.2 - Certificação.......................................................................................
  • 18.3 - Web....................................................................................................
  • 18.4 - J2EE...................................................................................................
  • 18.5 - Frameworks......................................................................................
  • 18.6 - Revistas.............................................................................................
  • 18.7 - Grupo de Usuários............................................................................
  • 18.8 - Falando em Java................................................................................
• Capítulo 19: Apêndice A - Sockets..................................................................
  • 19.1 - Protocolo...........................................................................................
  • 19.2 - Porta..................................................................................................
  • 19.3 - Socket................................................................................................
  • 19.4 - Servidor.............................................................................................
  • 19.5 - Cliente...............................................................................................
  • 19.6 - Imagem geral....................................................................................
  • 19.7 - Exercícios..........................................................................................
  • 19.8 - Desafios.............................................................................................
  • 19.9 - Solução do sistema de chat...............................................................
• Capítulo 20: Apêndice B – Swing básico.........................................................
  • 20.1 - Interfaces gráficas em Java...............................................................
  • 20.2 - Portabilidade.....................................................................................
  • 20.3 - Começando com Swing..................................................................... Caelum Java e Orientação a Objetos
  • 20.4 - Nosso primeiro formulário................................................................
  • 20.5 - Adicionando eventos.........................................................................
  • 20.6 - Gerenciadores de Layout..................................................................
  • 20.7 - Look And Feel....................................................................................
  • 20.8 - Para saber mais.................................................................................
• Capítulo 21: Apêndice C - Mais java...............................................................
  • 21.1 - Import Estático.................................................................................
  • 21.2 - final...................................................................................................
  • 21.3 - Calendar............................................................................................
  • 21.4 - Date...................................................................................................
  • 21.5 - Outras classes muito úteis................................................................
  • 21.6 - Anotações..........................................................................................
• Capítulo 22: Apêndice D – Instalação do JDK.................................................
  • 22.1 - O Link................................................................................................
  • 22.2 - Instalação do JDK em ambiente Windows........................................
  • 22.3 - Instalação do JDK em ambiente Linux..............................................
• Data desta edição: Agosto/

Caelum – http://www.caelum.com.br Java e Orientação a Objetos

1 Como aprender Java

“Homens sábios fazem provérbios, tolos os repetem” Samuel Palmer Como o material está organizado e dicas de como estudar em casa.

1.1 - O que é realmente importante?

Muitos livros, ao passar os capítulos, mencionam todos os detalhes da linguagem juntamente com os princípios básicos dela. Isso acaba criando muita confusão, em especial pois o estudante não consegue distinguir exatamente o que é importante aprender e reter naquele momento daquilo que será necessário mais tempo e principalmente experiência para dominar. Se uma classe abstrata deve ou não ter ao menos um método abstrato, se o if só aceitar argumentos booleanos e todos os detalhes de classes internas realmente não devem ser preocupações para aquele que possui como objetivo primário aprender Java. Esse tipo de informação será adquirida com o tempo, e não é necessário até um segundo momento. Neste curso separamos essas informações em quadros especiais, já que são informações extras. Ou então apenas citamos num exercício e deixamos para o leitor procurar informações se for de seu interesse. Algumas informações não são mostradas e podem ser adquiridas em tutoriais ou guias de referência, são detalhes que para um programador experiente em Java pode ser importante, mas não para quem está começando. Por fim falta mencionar sobre a prática, que deve ser tratada seriamente: todos os exercícios são muito importantes e os desafios podem ser feitos quando o curso acabar. De qualquer maneira recomendamos aos alunos estudar em casa, principalmente aqueles que fazem os cursos intensivos.

O curso

Para aqueles que estão fazendo o curso Java e Orientação a Objetos, é recomendado estudar em casa aquilo que foi visto durante a aula, tentando resolver os exercícios que não foram feitos e os desafios que estão lá para envolver mais o leitor no mundo de Java.

Convenções de Código

Para mais informações sobre as convenções de código fonte Java, acesse: http://java.sun.com/docs/codeconv/

1.2 - Sobre os exercícios

Os exercícios do curso variam entre práticos até pesquisas na Internet, ou mesmo consultas sobre assuntos avançados em determinados tópicos para incitar a curiosidade do aprendiz na tecnologia. Capítulo 1 Como aprender Java Página 1

capítulo 1

PLATAFORMA JAVA SUN Caelum – http://www.caelum.com.br Java e Orientação a Objetos

2 O que é Java

“Computadores são inúteis, eles apenas dão respostas” Pi casso Chegou a hora de responder as perguntas mais básicas sobre Java. Ao término desse capítulo você será capaz de:

• responder o que é Java;
• mostrar as vantagens e desvantagens de Java;
• compilar e executar um programa simples.

2.1 - Java

Muitos associam Java com uma maneira de deixar suas páginas da web mais bonitas, com efeitos especiais, ou para fazer pequenos formulários na web. O que associa as empresas ao Java? Já iremos chegar neste ponto, mas antes vamos ver o motivo pelo qual as empresas fogem das outras linguagens: Quais são os seus maiores problemas quando está programando?

• ponteiros?
• liberar memória?
• organização?
• falta de bibliotecas boas?
• ter de reescrever parte do código ao mudar de sistema operacional?
• custo de usar a tecnologia? Java tenta amenizar esses problemas. Alguns desses objetivos foram atingidos muito tempo atrás, porque, antes do Java 1.0 sair, a idéia é que a linguagem fosse usada em pequenos dispositivos, como tvs, aspiradores, liquidificadores e outros. Apesar disso a linguagem teve seu lançamento mirando o uso dela nos clientes web (browsers) para rodar pequenas aplicações (applets). Hoje em dia esse não é mais o foco da linguagem. O Java é desenvolvido e mantido pela Sun (http://www.sun.com) e seu site principal é o http://java.sun.com. (java.com é um site mais institucional, voltado ao consumidor de produtos e usuários leigos, não desenvolvedores).

A história do Java

A Sun criou um time (conhecido como Green Team) para desenvolver inovações tecnológicas em

1992. Esse time foi liderado por James Gosling, considerado o pai do Java. O time voltou com a idéia de criar um interpretador (já era uma máquina virtual, veremos o que é isso mais a frente) para pequenos dispositivos, facilitando a reescrita de software para aparelhos eletrônicos, como vídeo cassete, televisão e aparelhos de tv a cabo. Capítulo 2 O que é Java Página 3

capítulo 2

Caelum – http://www.caelum.com.br Java e Orientação a Objetos A idéia não deu certo, tentaram fechar diversos contratos com grandes fabricantes de eletrônicos, como a Panasonic, mas não houve êxito devido ao conflito de interesses. Hoje sabemos que o Java domina o mercado de aplicações para celulares, porém parece que em 1994 ainda era muito cedo. Com o advento da web, a Sun percebeu que poderia utilizar a idéia criada em 1992 para poder rodar pequenas aplicações dentro do browser. A semelhança era que na internet havia uma grande quantidade de sistemas operacionais e browser, e com isso seria grande vantagem poder programar numa única linguagem, independente da plataforma. Foi aí que o Java 1.0 foi lançado: focado em deixar o browser não apenas um cliente burro, fazendo com que ele possa também realizar operações, não apenas renderizar html. Sabemos que hoje os applets realmente não são o foco da Sun. É engraçado que a tecnologia Java nasceu com um objetivo em mente, foi lançado com outro mas no final decolou mesmo no desenvolvimento de aplicações do lado do servidor. Sorte? Você pode ler a história da linguagem Java em: http://java.sun.com/java2/whatis/1996/storyofjava.html No Brasil, diversos grupos de usuários se juntaram para tentar disseminar o conhecimento da linguagem. Um deles é o GUJ (www.guj.com.br), uma comunidade virtual com artigos, tutoriais e fórum para tirar dúvidas, o maior em língua portuguesa. Encorajamos todos os alunos a usar muito os fóruns do mesmo pois é uma das melhores maneiras para achar soluções para pequenos problemas que acontecem com grande freqüência.

2.2 - Máquina Virtual

Em uma linguagem de programação como C e Pascal, temos o seguinte quadro quando vamos compilar um programa. O código fonte é compilado para uma plataforma e sistema operacional específicos. Muitas vezes, o próprio código fonte é desenvolvido visando uma única plataforma!

Código fonte em C

Código binário para

um determinador SO

compila

Esse código executável (binário) resultante será executado pelo sistema operacional e, por esse motivo, ele deve saber conversar com o sistema operacional em questão. Capítulo 2 O que é Java Página 4

BYTECODE Caelum – http://www.caelum.com.br Java e Orientação a Objetos possa a vir a interferir na boa execução de outras aplicações. Para tudo isso precisamos de um “ bytecode ”. Bytecode é o termo dado ao código binário gerado pelo compilador Java (pois existem menos de 256 códigos de operação dessa linguagem, e cada “opcode” gasta um byte, dando origem ao nome bytecode). O compilador Java gera esse bytecode que, diferente das linguagens sem máquina virtual, vai servir para diferentes sistemas operacionais, já que ele vai ser “traduzido” pela máquina virtual.

Write once, run anywhere

Esse é um slogan que a Sun usa para o Java, já que você não precisa reescrever parte da sua aplicação toda vez que quiser mudar de sistema operacional. Muitas pessoas criticam ou criam piadas em cima desse slogan, por acharem que nem sempre uma aplicação Java pode rodar em duas plataformas diferentes sem problemas.

2.3 - Java lento? Hotspot e JIT

Hotspot é a tecnologia que a JVM utiliza para detectar pontos quentes da sua aplicação: código que é executado muito, provavelmente dentro de um ou mais loops. Quando a JVM julgar necessária, ela vai compilar aquele código para instruções nativas da plataforma, tendo em vista que isso vai provavelmente melhorar a performance da sua aplicação. Esse compilador é o JIT: Just inTime Compiler, o compilador que aparece “bem na hora” que você precisa. Você pode pensar então: porque a JVM não compila tudo antes de executar a aplicação? É que teoricamente compilar dinamicamente, a medida do necessário, pode gerar uma performance melhor. O motivo é simples: imagine um .exe gerado pelo VisualBasic, pelo gcc ou pelo Delphi, ele é estático. Ele já foi otimizado baseado em heurísticas, o compilador pode ter tomado uma decisão não tão boa. Já a JVM, por estar compilando dinamicamente durante a execução, pode perceber que um determinado código não está com performance adequada, e otimizar mais um pouco aquele trecho, ou ainda mudar a estratégia de otimização. É por esse motivo que as JVMs mais recentes (como a do Mustang, Java 6), em alguns casos , chega a ganhar em muitos casos de códigos C compilados com o GCC 3.x, se rodados durante um certo tempo.

2.4 - Versões do Java... e a confusão do Java

Java 1.0 e 1.1 são as versões muito antigas do Java. Com o Java 1.2 houve um aumento grande no tamanho da API, e foi nesse momento em que trocaram a nomenclatura de Java para Java2, com o objetivo de diminuir a confusão entre Java e Javascript. Mas lembre se, não há versão do Java 2.0, o 2 foi incorporado ao nome: Java2 1.2. Depos vieram o Java2 1.3 e 1.4, e o Java 1.5 passou a se chamar Java 5, tanto por uma questão de marketing e porque mudanças significativas na lingaugem foram incluídas. É nesse momento que o “2” do nome Java desaparece. Repare que para fins de desenvolvimento, o Java 5 ainda é referido como Java 1.5. Até a versão 1.4 existia a terceira numeração (1.3.1, 1.4.1, 1.4.2, etc), indicando bug fixes e melhorias. A partir do Java 5 existem apenas updates: Java 5 update 7, por exemplo. O Java 6 está previsto para o fim de 2006, mas sem mudanças na especificação da linguagem. Capítulo 2 O que é Java Página 6

Caelum – http://www.caelum.com.br Java e Orientação a Objetos Existe compatibilidade para trás em todas as versões do Java. Um class gerado pelo javac da versão 1.2 precisa necessariamente rodar da JVM 5.0.

2.5 - JVM? JRE? JDK?

O que você vai baixar no site do java? JVM = apenas a virtual machine, esse download não existe JRE = Java Runtime Environment, ambiente de execução Java, formado pela JVM e bibliotecas, tudo que você precisa para executar uma aplicação Java. JDK = Nós, desenvolvedores, faremos o download do JDK do Java SE (Standard Edition).

2.6 - Onde usar e os objetivos do Java

No decorrer do curso você pode achar que o Java tem baixa produtividade, que a linguagem a qual você está acostumado é mais simples de criar os pequenos sistemas que estamos vendo aqui. Queremos deixar claro de que a premissa do Java não é a de criar sistemas pequenos, onde temos um ou dois desenvolvedores, mais rapidamente que linguagens como php, perl, entre outras. O foco da plataforma é outro: aplicações de médio a grande porte, onde o time de desenvolvedores tem várias pessoas e pode sempre vir a mudar e crescer. Não tenha dúvidas que criar a primeira versão uma aplicação usando Java, mesmo utilizando IDEs e ferramentas poderosas, será mais trabalhoso que usar uma linguagem script ou de alta produtividade. Porém, com uma linguagem orientada a objetos e madura como o Java, será extremamente mais fácil e rápido fazer alterações no sistema, desde que você siga as boas práticas, recomendações e design patterns. Além disso, a quantidade enorme de bibliotecas gratuitas, para realizar os mais diversos trabalhos (tais como relatórios, gráficos, sistemas de busca, geração de código de barra, manipulação de XML, tocadores de vídeo, manipuladores de texto, persistência transparente, impressão, etc) é um ponto fortíssimo para adoção do java: você pode criar uma aplicação sofisticada, usando diversos recursos, sem precisar comprar um componente específico, que costuma ser caro de acordo com sua especialização. Cada linguagem tem seu espaço e seu melhor uso. O uso do java é interessante em aplicações que virão a crescer, em que a legibilidade do código é importante, onde temos muita conectividade e se temos plataformas (ambientes e sistemas operacionais) heterogêneos (linux, unix, OSX e windows misturados). Você pode ver isso pela quantidade enorme de ofertas de emprego procurando desenvolvedores Java para trabalhar com sistemas web e aplicações de integração no servidor. Apesar disto, a Sun empenha se em tentat popularizar o uso do Java em aplicações desktop, mesmo com o fraco marketshare do Swing/AWT/SWT em relação as tecnologias concorrentes (em especial Microsoft .NET).

2.7 - Especificação versus implementação

Outro ponto importante: quando falamos de Java Virtual Machine estamos falando de uma especìficação. Ela diz como o bytecode deve ser interpretado pela JVM. Quando fazemos o download no site da Sun, o que vem junto é a Sun JVM. Em outras palavras, existem outras Capítulo 2 O que é Java Página 7

CLASSPATH Caelum – http://www.caelum.com.br Java e Orientação a Objetos do curso a utilização dos pacotes java.io, java.util e java.net reforçarão todo nosso aprendizado, tendo em vista que essas bibliotecas foram desenvolvidas com o objetivo de reutilização e extensão, então elas abusam dos conceitos previamente vistos.

2.9 - Instalando o Java

Antes de instalar, baixe o JDK 5.0 ou superior, do site do Java da Sun, em http://java.sun.com. Pegue a versão internacional e cuidado para não baixar o que tem mais de 90 megas, que é a primeira opção na página de download: esta versão vem com o Netbeans, que é uma ferramenta da Sun, e não nos interessa no momento. Mais para baixo da página existe uma versão menor, algo em torno de 60 megas, sem essa ferramenta. Esse software disponível na Sun é gratuito, assim como as principais bibliotecas Java e ferramentas. É interessante você também baixar a documentação do JDK 5.0, o link se encontra na mesma página e possui outros 40 megas. O procedimento de instalação no Windows é muito simples: basta você executar o arquivo e seguir os passos. Instale o no diretório desejado. Depois disso, é necessário configurar algumas variáveis de ambiente, para que você possa executar o compilador Java e a máquina virtual de qualquer diretório. Em cada Windows você configura as variáveis de ambiente de uma maneira diferente. São duas as variáveis que você deve mudar: CLASSPATH=. PATH=;c:\diretorioDeInstalacaoDoJava\bin A variável PATH provavelmente já tem muita coisa e você só precisa acrescentar. Já a variável CLASSPATH deve ser criada. No Linux, são as mesmas variáveis, mas o PATH é separado por :. Nos Windows velhos, como o 98, você deve alterar isso no autoexec.bat. Nos Windows mais novos, como NT, 2000, e XP, procure onde você pode adicionar novas variáveis de ambiente (em Iniciar Painel de Controle – Sistema – Avançado Variáveis de Sistema). No Linux, geralmente a alteração deverá ser feita no arquivo ~/.bashrc se você não tiver privilégios de administrador. Se você possui dúvidas sobre a instalação e configuração geral do ambiente, consulte o tutorial no site do guj: http://www.guj.com.br.

Versões do Java

Existe uma quantidade assombrosa de siglas e números ao redor do Java. No começo isso pode ser bastante confuso, ainda mais porque cada biblioteca do Java mantém seu próprio versionamento. Talvez, o que seja mais estranho é o termo “Java 2”. Sempre que você for ler alguma coisa sobre Java, vai ouvir falar em Java2 ou J2 como prefixo de alguma sigla. Na verdade não existe Java 2.0, acontece que quando a Sun lançou a versão 1.2 do Java fizeram uma jogada de marketing e decidiram chamá la de Java 2. Hoje em dia, o Java está na versão 1.5, mas o marketing utiliza “Java2 5.0”.

Java 5.0 e Java 1.

Muitas pessoas estão migrando para o Java 5.0, mas como ele é mais recente, algumas empresas Capítulo 2 O que é Java Página 9

Caelum – http://www.caelum.com.br Java e Orientação a Objetos vão se prender ao Java 1.4 durante muito tempo. Houve uma mudança significativa na linguagem entre essas duas versões, com certeza a mais significativa). No decorrer do curso, todos os recursos e classes que forem exclusivamente do Java 5.0 terão este fato destacado. A versão Java 6.0 já está em desenvolvimento e com o provável lançamento no fim de 2006. Apesar do nome, não há mudança na linguagem prevista, apenas melhorias na JVM e novas bibliotecas.

J2EE? Java EE?

Se você está começando agora com Java, não deverá começar pelo J2EE. Isso não importa agora. Quando você ouvir falar em Servlets , JSP e EJB , isso tudo faz parte do J2EE. Apesar da esmagadora quantidade de vagas de emprego para Java estarem no J2EE , ela é apenas uma especificação, algo relativamente simples de aprender depois que você firmar bem os conceitos do Java. Novamente, não comece aprendendo Java através do J2EE.

2.10 - Compilando o primeiro programa

Vamos para o nosso primeiro código! O programa que imprime uma linha simples! 1.class MeuPrograma {

2. public static void main(String[] args) {
3. System.out.println("Minha primeira aplicação Java!!");
4. } 5.}

Notação

Todos os códigos apresentados na apostila estão formatados com recursos visuais para auxiliar a leitura e compreensão dos mesmos. Quando for digitar os códigos no computador, trate os códigos como texto simples. A numeração das linhas não faz parte do código e não deve ser digitada; é apenas um recurso didático. O java é case sensitive: tome cuidado com maiusculas e minusculas. Após digitar o código acima, grave o como MeuPrograma.java em algum diretório. Para compilar, você deve pedir para que o compilador de Java da Sun, chamado javac, gere o bytecode correspondente do seu código Java. Capítulo 2 O que é Java Página 10

Caelum – http://www.caelum.com.br Java e Orientação a Objetos deve entender. É como um assembly, escrito para esta máquina em específico. Podemos ler os menmônicos utilizando a ferramenta javap que acompanha o JDK: javap c MeuPrograma E a saída: MeuPrograma(); Code: 0: aload_ 1: invokespecial #1; //Method java/lang/Object."":()V 4: return public static void main(java.lang.String[]); Code: 0: getstatic #2; //Field java/lang/System.out:Ljava/io/PrintStream; 3: ldc #3; //String Minha primeira aplicaão Java!! 5: invokevirtual #4; //Method java/io/PrintStream.println:(Ljava/lang/String;)V 8: return } É o código acima que a JVM sabe ler. Sim, um bytecode pode ser revertido para o .java original (com perda de comentários e nomes de variáveis locais). Caso seu software vá virar um produto de prateleira, é fundamental passar um obfuscador no seu código, que vai embaralhar classes, métodos e um monte de outros recursos. (veja http://proguard.sf.net).

2.14 - Exercícios

1 ) Altere seu programa para imprimir uma mensagem diferente. 2 ) Altere seu programa para imprimir duas linhas de texto usando duas linhas de código System.out. 3 ) Sabendo que os caracteres \n representam uma quebra de linhas, imprima duas linhas de texto usando uma única linha de código System.out.

2.15 - O que pode dar errado?

Muitos erros podem ocorrer no momento que você rodar seu primeiro código. Vamos ver alguns deles: Código: 1.public class X {

2. public static void main (String[] args) {
3. System.out.println("Falta ponto e vírgula")
4. } 5.} Erro: X.java:4: ';' expected } ^ 1 error Capítulo 2 O que é Java Página 12

Caelum – http://www.caelum.com.br Java e Orientação a Objetos Esse é o erro de compilação mais comum: aquele onde um ponto e vírgula fora esquecido. Outros erros de compilação podem ocorrer se você escreveu palavras chaves (a que colocamos em negrito) em maiúsculas, esqueceu de abrir e fechar as {}, etc. Durante a execução, outros erros podem aparecer: Se você declarar a classe como X, compilá la e depois tentar usá la como x minúsculo (java x), o Java te avisa: Exception in thread "main" java.lang.NoClassDefFoundError: X (wrong name: x) Se tentar acessar uma classe no diretório ou classpath errado, ou se o nome estiver errado, ocorrerá o seguinte erro: Exception in thread "main" java.lang.NoClassDefFoundError: X Se esquecer de colocar static ou o argumento String[] args no método main: Exception in thread "main" java.lang.NoSuchMethodError: main Por exemplo: 1.public class X {

2. public void main (String[] args) {
3. System.out.println("Faltou o static");
4. } 5.} Se não colocar o método main como public: Main method not public. Por exemplo: 1.public class X {
5. static void main (String[] args) {
6. System.out.println("Faltou o public");
7. } 5.}

2.16 - Um pouco mais...

1 ) Procure um colega, ou algum conhecido, que esteja em um projeto Java. Descubra porque Java foi escolhido como tecnologia. O que é importante para esse projeto e o que acabou fazendo do Java a melhor escolha?

2.17 - Exercícios

1 ) Um arquivo fonte Java deve sempre ter a extensão .java, ou o compilador o rejeitará. Além disso, existem algumas outras regras na hora de dar o nome de um arquivo Java. Experimente gravar o código deste capítulo com OutroNome.java ou algo similar. Compile e verifique o nome do arquivo gerado. Como executar a sua aplicação agora?

Curiosidade

Tente compilar um arquivo sem nada dentro, nem uma letra, nem uma quebra de linha. O que acontece? Capítulo 2 O que é Java Página 13