1.

Instalação do Java
Iremos instalar o Java em sua máquina. A instalação na verdade é feita
em duas partes: a primeira é a instalação do JDK que é o kit de
desenvolvimento, ou seja, o compilador; o segundo passo é o JRE que é uma
máquina virtual para rodar aplicações desenvolvidas em Java.
Você já deve estar com o arquivo de instalação baixado do site da Sun,
então siga os passos para instalar a máquina virtual Java:
1. Execute o arquivo para iniciar a instalação
2. Na tela de licença selecione “I accept the terms in the license
agreement” e clique em Next.

Figure 1.1 - Aceitação da Licença

3. Na janela de Custom Setup podemos escolher algumas características
da instalação, normalmente deixamos do modo padrão como mostrado
na figura abaixo. Clique em Next.

Figure 1.2 - Configuração da Instalação do Kit de Desenvolvimento

4. Bom agora basta esperar o final da instalação do kit de
desenvolvimento para instalarmos a máquina virtual, que será
executada automaticamente após a instalação do jdk.
 Figure 1.3 - Instalação do Kit de Desenvolvimento
5. Na janela de configuração da instalação da máquina virtual, podemos
modificar algumas características da instalação, mas, como na
instalação do kit de desenvolvimento, normalmente deixamos no modo
padrão como mostrado na figura abaixo. Clique em Next.

Figure 1.4 - Configuração da Instalação da Máquina Virtual

6. A instalação da máquina virtual permite instalar uma integração com
os navegadores como o Internet Explorer e o Mozilla (Firefox). Essa
integração serve para rodarmos programas Java a partir de páginas
html. Para isso basta selecionar qual integração deseja e clicar em Next.

Figure 1.5 - Integração com Navegadores

7. Pronto, agora é só esperar a instalação da máquina virtual.
 Figure 1.6 - Instalação da Máquina Virtual
8. Pronto, a instalação foi concluída com sucesso. Clique em Finish.

Figure 1.7 - Conclusão da Instalação

2. Instalação do Eclipse
A instalação do eclipse é bem simples, basta descompactar o arquivo
em um local desejado.

3. Configurações Iniciais
Vamos ter o primeiro contato com a ferramenta de programação. Vou
mostrar aqui as principais telas e configurações para um melhor ambiente de
desenvolvimento.
A primeira coisa que temos que fazer, é executar o arquivo eclipse.exe
que está dentro da pasta onde o eclipse foi descompactado.
Ao executar o eclipse a primeira janela que aparece é de seleção de
Workspace como mostrado abaixo.
 Figure 3.8 - Escolha do Workspace
O Workspace nada mais é que um diretório onde serão criados os
novos projetos. Existe um check box escrito “Use this as the default and not
ask again”, se habilitarmos essa opção isso fará com que o eclipse utilize esse
Workspace como o padrão para as próximas aberturas e não mais mostrará
essa janela. Isso é usado quando só temos um Workspace, mas podemos usar
vários Workspaces para organizar melhor nosso trabalho.
Escolha o Workspace com o botão Browse e clique em OK.
A primeira vez que executamos o eclipse aparece uma tela de Wellcome,
nessa tela podemos ver algumas funcionalidades do Eclipse e Tutoriais, para
passarmos à frente clique em Workbench como mostrado na janela abaixo ou
feche essa tab.

Figure 3.9 - Janela de Wellcome

 Agora com o Eclipse aberto podemos começar a explorar as janelas e
configurações.

Figure 3.10 - Ambiente de Desenvolvimento

O Eclipse é uma ferramenta de uso geral que pode ser configurado para
várias tarefas utilizando plug-in. O Eclipse vem preparado para
desenvolvimento em Java, mas facilmente podemos instalar um plug-in
chamado CDT para programarmos em C/C++ utilizando a mesma interface.
Para organizar essas várias interfaces de programação, o Eclipse utiliza
perspectivas. Podemos ver que estamos com a perspectiva Java ativada no
canto superior direito da tela, como mostrado na figura abaixo.
 Figure 3.11 - Botões de Perspectiva
Podemos abrir outras perspectivas acessando o menu Window – Open
Perspective. Sempre procure verificar se você está na perspectiva Java.
Em uma perspectiva podemos configurá-la da maneira que acharmos
melhor, por exemplo, podemos abrir outras janelas acessando o menu
Window – Show View. Abra a janela Console, essa janela será bem útil
quando começarmos a programar.
A tela pode estar como mostrada abaixo.
 Figure 3.12 - A Janela Console
Do lado esquerdo temos a janela Package Explorer, onde poderemos
gerenciar nossas classes separadas por projetos e pacotes. Essa janela pode ser
aberta acessando o menu Window – Show View – Package Explorer.
Do lado direito temos a janela Outline, onde poderemos ver a estrutura
de nossas classes, como variáveis e funções. Essa janela pode ser aberta
acessando o menu Window – Show View – Outline.
Em baixo temos a janela Console onde poderemos interagir com nosso
programa, vendo os valores impressos e digitando os valores de entrada. Essa
janela pode ser aberta acessando o menu Window – Show View – Console.

4. Como criar uma classe

A primeira coisa que devemos fazer é criar um projeto. O projeto é um
diretório onde ficarão guardados todos os nossos arquivos de código fonte e
configurações.
A manipulação de projetos e classes é feito a partir da janela Package
Explorer. Clique com o botão direito do mouse na área branca do Package
Explorer e selecione New – Project, como mostrado na figura abaixo.
 Figure 4.13 - Menu de Criação de Projeto
Na janela New Project, escolha o tipo do projeto que deseja criar. No
nosso caso iremos criar um Java Project ou Projeto Java. Clique em Next.
 Figure 4.14 - Janela de Tipo de Projeto
Clicando em Next iremos para a janela New Java Project onde
poderemos modificar algumas configurações do nosso projeto.
A primeira coisa que podemos fazer é colocar o nome do projeto no
campo Project Name, no meu caso escolhi o nome “Primeiro Projeto”.
Uma outra configuração importante fica em Project Layout, onde
podemos configurar para o Eclipse separar os arquivos fontes dos binários em
dois diretórios. Essa configuração fará com que o Eclipse crie dois diretórios
dentro do seu projeto: o diretório src, onde estarão os arquivos fontes (.java)
e o diretório bin, onde estarão os arquivos compilados (.class). Com isso
conseguimos melhorar a organização do nosso projeto. Essas configurações
são mostradas na figura abaixo. Clique em Finish para finalizar a criação do
projeto.
 Figure 4.15 - Configurações do Projeto
Criado o projeto, poderemos navegar em seus arquivos pela janela
Package Explorer, notem que o eclipse criou o diretório src onde criaremos
nossas classes.

Figure 4.16 - Projeto no Package Explorer

 Agora podemos criar nossa primeira classe, para isso basta clicar com o
botão direito do mouse em cima do diretório src e selecionar New – Class.

Figure 4.17 - Menu de Criação de Classe

Na janela New Java Class, podemos modificar algumas configurações
da nossa classe. Inicialmente iremos configurar o nome do pacote (1), o nome
da classe (2) e pedir para o Eclipse criar nossa classe já com um método main
(3). Clique em Finish.
 Figure 4.18 - Janela de criação de nova classe
Na linguagem Java as classes são divididas em pacotes para uma
melhor organização e possibilita a criação de classes com mesmo nome em
pacotes diferentes. Iremos entender isso melhor quando estivermos vendo
como utilizar as classes, mas já é bom ir criando o costume de utilizar pacotes.
Os pacotes devem seguir um padrão de criação com todas as letras
minúsculas. Se verificarmos a árvore de diretório em nosso projeto, veremos
que cada palavra separada por ponto no nome do pacote é um diretório criado
em nosso projeto. A figura abaixo mostra a árvore de diretório do projeto.
 Figure 4.19 - Árvore de Diretórios do Projeto
O nome da classe em Java também deve seguir um padrão. O nome da
classe deve ter uma letra maiúscula em cada palavra, por exemplo:
HelloWorld, ControlarCadastro, OperaçãoSoma etc.
O método main é o nosso método principal e é por ele que a execução
do nosso programa se iniciará. Uma classe que tenha o método main pode ser
chamada de classe executável.
Após a criação da classe, nosso código aparece no centro do Eclipse e
podemos ver do lado direito as informações do projeto na janela Package
Explorere e do lado esquerdo as informações da classe selecionada na janela
Outline, como mostrado na figura abaixo.

Figure 4.20 - Ambiente de Desenvolvimento

5. Executando um programa
Executar um programa no Eclipse é muito fácil, são apenas dois
cliques. Primeiro crie um projeto chamado “Primeiro Projeto” com uma classe
executável chamada “Olá”, depois insira o código abaixo no escopo do método
main. Não se esqueça de colocar um pacote quando estiver criando a classe.

System.out.println("Meu primeiro programa em Java");

O código completo deve estar parecido com este:

package edu.ead.helloworld;

public class Olá {

/**
* @param args
*/
public static void main(String[] args) {
System.out.println("Meu primeiro programa em Java");
}

Para executar nossa classe pela primeira vez é necessário clicar com o
botão direito do mouse no nome da classe no Package Explorer e selecionar
Run As – Java Application. As próximas execuções podem ser feitas
pressionando Ctrl+F11.
Ao executar essa aplicação, nós veremos no Console a mensagem “Meu
primeiro programa em Java”, com isso podemos deduzir que o comando
System.out.println() serve para imprimir informações no console. Nesse caso
o ln é para pular uma linha após escrever o texto entre aspas. Um texto entre
aspas em Java é chamado de String.
 Figure 5.21 - Ambiente de Desenvolvimento após a execução do programa

6. Executando passo a passo

Para treinarmos a execução passo a passo, precisamos de um programa
um pouco maior. Crie um novo projeto com uma classe executável chamada
SomaSimples. O código da classe é mostrado abaixo.

package edu.ead.helloworld;

public class SomaSimples {

/**
* @param args
*/
public static void main(String[] args) {
// Declaração de variáveis
int primeiroValor = 0;
int segundoValor = 0;

// Atribuição de valores
primeiroValor = 5;
segundoValor = 3;

// Execução do cálculo complexo :D

int resultado = primeiroValor + segundoValor;

// Saída de dados
System.out.println("A soma é: " + resultado);
}
}

No código acima é declarado duas variáveis inteiras, primeiroValor e

segundoValor, inicialmente com zero. Após a atribuição dos valores, é criada
uma variável chama resultado que recebe a soma de primeiroValor com
segundoValor e esse resultado é mostrado utilizando o comando
System.out.println().
Algumas considerações:
 Nome de variável sempre deve iniciar com uma letra minúscula
e as outras palavras que formam o nome devem iniciar com uma
letra maiúscula. Exemplos: primeiroValor, nomeCliente,
telefone etc.
 Sempre devemos iniciar as variáveis com um valor em sua
declaração, mesmo que seja zero.
 Variáveis em Java podem ser declaradas em qualquer parte do
código, mas só poderão ser usadas em linhas após sua
declaração.
 Notem que, para mostrar o resultado foi utilizado o comando
System.out.println() e no parâmetro da função println foi feito
uma soma entre uma String e um valor inteiro. A linguagem
Java permite concatenar String com outros valores, nesse caso o
valor é automaticamente convertido para String e adicionado no
final da String.
Ao executar o código criado iremos verificar o seguinte resultado no
console:

A soma é: 8

Antes de executarmos passo a passo, precisamos configurar um ponto

de parada chamado de Breakpoint. Para isso, basta dar dois cliques na área
cinza do lado esquerdo da linha onde você deseja que a execução pare para
que a partir dessa linha, o programa seja executado passo a passo. Ao fazer
isso, aparecerá uma bolinha azul na frente da linha onde foi inserido o
breakpoint.
 Figure 6.22 - Código com breakpoint
Para iniciar a execução passo a passo, ao invés de selecionar Run As –
Java Application ao clicar com o botão direito do mouse no nome da classe no
Package Explorer, selecionaremos Debug As – Java Application.
Como já havia comentado antes, o Eclipse trabalha com perspectivas
para cada tarefa que o usuário deseja executar. No caso de uma execução
passo a passo, o Eclipse é configurado para mudar automaticamente para a
perspectiva Debug, mas antes ele pergunta se é isso mesmo que o usuário quer
e se sempre deve fazer isso.
Na janela Confirm Perspective Switch, habilite a opção “Remember my
decision” e clique em Yes como mostrado abaixo.

Figure 6.23 - Janela de confirmação de troca de perspectiva

 Ao mudar para a perspectiva Debug, o programa será executado e
pausado na linha que colocamos o breakpoint.

Figure 6.24 - Início da execução passo a passo

Como vemos na figura anterior, temos um ambiente um pouco mais
detalhado na perspectiva debug. Nosso código está sendo mostrado na região
central com a linha do breakpoint sendo indicada por um fundo verde e uma
seta azul na região cinza do lado esquerdo da linha, junto à bolinha azul do
breakpoint.
A janela Variables é uma das mais importantes em um debug e serve
para verificarmos ou modificarmos o valor de cada variável que está sendo
utilizado nessa parte do código. Notem que inicialmente as variáveis
primeiroValor e segundoValor estão com zero, pois ainda não foi executada a
linha onde contém o breakpoint e que é atribuído o valor 5 à variável
primeiroValor.
Uma outra janela importante é a janela Expressions que inicialmente
não é mostrada na perspectiva, mas clique no menu Window e selecione
Show View – Expressions. Lembre-se que para mostrar qualquer janela em
uma perspectiva basta acessar o menu Window – Show View.
A janela de Expressions é usada para mostrar qualquer expressão
utilizada no código, por exemplo, podemos colocar a expressão
“primeiroValor + segundoValor”. Para isso é só clicar com o botão direito do
mouse na janela Expression, selecionar Add Watch Expression e digitar a
expressão desejada na janela. Uma outra maneira é selecionar a expressão no
código, clicar com o botão direito do mouse e selecionar Watch.
 Figure 6.25 - Criação de uma expressão a partir da janela Expressions

Figure 6.26 - Criação de uma expressão a partir do código

A janela Expression deve mostrar a expressão e o seu valor, como
mostrado abaixo.
 Figure 6.27 - Janela Expression com a expressão e seu valor
A medida que executarmos nosso programa passo a passo, iremos
verificar os valores nas janelas Variables e Expressions.
Para executar o nosso programa passo a passo, usaremos o comando
básico de debug que é o Step Over. Esse comando executará uma linha do
nosso programa por vez. O comando Step Over pode ser executado
pressionando a tecla F6 ou através do menu Run.
Pressione duas vezes a tecla F6 para executarmos duas linhas do nosso
programa e verifique os valores na janela Variables e Expressions.

Figure 6.28 - Janela Variables após a execução

Figure 6.29 - Janela Expressions após a execução

 Figure 6.30 - Código após a execução
Vemos que na janela Variables a variável primeiroValor tem o valor 5 e
a variável segundoValor está com valor 3. Na janela Expression, verificamos
que o valor da soma entre as duas variáveis é 8 e é esse valor que será
armazenado na variável resultado se executarmos mais um passo na execução
do nosso código. Mas antes disso vamos mudar o valor da variável
segundoValor para 5.
Na janela Variables, clique no valor da variável segundoValor, que
deve ser 3, e mude para 5. Note que o valor da expressão na janela Expression
já foi recalculado automaticamente.

Figure 6.31 - Alterando o valor na janela Variables

Figure 6.32 - Janela Expressions com o valor recalculado

 Execute mais um passo do seu programa pressionando F6 e verifique
as variáveis na janela Variables.
Finalize a execução do seu programa pressionando F8 que fará com
que a execução continue normalmente até encontrar um outro breakpoint ou
o final do programa. Se quiser interromper a execução do seu programa pela
metade é só selecionar o menu Run – Terminate.
Para voltar à perspectiva Java é só clicar no botão Java perspective no
canto superior direito do eclipse.

Figure 6.33 - Botão Java perspective