[Cursos] Tutoriais sobre Java!

Conceito Java

O Java é uma linguagem de programação multiplataforma, com uma sintaxe
até certo ponto parecida com o C++, porém com bibliotecas diferentes. Os
programas em Java podem ser executados em qualquer sistema operacional,
desde que o interpretador esteja instalado.

A JVM é um programa que converte o código Java em comandos que o sistema
operacional possa executar. Existem máquinas virtuais para vários
sistemas operacionais: o problema é que, devido ao processamento
executado pela máquina virtual, o programa torna-se mais pesado do que
seria caso escrito diretamente para a plataforma.
Um exemplo de programa desenvolvido desta forma é o Mercury (um cliente
MSN com versões para Linux e Windows, um dos primeiros a oferecer
suporte a webcam e por isso bastante famoso). Embora o código fonte do
programa seja relativamente simples e bem escrito, ele é bem mais pesado
que outros programas similares, por causa da máquina virtual.

Explicando de forma mais elaborada, linguagens de programação
"tradicionais", como o C e o C++, utilizam um compilador diferente para
cada plataforma ou sistema operacional em que o programa irá rodar. O
código fonte em si pode ser escrito de forma a ser facilmente portável,
ou seja, rodar em diferentes versões do Unix ou em várias famílias de
processadores diferentes sem muitas alterações, mas ainda assim será
necessário recompilar o código fonte, gerando um binário diferente para
cada caso.

Embora o trabalho inicial seja maior, a vantagem desta abordagem é que o
desempenho é o melhor possível, já que sempre teremos um programa
binário otimizado para a plataforma.

O Java utiliza um conceito diferente. Ao invés de gerar um binário
diferente para cada plataforma, é gerado um binário que pode ser
executado em qualquer plataforma, dentro de uma máquina virtual. Este
binário "universal" é chamado de bytecode.

A idéia é criar aplicativos que possam ser escritos uma vez e a partir
daí serem executados em qualquer plataforma, reduzindo os custos de
desenvolvimento. Apenas o software da máquina virtual é que precisa ser
reescrito para cada plataforma, mas isso é problema dos desenvolvedores
da linguagem, não do programador.

Existe ainda a opção de abrir mão da flexibilidade do bytecode em troca
de um maior desempenho, passando a compilar os programas com otimizações
para uma determinada plataforma. Isso é muito útil quando o programa
será executado apenas dentro de computadores de uma certa plataforma,
como PCs rodando Linux, por exemplo.

No caso do Java, a máquina virtual que executa os programas é chamada de
Java Virtual Machine. Muitas páginas web utilizam applets Java, por
isso a maioria das pessoas acaba instalando o suporte a Java. Hoje em
dia, além do Java da Sun, temos versões alternativas, como o Blackdown e
o Kofee, que possuem conjuntos de recursos variados, mas são a
princípio compatíveis com o código gerado para o Java da Sun.

Embora tenha ganhado relevância com o Java, este conceito não é
exatamente novo. Linguagens mais antigas como o LISP e o Prolog já
utilizam bytecode e máquinas virtuais.

Diferença entre Java e Javascript

Ainda que os nomes sejam quase os mesmos, Java não é a mesma coisa que
Javascript! Essas são duas técnicas diferentes de programação na
Internet. Java é uma linguagem de programação. Javascript é uma
linguagem de scripting (tal como diz o nome). A diferença é que se pode
criar programas reais com Java. O mais das vezes, porém, você quer
apenas criar um efeito chamativo, sem se importar com qualquer programa
real. Assim, Javascript foi pensado como algo fácil de se compreender e
de se usar. Os autores de Javascript não têm que se importar muito com
programação. Nós poderíamos até dizer que Javascript é muito mais uma
extensão do HTML do que uma linguagem de computador separada.
Naturalmente essa não é uma definição "oficial" mas acho que ela torna
mais compreensível a diferença entre Java e Javascript.

Como os scripts do Javascript podem ser rodados?

O primeiro browser a suportar Javascript foi o Netscape Navigator 2.0. É
claro que as versões maiores também rodam Javascript. Você deve saber
que nem toda as versões de Netscape Navigator 2.0 (ou maiores) rodam
Java. Mas isso não é verdadeiro para o Javascript - ainda que existam
problemas entre as diferentes versões. A versão Mac, por exemplo, parece
ter apresentado muito defeito. No futuro próximo
deverá haver outros browsers que suportarão também o Javascript. O
Microsoft Internet Explorer 3.0, por exemplo, suportará Javascript.
Browsers habilitados ao Javascript tendem a se tornar daqui a pouco
muito populares, por isso vale a pena aprender essa técnica logo. Você
já deve estar imaginando que é realmente fácil escrever scripts de
Javascript. Tudo o que se tem a fazer é conhecer algumas técnicas
básicas, e trabalhar algum tempo em torno dos problemas que você pode
encontrar.
Naturalmente, você vai necessitar de um
básico de HTML antes de começar a ler este tutorial. Você pode achar
muitos recursos on-line sobre HTML que são excelentes. O melhor é fazer
uma busca on-line de 'html' no Yahoo, se você quer ficar por dentro da
matéria. (Esses documentos on-line são freqüentemente mais atualizados
do que livros: a Internet anda muito rápida atualmente...)

Java - por onde eu começo?

Se você nunca ouviu falar de Java, começe lendo o documento da Sun "What
Is the Java Platform" (O Que É A Plataforma Java). Se você já ouviu
falar, sugiro que você leia esse documento assim mesmo. Especialmente se
você nunca assistiu uma palestra minha. Isso vai te dar algumas
informações importantes sobre os objetivos basicos da tecnologia Java.
Outra forma de começar é ler o "Getting Started With Java Technology",
que é um documento com mais ou menos os mesmos objetivos desse meu, mas
bem mais resumido (mas que contém alguns links interessantes).

Outra coisa importante é que Java é uma tecnologia orientada a objetos.
Se você nunca ouviu falar disso, ou se você não conhece a terminologia
básica de orientacão a objetos, sugiro que você começe lendo algo a
respeito. Uma opção é ler a FAQ sobre OO, escolha o item "Basics" para
ver as terminologias básicas. Se você preferir o Java Tutorial (sobre o
qual eu falo mais pra frente), também contém um conjunto de lições com
informações básicas sobre OO.

Baixe o que você vai precisar...
Em seguida, você deve começar a se preparar para aprender Java de fato.
Java é uma tecnologia para desenvolvimento, e portanto, você vai
precisar de ferramentas, documentação, e mais algumas coisinhas. Se
prepare para algumas horas pendurado na Internet. Abaixo, eu listo o
imediato, e o que pode esperar um pouco:

* Java 2 SDK, Standard Edition - o SDK (software development kit)
contém todas as ferramentas para você começar o seu desenvolvimento em
Java. Você pode encontrar todas as versões e pacotes do SDK na página [Tens de ter uma conta e sessão iniciada para poderes visualizar este link]
e sempre é bom você conhecer essa página e o que você pode baixar a
partir dela. Para quem tem dificuldades com o inglês, ou não sabe
exatamente o que baixar, vá direto para a página do SDK para Solaris ou
para Windows[95/98/NT]. Nos dois casos, as instruções para o download
são os grandes números em vermelho. Não se esqueca de seguir o link para
as instruções de instalação. Se você quiser, você pode dar uma olhada
também na página de outras plataformas. Observe que nas listas de
discussão quase todo mundo trata o SDK como JDK (Java development kit),
que era como o SDK era chamado até a versão anterior. [uma palavrinha
sobre as versões de Java]
* Java 2 Standard Edition API Documentation - essa é a
documentação completa do SDK e de todas as APIs básicas do Java. Apesar
de você poder acessar via web, eu recomendo que você baixe e instale
localmente, já que você usará isso o tempo todo.
* Java Tutorial - esse é o tutorial que você vai utilizar para
aprender Java, e também pode ser utilizado direto da web o que é
recomendado, já que você não precisa de tudo de uma só vez. Mas se você
quiser, pode baixa-lo também.
[size=18] * NetBeans [size]- essa é uma poderosa ferramenta de
desenvolvimento, que você irá utilizar mais pra frente, depois de ter
aprendido o básico. Portanto, também pode deixar para baixar depois (mas
não deixe de fazê-lo!). O NetBeans é uma ferramenta da Sun, ela própria escrita em Java, e é disponibilizada gratuitamente. Pode ser baixada a partir do site [Tens de ter uma conta e sessão iniciada para poderes visualizar este link]
(OBS: muita gente me pergunta se não tem uma outra alternativa para
baixar essas coisas, ou se pode vir aqui na Sun buscar. Descupe, mas não
dá pra fazer isso. Se você realmente tiver problemas, compre um CD que
contém tudo isso, e muito, muito mais...)

Depois de baixar tudo, instale o SDK, a documentação, e se você tiver
baixado, o Java Tutorial. O NetBeans você pode instalar se quiser, mas
eu sugiro que você não o utilize antes de ter aprendido o básico com as
ferramentas mais rudimentares do SDK.

Antes de mais nada, entenda a documentação...

Uma das coisas mais importantes, é saber procurar na documentação. No
diretório em que foi instalada a documentação, voce encontrará um
arquivo "index.html", que te dará links para os principais documentos
que você estará utilizando. Observe que ao lado de cada link indica se
isso faz parte da documentação que você baixou (docs) ou se está na web
(website).

O link mais importante que você vai precisar aprender a usar é o que se
encontra no subtítulo "API & Language Documentation", e é o link
"Java Platform 1.2 API Specification". Grande chances de você não
entender nada nesse ponto, mas siga esse link, e procure entender o que
significa a página seguinte (se você decidiu não baixar a documentação,
voce pode acessar essa mesma página através desse link):

* o frame pequeno no canto superior esquerdo lista os pacotes (packages)
Java disponíveis. Considere esses pacotes como um agrupamento de
classes similares. Em Java, as classes são separadas nesses packages, e
portanto, é importante que voce entenda o que cada package contém, pois
isso te facilitará na hora de procurar o que você precisa.
* o frame comprido no canto inferior esquerdo lista as classes do pacote
escolhido no frame anterior. Quando você carregar essa pagina pela
primeira vez, você verá aqui a lista de todas as definicões de objetos
da Java.
* o frame grande que ocupa o resto da pagina te fornece a documentação
da classes que você escolheu. Ele começa mostrando uma descrição de alto
nível dos pacotes Java existentes. Eu sugiro que antes de mais nada
você leia essa descrição de cada pacote, para você já começar a se
acostumar a procurar o que você precisa.

A correta utilização da documentação irá facilitar enormemente o seu
aprendizado e é ponto fundamental para que você se torne um bom
programador Java. Portanto, leia a descrição dos packages (ainda que
algumas delas não signifiquem muito nesse momento), e gaste alguns
minutos navegando na documentação e tentando entender o que acontece
quando você clica em cada coisa. Quanto melhor você souber usá-la melhor
profissional você será.

Meu caro novato, te apresento o Java Tutorial!

Um dos mais lindos recursos existentes para você que esta começando (e
mesmo para pessoas mais experientes) é o Java Tutorial. Nele você vai
encontrar tudo o que você precisa para começar a aprender Java, e mais
tarde, para aprender cada uma das dezenas de tecnologias envolvidas.

O Java Tutorial é dividido em "trails" (caminhos), e cada um deles vai
te levar através de uma série de lições que vão cobrir diversos aspectos
do assunto abordado. Sempre que você quiser aprender algum aspecto da
tecnologia Java, o primeiro lugar para você olhar deverá ser sempre o
Java Tutorial.

Portanto, o seu próximo passo na sua busca pelo
é seguir os "trails" que estão na seção "Trails Covering the Basics".
Vão ser um total de umas 20 a 30 pequenas lições, que vão cobrir desde
os primeiros passos na criação e compilação de uma aplicação Java,
conceitos básicos de orientação a objetos, as classes mais importantes
de Java, e que vai chegar até a criação de aplicações e uma visão geral
das funcionalidades existentes.

Lembre-se que o Java Tutorial pode ser visto na web ou então, você pode baixa-lo e instalá-lo localmente.

Mas só comando de linha?
Muita gente que vem do mundo de desenvolvimento visual acaba se
assustando com as ferramentas básicas que fazem parte do Java
Development Kit (JDK). É extremamente importante que você aprenda essas
ferramentas, pois elas te obrigam a entender algumas coisas que as
ferramentas visuais acabam por esconder.

Mas para o desenvolvimento em Java existem dezenas de ferramentas, e
entre elas existem ferramentas tão e até mais sofisticadas do que as
ferramentas existentes para outras linguagens. Portanto, eu aconselho
que como parte do seu aprendizado, você coheça pelo menos uma dessas
ferramentas, e eu sugiro que você faça o download da ferramenta
NetBeans, uma ferramenta de desenvolvimento Java, visual, ela própria
escrita em Java (assim você inclusive tem uma idéia de que aplicações
muito sofisticadas podem ser desenvolvidas inteiramente em Java, e que
Java tem performance adequada), e é totalmente gratuita.

Sugestões de cursos , livros?

Honestamente, siga o Java Tutorial. É de graça, e depois que você tiver
feito todas as lições do Java Tutorial, você terá capacidade de procurar
livros e cursos que atendam as suas necessidades.

Para aqueles que ou não conseguem aprender por conta própria
(ou porque não tem tempo, ou porque tem dificuldades com o inglês, ou
porque não adianta tentar aprender no ambiente de trabalho e é melhor
sair pra fazer um curso) ou que por qualquer outro motivo tenham
preferência por assistir um curso, a Sun Education possuiu uma linha
muito legal de cursos de Java (em especial os cursos mais avançados), e
eu recomendo.

Apenas lembre-se de, depois de ter feito o curso, percorrer o Java
Tutorial. Você terá que fazer uma dezena de cursos para cobrir tudo o
que o tutorial cobre...

Quanto a livros, bem, isso fica para um outro documento. Mas você sempre
pode consultar a lista de livros da JavaWorld, que procura listar todos
os títulos que já foram impressos sobre Java. É livro que não acaba
mais...

Para onde eu vou depois disso?

Aqui é que as coisas começam a ficar interessantes.

Em primeiro lugar, filie-se ao Java Developer Connection, é gratuito, e é
a única forma que você terá de ter acesso a alguns recursos mais
técnicos de extrema importância. Lembre-se de guardar o seu login e
password que você gerar, já que você irá precisar disso depois.

Depois, procure algum grupo de usuários Java (JUG - Java User's Group) próximo
da sua região e filie-se a ele. Independente de existir algum JUG na
sua região, você deve considerar filiar-se à Sociedade de Usuários Java -
SouJava, que além de ser o maior JUG brasileiro, e também o grupo do
qual sou coordenador técnico.

Como forma de aprimorar a sua capacidade em Java, dê uma olhada em como
resolver problemas com a tecnologia Java nesse artigo "Buscando a
Solução na Web".

Além disso, sugiro que você conheça e frequente os seguintes links:

* java.sun.com - o principal site de Java
* SouJava - Sociedade de Usuários Java da Sucesu-SP
* Meus links pessoais - aqui estão os meus links sobre Java e tecnologias relacionadas;
* FAQs (frequently asked questions)
o Lista de FAQs da Sun
o Java Programmer's FAQ
o Lista de FAQs da About.com
o FAQ do SouJava (em portugues)




O que é Java?

Java é uma tecnologia. É um mundo tão grande que ninguém se arrisca a
dizer: ? Eu sei Java ?. Basicamente constitui-se de uma linguagem de
programação e um programa para execução chamado de máquina virtual ou
virtual machine. Quando programa-se em Java usa-se a linguagem de
programação Java e um ambiente de desenvolvimento Java para gerar um
software que será executado em um ambiente de distribuição Java. Tudo
isso é a tecnologia Java.

1.1 O que pode ser feito em Java?

TUDO! Java é uma linguagem que não se prende a nenhuma arquitetura e a
nenhuma empresa, é rápida e estável. Pode construir sistemas críticos,
sistemas que precisam de velocidade e até sistemas que vão para fora do
planeta, como a sonda Spirit enviada pela Nasa para Marte. Java tem um
mar de projetos open source, que estão lá, esperando por usuários e
desenvolvedores.

Java tem o apoio, a participação e o patrocínio das maiores organizações
e empresas de tecnologia do Mundo: Oracle, Sun Microsystems, IBM, Nokia
Corporation, Hewlett-Packard, Borland Software Corporation, Apache
Software Foundation, SAP AG, SavaJe Tenologies, Apple Computer Inc,
Cisco Systems, Fujitsu Limited, Macromedia Inc, Rational Software,
Unisys, America Online, Hitachi LTDA, Mitsubishi Eletric Corp, NEC, Sony
Internacional, Sharp, Ericsson Inc, Matsushita Eletric, Motorola,
Samsung Eletronics, Siemens AG, Symbian, Novell, PalmSource Inc, BEA
Systems, Object People e muitas outras.

1.2 Um pouco de história

A tecnologia Java começou a ser criada em 1991 com o nome de Green Project. O projeto era esperado como a próxima
geração de software embarcado. Nele trabalhavam James Grosling, Mike
Sheridan e Patrik Naughton. Em 1992 surge a linguagem ? Oak ? a primeira
máquina virtual implementada. Várias tentativas de negócio foram feitas
para vender o ? Oak ? mas nenhuma com sucesso.

Em 1994 surge a internet, a Sun vê uma nova possibilidade para o Green
Project e cria uma linguagem para construir aplicativos Web baseada na
Oak, a Java. Em 23 de maio de 1995 a linguagem Java é oficialmente
lançada na SunWorld Expo 95 com a versão JDK 1.0 alpha. A Netscape
aposta na idéia e inicia a implementação de interpretadores Java em seu
navegador, possibilitando a criação de Java applets. A partir desta
etapa o Java começa a crescer muito.

Em 1997 é lançado a prova da maturidade da tecnolo

De 1998 até hoje a tecnologia evoluiu muito possuindo um dos maiores
repositórios de projetos livres do mundo, o java.net. Em 1999 surgiu a
plataforma para desenvolvimento e distribuição corporativa batizado de
Java 2 Enterprise Edition (J2EE) e a plataforma Java 2 Mobile Edition
(J2ME) para dispositivos móveis, celulares, PDAs e outros aparelhos
limitados.

Atualmente Java é uma das linguagens mais usadas e serve para qualquer
tipo de aplicação, entre elas: web, desktop, servidores, mainframes,
jogos, aplicações móveis, chips de identificação, etc.

Você sabia que seu cartão de crédito pode ter um JavaCard?

1.3 Máquina Virtual?

Java é multiplataforma. Quando um programa Java é compilado um código
intermediário é gerado, chamado de bytecode. Este bytecode é
interpretado pelas máquinas virtuais java (JVMs) para a maioria dos
sistemas operacionais. A máquina virtual é a responsável por criar um
ambiente multiplataforma, ou seja, se alguém construir um sistema
operacional novo, basta criar uma máquina virtual java que traduza os
bytecodes para código nativo e pronto! Todas as aplicações java estarão
rodando sem problemas.

Entre outras funções, a máquina virtual java também é responsável por
carregar de forma segura todas as classes do programa, verificar se os
bytecodes aderem a especificação JVM e se eles não violam a integridade e
a segurança do sistema.

A figura 1.1 mostra como acontece a compilação e a execução de um
programa Java. De um código Java, que está em um arquivo. java, o
compilador javac gera o bytecode: um arquivo. class. Após isso uma
máquina virtual java executa o bytecode e roda o programa.

[Tens de ter uma conta e sessão iniciada para poderes visualizar esta imagem]

Figura 1.1: Compilador e Interpretador Java

1.4 As três grandes edições

Java se divide em três grandes edições.

* Java 2 Standard Edition (J2SE): É a tecnologia Java para
computadores pessoais, notebooks e arquiteturas com poder de
processamento e memória consideráveis. Várias APIs acompanham esta
versão e tantas outras podem ser baixadas opcionalmente no site da Sun. É
com elas que a maioria das aplicações são construídas e executadas. O
J2SE possui duas divisões:
o Java Development Kit (JDK) ou Standard Development Kit
(SDK): um conjunto para desenvolvimento em Java e deveria ser instalado
apenas pelos desenvolvedores por possuir ferramentas para tal tarefa.
o Java Runtime Edition JRE: uma versão mais leve da JDK pois é
preparada para o ambiente de execução, ou seja, é esta versão que
executará os sistemas construídos com a SDK.
* Java 2 Mobile Edition (J2ME): É a tecnologia Java para
dispositivos móveis com limitações de memória ou processamento. Possui
APIs bem simples e leves para economizar espaço, memória e
processamento. São utilizadas para sistemas em celulares, palm tops,
pocket pcs, smartphones, javacards e demais dispositivos. O J2ME se
divide em dois grupos de bibliotecas. É dividida em dois grupos:
o Connected Limited Device Configuration (CLDC): Para celulares e smartphones, que são mais limitados
o Connected Device Configuration (CDC): Para Palmtops e Pocket pcs e alguns dispositívos mais poderosos.
* Java 2 Enterprise Edition (J2EE): É a tecnologia Java para
aplicações corporativas que podem estar na internet ou não. Possui um
grande número de APIs onde a segurança é a principal preocupação. É
ideal para a construção de servidores de aplicação, integração de
sistemas ou distribuição de serviços para terceiros.

Neste tutorial nós iremos estudar apenas a edição J2SE para desenvolvimento de aplicações desktop comuns.

1.5 Java 2 Standard Edition

Podemos analisar na figura 1.2 toda a complexidade da arquitetura J2SE.
Este gráfico, mostra todos os recursos que estão disponíveis, incluindo a
separação entre JRE e JDK.

[Tens de ter uma conta e sessão iniciada para poderes visualizar esta imagem]

Umas da maiores e, talvez, mais usadas APIs da J2SE é a Swing. Swing é
uma biblioteca de classes para a construção de interfaces gráficas em
ambiente desktop. Entre as classes existentes estão: Telas, botões,
diálogos, mensagens, editores, entre outros. Esta biblioteca será vista
logo após a linguagem java.

1.6 Instalação e Execução

O Java está disponível para download no site da Sun: [Tens de ter uma conta e sessão iniciada para poderes visualizar este link]
clicando em J2SE. Agora é só escolher a versão desejada, clicar em
downloads e escolher o subgrupo desejado JDK para desenvolvedores ou JRE
para usuários finais. Neste site também existe para download o
NetBeans, que é uma ferramenta para desenvolvimento Java livre. Para os
iniciantes a sugestão é baixar somente o JDK, sem o NetBeans e utilizar
algum editor de texto para escrever seus programas. Quando não se usa a
IDE o desenvolvedor é forçado a aprender muito mais.

Após escolher o grupo, a licença do Java é mostrada. Aceitando a licença da Sun, aparecerão as verões próprias
para cada sistema operacional. Basta escolher o mais apropriado e
aguardar o download. A instalação é simples, não é demorada e depende de
cada sistema operacional. Geralmente, basta executar o arquivo baixado e
seguir as instruções.

Após a instalação pode-se ir até um shell ou um prompt de comando e
digitar java - version. O comando fará aparecer a versão da máquina
virtual instalada. No diretório de instalação do Java encontra-se uma
pasta bin e dentro dela existem várias ferramentas. Na tabela 1.1 Mostra
a descrição de algumas delas.

Executável Nome Descrição
=================================================
appletviewer Java Applet Viewer Visualizar applets sem navegador.
----------------------------------------------------------------------------------------
java Interpretador Java Executa programas java.
----------------------------------------------------------------------------------------
javac Compilador Java Compila programas java.
----------------------------------------------------------------------------------------
javadoc Documentador Gera documentação pelos coment.
----------------------------------------------------------------------------------------
jar Compactador Compacta em um único arquivo.
----------------------------------------------------------------------------------------
javap Disassemblador Java Mostra o código de um. class.
----------------------------------------------------------------------------------------
jdb Java Debugger Debug de programas java.
=================================================

Tabela 1.1: Ferramentas disponíveis para os desenvolvedores

Estas ferramentas são invocadas via linha de comando e são úteis quando
queremos independência de ambiente de produção. Utilizando elas, o único
recurso necessário é um editor de textos, como um Notepad, para
desenvolver o código. Ainda no diretório de instalação do Java,
encontra-se uma pasta docs onde estarão todos os documentos necessários
para o desenvolvimento. Outros manuais e documentação de APIs podem ser
baixadas no site da Sun.

1.7 O compilador javac

O javac é um compilador de código fonte java com uma saída em bytecodes,
os. class. É encontrado dentro da pasta bin da instalação. Para
executá-lo, siga essas regras:


Código:

> javac [opções] [...]

Pode-se compilar um ou mais arquivos utilizando as características de cada sistema operacional, como:


Código:

> javac MinhaPrimeiraClasse.java
> javac MinhaPrimeira. *
> javac MeuProjeto

Uma série de opções que podem ser utilizadas são mostradas na tabela abaixo:


Código:

Opção e descrição


Código:

- classpath: Especifica o caminho para as classes / bibliotecas.
- cp: [caminho] Especifica o caminho para as classes / bibliotecas.
- d: [dir] Diretório para armazenar os arquivos compilados.
- source: Localização dos fontes para serem compilados.
- deprecation: Advertência para funções que não devem ser utilizadas.
- g: Compila com tabelas de debug.
- nowarn: Desativa as mensagens de Warning.
- verbose: Mostra detalhes da compilação.
- depend: Compila todos os fontes, incluindo suas dependências.
- target: Especifica a versão da JVM que irá executar o programa.
- O: Otimização de código para gerar programas mais rápidos.
- version: Informa a versão do javac.
- help: Pequena ajuda com lista de opções.
- X: Opções avançadas de compilação.
- J: Passa um parâmetro fixo para o interpretador.


Código:

1.8 O interpretador java

O aplicativo java, encontrado na pasta bin da instalação, executa aplicações java compiladas (bytecodes). Para utilizá-lo, siga as instruções:


Código:

java [opções] [argumentos de entrada do programa] java [opções] - jar [argumentos de entrada do programa]

Exemplo:


Código:

> java MinhaPrimeiraClasse
> java - jar MeuPrimeiroJar

As opções possíveis são listadas na tabela abaixo:


Código:

Opção Descrição

- classpath: Especifica o caminho para as classes / bibliotecas.
- cp: Especifica o caminho para as classes / bibliotecas.
- verbose: Mostra detalhes da compilação.
- version: Informa a versão do javac.
- help: Pequena ajuda com lista de opções.
- X: Opções avançadas de interpretação.
- Xdebug: Permite o uso do depurador.
- D =: Definição de propriedades com a chave nome = valor.

O interpretador javaw é utilizado opcionalmente em programas
gráficos. O java cria uma janela de comandos a cada execução do
programa, já o javaw não. Para executar uma applet usa-se o utilitário
appletviewer, também encontrado na pasta bin da instalação do java.
Neste caso, não é necessário um navegador para a visualização.

2 O que é Java?

Começamos nesta seção a colocar a mão na massa desenvolvendo código, compilando, executando e testando.

A linguagem Java possui um princípio: ? Mantenha-na simples, pois o que é
complexo é difícil de construir, testar, depurar, aprimorar e explicar.
? Visando continuar com este princípio, no código 2 está um pequeno e
simples exemplo muito conhecido em todas as linguagens. O Olá Mundo!
feito em linguagem Java.


Código:

// Olá mundo em java.
// Arquivo BemVindo.java.
public class BemVindo {
** public static void main(String[] args) {
******System.out.println("Olá Mundo!");
** }
}

Este código deve ser salvo em um arquivo com o nome BemVindo.java
e em seguida deve-se executar: javac BemVindo.java estando na pasta que
contém o arquivo. Este comando irá gerar um BemVindo.class que é o ?
executável ? do java. Para rodar o programa, basta digitar: java
BemVindo. Será impresso na tela do prompt o texto: Olá Mundo!.

Todo código fonte em Java deve ser salvo com a extensão. java. O
compilador irá gerar no mínimo um. class para cada. java existente.

Este código não é muito diferente de um código em linguagem C, isto
acontece porque a linguagem Java foi criada com base na linguagem C
possuindo quase todas as palavras reservadas dela e um conceito que
deixa muitos desenvolvedores descontentes: o case-sensitive. Isso mesmo,
Java é case-sensitive, portanto maiúsculas são diferentes de
minúsculas, ? a ? é diferente de ? A ?.

Ao contrário do C, Java é fortemente tipada, tanto que não existe nenhum
tipo de variável primitiva indefinido como o variant do Delphi e não
possui ponteiros. Java não possui herança múltipla de classes, diretivas
de pré-compilação,
modelos (Templates) e nem funções sem classes. A semântica de orientação
a objetos é do SmallTalk, uma famosa e antiga linguagem totalmente
orientada a objetos.

No java, os comandos são terminados com o sinal de ponto e vírgula ?; ? e
os blocos de código tem inicio e tem o seu fim representados pelo uso
das chaves ? {? e ?} ? respectivamente. Não existe restrição com espaços
em branco, com tabulação ou nova linha, ficando a cargo do
desenvolvedor definir o formato do código fonte.

2.1 Explicando o Olá Mundo!

Iniciaremos pela linha 3, public class BemVindo onde existe uma
definição de classe. Cada arquivo java tem, pelo menos, uma classe
definida e uma classe pública. O nome da classe pública deve ser o mesmo
do nome do arquivo, considerando a propriedade case-sensitive da
linguagem. Mais a frente será tratado a visibilidade dos
identificadores. Por convenção todo a nome de classe deve iniciar com
uma letra em maiúscula e a cada nova palavra a primeira letra também
deve ser maiúscula, como no exemplo.

Na linha 4, public static void main (String [] args) existe a definição
de um método. Este método é essencial para todo o programa java. O
método main é o que será chamado para iniciar a execução da aplicação, é
o início de tudo. Este método deve ser público public, estático static,
sem retorno (void) e deve possuir um array de cadeia de caracteres
String [] como parâmetro. Nesta cadeia de caracteres é que virá os
argumentos / parâmetros da aplicação. Todos esses conceitos serão vistos
mais adiante.

A linguagem Java diferencia os métodos dos atributos pelo uso dos
parênteses (e). Nela todos os métodos, sem exceção, usam parênteses
tanto na definição quanto no uso, mesmo aqueles que não possuem
parâmetros.

Na linha 5, System.out.println (" Olá Mundo! "); existe uma chamada de
método. É a primeira e a última linha de código que será executada pelo
interpretador Java. System é uma classe que mantém uma série de
configurações sobre o sistema que a máquina virtual está executando. Uma
dessas configurações é o atributo público out, que define o local onde
está a saída padrão. O atributo out é uma variável de escrita da classe
PrintStream que possui o método println (). Este método é quem irá
enviar a mensagem Olá Mundo! para o prompt ou shell exibir.

2.2 Comentários e documentação

Analisando o código, pode-se constatar que a linha 1 e a linha 2 possuem
os caracteres // o que significa que são comentários de programa. Este é
o comentário de linha e tudo que estiver depois da // não será
compilado. Para fazer um comentário com mais de uma linha, o comentário
de bloco, utiliza-se a construção /* e */. Os caracteres /* abrem um
bloco de comentário e */ fecham o bloco. Por exemplo:


Código:

/* Este é um comentário de bloco para o programa
** BemVindo.java que apresentará a mensagem Olá
** Mundo! para quem o executar. */

Este tipo de comentário pode-se estender por muitas linhas,
quantas o programador achar necessário. Mas não abuse, comentário demais
também complica o sistema. As duas maneiras de comentário acima são
herdadas das características da linguagem C. Mas a linguagem Java não
foi só cópia, ela inventou o conceito de comentário de documentação.
Este comentário é específico para quem precisa saber o que o fonte faz
sem ver o código, ou seja, é um comentário para documentos. Este tipo de
comentário é semelhante ao comentário de bloco, mas abre o bloco com um
asterisco a mais: /** e fecha com o mesmo */. Exemplo:


Código:

/**
** Esta classe chamada de BemVindo é simplesmente
** um Olá Mundo! da linguagem Java.
** @author Vitor Fernando Pamplona
** @since 15/01/2005
*/
public class BemVindo {
** public static void main(String[] args) {
******System.out.println("Olá Mundo!");
** }
}

Este tipo de comentário não é compilado pelo javac, mas é
considerado por uma outra aplicação, o javadoc que está dentro da pasta
bin da instalação do java. O javadoc copia os comentários e compila
determinadas tags gerando várias páginas HTML como a figura abaixo. O
comentário de documentação deve ser sempre adicionado acima do ítem que
se deseja comentar, escrevendo primeiramente o seu texto e após
adicionando as tags como no exemplo de código 2.2.

[Tens de ter uma conta e sessão iniciada para poderes visualizar esta imagem]

Figura 2.1: HTML gerado do exemplo de código 2.2

Como são geradas páginas HTML o desenvolvedor pode adicionar códigos
HTML a vontade na documentação, pois elas serão copiadas e farão o seu
papel no arquivo HTML gerado. O JavaDoc compila somente as tags de
documentação, iniciadas pela ? @ ?, para melhorar o visual e padronizar a
documentação. Entre as tags mais freqüentes estão:


Código:

Nome Descrição


Código:

@ author: Atribui uma classe ou método a um autor.
@ since: Data da escrita do código
@ version: Versão de determinada classe ou método
@ see: Indicação de ? Leia Mais ?
@ param: Parametro de um método
@ return: Retorno de um método
@ throws: Possíveis exceções lançadas que veremos mais a seguir
@ deprecated: Componente deve ser removido nas próximas versões

2.3 Convenção da linguagem

Na linguagem Java é utilizada a seguinte convenção para formação de identificadores:

* Constantes com todas as letras em maiúsculo: CONSTANTE
* Variáveis começam com letra minúscula: variável
* Classes começam com letra maiúscula: Classe
* Se o nome for composto, cada nome começa com letra maiúscula: variávelComNomeComposto

Esta é a famosa linguagem Java e esta foi a primeira parte do tutorial.
Em seguida, veremos algumas das características da linguagem java.



3. Características Básicas

Este capítulo apresenta as características básicas da linguagem, como
identificadores, palavras chave, valores literais, tipos de dados e
operadores.

3.1 Palavras chave e valores literais

Java possui 49 palavras chave, todas elas são escritas em minúsculas:

byte - short - int - long - char - boolean -
double - float - public - private - protected - static - abstract -
final - strictfp - transient - synchronized - native - void - class -
interface - implements - extends - if - else - do - default - switch -
case - break - continue - assert - const - goto - throws - throw - new -
catch - try - finally - return - this - package - import - instaceof -
while - for - volatile - super

Possui três identificadores que são valores literais:

null, false, true

Cada uma dessas palavras serão vistas mais adiante no tutorial.

3.2 Tipos primitivos

Existem somente oito tipos primitivos em Java, todo o resto é objeto.
Estes tipos ficaram na linguagem pela sua velocidade de interação, e por
isso não foram transformados em Objetos. Como não são objetos a sua
declaração já cria a variável em memória não necessitando de
construtores.

Nesta seção os tipos Array e String não são tratados, pois não são
considerados tipos primitivos. Ambos são classes e serão tratadas no
capítulo sobre classes.

3.2.1 Numéricos inteiros

Todos esses tipos possuem uma representação interna em complemento de
dois. O valor default para esses atributos é 0 e cada vez que se usar
uma constante numérica no código fonte ela será um int a não ser que se
coloque a constante? L? no final do número.


Código:

* byte - Tamanho de 8 bits com sinal. Valores de - 128 a + 127.
** * short - Tamanho de 16 bits com sinal. Valores de - 32.768 a + 32.767.
** * int - Tamanho de 32 bits com sinal. Valores de - 2.147.483.648 a + 2.147.483.647.
** * long - Tamanho de 64 bits com sinal. Valores de - 9.223.372.036.854.775.808 a + 9.223.372.036.854.775.807.

Exemplo:


Código:

100L = > long
** 100 = > int
** 0L = > long
** 0 = > int

Não existe os tipos unsigned, long int ou short int em Java.

3.2.2 Ponto flutuante

Os pontos flutuantes seguem a representação IEEE 754, sendo que 0.0 é o
valor default. No código fonte, tudo o número com decimais será um float
a não ser que o caractere ? d ? ou ? D ? estejam no final do número.


Código:

* float - Tamanho de 32 bits com sinal. Valores de - 1.40239846E-45 a + 3.40282347E + 38 (com nove dígitos significativos de precisão).
** * double - Tamanho de 64 bits com sinal. Valores de - 4.94065645841246544E-324 a + 1.79769313486231570E + 308 (com 18 dígitos significativos de precisão).

Exemplo:

Código:

100.0 = > float
** 100.00d = > double
** 0 = > float
** 0f = > float
** 0d = > double

3.2.3 Caractere

O caractere guarda o valor traduzido de um código ASCII. Seu valor default é o código zero, \ 0;


Código:

char - Caractere Unicode com tamanho 16 bits sem sinal. Valores possíveis 0 a 65535

O char também pode ser representado por um numero inteiro de 16
bits sem sinal, ou seja, pode-se atribuir à uma variável char o valor
100 ou o valor 65535, pois se está operando com os valores da tabela
Unicode que representam caracteres de qualquer idioma.

3.2.4 Booleano

Tipos boleanos identificam verdadeiro ou falso e podem ser utilizados
diretamente em expressões de retorno para testes como if, switch, while e
for., porém não podem ser comparados com variáveis ou constantes
numéricas como em C.


Código:

boolean - Valor indicando true ou false. Tamanho de 8 bit.

3.2.5 Valores padrão

Abaixo segue uma lista com os valores padrões de todos os tipos
primitivos, sendo que não é necessário inicializar as variáveis com
esses valores, a máquina virtual cuidará desse trabalho.


Código:

* byte = 0;
** * short = 0;
** * int = 0;
** * long = 0;
** * float = 0.0;
** * double = 0.0;
** * boolean = false;
** * char = ` \ u0000 ';
** * Object = null;

Um objeto, como veremos mais adiante, é inicializado com valor
null, pois ele necessita que a instância seja criada explicitamente, o
que não ocorre em tipos primitivos.

3.3 Identificadores

Os identificadores em Java iniciam com uma letra, um sublinhado ? _ ?
ou um sinal de dólar " $ " e podem possuir números após o primeiro
caractere da palavra. Pela premissa de ser case-sensitive existe uma
diferenciação entre letras maiúsculas e minúsculas. Identificadores
válidos são: identificador, meu_Carro, MeuCarro2, _atributo, $bola _2seg

Identificadores usados para determinar nomes de variáveis, atributos de classe ou de instância, parâmetros e métodos.

3.4 O operador de atribuição

O sinal de atribuição em Java é o " = " igual ao " = " do C e ao ": = "
do Delphi. Vale deixar gravado que a comparação é feita com " = = " como
no C. Uma atribuição é feita com a seguinte sintaxe:


Código:

=;

Veja o exemplo:


Código:

public class Atribuição {
**** public static void main (String [] args) {
********int x = 1;
********int y = 5;
**** }
** }

No exemplo é atribuído as variáveis inteiras x e y os valores 1 e 5 respectivamente.

3.5 Literais

O valor literal é um valor escrito no código fonte e identificado como de um tipo primitivo.


Código:

int x = 1; // literal inteiro
** char u = 'a'; // literal char
** boolean b = true; // literal boolean
** double d = 002.11d; // literal double

Há três maneiras de representar literais numéricos inteiros em Java:

- octal (base . Representado com um 0 na frente de cada valor numérico. Exemplo:


Código:

int x = 01;
** int x = 0931;
** int x = 021;

- hexadecimal (base 16). Representado com um 0x na frente de cada valor numérico. Exemplo:


Código:

int quinze = 0xF; // 15 (decimal)
** int vinte_e_nove = 0x1D; // 29 (decimal)
** int vinte_e_nove = 0x1D; // 29 (decimal)
** int valor = 0xBAFAFA; // 12253946 (decimal)
** int valor = 0XBaFaFa; / / 12253946 (decimal)

- decimal (base 10). Representado normalmente como o primeiro exemplo.

Caracteres também possuem representação especial. Todo o caractere se
encontra entre aspas simples, porém pode-se atribuir um valor inteiro ao
caractere sem precisar de uma conversão explícita. Alguns exemplos são:


char a = 'A'; // letra A
char b = '&'; // caractere &
char c = '\u004D'; // letra M (Unicode)
char d = '\n'; // Pula de linha
char e = '\t'; // Tab
char f = '\r'; // Retorno de carro
char g = '\b'; // Backspace
char h = '\f'; // FormFeed
char i = '\'; // Barra
char j = '''; // Apostrofo
char k = '"'; // Aspas duplas
char l = 65; // char recebe o valor de um int
char m = (char) -1; // fora do intervalo, conversão explícita
char n = (char) 100000; // fora do intervalo, conversão explícita

3.6 Conversões entre tipos primitivos


Existem duas maneiras de fazer conversões de tipos:

1. Conversão implícita, quando o tamanho de uma variável é maior que o
tamanho da variável ou o valor que está sendo atribuído. Exemplo:

Código:

int y = 10;
** long x = y;

O tamanho de int é menor que o de long, portanto é perfeitamente aceitável.

2. Conversão explícita, quando o tamanho de uma variável é menor que o
tamanho da variável ou o valor que está sendo atribuído. Exemplo:


Código:

long y = 10L;
** int x = (int) y;

O tamanho de long é maior que o de int, portanto necessita indicar
uma conversão. Esta indicativa é feita pelo tipo da variável, que irá
receber o valor, entre parênteses: (int). Se esta informação não for
colocada, ocorreria um erro de compilação indicando tipos incompatíveis.
Outra forma é usar as constantes de identificação de tipos para fazer
uma conversão explícita, como em: long y = 10L;

3.7 Operadores aritméticos

Operadores aritméticos são aqueles que efetuam operações aritméticas em
um ou mais tipos primitivos. A seguir são apresentados os operadores
aritméticos unários, que atuam sobre um único identificador.


Código:

Op**Nome************Uso********Descrição
** ++**Incremento**var++ / ++var**Retorna e adiciona / adiciona e retorna.
** --**Decremento**var-- / --var**Retorna e subtrai / subtrai e retorna.
** -** Negativo********-var****** Inverte o sinal da variável
** +** Positivo********+var****** Não tem efeito.

Abaixo estão os operadores aritméticos que atuam sobre duas variáveis.


Código:

Op******Nome******** Uso** Descrição
****+**** Adição****** x + y**Soma x com y.
****-****Subtração**** x - y**Subtrai y de x.
*******Multiplicação** x * y**Multiplica x por y.
****/**** Divisão******x / y**Divide x por y.
****%******Resto****** x % y**Resto da divisão de x por y.

3.8 Operadores relacionais e lógicos

Os operadores relacionais e lógicos são utilizados em testes e condições
de entrada em um fluxo do programa. Abaixo estão todos eles
relacionados.


Código:

Op************Nome************** Uso********** Descrição
****>******** Maior que************x > y**********x maior que y.
****>=********Maior ou igual a**** x >= y******** x maior ou igual a y.
****<******** Menor que************x < y**********x menor que y
****<=********Menor ou igual a **** x <= y******** x menor ou igual a y.
****==********Igual a ************ x == y******** x igual a y.
****!=********Diferente de **** x != y******** x diferente de y.
****!******** NÃO lógico (NOT)****** !y ************contrário de y.
****&&********E lógico (AND) **** x && y******** x e y.
****||********OU lógico (OR) **** x ||y ************x ou y.
**instanceof**Verif Instância ****x instanceof X****x é instância da classe X

3.9 Operadores bitwise

Os operadores bitwise são aqueles que alteram o valor das variáveis em
operações lógicas diretamente no processador, tornando-as muito mais
performáticas. Estas operações são geralmente chamadas de ? tratamento
por bits ? pois são operações que comparam e modificam a variável bit
por bit.


Código:

Op****Nome**************Uso******Descrição
** ~**** Inversão**********~x****** Inversão dos bits de x.
** &**** E lógico******** x & y**** AND bit a bit entre x e y.
** |**** OU lógico********x | y**** OR bit a bit entre x e y.
** ^**** OU excl. lógico**x ^ y**** XOR bit a bit entre x e y.
** <<****Desloc. a esq.** x << y****Desloc. a dir os bits de x, y vezes.**
** >>****Desloc. a dir.** x >> y****Desloca a direita os bits de x, y vezes.
** >>>** Desloc. a dir.**x >>> y****Preenche zero a esquerda de x, y vezes.

3.10 O operador de atribuição composto

Já foi apresentado o operador de atribuição " = ". Porém este operador
pode funcionar em conjunto com outros operadores reduzindo o tempo de
processamento de determinadas chamadas. O operador de atribuição
composto junta um operador aritmético ou de bitwise com o operador de
atribuição. É sempre utilizado na sintaxe var = var como no exemplo
abaixo:


Código:

public class OperadorAtribuicaoComposto {
**** public static void main (String [] args) {
****** int x = 1;
****** x + = 5;
**** }
** }

Neste exemplo a variável inteira x é inicializada com 1 e na linha
seguinte é realizado uma operação composta: A soma e atribuição. Esta
instrução é semelhante a esta: x = x + 5;. O resultado em x será 6.
Outros exemplos são:


Código:

public class OperadorAtribuicaoComposto {
**** public static void main (String [] args) {
********int x = 1; // Atribui 1 a x
********x += 5; // Equivalente a x = x + 5; x é igual a 6
********x *= 2; // Equivalente a x = x * 2; x é igual a 12
********x /= 2; // Equivalente a x = x / 2; X é igual a 6
********x -= 3; // Equivalente a x = x - 3; x é igual a 3
********x %= 5; // Equivalente a x = x % 5; x é igual a 3
********x |= 4; // Equivalente a x = x | 4; x é igual a 7
********x ^= 1; / / Equivalente a x = x ^ 1; x é igual a 6
********x &= 255; / / Equivalente a x = x & 255; x é igual a 6
********x <<= 2; / / Equivalente a x = x << 2;** x é igual a 24********
********x >>= 4;****// Equivalente a x = x > > 3; x é igual a 1
********x >>>= 7; / / Equivalente a x = x > > > 7; x é igual a 0
**** }
** }

3.11 Precedência de operadores

Tabela de precedência de operadores em ordem decrescente, ou seja, o que está mais acima, ocorre antes.

Precedência
+ + - - + - ! (cast)
* / %
+ -
<< >> >>>
<>< = > = instanceof
= =! =
&
^
|
&&
| |
?:
= * = / = % = + = - = << = >> = >>> = & = | =

4 Comandos de decisão, repetição e desvio

Este capítulo apresentará o extremamente necessário para a construção
de qualquer sistema em Java. Declaração de variáveis, comandos de
decisão, repetição e desvio de fluxo no programa. 4.1 Declaração e
Inicialização de Variáveis
A declaração de variáveis em Java pode ser feita em qualquer local do
código fonte desde que esteja dentro de uma classe. Quando a declaração
da variável é feita globalmente, ou seja, na estrutura da classe, é dita
que a variável é um atributo, caso contrário ela continua sendo chamada
de variável. O escopo ou a vida de uma variável em Java dura de acordo
com o bloco onde ela foi declarada. A variável é criada no primeiro
acesso a ela e destruída após o interpretador sair do bloco de execução
ao qual ela pertence.

Em Java a declaração de variáveis é feita pelo tipo e depois um
identificador. A declaração muitas vezes é acompanhada pela
inicialização a qual acrescenta o sinal de atribuição e um valor literal
ou variável.

A declaração de uma variável é feita no formato:


Código:

Tipo identificador [= valor_inicial];

Observando o exemplo 4.1 pode-se identificar várias maneiras de
declarar inicializar tipos primitivos e objetos. Na linha 3 existe uma
declaração simples, ela está criando uma variável byte e o valor de bt
será 0. Na linha 4 há a declaração de três variáveis do tipo short:
sht1, sht2 e sht3. Todas as três serão inicializadas com zero. Na linha 5
existe a declaração de um inteiro i e a sua inicialização atribuindo o
valor 9 para a variável. Na linha 6 há duas variáveis sendo criadas: f1 e
f2, ambas receberão o mesmo valor 98.76. Na última linha existe a
declaração de uma variável de tipo complexa String. String é a classe
que armazena uma cadeia de caracteres sem tamanho definido em Java. No
exemplo, ela está sendo inicializada com a cadeia " TESTE ". Exemplo:


Código:

public class DeclarandoVariáveis {
**** int atributo = 9; // Declarando uma variável global => Atributo.
**
**** public void main(String[] args) {
********byte bt; ******************// Declaração simples
********short sht1, sht2, sht3; // Declaração múltipla
********int i = 9;**************// Declaração e inicialização
********float f1, f2 = 98.76****// Declaração e inicialização múltipla
********String str = "TESTE"****// Declaração e criação de um objeto String
**** }
**}

4.2 Instruções de Desvio

Linguagens de alto nível implementam várias estruturas de controle do
fluxo do programa para facilitar o desenvolvimento de programas e
promover um melhor estilo de programação. Os comandos de seleção e
repetição são mais empíricos do que os comandos tradicionais em
linguagem de máquina.

Java possui duas instruções de desvio condicionais mais uma palavra
reservada que não deve ser usada. Todas elas existem em várias outras
linguagens e plataformas.


Créditos Gerais: JavaFree.Org