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