Curso: Java na Prática

Módulo 1: Introdução

Neste módulo faremos a apresentação de alguns conceitos Java e a

preparação do ambiente de programação. Este curso tem o objetivo de ser
bem prático, com muitos exemplos, telas, exercícios e dicas. Com um
pouco de teoria e nós já vamos começar a programar em breve sempre
visando à prática. No módulo IV temos vários exemplos mais rebuscados,
explicados linha a linha, com muitos conceitos e dicas. Tente fazer todos.

Módulo 2: Breve história do Java

Em 1992 a Sun ([Link]) estava atrás de inovações tecnológicas e

criou um time de programadores liderado por James Gosling (“pai” do
Java), com esta responsabilidade. A princípio a ideia era criar uma
linguagem de programação que em um futuro próximo se comunicasse com
dispositivos como TVs, liquidificadores, aspiradores, etc. Como a
tecnologia da época era limitada, essa ideia não deu certo. Com isso o foco
foi mudado para o ambiente web (browsers) da época para se rodar
pequenas aplicações no lado Cliente: os Applets. Hoje em dia o verdadeiro
mercado do Java fica no lado servidor, ou seja, o Java foi lançado para um
ramo, cresceu em outro e se firmou em um terceiro.

:: Porque Adotar o Java?

- É uma linguagem madura e estável;

- Grandes empresas utilizam esta linguagem;

- Possui uma grande quantidade de bibliotecas gratuitas para as mais

diversas atividades, como por exemplo: manipulação de datas, ordenações,
cálculos matemáticos, contabilidade, etc.

- Possui uma extensa quantidade de documentação.

- Mercado de trabalho totalmente aquecido e precisando de programadores

Java.

:: JVM (Java Virtual Machine – Máquina Virtual Java)

A JVM é uma camada entre o Sistema Operacional e a aplicação. Esta

aplicação se comunica apenas com a JVM, independente do Sistema
Operacional utilizado. Isso é muito interessante, visto que, a sua aplicação
pode ser rodada em qualquer plataforma (Windows ou Linux),
diferentemente de algumas linguagens como C++, Pascal onde o
programador tem que recompilar e às vezes até recriar várias versões da
sua aplicação, uma para cada Sistema Operacional.

:: Bytecode

O Bytecode é uma linguagem que é entendida pela JVM, que é gerada após
a compilação do código Java, geralmente pelo compilador javac. Quando
criamos uma aplicação Java estamos criando um “arquivo .java” . Quando
compilamos este arquivo nós teremos como resultado desta compilação um
“arquivo .class”, que é justamente o Bytecode. Com esse Bytecode gerado
pelo compilador nós podemos rodar nossa aplicação em qualquer
plataforma: Windows e Linux. Resumindo, ao mudar de plataforma o
Bytecode não precisa ser mudado. Este Bytecode nos fornece a chamada
Portabilidade.

Módulo 3: Divisões do Java, preparando o ambiente

:: Divisões do Java

- JSE (Java Standard Edition): é a base do Java. É composta pelo ambiente

de execução e principais bibliotecas.

- JEE (Java Enterprise Edition): compreende aplicações corporativas e

Internet.

- JME (Java Micro Edition): para aplicações em dispositivos móveis.

Neste curso vamos abordar especificamente o JSE.

:: Kit de desenvolvimento

- JRE (Java Runtime Enviroment): compreende a JVM + bibliotecas. É

justamente a JRE que você deve instalar no seu computador para executar
aplicações Java. A JRE pode ser obtida gratuitamente no site da Oracle (a
Sun foi comprada pela Oracle).

- JDK (Java Development Kit): compreende JRE + kit completo de

desenvolvimento. O JDK serve para criar e executar aplicações Java no seu
computador. É o que os desenvolvedores usam e também se encontra
gratuitamente no site da Oracle. Iremos utilizar este kit.

:: Preparando o ambiente de desenvolvimento

A preparação do ambiente de desenvolvimento é muito importante.

Obs.: No decorrer do curso faremos vários downloads e criaremos muitos

códigos. Crie uma pasta específica (por exemplo "Java na Prática -
Básico") para guardar estes arquivos/programas para mantermos uma
organização.

Primeiramente precisamos baixar o JDK. Como a Oracle comprou a Sun,

devemos baixar o JDK direto do site da Oracle em:

[Link]
[Link]

Java SE 8 é a versão mais recente e iremos utilizá-la.

Neste curso trabalharemos com a versão para Windows X86, mas você
pode baixar a versão para o seu respectivo sistema operacional que não
influenciará nas aulas.

Depois de clicar no JDK para download conforme figura acima, devemos

aceitar os termos de licença e escolher a plataforma a ser utilizada: no
nosso caso Windows X86.

Depois que o download do JDK for concluído, precisamos agora proceder

com a instalação. Executando o arquivo baixado teremos a seguinte tela,
bastante clássica, de instalação:

Clicando em Next:
Clicando em Next:
Clicando em Next:

E finalmente:
Clicando em Close nossa instalação do JDK está concluída.

Continuando a preparação do ambiente, agora iremos baixar o Eclipse. A

IDE Eclipse ([Link], é a mais utilizada ) é um ambiente gráfico
de desenvolvimento gratuito do Java que facilita muito a vida do
desenvolvedor e é no Eclipse que desenvolveremos as aplicações deste
curso. Mas há outras IDEs como NetBeans, JCreator... Lembrando que
antes de iniciarmos o Eclipse devemos baixar e instalar o JDK.

Para baixar o Eclipse acesse [Link]/downloads e escolha a

opção Eclipse Classic, conforme figura abaixo:

Depois de terminado o download do Eclipse 32 Bit fica muito fácil a sua

execução. O Eclipse vem na forma de um arquivo compactado, bastando
você descompactá-lo na pasta desejada (pode ser a pasta Eclipse mesmo).
O Eclipse não precisa ser instalado, basta descompactar e executar o
arquivo [Link] . Pronto, já estamos executando o Eclipse.

Ao executarmos o Eclipse pela primeira vez, teremos a seguinte tela:

Esta tela está pedindo para escolher onde será definido o seu Workspace. O
Workspace nada mais é onde você irá guardar os seus projetos Java.
Escolha a pasta de sua preferência (por exemplo crie uma pasta “Projetos”,
a utilizaremos para guardar nossos códigos), selecione esta pasta e clique
OK.

Depois de você ter clicado OK, o Eclipse será inicializado e teremos a

seguinte tela de boas-vindas que você pode fechá-la normalmente, não
servirá para nós:

Fechada a tela de boas-vindas temos finalmente o ambiente Eclipse

propriamente dito:
Agora vamos dar uma visão geral nesta tela inicial do Eclipse. O Eclipse
trabalha com o conceito de perspectivas, onde dependendo da linguagem
que você está utilizando pode-se alterar o modo de visualização no canto
superior direito da tela. No nosso curso vamos utilizar a perspectiva Java.

:: Regras e convenções em Java – muito importante

Antes de criarmos o nosso primeiro projeto em Java, temos que nos

familiarizar com algumas regras e convenções da linguagem, são elas:

- Todo arquivo Java deve ter uma extensão .java (em minúscula);
- Um arquivo a ser executado deve ter obrigatoriamente uma única classe
pública (public) com um método “main” dentro dela (mais detalhes desta
classe e deste método nos próximos capítulos);

- O arquivo deve ter o mesmo nome desta classe pública;

- O Java diferencia letras maiúsculas de minúsculas;

- Os comandos em Java devem ser finalizados com ponto e vírgula “;”.

- O nome de uma classe é um substantivo começando com letra maiúscula,

por exemplo: Banco, Cliente, ContaCliente, AgenciaCliente.

- O nome de um método é um verbo representando uma ação começando

com letra minúscula, por exemplo: saltar, correr, sacarDinheiro,
depositarDinheiro.

- O nome de uma variável que contém duas palavras também segue o

modelo primeira palavra começando em minúscula e a segunda palavra
começando em maiúscula.

Obs.: Mais adiante iremos falar de todos estes conceitos como métodos,
classes, pacotes, etc. e também veremos outras regras, convenções e
conceitos de orientação a objetos durante o curso.

Módulo 4: Criando o primeiro projeto Java

:: Criando o primeiro projeto Java

Um Projeto Java (é como se fosse uma pasta) no Eclipse é onde nós iremos
guardar/executar nossos códigos. Dentro do Eclipse clique em File, New,
Java Project.
Teremos a seguinte tela onde no campo Project name daremos o nome
de JavaNaPratica (note a convenção do nome com duas palavras
começando com letra maiúscula e sem espaço), clique em Finish:

Após o Finish, nosso projeto (que agora está no workspace, pasta Projetos)
está criado e nossas classes ficarão na pasta src (pasta padrão) conforme
figura abaixo:

Agora que já temos o nosso Projeto criado, precisamos de uma classe para
trabalhar (a classe fica dentro do pacote que fica dentro de um
projeto). Lembrando que cada projeto Java obrigatoriamente terá uma
classe pública com um método main.

Obs.: No Módulo onde falamos sobre Orientação a Objetos iremos ver

mais detalhadamente esses conceitos como classe, método, objeto... e
assim entender 100% de cada linha dos nossos códigos. Fique tranquilo
(a).

Vamos criar nossa classe: clique com o botão direito na pasta src do nosso
projeto PrimeiroProjeto, New, Class. Teremos a seguinte tela, onde no
campo Name daremos o nome “PrimeiroExemplo” à nossa classe:
Deixe marcada a opção public static void main(String[] args) e perceba a
opção “public” marcada. Lembrando que temos que ter obrigatoriamente
uma classe pública para executar o método main.

Pronto, após clicar em Finish teremos criado a nossa primeira classe em

Java. Agora nós temos uma classe pública chamada [Link]
com o seu método main obrigatório.

Para efeito de melhor visualizar o código, vamos exibir as linhas

numeradas no Eclipse. Segue o passo a passo: Menu Window, Preferences,
General, Editors, Text Editors e marque a opção Show line numbers.
Finalmente vamos ao que interessa: PROGRAMAÇÃO!

Vamos digitar um código para mostrar uma mensagem na tela e compilá-

lo. Digite o código conforme figura abaixo:

Estas linhas com barras e asteriscos são apenas comentários, não

interferem no código no momento, você pode até apagá-las se quiser.
Falaremos sobre comentários mais adiante.
Comando digitado agora tecle CTRL+S para salvar. Após salvar o arquivo
vamos executá-lo. Tecle F11 ou clique em na parte superior da tela do
Eclipse. Agora na view Console teremos a execução da nossa primeira
aplicação Java.

A tela mostra o resultado da execução da nossa aplicação.

Utilizamos o comando [Link]() para exibir a frase “Meu

primeiro código em Java” na tela. Perceba a utilização de aspas dentro do
parêntese, que é onde o texto deve ficar. O que estiver dentro dessas aspas
o Java vai entender como apenas texto.

Dica:

- Digite syso, tecle CTRL + espaço e depois Enter você terá toda a linha de
exibição na tela “[Link]()”.

- Dentro da classe pública você pode digitar main, depois CTRL + espaço,
Enter. Você terá automaticamente toda a linha obrigatória da classe
pública “public static void main (String[] args)” .

Módulo 5: Tipos de dados, utilizando variáveis, comentários

Agora que já estamos com o nosso ambiente de desenvolvimento pronto e

testado, vamos fazer uma pausa muito importante para vermos alguns
conceitos de POO (Programação Orientada a Objetos).

Para se criar uma classe no Java utilizamos a palavra reservada class como
fizemos no exemplo anterior:
public é o modificador (veremos mais adiante), class é a palavra reservada
para criar uma classe e as chaves delimitam o escopo, o corpo da classe,
que é onde nosso código ficará.

Para criamos um objeto desta classe utilizamos a palavra

reservada NEW, veremos adiante uma lista com essas palavras
reservadas.

:: Tipos de dados

Sempre que formos utilizar uma variável devemos declarar o seu tipo de
dado. Iremos ver agora os tipos de dados existentes no Java. São eles:

- boolean: armazena um valor lógico true (verdadeiro) ou false (falso). Não

se pode converter um valor lógico em outro tipo de dado;

- byte: compreende valores de -128 a 127. Muito usado para economizar

espaço em disco.

- short: compreende valores de -32768 a 32767;

- int: tipo inteiro, suporta números de 32 bits. Este tipo de dado é padrão
para operações com números inteiros em Java.;

- long: suporta números de 64 bits;

- float: armazena números de ponto flutuante (dízimas) com 32 bits. Para

definirmos um valor com esse tipo de dado devemos atribuir-lhe um “F” ou
“f” no final. Exemplo: float num = 33.45F;
- double: armazena números de ponto flutuante (dízimas) com 64 bits. Para
definirmos um valor com esse tipo de dado devemos atribuir-lhe um “D”
ou “d” no final. Exemplo: Double num = 33.45D;

- char: criado para armazenar um caracter Unicode. Exemplo: char c1 = ‘B’

;

- String: armazena texto. Obs: String é um tipo mais especial, veremos

mais detalhes à frente. Detalhe: O tipo String não é bem um tipo primitivo,
na verdade é uma classe inteira com vários métodos. Veremos sobre a
classe String mais adiante.

Caracteres de escape:

‘ ’ : nova linha

‘ ’ : retorno do carro

‘ ’ : tabulação

:: Utilizando variáveis
Declaração de variáveis: para declarar uma variável no Java devemos
indicar o tipo de dado e um nome para a variável. Exemplo:

Neste exemplo declaramos uma variável “x” do tipo int e atribuímos o

valor 10 a esta variável.

Perceba a utilização de “//” para realizar um comentário de uma linha e

o “/* */” para comentário de mais de uma linha. Comentários são
ignorados pelo Java, não interferem no código, sua utilização serve apenas
para anotações. Utilizamos também o comando [Link]() para
exibir o valor da variável x, que no caso é 10. Tecle Ctrl+s para salvar,
execute este código teclando F11 e veja o resultado.

Dentro do comando [Link]() temos entre aspas o texto “valor

de x=” concatenado com a variável x. A concatenação utiliza o símbolo
“+”. Não confundir com o símbolo de soma que todos conhecemos, não
tem nada a ver. Concatenação é uma junção. Nesse caso, uma junção do
texto e do valor da variável x que é 10.

Também podemos declarar uma variável já atribuindo um valor inicial na

hora da declaração.
Lembre-se de executar o código (tecla F11) para visualizar o resultado.

Podemos atribuir o valor desta variável a outra variável. Exemplo:

Neste caso estamos declarando uma variável x, do tipo int com valor inicial
10, uma variável y, do tipo int com valor inicial x + 5, ou seja, y valerá 15.

Podemos também alterar o valor de uma variável no meio do caminho.

Exemplo:

Agora declaramos uma variável x, do tipo int, com valor inicial 10; depois
atribuímos a x o valor x + 4, ou seja, agora x vale 14. Também podemos
escrever o exemplo acima de uma outra forma. Exemplo:
Lemos a operação acima da seguinte maneira: x recebe x + 4, ou seja, o x
ainda valerá 14.

No Java também existe os operadores de incremento (++) e decremento (-

-). Exemplo:

Aqui nós utilizamos o operador de incremento “++” e lemos da seguinte

forma: x recebe x + 1, ou seja, o x agora valerá 11.

Agora veremos o operador de decremento:

Aqui nós utilizamos o operador de decremento -- e lemos da seguinte

forma: x recebe x - 1, ou seja, o x agora valerá 9.

:: Escopo das variáveis

No Java, diferente de outras linguagens, pode-se declarar variáveis a

qualquer momento e em qualquer lugar do código, mas dependendo de
onde você as declarou ela irá valer de determinado ponto a outro do código.
O escopo de uma variável é o nome dado ao trecho de código em que
aquela variável existe e pode ser acessada. Exemplo:

Na linha 8 declaramos uma variável de escopo da classe, ou seja, a classe

inteira e quem estiver dentro dela poderá utilizar esta variável contador;

Na linha 10 declaramos uma variável de escopo do método (também

chamada de variável local), ou seja, esta variável contador só existe dentro
do método variáveis(), só pode ser usada dentro dele;

Obs.: Observe que apesar das duas variáveis de nosso exemplo terem o
mesmo nome (contador), elas são completamente diferentes. Uma pode ser
usada pela classe inteira e a outra só existe dentro do método variáveis().

- Variáveis de instância (linha 8) são campos do objeto, declarados fora de

qualquer método e inicializados quando é instanciado (criado) um objeto da
classe. Também são chamadas de campos ou atributos.

- Variáveis locais (linha 10) são as declaradas dentro de um método. Seu

ciclo de vida está relacionado ao seu escopo (no máximo o do método) e
elas sempre ficam numa área de memória chamada de stack. Antes de
tentar utilizá-las é necessário inicializá-las explicitamente, em uma parte
atingível do código (fora de um if, por exemplo), senão o compilador
retornará um erro. Variáveis locais também são chamadas de variáveis de
stack, temporárias, automáticas ou de método.

– Vamos desenvolver um programa simples onde criamos variáveis com

seus respectivos atributos e tipos de dado e exibimos no console do Eclipse
os seus valores iniciais.
Explicando o código acima:

1 – criamos nossa classe pública com o seu método main obrigatório:

2 – declaramos nossas variáveis (atributos) com : tipo de dado, nome do

atributo e seu valor inicial respectivamente. Lembrando que não é
obrigatório atribuir um valor inicial a estas variáveis.

3 – Exibimos os valores inicias das variáveis no console através do

comando [Link](). Não esqueça de utilizar o syso, tecle CTRL
+ espaço e depois Enter, para facilitar:

4 – Teclando F11 nós vamos executar o código e obteremos o resultado na

view Console:
:: Operadores

- Aritméticos: + (soma), - (subtração), * (multiplicação), / (divisão), %

(resto da divisão ou módulo)

- Igualdade e Desigualdade: == (igual), !=(diferente).

- Relacionais: >, <. >=, <=.

- Lógicos: && (e), || (ou).

Exemplo de código utilizando operadores e comentários. Crie uma classe

chamada ExemploOperadores e digite o seguinte código:
Pressione F11 para executar o código e teremos o seguinte resultado no
console do Eclipse:

Obs.: Lembre-se que o sinal de “+” pode ter dois comportamentos

distintos: a soma e a concatenação. Na linha 15 ele soma os valores de x e
y. Já nas linhas 16, 18, 20, 22 e 24 este sinal tem comportamento de
concatenação, junção.

:: Controle de Fluxo
- Instrução If else (se então): podemos ler como “se, condição verdadeira
faça, senão faça outra coisa”, ou seja, o bloco de instrução só será
executado se uma certa condição for satisfeita. Exemplo:

No exemplo acima a variável dia começa valendo 0, depois o seu valor é

alterado para 7; se a variável dia for igual a 7 tem-se a mensagem “o dia é
7”; se a variável dia não for igual a 7 tem-se a mensagem “o dia não é 7”.

Faça um teste também alterando o valor da variável dia para, por exemplo,
5. Perceba também que cada bloco de instrução começa e termina com suas
respectivas chaves { } e dentro do If o operador de igualdade é “==” (nesse
caso seria um operador de comparação).

Utilizando vários blocos de controle de fluxo ou condição. Exemplo:

O resultado desta operação será a mensagem “igual a 10”. A
variável num começa com o valor 10, em seguida o java testa
se num é maior que 10, depois testa se num é menor que 10 e finalmente
verificado que num não é maior e nem menor que 10, logo num será igual a
10.

Faça o teste com outros valores para num e você pode também salvar esta
classe com outro nome por exemplo “ControleFluxo”. Menu File, Save
As, digite o nome, Ok.

- Instrução Switch: esta instrução testa somente variáveis que possam ser
convertidas para inteiro. Depois de testada a variável devemos trabalhar
com blocos “case” dentro do switch. Exemplo:

No exemplo acima o Switch verifica o valor da variável num, dependendo

do valor que lhe foi atribuído um bloco case referente será executado, nesse
caso o resultado da aplicação será a mensagem “o valor é 5”. O switch é
muito usado para se evitar vários blocos IF else, com os blocos case fica
mais prático. Podemos ler o exemplo acima da seguinte forma:
caso num igual a 10, caso num igual a 5, caso num igual a 0.

Perceba a utilização em cada case da palavra reservada “break”, ela serve

para executar o case referente ao resultado da variável testada e logo depois
sair do Switch, se você não utilizar o break, todos os cases serão
executados. Teste este código no seu Eclipse atribuindo outros valores à
variável num.

Outro exemplo da instrução Switch:

No exemplo acima o Switch verifica o valor da variável mes, dependendo
do valor que lhe foi atribuído um bloco case referente será executado, nesse
caso o resultado da aplicação será a mensagem “mês inválido”, se
colocarmos a variável mes com o valor 10, por exemplo, a mensagem será
“Outubro” e assim por diante. Atenção na linha 45, caso a variável mês
tenha um valor não encontrado em todos os blocos case, então será exibido
um valor padrão (default).

Instrução While (enquanto): o bloco será executado enquanto a condição

for verdadeira. Perceba a diferença entre o If else e o While. No primeiro o
bloco será executado somente SE a condição for verdadeira; no segundo o
bloco será executado ENQUANTO a condição for verdadeira. Exemplo:

Neste exemplo declaramos uma variável x, do tipo int, com valor inicial 0.
Em seguida o Java exibe na tela o valor de x, que começou com 0, depois
acrescenta 1 a este valor utilizando o operador de incremento ++.

Resumindo: o valor de x será exibido e acrescentado 1 ENQUANTO x for

menor que 10. Outra coisa para se notar é que neste código removemos o
“ln” (linha) do final do comando “[Link]”, por isso tudo foi
exibido na horizontal. Outra coisa foi a concatenação da variável x com
espaço em branco entre aspas. Digite este código no Eclipse e tecle F11
para testar.

Com o While também podemos utilizar o “break” para sair do bloco.

Exemplo:
Neste exemplo assim que o Java entra no bloco while ele exibe o valor
atual do x (que no caso é 0), testa se x é igual a 5, se x for igual a 5
interrompemos o bloco utilizando o break, se ainda não for igual a 5 ele é
incrementado com 1 e volta para o início do laço. Se executar este código o
resultado final de x será 5. Teste este código no Eclipse.

Outro exemplo do While. Este código verifica quando um número 0 a 70 é

ímpar e quando ele é divisível por 4. Perceba que agora vamos misturar
While com If Else.

- Linha 6: variável num recebe 0 como valor inicial;

- Linha 8: estrutura While será executada enquanto num for menor ou igual
a 70, ou seja, em 71 ele para e finaliza o laço;
- Linha 10: comando If testa de o módulo (%, resto da divisão) da divisão
por num é igual a 0, se for = a 0, significa que o número é divisível por 4,
se for diferente de 0, então ele passa adiante para a linha 13;

- Linha 13: comando If testa se o módulo da divisão por num é diferente de

0, se for, o número é impar;

- Linha 16: num é incrementado em uma unidade com o sina ++;

Executando este código:

- Instrução For (para): o bloco será executado até que atinja o valor
recebido pela variável. Exemplo:

Perceba que dentro dos parênteses do For temos 3 passos importantes

separados por ponto e vírgula, são eles respectivamente: declaração da
variável a ser testada com atribuição de um valor inicial (int x=0); o teste
efetivo desta variável (x < 10); o seu incremento (x++).

No código acima a variável x é do tipo int e recebe 0 como valor inicial;

depois defini-se até quando o laço será executado (no caso, até x menor que
10, ou seja, 9); e depois incrementa x, que começou com 0, em uma
unidade utilizando o operador de incremento ++. No exemplo acima o Java
exibirá na tela o valor de x, incrementando uma unidade, enquanto x for
menor que 10.

Teste este código no elipse para vê-lo funcionando. Se quiser o resultado

apresentado na vertical, basta acrescentar o “ln” ao final do comando
[Link] .

Outro exemplo do For. Neste código temos dois em um: o primeiro código
exibe a soma dos primeiros 30 números inteiros; o segundo código exibe a
tabuada de um número.

- Linha 7: variável soma recbe 0 como valor inicial;

- Linha 8: instrução for que inicializa uma variável x com valor inicial 0,
executa o código até que x seja menor ou igual a 30 e incrementa (++) x em
uma unidade;

- Linha 9: variável soma recebe o valor de soma mais o valor de x;

- Linha 11: exibe na tela o valor final de soma;

- Linha 14: linha em branco com o comando [Link]();

- Linha 17: variável numTabuada recebe 6 como valor inicial;

- Linha 18: instrução for que inicializa uma variável y com valor inicial 0,
executa o código até que y seja menor ou igual a 10 e incrementa (++) y em
uma unidade;

- Linha 19: exibe na tela o valor atual de y multiplicado por numTabuada;

Módulo 6: Métodos, Objetos, Características da P.O.O.

:: Trabalhando com métodos e Objetos

Agora faremos um exemplo um pouco mais complexo. Como vimos antes

neste curso, os métodos irão representar uma ação e seu nome começa com
letra minúscula por convenção. Neste exemplo teremos um programa que
irá exibir os números ímpares de um certo intervalo e também teremos
vários conceitos de orientação a objetos. Você irá gostar deste tópico!
Antes, mais um pouco de teoria.

:: Características da Orientação a Objetos:

- Reutilização de código: o programador muitas vezes usa o mesmo código

em várias ocasiões, isso diminui muito o tempo e trabalho de programação.
No Java podemos reutilizar o mesmo código várias vezes;

- Concentração de tarefas: cada objeto realiza a sua tarefa. Por exemplo,

você tem uma classe que só realiza cálculo de Imposto de Renda, então
toda vez que o governo fizer uma alteração na base de cálculo, só esta
classe será alterada, deixando todo o restante do projeto imutável;

- Encapsulamento: haverá casos na nossa programação que não é

interessante exibir todo o nosso código, nós vamos ocultar (encapsular)
determinadas áreas do código. Usando como exemplo uma analogia
clássica na Orientação a Objetos: todo mundo sabe utilizar um
liquidificador ligando, aumentando a velocidade, encaixando o copo, mas
não sabemos como funciona a parte elétrica dele, não é interessante para o
fabricante que se mexa nesta parte então ele (o fabricante) à encapsula;
- Herança: muitas vezes um determinado indivíduo (objeto) herdará
características de outros. Por exemplo: um carro Gol e um Golf, ambos são
carros diferentes, mas todos tem portas, motor, pneus, bancos... são
atributos herdados de outros carros;

- Polimorfismo: um objeto irá se comportar de várias formas diferentes.

:: Pacotes, Classes, Métodos, Objetos e Atributos

- Pacote (package) é um conjunto de classes. Ex: [Link] é um pacote que

contém várias classes como Date, SimpleDateFormat e muitas outras.

- Uma classe é um tipo de dados que representa uma estrutura e é definida

pelo programador. Por exemplo, criar uma classe que somente realiza o
cálculo do FGTS, outra que só calcula o Imposto de Renda.

- Um objeto representa um elemento desta classe.

- Método é a maneira com que uma classe irá realizar ações por exemplo
soma(), subtração(). Lembrando que sempre haverá parênteses após o nome
do método.

- Atributos (campos) são as características desse objeto. Por exemplo, o

campo idade, endereço, cep etc.

- O escopo (podemos entender como o corpo do código) de uma classe é

delimitado por chaves “ { } “. Todo o código da classe estará dentro destas
chaves.

Por exemplo, fazendo uma analogia com a planta de uma casa. A planta da
casa seria a nossa classe; as casas que nós criamos a partir desta planta
seriam os objetos; as características dessa casa (tamanho, cômodos, cor,
altura) seriam os atributos, ou seja, a partir de uma classe eu posso criar
vários objetos com vários atributos.

Também podemos dizer que um objeto é uma instância de uma classe. A

casa que criamos a partir da planta da casa é um objeto, que também pode
ser chamado de instância (acostume-se com este termo).

Vamos ao exemplo. Primeiro crie uma classe chamada [Link], já

vimos isso no começo do curso. File, New, Class, [Link]. Não
esqueça de deixar marcada a opção . Digite o
código abaixo:
Neste código aplicamos vários conceitos explicados até aqui, então leia este
passo a passo pelo menos 3 vezes para entender tudo perfeitamente.
Explicando:

- Linha 1: criamos uma classe (class) pública (public) com o nome

ExibeImpar (seguimos a convenção Java para nomes de classe, quando tem
mais de uma palavra a primeira letra de cada palavra é maiúscula) e
lembrando que o nome do arquivo deve ser o mesmo da classe pública;

- Linha 7: muita atenção agora. Nesta linha nós criamos

um Método (representa uma ação) público (public), sem valor de retorno
(void indica que o método não retorna nenhum valor), com o
nome exibir().

Obs.: Perceba que abrimos e fechamos um parêntese para identificar um

método, isso é uma regra e não uma convenção;

- Linha 8: nós criamos uma variável local (só pode ser utilizada dentro do
método) chamada contador e atribuímos um valor inicial 1, este valor será
utilizado pelo bloco while;
- Linha 10: abrimos um bloco While que será executado até
que contador seja menor ou igual a 20, lembrando que a variável contador
já está com o valor 1;

- Linha 11: abrimos um laço IF (perceba que agora temos um

laço IF dentro de um While) que testa se o resto da divisão (%, resto da
divisão, também chamado de módulo) de contador por 2 é diferente de 0.
Se for diferente de zero é porque o valor de contador é ímpar;

- Linha 12: exibe na tela o valor ímpar de contador com o comando

[Link]();

- Linha 13: fecha o escopo do bloco IF;

- Linha 14: incrementa contador em uma unidade com o operador de

incremento. Lembre-se que o laço while só será finalizado
quando contador for menor ou igual a 20, enquanto não atingir este valor
ele continuará executando;

- Linha 15: fecha o escopo do laço while;

- Linha 2: criamos o nosso método main (obrigatório para executar o

programa);

- Linha 3: importante. Declaramos uma variável chamada de ei do tipo

classe ExibeImpar. Esta variável ei é que será utilizada para acessar o
método da classe;

- Linha 4: utilizando a palavra reservada NEW, criamos (instanciamos) um

objeto da classe ExibeImpar e o atribuímos à variável ei, ou seja, ei é uma
variável de objeto (instância da classe). Instanciamos esta variável para
podermos acessar o método exibir(). Mais tarde iremos aprender a fazer
todo essa operação de criação de objetos em uma só linha.

- Linha 5: utilizamos a instância da classe para acessar o método exibir() e

executar o que está dentro dele.

Digite e execute este código no seu Eclipse.

Você pode alterar este código para exibir os números pares, basta que o
resto da divisão por 2 seja “==0” e não “!=0”.

No próximo módulo do curso faremos vários exemplos de código,

utilizando conceitos, para realmente você entender.
Módulo 7: Pacotes, praticando com exemplos mais rebuscados

:: Pacotes

O código fonte de uma aplicação real é formado por uma quantidade

grande de arquivos, conforme essa quantidade cresce surge a necessidade
de algum tipo de organização para poder encontrar os arquivos mais
rapidamente quando for necessário modificá-los.

A ideia para organizar logicamente os arquivos de uma aplicação é bem

simples e muito parecida com o que um usuário de computador já está
acostumado a fazer. Os arquivos são separados em pastas e subpastas ou
diretórios e subdiretórios.

Na terminologia do Java, dizemos que as classes são organizadas

em pacotes, também conhecidos como bibliotecas ou API. O primeiro
passo, para colocar uma classe em um determinado pacote, é utilizar o
comando Package no código fonte. Por exemplo, vamos criar um pacote
chamado Array seguindo os passos abaixo:

Dentro do Eclipse: File, New, Package

Depois de colocarmos o nome basta clicar Finish. Todas as classes que
forem criadas dentro deste pacote terão a palavra reservada package.
Depois de criado o pacote, crie uma classe chamada Array1 (botão direito
no pacote Array, New, Class). Perceba na figura abaixo que agora estamos
realmente dentro do pacote Array.

Isso é muito bom para organizar todas as classes com um grau de afinidade
em um mesmo pacote. Digamos que você tenha várias classes que realizam
cálculos matemáticos, você pode organizá-las em um único pacote
chamado Cálculos. Detalhe, quando você deseja utilizar uma classe de
determinado pacote você deve utilizar a palavra reservada import “nome
do pacote”. Exemplo:

No exemplo acima estamos utilizando a classe [Link] do pacote

Strings_E_Datas.

Neste trecho de código estamos avisando ao Java que a nossa classe

pertence ao pacote Strings_E_Datas, para manter organizado neste pacote
Strings_E_Datas poderíamos ter somente classes referentes à manipulação
de Strings e Datas, se alguém quiser usar essas classes terá que importá-
las com o comando import. Na Linha 3 temos algo parecido com isso:
estamos importando todas as classes [Link] (indicamos isso com o *) do
pacote String_E_Datas.

No Java temos um pacote padrão que a maioria das classes utiliza, é o

pacote [Link]. Esse pacote é automaticamente importado pelo
compilador do Java em qualquer programa. O Java disponibiliza na Internet
gratuitamente milhares de API’s (pacotes) prontas para uso. Por exemplo,
mais a frente, vamos utilizar API’s com dezenas de classes e métodos
específicos para tratar Datas, Strings e Cálculos matemáticos.

:: Praticando – Prepare-se que vamos treinar e aprender muito mais agora.

Faça todos esses exemplos, pratique.

Agora que já temos alguns fundamentos do Java e da Orientação a Objetos,

vamos praticar mais um pouco e aproveitar para aprender novas funções do
Java, na prática, nos códigos abaixo. Os próximos exemplos devem ficar
em nosso pacote padrão mesmo, o default.

1 – Criar uma classe com o nome Ordena onde o usuário entra com dois
valores e o sistema os exibe no console ordenando-os do menor para o
maior:
Explicando o código:

- Linha 1: através do comando import nós chamamos o pacote (API do

Java), e suas classes, [Link].*, podemos ler como “importe todas as
classes do pacote [Link]”. Neste momento podemos utilizar todas as
classes e métodos deste pacote. Acostume-se a conhecer as principais
API’s do Java, são muito úteis para o programador não ter que “reinventar
a roda”, já está tudo prontinho e testado para ser utilizado;

- Linha 2: criamos nossa classe pública obrigatória;

- Linha 3: criamos o método main (principal e obrigatório para a execução

do código);

- Linha 4: novidade. Instanciamos um objeto da classe Scanner e o

atribuímos à variável infor. A classe Scanner pertence ao pacote [Link] e
basicamente a utilizaremos para entrada ou saída de dados. No nosso caso,
entrada de dados pelo teclado;

- Linha 5: declaramos as variáveis x,y,z do tipo int;

- Linha 7: exibimos o texto “digite o valor de X= “ para indicar ao usuário

que ele deve entrar com o valor de x;

- Linha 8: importante. Utilizamos a variável de instância (ou variável de

objeto) infor para acessar o método nextInt() da classe Scanner do
pacote [Link]. O método nextInt() aguarda um valor inteiro vindo do
teclado que o usuário deverá digitar;

Obs.: Se o usuário for digitar um Double, utiliza-se nextDouble(), se o

usuário for digitar um float, utiliza-se nextFloat(), etc.

Linhas 9 e 10 é o mesmo raciocínio das linhas 7 e 8 só que para a variável

Y;

Linha 12: testa se o valor de x é maior que o valor de y, ambos valores

informados pelo usuário. Se x for maior que y então se executam as Linhas
13 e 14, ou seja, exibe primeiro o valor de y e depois o valor de x. Se x for
menor que y então se executam as Linhas 16 e 17, ou seja, exibe primeiro o
valor de x e depois o valor de y;

Digite e execute o código acima.

2- Crie uma classe AreaCirculo para determinar a área de um círculo (área

= ¶ * raio2): Atenção na linha 10.
- Linha 4: variável raio, do tipo int, com valor inicial 8;

- Linha 5: variável área do tipo double sem valor inicial.

- Linha 6: variável pi que irá armazenar o valor de ¶ . Para obtermos o valor

do ¶ utilizamos o método PI da classe Math (atenção para esta classe, ela é
muito útil para cálculos matemáticos);

Obs.: Utilizamos neste exemplo a classe Math sem precisarmos dar um

import do pacote. Isso porque esta é uma classe do pacote [Link] (já
mencionado acima) que é automaticamente importado pelo Java sem
precisar explicitar isso com o comando import. É o único pacote do Java
com essas características, os outros devem ser importados normalmente.

- Linha 7: variável potencia do tipo double, onde vamos armazenar o valor

do raio elevado ao quadrado. Note que utilizamos o método pow (potência)
da classe Math do pacote [Link] (importado automaticamente pelo
Java);

- Linha 9: a variável area recebe o valor do ¶ e o multiplica pelo valor da

variável potencia;

- Linha 10: exibe o resultado no console. Detalhe: perceba essa parte do

código Que raios esse float dentro dos parênteses está
fazendo? Ele está fazendo um Casting de Tipos Primitivos, é uma
“conversão” de um tipo em outro. Por exemplo, tipo int em Double, tipo
float em int, etc. Veremos um exemplo logo abaixo após a tela com outros
métodos da classe Math.
Digite e execute o código acima.

Módulo 8: Mais métodos da classe Math, Casting de tipos primitivo

Mais alguns métodos importantes da classe Math, pratique:

Crie uma classe chamada ClasseMath

:: Pausa para conhecer Casting (implícito e explícito) de tipos primitivos:

é como se fosse uma “conversão” de um tipo primitivo para o outro.
Exemplo:
Casting Implícito

- Linha 5: uma declaração normal da variável x sendo do tipo int;

- Linha 6: uma variável y do tipo double recebendo a variável x que é do

tipo int. Neste momento o valor 10 que antes era int, agora se tornou
double.

- Linha 7: por padrão o número 10 é um int, então temos que informar que
queremos que ele seja long, fazemos isso com a letra L no final;

- Linha 9: por padrão o número 10.0 é um Double, então temos que

informar que queremos que ele seja float, fazemos isso com a letra F no
final;

Casting Explícito

- Linha 10: 14.5 por padrão é um Double, queremos realizar o casting para
int, antecedemos o valor 14.5 com (int). Detalhe: o valor decimal é
truncado, a variável r ficará com o valor 14. Foi o que fizemos no código 2,
no exemplo da Área do Círculo.

3 – Crie um programa que soma 5 números inteiros:

- Linha 4: criamos uma variável contador, do tipo int, que recebe o valor
inicial 1;

- Linha 5: criamos uma variável valor, do tipo int, que recebe o valor inicial
0;

- Linha 7: um laço WHILE que executará o seu código até que a variável
contador atinja um valor menor ou igual a 5;

- Linha 8: a variável valor recebe valor + contador;

- Linha 9: incrementamos o valor de contador em uma unidade utilizando o

operador de incremento (++);

- Linha 11: exibimos na tela o resultado da variável valor;

4 – Crie um programa onde o usuário entra com um ano e o sistema

identifica se é bissexto ou não:
Linha 5: utilizando a palavra reservada NEW, criamos (instanciamos) um
objeto da classe Scanner e o atribuímos à variável infor, ou seja, infor é
uma variável de objeto (instância da classe). Instanciamos esta variável
para podermos acessar o método [Link]() na Linha 8. Utilizamos a
variável de instância (ou variável de classe) infor para acessar o
método nextInt() da classe Scanner do pacote [Link];

Linha 6: criamos uma variável ano, do tipo int;

Linha 8: a variável ano recebe um valor do tipo int informado pelo usuário;

(repetindo: variável infor acessando o método nextInt() da classe Scanner

do pacote (API) [Link]) Ufa!!!

Linha 10: com o IF testamos se o ano informado pelo usuário é bissexto;

5 - Crie um programa onde o usuário entra com o valor da sua dívida e o

sistema verifica a quantidade de parcelas:
- Linha 1: importamos todas as classes do pacote [Link];

- Linha 4: criamos uma variável de classe entra que irá receber um valor
fornecido pelo usuário;

- Linha 5: criamos duas variáveis divida e dividaFinal do tipo Double;

- Linha 6: variável juros do tipo float;

- Linha 7: variável qtdMeses do tipo int;

- Linha 10: a variável divida recebe um valor do tipo double informado

pelo usuário;

- Linha 12: a variável qtdMeses recebe um valor do tipo int informado pelo
usuário;

- Linha 15: a variável juros recebe um valor do tipo float informado pelo
usuário;

- Linha 16: a variável juros recebe o cálculo dos juros da divida e também
utilizamos o casting explícito para que o valor final seja um float;
- Linha 17: a variável dividaFinal receberá o cálculo da dívida;

- Linha 18: exibe na tela o valor da dívida realizando o casting explícito do

valor para float.

6: Crie um programa onde o usuário entra com um número e o sistema

informa todos os valores da tabuada deste número:

Linha 4: Utilizamos a variável de classe (ou variável de instância) x para

acessar o método nextInt() da classe Scanner do pacote [Link];

Linha 5: variável contador com valor inicial 1 e variável result com valor
inicial 0, ambas do tipo int;

Linha 7: variável nt, do tipo int, que irá receber um número inteiro
informado pelo usuário;

Linha 9: laço WHILE que executará o seu código até que a variável
contador seja menor ou igual a 10;
Linha 10: atribui-se o valor da multiplicação de nt por contador à
variável result;

Linha 12: incrementamos em uma unidade a variável contador utilizando o

operador de incremento (++).

Módulo 9: Extras

:: A Classe STRING

Comentamos rapidamente sobre a classe String na parte de declaração de

tipos primitivos e vamos agora aprofundar o assunto que é muito
importante. Variáveis do tipo String guardam referências a objetos, e não
um valor, como acontece com os tipos primitivos. Assim como vimos
vários métodos da classe Match, também veremos vários métodos da classe
String.

Uma string irá armazenar um conjunto de caracteres como por exemplo

nome, endereço, cidade, etc. Temos duas maneiras para declarar uma
String e dependendo do modo de declaração o resultado retornado poderá
ser diferente. Vamos entender melhor no exemplo. Crie uma classe
chamada ClasseString:
Linha 2: Criamos a classe ClasseString;

Linhas 5 e 6: Declaramos duas variáveis y1 e y2 de forma literal (é a forma

mais simples e mais utilizada), bem semelhante à declaração de qualquer
variável de tipo primitivo como já vimos várias vezes. Perceba que ambas
tem o mesmo conteúdo;

Linha 8: com o comando IF iremos comparar (com o sinal ==) os

conteúdos das variáveis para saber se são iguais. Neste caso sim, eles são
iguais como mostra o resultado da execução;

Linha 14 e 15: a segunda maneira de declarar uma String. Instanciamos

dois objetos x1 e x2 da classe String com conteúdos iguais.

Linha 17: novamente com o comando IF iremos comparar os conteúdos das

variáveis para saber se são iguais. Neste caso perceba que agora o resultado
do programa deu “diferente” mesmo os conteúdos das variáveis sendo
idênticos. A pergunta inevitável: (porque?)

O Java reserva uma área chamada String Constant Pool (pool constante de
string). Sempre que uma nova variável na forma literal (como nas linhas 5
e 6) é criada, o Java verifica o pool (área de memória) para confirmar se
existe uma variável string idêntica à que foi criada, que no nosso exemplo
sim, elas são iguais.

Na forma literal utilizando o operador “==” o Java compara os endereços

de memória, já na segunda forma de declaração, com o objeto instanciado,
o Java compara os conteúdos com o auxílio do método equals() (método
este da classe String) como na linha 23.

Resumindo: na linha 17 não comparamos o conteúdo, comparamos os

objetos, área de memória diferentes. Já na linha 8 comparamos o conteúdo.
Mesma área de memória. É a forma mais utilizada.

- Linha 23: com o comando IF comparamos, com o auxílio do

método equals(), da classe String, os dois objetos x1 e x2. Agora sim o
resultado será “igual”, objetos com conteúdos idênticos, conforme
podemos verificar na figura da execução do programa. UFA!!
Digite e execute este código no seu Eclipse.

Mais alguns métodos importantes da classe String:

:: Palavras chaves ou reservadas

São aquelas palavras que só podem ser utilizadas pelo Java. Por exemplo
você não pode chamar uma variável com o nome “byte”, você terá que usar
outro nome.
:: Referência This:

É permitido que uma variável local tenha o mesmo nome de uma variável
de instância. Neste caso, utilize a referência this para acessar a variável de
instância.

Se de dentro do método variáveis() quisermos referenciar(chamar) a

variável contador do escopo da classe, utilizamos a palavra reservada this.
Exemplo:

Entendendo: perceba que dentro do método variáveis nós continuamos

tendo duas variáveis totalmente diferentes. Na linha 10 declaramos uma
variável local contador (só funciona dentro do método variáveis() ).

Na linha 11 estamos utilizando a palavra reservada this para acessar a

variável de instância contador da linha 8.

:: Falando mais sobre Métodos

Um método é um procedimento ou função que foi criada dentro de uma

classe. Um Método é um bloco de instruções que vai gerar uma ação e só
pode ser criado dentro de uma classe. Vamos ao exemplo e explicação em
cima dele:
Essa parte do nosso curso é, mais uma vez, muito importante, atenção.
Neste exemplo vamos criar uma classe Lâmpada onde teremos dois
estados: ligada e desligada definidos por métodos. Lembrando que esta
classe não pode ser executada, perceba que não há o método main
obrigatório.

Linha 3: variável ligada do tipo boolean (valor true ou false). Esta variável
irá guardar o estado da lâmpada: se ligada true, se desligada false;

Linha 5: Neste método (um método representa uma ação) iremos “ligar” a
lâmpada atribuindo o valor true a variável ligada. Criamos o
método ligar( ) - perceba a obrigatoriedade dos parênteses no final do
método – a palavra reservada void indica que o método não terá valor de
retorno . Já dentro do método nós acessamos a variável de classe com a
palavra reservada this e atribuímos o valor true a ela. Lembrando que essa
variável ligada poderá ser usada pela classe inteira e quem estiver dentro
dela, sendo acessada com o auxílio do this;

Obs.: Para criar um método nós utilizamos o que chamamos de assinatura

do método. Onde identificamos se haverá retorno de algum valor com a
palavra reservada void, damos um nome ao método seguido de parênteses,
abrimos e fechamos chaves que é onde o código do método ficará (o
escopo).

Linha 9: criamos o método desligar() sem valor de retorno (void).

Atribuímos o valor false à variável de classe ligada;

Linha 13: criamos um método imprimir() que irá nos mostrar na tela o
estado atual da lâmpada, utilizando o IF que já aprendemos anteriormente
no curso. Se a variável ligada receber true aparecerá a mensagem “lâmpada
ligada”, se receber false aparecerá a mensagem “lâmpada desligada”.

Agora estamos realmente pensando “orientado a objetos”. Criamos uma

classe Lâmpada que é especializada em alterar/exibir o estado atual da
lâmpada com seus métodos. Poderíamos por exemplo criar uma outra
classe especializada em somente verificar a voltagem da lâmpada e
colocarmos outros métodos dentro desta classe.

Agora criaremos a classe principal onde teremos nosso método obrigatório

main e também iremos instanciar um objeto para chamar esses métodos
ligar(), desligar() e imprimir() que criamos. Crie uma classe chamada
TesteLampada.
- Linha 3: declaramos o nosso método principal main. É ele que o Java irá
procurar para executar definitivamente o código;

- Linha 4: importante. Em uma só linha utilizando a palavra

reservada NEW, criamos (instanciamos) um objeto da classe Lâmpada e o
atribuímos à variável lamp, ou seja, lamp é uma variável de objeto
(instância da classe Lâmpada). Trazendo isso para o mundo real podemos
dizer que criamos uma lâmpada, mas podemos criar quantas lâmpadas
quisermos como lamp2, lamp3, etc;

- Linha 6: agora que criamos uma lâmpada (instanciamos um objeto da

classe Lâmpada, estou repetindo bastante porque é importante mesmo),
vamos utilizar a variável lamp para acessar os métodos da classe Lâmpada.
Nesta linha 6 nós utilizamos a variável lamp, seguida de ponto, para
acessar o método ligar(), ou seja, nesse momento a variável ligada da
classe Lâmpada recebeu o valor true;

- Linha 7: utilizamos a variável lamp, seguida de ponto, para acessar o

método imprimir(), para verificar o estado atual da variável lamp ( que no
nosso caso está ligada com o valor true);

- Linha 8: desligamos a lâmpada, ou seja, chamamos o método desligar()

onde se atribui false à variável ligada da classe Lâmpada;

- Linha 9: utilizamos a variável lamp, seguida de ponto, para acessar o

método imprimir(), para verificar o estado atual da variável lamp ( que no
caso agora está desligada, com o valor false).

Perceba que nosso programa completo é formado por dois

arquivos: Lampada e TesteLampada.
No começo parece confuso, mas depois a gente se acostuma com a
orientação a objetos, relaxa, veremos outros exemplos adiante. Teste o
código acima no seu Eclipse.

- Herança: muitas vezes um determinado indivíduo (objeto) herdará

características de outros. Por exemplo: um carro Gol e um Golf, ambos são
carros diferentes, mas todos tem portas, motor, pneus, bancos... são
atributos herdados de outros carros;

- Polimorfismo: um objeto irá se comportar de várias formas diferentes.

:: Modificadores

Métodos e variáveis de instância são chamados de "membros" e podem

utilizar modificadores de acesso, ao contrário de variáveis locais. Porém, se
a classe em si não estiver visível para outra classe, seus membros também
não estarão visíveis, independentemente de qualquer modificador utilizado
neles. Os modificadores de acesso aplicáveis são:

-public: qualquer classe pode acessar

-private: não pode ser acessado por nenhuma outra classe. Campos com
esse modificador só podem ser vistos/acessados pelos membros da classe
que ele se encontra. Este modificador é responsável por um dos conceitos
mais importantes da orientação a objetos, o Encapsulamento. Quando
você utiliza este modificador você está encapsulando (pode-se entender o
termo como “escondendo/ocultando”) o membro da classe: variável ou
método;

-default(não declarando explicitamente nenhum dos outros modificadores

o Java entende que você está utilizando o default): acessível somente por
classes do mesmo pacote.

-protected: acessível por classes do mesmo pacote ou através de herança.

Os membros herdados não são acessíveis a outras classes fora do pacote em
que foram declarados.

Como de costume, exemplo. Anteriormente criamos a classe

TesteLampada que chamava três métodos da classe Lampada: ligar(),
desligar() e imprimir(). Caso estes métodos estivessem com o
modificador private, este acesso não seria possível, pois tais métodos só
podem ser acessados/vistos pela sua própria classe Lampada.
- Os três métodos da classe Lâmpada encontram-se com o
modificador private, com isso somente métodos desta classe podem
acessá-los, outras classes não poderão fazê-lo. Isto é
o Encapsulamento trabalhando, Orientação a Objeto na veia. Se estes
métodos estivessem declarados com public por exemplo, qualquer classe
estaria liberada para acessá-los.

Obs.: Apenas uma classe (não estou me referindo a métodos) definida

como public pode existir em um arquivo Java e o nome deste arquivo deve
ser o mesmo da classe definida como public. No exemplo acima temos a
classe Lâmpada (pública) dentro do arquivo Lâ[Link], ou seja, para
um arquivo Lâ[Link] só pode existir uma e somente uma classe
pública.

Teste o código acima e perceba o erro que irá acontecer na classe

TesteLampada. Os métodos não poderão mais ser acessados devido a
utilização do modificador private.
Perceba que nenhum dos métodos pôde ser acessado justamente por
estarem encapsulados pelo modificador private na classe Lampada. Se você
voltar na classe Lampada e retirar esses modificadores private, tudo voltará
ao normal e os métodos poderão agora ser acessados. Faça esse teste para
visualizar o funcionamento.

:: Métodos get e set

Como visto anteriormente, o Encapsulamento "protege/oculta" os

atributos ou métodos dentro de uma classe, portanto devemos prover meios
para acessar tais membros quando eles são privados, ou seja, quando
possuem o modificador private. O que torna isso possível é a criação de
métodos.

Em programação orientada a objetos, esses métodos são chamados de

métodos getters e setters, pois eles proveem acesso aos atributos da
classe declarados como private e, geralmente, se iniciam com get ou set.

Na verdade, não há nada de diferente entre os métodos comuns e

os métodos assessores (como são chamados) getters e setters. A única
importância está no fato da orientação a objeto. Pois, sempre que formos
acessar um membro privado em Java usaremos get ou set, é uma convenção
muito utilizada. Uma das vantagens é que os getters e setters protegem os
atributos de algum acesso indevido de uma outra classe.

Antes de mais nada, é uma má prática de programação sair criando getters

e setters para todos os atributos de uma classe que estão com o modificador
private. Só os utilize quando realmente necessários. E é uma boa prática de
programação declarar como privados os atributos quando necessário e criar
seus métodos setters e getters para acessá-los de fora da classe.
- Set

Nomeamos um método com set toda vez que este método for alterar algum
campo (atributo) de uma classe, ou seja, se não criarmos um método
assessor set para algum atributo, isso quer dizer que este atributo não deve
ser alterado.

Portanto, como o valor de um atributo da classe será modificado não é

necessário que este método retorne nenhum valor, por isso, os métodos
setters são void. Porém, obrigatoriamente, eles têm que receber um
argumento que será o novo valor do campo. Calma J.

- Get (que também pode ser chamado de “is”)

Nomeamos um método com get toda vez que este método for verificar
algum campo ou atributo de uma classe. Como este método irá verificar um
valor, ele sempre terá um retorno como String, int, float, etc. Mas não terá
nenhum argumento.

Já sei, já sei ... EXEMPLO: continuando com nossa classe Lampada.

- Linha 2: a classe pública obrigatória e com o mesmo nome do arquivo

Java;

- Linha 3: declaração da variável ligada, do tipo boolean (verdadeiro ou

falso) e com o modificado private, ou seja, somente pode ser acessada
dentro da classe Lâmpada;

- Linha 5: método setLigar para iniciar um valor na variável de

classe ligada.

Considerações: perceba que o método set irá receber um valor (parâmetro),

por isso a declaração da variável lig dentro dos ( ). Outra coisa a se notar é
que como o método set terá que receber um valor, então o seu tipo é
declarado como void;

- Linha 6: a variável de classe ligada (lembra do this ?) recebe o valor

passado como parâmetro na variável lig;

- Linha 9: semelhante ao método setLigar. O método setDesligar recebe

um valor para a variável deslig e por isso também vai ser declarado
como void;

- Linha 10: a variável de classe ligada (o this novamente) recebe o valor

passado como parâmetro na variável deslig;

Obs.: Note as variáveis lig e deslig, elas estão declaradas dentro dos ( )
dos métodos setters. Elas são chamadas variáveis de método, pois só
podem ser utilizadas dentro deles, dos seus respectivos métodos.

- Linha 13: método getImprimir (ou isImprimir, também é aceito

normalmente) que irá retornar o valor atual da variável de classe ligada.
Perceba que este método é diferente, os ( ) estão vazios, ou seja, ele não
recebe nenhum valor, não recebe nenhum parâmetro, logo, ele não deve ser
declarado como void, deve ser declarado com o tipo de dado da variável
privada que estamos tratando, no nosso caso boolean, linha 3;

- Linha 14: retorna para o Java o valor atual da variável de classe ligada.
Note a utilização da palavra reservada return (atenção, isso é muito
importante);

Beleza estamos realmente pensando Orientado a Objetos. Criamos uma

classe Lampada especializada em acender e apagar a nossa lâmpada,
encapsulamos (private) nossa variável de classe ligada e utilizamos
métodos getters e setters para podermos acessá-la posteriormente. Agora
precisamos de uma classe com o método main obrigatório para podermos
utilizar estes métodos da classe Lâmpada fora dela.

As coisas começam a se encaixar. Continuando:

- Linha 2: criamos a classe pública TesteLampada que será responsável por
acessar a classe Lâmpada e seus métodos assessores setters e getters;

- Linha 3: método main obrigatório para executar a classe;

- Linha 4: instanciamos um objeto (com a palavra reservada new) da classe

Lâmpada e o atribuímos à variável lamp;

- Linha 6: com o auxílio da variável lamp acessamos o método setLigar da

classe Lâmpada e passamos como parâmetro o valor true dentro dos
parênteses;

- Linha 7: através do método getImprimir (ou isImprimir) exibimos o

estado atual da Lâmpada, que no caso é verdadeiro/ligada;

- Linhas 8 e 9: é a mesma coisa, só que agora passamos o valor false como

parâmetro para o método setDesligar, a lâmpada está desligada. Teste o
código acima.

Dica: assim que você declarar uma variável com o modificador private, o
Eclipse já sabe que devem ser criados os setters e getters correspondentes,
então no Eclipse temos atalho para fazer isso mais rapidamente. Logo
depois de declarada a variável com o modificador private tecle CTRL +
espaço (veja figura) e você verá uma lista onde as últimas opções são os
métodos set e get (is) já prontinhos, basta clicar e o Eclipse faz o resto.
Referências Bibliográficas

[Link]

[Link]

[Link]

[Link]

Java 2 Certificação Sun – Kathy Sierra

Java Fundamentos JDBC – Ivan Mecenas

Java Como programar - Deitel

Curso Formação Java SoftBlue – Básico, Médio e Avançado

Curso Formação Java 4Linux

Apostilas gratuitas da K19 e Cailum