Programação Java

Silvio Fernandes Menezes Vasconcelos

PROGRAMAÇÃO JAVA

Senac - Serviço Nacional de Aprendizagem Comercial

Departamento Regional – Sergipe

Instrutor - Autor
Silvio Fernandes Menezes Vasconcelos

Presidente do Conselho Regional

Abel Gomes da Rocha Filho

Diretor Regional
Paulo do Eirado Dias Filho

Divisão de Desenvolvimento Institucional (DDI)

Marcos Antônio Barros Barreto

Divisão de Educação Profissional (DEP)

Dayse Góes Prado

Divisão de Gestão de Pessoas e Administração (DGA)

Givando de Oliveira Silva

Divisão Financeira (DIF)

Rodrigo Sales Albuquerque Cunha

Empresa Pedagógica de Hotelaria

Ivo Rodrigues dos Santos

Unidade Móvel
Edivaldo Costa Fontes

Centro de Formação Profissional - Aracaju

Maria Anaciete Chaves

Centro de Formação Profissional - Itabaiana

Maria Isabel Lima Santos

Centro de Formação Profissional - Lagarto

João de Deus

Centro de Formação Profissional – Tobias Barreto

Nadja Menezes

Senac - Departamento Regional

Av Ivo do Prado, 564 - São José - Aracaju - SE – Brasil
CEP 49045-070 - (79) 3212-1560 | www.se.senac.br
PROGRAMAÇÃO JAVA

ICONOGRAFIA

Veja, abaixo, alguns símbolos utilizados neste

material para guiá-lo em seus estudos.

Professor falando.

Fique Atento! Conceito importante.

Praticando, pode ser usado folha, caderno,

etc. para respostar questões se necessário.

Destaque de algo importante. Atenção!

Complementando...
PROGRAMAÇÃO JAVA

SUMÁRIO

CAPÍTULO 1: LINGUAGEM JAVA................................................................... 6

1.1. CONCEITOS BÁSICOS.................................................................... 6
1.2. DEFINIÇÃO DE VARIÁVEIS E TIPOS DE DADOS......................... 9
1.3. STRING............................................................................................. 12
1.4. ARRAY.............................................................................................. 13
1.5. OPERADORES................................................................................. 15
1.6. FUNÇÕES MATEMÁTICAS.............................................................. 16
1.7. CONTROLE DE FLUXO................................................................... 17
1.7.1. Estrutura condicional if () (Decisão)........................................ 17
1.7.2. Estrutura condicional switch () (Decisão Múltiplas)................. 17
1.7.3. Estrutura de repetição for ()..................................................... 20
1.7.4. Estrutura de repetição while ()................................................. 20

CAPÍTULO 2: INTERFACE GRÁFICA............................................................. 23

2.1. COMPONENTE DA INTERFACE..................................................... 23
2.2. CAIXA DE DIÁLOGOS..................................................................... 28

CAPÍTULO 3: INICIANDO OS PASSOS EM JAVA.......................................... 32

3.1. LINGUAGEM JAVA.......................................................................... 32
3.2. CRIAÇÃO DE PROGRAMA EM JAVA............................................. 33
3.3. PRIMEIRO EXEMPLO DE PROGRAMA EM JAVA.......................... 34
3.4. INCLUINDO COMPONENTES NOS PAINEIS................................. 40
3.5. ADICIONANDO FUNCIONALIDADES AO PROGRAMA................. 41

CAPÍTULO 4: CLASSE, OBJETO E MÉTODOS............................................. 46

4.1. INTRODUÇÃO A CRIAÇÃO DE OBJETO........................................ 46
4.2. CLASSE E OBJETO......................................................................... 46
PROGRAMAÇÃO JAVA

4.3. CLASSES E OBJETOS EM JAVA.................................................... 48

4.4. MÉTODOS........................................................................................ 50

CAPÍTULO 5: ENCAPSULAMENTO, POLIMOFISMO E HERANÇA.............. 55

5.1. CONSTRUTORES............................................................................ 55
5.2. ENCAPSULAMENTO....................................................................... 60
5.3. POLIMOFISMO................................................................................. 63
5.3.1. Hrança..................................................................................... 64
5.3.2. Sobre carga de Métodos......................................................... 69
5.3.3. Reescrita de Métodos.............................................................. 70
5.3.4. Pacotes.................................................................................... 72

CAPÍTULO 6: CONTROLE DE ERROS........................................................... 74

6.1. TRATAMENTO DE EXCEÇÕES...................................................... 74
6.2. TRY-CATCH..................................................................................... 74
6.3. TRY-FINALY..................................................................................... 75
6.4. TIPO DE ERROS.............................................................................. 76

CAPÍTULO 7: BANCO DE DADOS COM JAVA............................................... 78

7.1. COMO CONECTAR E INSERIR DADOS DO BD............................. 78
7.2. COMO RECUPERAR DADOS DO BD.............................................

REFERÊNCIAS................................................................................................
PROGRAMAÇÃO JAVA

CAPÍTULO 1

LINGUAGEM JAVA

1.1. CONCEITOS BÁSICOS

Neste capítulo ainda não mostraremos os conceitos de orientação a

objeto, que é uma das principais características da linguagem Java. Também
deixaremos um pouco de lado a criação de interfaces gráficas, que iniciamos
no capítulo passado, e retomaremos mais para a frente. Por enquanto, vamos
nos focar na criação de programas em Java semelhantes aos que criávamos
em C. Apresentamos a seguir um exemplo simples de código na linguagem
Java.

Exemplo:
public class Exemplo01 {
public static void main (String args[ ]) {
System.out.println ("Primeiro exemplo");
}
}

A principal diferença que podemos notar já de início é que todo progra-ma

em Java inicia-se com a definição de uma classe. Uma classe é definida
através da palavra reservada class, seguida pelo nome da classe (neste caso,
o nome da classe é “Exemplo01”). Por convenção, todo nome de classe inicia-
se com uma letra maiúscula.

Prestando atenção na sintaxe, pois Java é case sensitive

(sensível ao caso), ou seja, o compilador diferencia letras
maiúsculas de minúsculas.

6
PROGRAMAÇÃO JAVA

Uma classe em Java é composta por métodos (considerados funções ou

procedimentos em outras linguagens de programação). Obrigatoriamente, a
classe principal (aquela que será executada inicialmente pelo programa) deve
possuir um método chamado main, assim como em C, que é invocado quando
a classe é executada.

A palavra main significa principal em inglês. O método main, portanto,

será o método principal do seu programa.

Os atributos “public” e “static” serão descritos mais adiante. O atributo

“void”, assim como em C, indica que o método não possui retorno. O
argumento “String[] args” é um vetor de Strings formado por todos os
argumentos passados ao programa na linha de comando quando o programa é
invocado. O comando “System.out.println ( )” imprime algo na tela.

Para compilar e executar o programa, primeiro é preciso salvá-lo com o

nome “Exemplo01.java”. Você pode fazê-lo até mesmo em um editor de texto
simples, mas continuaremos a mostrar nossos exemplos no NetBeans. Para
não haver confusão com os códigos do capítulo passado, crie um novo projeto
no NetBeans. Desta vez, deixe marcadas as opções “Criar classe principal”
(defina o nome da classe principal como “Exemplo01”) e “Definir como projeto
principal”. A classe “Exemplo01” criada já irá possuir um método “main”. Neste
caso, apenas insira no método o comando “System.out.println (“Primeiro
exemplo”)”.

7
PROGRAMAÇÃO JAVA

Figura 1. Saída de um programa Java no Netbeans (console).

Segue link a baixo para complementar o aprendizado:

http://javafree.uol.com.br/artigo/871498/Tutorial-Java-
O-que-e-Java.html

1
Altere o programa anterior para que ele imprima
duas mensagens, uma em cada linha.

8
PROGRAMAÇÃO JAVA

1.2. DEFINIÇÃO DE VARIÁVEIS E TIPOS DE DADOS

Os tipos de dados primitivos da linguagem Java estão enumerados no

Quadro 1 -mostrado a seguir:

TIPO DESCRIÇÃO VALORES

boolean Pode assumir dois valores: true boolean conf = true;

(verdadeiro) ou false (falso).
char Um Caractere em notação unico de 16 char sexo = "F";
bits. Serve para a armazenagem de dados
alfanuméricos.
string Armazena um conjunto de caracteres em String nome = "Silvio"
notação de 16 bits. Serve para a
armazenagem de dados alfanuméricos.
int Tipo numérico inteiro, aloca inteiros de int numero = 3;
32 bits na memória.
short Tipo numérico inteiro, aloca inteiros de short numero = 27
16 bits na memória.

long Tipo numérico inteiro, aloca inteiros de long numero = 59

64 bits na memória.

float Representa números em notação de ponto float numero = 7.6

flutuante (casa decimais), normalizada
em precisão simples de 32 bits.
double Representa números em notação de ponto double numero = 8.564
flutuante (casa decimais), normalizada
em precisão simples de 64 bits.
Quadro 1. Tipos de dados em Java.

9
PROGRAMAÇÃO JAVA

Para manipular uma variável, ela precisa ser declarada. Opcionalmente,

ela pode ser inicializada já no momento de sua declaração. O código fonte a
seguir mostra alguns exemplos de manipulação de variáveis em Java:

class Exemplo02 {
public class ExeVariavel {
public static void main (String[] rgs[ ]) {
int num1 = 0, num2 = 4;
char k = 'x’;
num1 = num2 + 8;
System.out.println("Primeiro valor: " + num1);
System.out.println("Segundo valor: " + num2);
System.out.println("Terceiro valor: " + k);
}
}

Tendo como resposta no console:

Primeiro valor: 12
Segundo valor: 4
Terceiro valor: x

2
Insira em seu programa duas variáveis de cada um
dos tipos primitivos do Java. Coloque valores diferentes
em cada uma delas e depois imprima-as.

3
Altere três vezes o valor de uma das variáveis do
programa anterior. Imprima a variável a cada nova
atribuição.

Em Java, existem duas formas de convertermos valores de um tipo para

outro:

10
PROGRAMAÇÃO JAVA

1. A conversão implícita, na qual os dados são convertidos

automaticamente, sem a preocupação do programador. Ela ocorre, por
exemplo, quando convertemos um número inteiro para um número real. Neste
caso, a conversão é implícita porque é óbvio para o compilador que um número
inteiro pode ser representado também como um número real.
Exemplo: int x = 4;
float y = x; // convertendo inteiro para float
double z = y; // convertendo float para double

2. A conversão explícita, quando o programador precisa explicitar no

código que um valor será convertido de um tipo para outro. No caso de um
número real para um inteiro, por exemplo, pode haver perda na precisão do
número (por isso é necessário que o usuário deixe explícito que ele quer
realizar a conversão).

Exemplo: float a = 9;
float b = a/8; // b = 1.125
int c = (int)b;
System.out.println(b);
System.out.println(c);

Cuidado:

O tipo boolean não pode ser convertido para nenhum outro

tipo.

11
PROGRAMAÇÃO JAVA

4
Crie três variáveis do tipo int contendo os valores
12, 13 e 14. Converta cada uma para um float e imprima
o valor convertido. Qual o resultado impresso na tela?.

5
Agora, crie três variáveis do tipo float contendo os
valores 12.3, 12.5 e 12.8. Converta cada uma para int e
imprima o valor convertido. Qual o resultado impresso
na tela?.

6
Tente imprimir a soma de uma variável inteira com
uma do tipo float. O que acontece?

1.3. STRING

String é uma classe para representarmos uma cadeia de caracteres, e

que oferece diversos métodos para manipularmos essa cadeia. Objetos da
classe String podem ser concatenados com o operador “+”.

Exemplos: String A = "Silvio", B = "Fernandes";

System.out.println(A + B);
System.out.println(A + " " + B);

Para compararmos se o valor de duas Strings são iguais, utilizamos o

método equals (o operador “==” não compara Strings).

Exemplo: if (A.equals(B) ) {
System.out.println(“Nome e sobrenomes são iguais”);
}
Outros métodos úteis da classe String:

// O método length retorna o tamanho da String

12
PROGRAMAÇÃO JAVA

System.out.println(“Tamanho da String: “ + nome length());

// O método substring retorna um pedaço da String

System.out.println(“Substring: “ + nome.substring(0, 5) );

// O método charAt retorn o caracter em dado índice da String

System.out.println(“Caracter na posição 5: “ + nome. charAt(5));

// O método split quebra a String em várias outras, pelo separador

desejado

String frase = “Isto é uma frase”;

String palavras[] = frase.split(“ “);

System.out.println(frase.indexOf(“uma”));

// replace troca todas as ocorrência de um caracter por outro

System.out.println(“Paulo”.replace(‘o’, ‘a’));

7
Crie uma String com seu nome completo e
sobrescreva as ocorrências da letra "a" pela letra "p".
Como ficou seu nome?

8
Utilize o método split para separar cada nome e
sobrenome da String acima.

1.4. ARRAY

Arrays (vetores) em Java podem conter qualquer tipo de elemento

valorado (tipos primitivos ou objetos), mas você não pode armazenar diferentes
tipos em um simples array (por exemplo, você pode criar um array de inteiros,

13
PROGRAMAÇÃO JAVA

ou um array de strings, ou um array de array, mas você não pode criar um

array que contenha ambos os objetos strings e inteiros).

Exemplo: String[] nome; // Array contendo Strings

int[] valor; // Array contendo inteiros

Outra forma de criar criarmos um objeto array é usando o operador new,

que cria uma nova instância de um array.

Exemplo: int[] valor = new int[20];

Nesse exemplo é criado um array de inteiro com 20 posições.

Também é possível criarmos um array ao mesmo tempo em que o

declaramos.

Exemplo: String[] nomes = {"Silvio", "Paty", "Anthony"};

9
Crie um novo programa, que armazene um vetor
com as notas de 10 alunos, e imprima a média dessas
notas.

10
Crie no mesmo programa acima um array de Strings
com o nome dos meses do ano. Crie uma variável inteira
com um valor entre 1 e 12, e imprima o nome do mês
correspondente ao valor da variável.

Segue link a baixo para complementar o aprendizado:

http://javafree.uol.com.br/artigo/871496/Tutorial-Java-2-
Caracteristicas-Basicasindex

14
PROGRAMAÇÃO JAVA

1.5. OPERADORES

Quadro 2. Operadores Aritméticos.

Quadro 3. Operadores Lógicos.

15
PROGRAMAÇÃO JAVA

Quadro 4. Operadores Relacionais.

1.6. FUNÇÕES MATEMÁTICAS

Na classe Math, existe uma série de métodos estáticos que fazem ope-
rações com números como, por exemplo, arredondar (round), obter o valor
absoluto (abs), obter a raiz (sqrt), calcular o seno (sin) e outros.

Exemplo: double a = 7.6;

long i = Math.round(a);
int k = -6;
int j = Math.abs(k);
double area = Math.PI * a^2;

16
PROGRAMAÇÃO JAVA

1.7. CONTROLE DE FLUXO

1.7.1. Estrutura Condicional if () (Decisão)

Comandos condicionais em Java são semelhantes aos de C.

A sintaxe de decisão em Java é dada abaixo:

if (condição) {

{Bloco de comandos executados se for verdadeira}

}
else {

{Bloco de comandos executados se for falsa}

}

Caso você não queira executar qualquer comando se a condição for falsa,
suprima toda a cláusula else :

if (condição) {
{Bloco de comandos executados se verdadeira}
}

Exemplo: double nota = 7.5;

if (nota >= 7) {
System.out.println("Aprovado");
} else {
System.out.println("Reprovado");
}

1.7.2. Estrutura Condicional switch () (Decisão Múltiplas)

A sintaxe de decisão múltiplas em Java é dada abaixo:

17
PROGRAMAÇÃO JAVA

switch (expressão) {
case possibilidade1:
bloco_de_instrução1;
break;
case possibilidade2 :
bloco_de_instrução2;
break;
case possibilidadeN :
bloco_de_instruçãoN;
break;
default:
bloco_de_instrução;
}

O comando case é um substituto mais elegante e mais legível para

condições múltiplas. A expressão (ou possibilidade) deverá ser de tipo com o
tamanho máximo de 2 bytes (Byte, Char,Word ou Int).

Exemplo:

int numero1 = 10, numero2 = 5, resultado=0;

char ch = '+';
switch (ch) {
case '+':
resultado = numero1 + numero 2;
break;
case '-' :
resultado = numero1 - numero 2;
break;
case '/' :
resultado = numero1 / numero 2;
break;
case '*' :
resultado = numero1 / numero 2;
break;
default:
System.out.println("Operador inválida...");
}

18
PROGRAMAÇÃO JAVA

11
Crie três variáveis reais, defina valores quaisquer
para elas, e defina um código que verifique se elas
mesmas podem ser lados de um triângulo (ou seja,
nenhuma pode ser maior que a soma das outras duas).

12
Crie uma variável contendo a idade de uma pessoa,
e verifique sua classe eleitoral:

 até 16 anos não pode votar;

 entre 16 e 18 anos ou mais que 65 é

facultativo;

 entre 18 e 65 anos é obrigatório.

13
Crie uma variável inteira contendo um dia do ano e
outra contendo um mês, e verifique se elas formam uma
data válida (considere que fevereiro sempre possui 28
dias).

14
Crie uma variável inteira contendo um dia do ano e
outra contendo um mês, e verifique se elas formam uma
data válida (considere que fevereiro sempre possui 28
dias).

19
PROGRAMAÇÃO JAVA

1.7.3. Estrutura de Repetição for ()

A sintaxe de repetição em Java é dada abaixo:

for (int contador =0; condição; incremento) {

{bloco_de_instruções};
}

contador é uma variável inteira com valor inicial;

condição é a condição para o encerramento do loop;

incremento esse incrementa ou decrementa o valor do contador cada

vez que o bloco de instruções é executado.

Exemplo: for (int conta = 0;conta < 10;conta++) {

System.out.println(conta);
}

1.7.4. Estrutura de Repetição while ()

A sintaxe de repetição em Java é dada abaixo:

while (expressão) {
{bloco_de_instruções}
}

Note que o bloco_de_instruções é executado enquanto a expressão for

verdadeira.

Note que como a expressão é avaliada antes da execução do

bloco_de_instruções, se a expressão for falsa o bloco_de_instruções não será
executado nenhuma vez.

20
PROGRAMAÇÃO JAVA

Exemplo: int conta = 0;

while (conta < 10) {
System.out.println(conta);
conta++;
}

O FOR e o WHILE podem ser utilizados para o mesmo propósito. Porém,

o código do FOR indica claramente que a variável conta serve, em especial,
para controlar a quantidade de laços executados. Use cada um quando achar
mais conveniente.

O for pode ser usado também para percorrermos um array. Para isso,
basta usarmos o atributo “length”, que retorna o tamanho do array.

Exemplo: for (int x = 0; x <= nome_do_array.length; x++) {

System.out.println(nome_do_array[i]);

Em Java, podemos declarar variáveis a qualquer

momento. Entretanto, o trecho de código em que a variável
será válida dependerá de onde ela foi declarada.

Escopo da variável é o nome dado ao trecho de código em

que a variável existe e no qual é possível acessá-la.

21
PROGRAMAÇÃO JAVA

15

Use WHILE ou FOR nas questões a seguir:

1) Imprima todos os números de 150 a 300.

2) Imprima a soma de todos os números de 1 a 1000.
3) Crie um número inteiro e verifique se ele é primo.
4) Imprima o fatorial de um número inteiro
qualquer.
5) Imprima os 30 primeiros elementos da série de
Fibonacci. A série é a seguinte: 1, 1, 2, 3, 5, 8,
13, 21, etc. Para calculá-la, o primeiro e segundo
elementos valem 1; daí por diante, cada
elemento vale a soma dos dois elementos
anteriores (ex: 8 = 5 + 3).

22
PROGRAMAÇÃO JAVA

CAPÍTULO 2

INTERFACE GRÁFICA

2.1. COMPONENTES DA INTERFACE

A seguir, mostramos os principais componentes de uma interface gráfica

em Java.

 JFrame: É onde ficarão todos os componentes da interface. O Frame,

que contém os componentes da interface, possui alguns métodos que
podem ser úteis:

 JFrame( ): Cria uma janela vazia.

 getTitle( ): Obtém o título da janela.
 setTitle( ): Define o nome da janela.
 setSize( ): Define o tamanho da janela.
 setLocation( ): Define a posição da janela na tela.
 isResizable( ): Verifica se a janela é ou não redimensionável.
 setResizable(boolean): Especifica se a janela é ou não
redimensionável.

 Painel (JPanel): É um painel criado em cima de um JFrame. Permite,

entre outras opções, adicionar cor de fundo e borda ao JFrame. Pode
haver mais de um painel em um mesmo JFrame e é utilizado para
organizar melhor sua interface. Como mostrar a Figura 2.

23
PROGRAMAÇÃO JAVA

Figura 2. Frame com dois painéis.

 Rótulo (JLabel): É um campo no qual podemos inserir textos e até

imagens. Como mostrar a Figura 3:

Figura 3. Rótulo.

 Campo de Texto (JTextField): É um campo de texto cujo conteúdo

pode ser modificado pelo usuário. É nele que o usuário insere dados
que serão utilizados pelo programa. Todos os dados inseridos em um
JTextField são tratados como String. Portanto, dados numéricos
precisam ser convertidos. Como mostrar a Figura 4.

24
PROGRAMAÇÃO JAVA

Figura 4. Campo de Texto.

 Área de Texto (JTextArea): É semelhante ao JTextField, mas permite

a entrada de textos maiores (com mais de uma linha). Como mostrar a
Figura 5.

Figura 5. Área de Texto.

 Botão de Opção (JRadioButton): É um conjunto de opções no qual

apenas uma pode ser selecionada pelo usuário. Um Grupo de Botões
(ButtonGroup) é um componente utilizado para criar grupos de
JRadioButtons (é útil para não haver confusão quando temos
vários conjuntos de JRadioButton). Como mostrar a Figura 6.

25
PROGRAMAÇÃO JAVA

Figura 6. Botão de opção.

 Caixa de Seleção (JCheckBox): É parecido com o JRadioButton, mas

permite que vários itens sejam selecionados ao mesmo tempo. Como
mostrar a Figura 7.

Figura 7. Botão de seleção.

 Caixa de Combinação (JComboBox): É como uma lista de itens na

qual o usuário pode escolher apenas uma opção. Como mostrar a
Figura 8.

26
PROGRAMAÇÃO JAVA

Figura 8. Caixa de Combinação.

 Botão (JButton): É um botão que permite que executemos

determinadas ações quando são clicados.

Figura 9. Botão.

 Barra de Rolagem (JScrollBar): Permite ajustar o conteúdo da área de

visualização. Como mostrar a Figura 10.

27
PROGRAMAÇÃO JAVA

Figura 10. Barra de Rolagem.

 Barra de Progresso (JProgessBar): Mostra o progresso e a

porcentagem de conclusão de uma determinada ação.

Além destes, existem componentes para adicionarmos menus a uma

interface. O NetBeans permite a manipulação dos componentes de forma
fácil.

2.2. CAIXA DE DIÁLOGO

A inclusão de mensagens é realizada por meio da classe “JOptionPane”,

especializada na geração de caixas de diálogo, isto é, pequenas janelas que
fazem uma pergunta, avisam algo ao usuário ou fornecem uma mensagem
qualquer. Pois as caixas de mensagens são criadas diretamente pelo método
da classe. Lembrando para usar as funcionalidade dessa classe, primeiramente
temos que importa-la. Exemplo: import javax.swing.JOptionPane;

28
PROGRAMAÇÃO JAVA

Existem quatro tipos padrão de caixas de diálogo:

MessageDialog: Caixa de diálogo que apresenta uma mensagem,

possibilitando acrescentar ícones de alerta ao usuário. É utilizada para
mostrar ao usuário alguma informação e não retorna nenhum tipo de valor de
resposta. A sintaxe é: JOptionPane.showMessageDialog(Component,
<mensagem>, <título da mensagem>,<tipo de mensagem>).

Onde:

 Componente - Define a posição da tela em que a caixa de mensagem

aparecerá. Quando deixado com “null”, aparecerá centralizada na tela.
 Mensagem - String com a mensagem a ser exibida para o usuário.
 Titulo da mensagem - É o título da janela que será aberta.
 Tipo de Mensagem - É o ícone que representa o tipo de mensagem. O
Quadro 5 - apresenta as constantes da linguagem Java para definição
dos ícones.

Quadro 5. Tipo de mensagem e a ícone.

29
PROGRAMAÇÃO JAVA

Figura 11. Caixa de mensagem do MessageDialog.

InputDialog: Caixa de diálogo que, além de emitir uma mensagem,

permite a entrada de um texto. Utilizada para fazer uma pergunta e solicitar a
entrada de um texto. A sintaxe é: String resp =
JOptionPane.showInputDialog (null, <mensagem>, <título da mensagem>,
<tipo de mensagem>).

Figura 12. Caixa de mensagem do InputDialog.

ConfirmDialog: Caixa de diálogo que, além de emitir uma mensagem,

possibilita ao usuário responder a uma pergunta. Utilizadas para o usuário
responder “Yes”, “No”, “OK” e “Cancel”. Existem três tipos de caixa de
confirmação:

30
PROGRAMAÇÃO JAVA

 Yes/No: YES_NO_OPTION (ou 0);

 Yes/No/Cancel: YES_NO_CANCEL_OPTION (ou 1);
 OK/Cancel: OK_CANCEL_OPTION (ou 2).

A sintaxe é: int resposta = JOptionPane.showConfirmDialog(Component,

<mensagem>, <título da mensagem>, <botões presentes>, <tipo de
mensagem>)

Figura 13. Caixa de mensagem do ConfirmDialog.

31
PROGRAMAÇÃO JAVA

CAPÍTULO 3

INICIANDO OS PASSOS EM JAVA

3.1. LINGUAGEM JAVA

A linguagem Java foi criada originalmente para a utilização em pequenos

dispositivos eletrônicos inteligentes. No entanto, com as dificuldades de
financiamento desse setor na época e, principalmente, devido à popularização
da Internet a partir de 1993, novas oportunidades apareceram e a Sun "entrou
de cabeça" nessa área.

A partir de 1995, a Sun anunciou o Java não apenas como mais uma
linguagem de programação, mas como uma nova plataforma de
desenvolvimento. Desde o ano de 1996 até hoje, a linguagem Java não para
de crescer, produzindo soluções desde pequenas aplicações até aplicativos
corporativos, controles de servidores WWW, etc.

A tecnologia Java é composta por infinitos produtos, baseados no poder

da rede e na idéia de que um software deveria ser capaz de rodar em
diferentes máquinas, sistemas operacionais e dispositivos, tais como,
computadores, servidores, notebooks, handhelds, PDAs (Palm), celulares, TV,
geladeiras e tudo mais o que for possível.

Os programas feitos em Java rodam em diferentes ambientes devido a

um componente da plataforma chamado JVM (Java Virtual Machine) – que é
um tipo de tradutor de código Java para instruções específicas de cada sistema
e dispositivo.

32
PROGRAMAÇÃO JAVA

Java também pode atuar em conjunto com outras linguagens. As

aplicações podem ser embutidas até mesmo em documentos HTML, por
exemplo, podendo ser transmitidas e utilizadas na Internet.

3.2. CRIAÇÃO DE PROGRAMA EM JAVA

Assim como em qualquer outra linguagem, Java precisa de um processo

de compilação para ser analisada a existência de erros de sintaxe. O
compilador é responsável pela tradução do programa escrito em Java para
uma linguagem intermediária chamada Java bytecodes – um código
independente de plataforma que é interpretado por um interpretador Java. Para
que um programa em Java seja executado, a máquina tem que possuir uma
outra ferramenta chamada interpretador, que estará emulando a JVM (Máquina
Virtual do Java) em qualquer computador e sistema operacional que esteja
usando. Para instalar o Kit de Desenvolvimento da Sun, é necessário seguir os
seguintes passos:

 Realizar o download do kit de desenvolvimento Java 6 SDK (Standard

Edition – J2SE) ou superior, popularmente conhecido como JDK (Java
Development Kit). Para isso, acesse o site http://java.sun.com e escolha
a ver-são de acordo com o sistema operacional que será utilizado.

 Após instalar a ferramenta, é necessário criar uma variável de ambiente

chamada JAVA_HOME (que deve guardar o caminho do diretório onde o
Java foi instalado) e adicioná-la ao PATH do seu S.O. No Windows, a
sintaxe é a seguinte (para a versão 1.5.0 do JDK, por exemplo):

Exemplo: SET JAVA_HOME = C:\JDK1.5.0

SET PATH = %PATH%;%JAVA_HOME%\bin

33
PROGRAMAÇÃO JAVA

SET CLASSPATH = %JAVA_HOME%\lib;.;

Existem diversos IDEs (do inglês "Integrated Development Environment",

que significa Ambiente Integrado de Desenvolvimento) com ferramentas de
apoio ao desenvolvimento de softwares em Java, com o objetivo de agilizar
este processo.

Nesta disciplina, utilizaremos o "NetBeans IDE". Para baixá-lo, acesse o

site http://www.netbeans.org/index_pt_BR.html e baixe a versão mais recente
(a versão utilizada neste material é a 7.3.1). Na página de downloads, você
também pode baixar diretamente o JDK com o NetBeans IDE Java SE já
embutido. Neste caso, não será necessário executar os passos de instalação e
configuração do Java descritos acima.

Antes de realizar o download, não se esqueça de confirmar que o

programa será baixado em português.

3.3. PRIMEIRO EXEMPLO DE PROGRAMA EM JAVA

Vamos agora criaremos um programa em Java que calcula a média final

de um aluno. No programa, a média do aluno será composta:

 Pela soma das notas das duas provas presencias (30 pontos);
 Da nota dos exercícios (40 pontos);
 Prova final, 40% do valor da média final serão compostos pela média
parcial calculada anteriormente;
 60% restantes serão compostos pela nota da prova final.

34
PROGRAMAÇÃO JAVA

Com o NetBeans criaremos um novo projeto. Para isso, realize os passos

a seguir:

A. Clique em "Arquivo" > "Novo Projeto".

B. Na janela Novo Projeto, nas opções "Categorias" da janela
aberta, escolha "Java". Dentro de "Projetos", escolha "Aplicativo
Java". Clique em "Próximo".
C. Coloque o nome do projeto, por exemplo: MediaAluno e certifique-
se de que apenas a opção "Definir como projeto principal" esteja
selecionada. Clique em "Finalizar".

Depois do projeto criado, ele passa a ser exibido na aba "Projetos" (lado
esquerdo do NetBeans). Vamos começar nosso projeto desenvolvendo a
interface gráfica de nosso programa. Para isso, precisamos criar um "quadro"
(frame), que é o local onde os componentes de nossa interface serão
mostrados. Este quadro pode ser criado da seguinte forma:

A. Na aba de "Projeto", clique com o botão direito do mouse no nome

de nosso projeto.
B. Escolha as opções "Novo" > "Form JFrame".

Digite um nome para o frame e outro para o pacote em que ele estará
inserido, por exemplo, "Interface" para o nome do frame coloque
"pacoteInterface" para o nome do pacote. Mais adiante, explicaremos
detalhadamente para que servem os "pacotes" em Java. Clique em
"Finalizar".

35
PROGRAMAÇÃO JAVA

Figura 14. Frame para a interface do programa.

O quadro cinza à esquerda da Figura 2 - é o frame onde os componentes

da interface irão aparecer. Na aba “Paleta”, no canto direito da figura, estão os
componentes que serão se inseridos. Vamos criar um “Painel” onde o usuário
irá digitar o nome e a matrícula de um aluno. Clique em “Painel” na opção
“Contêineres Swing” da aba “Paleta”. Arraste o ponteiro do mouse para a
área do frame e você verá uma tela como a mostrada na Figura 3.

Figura 15. Inserindo um Painel na interface do programa

36
PROGRAMAÇÃO JAVA

Nosso programa conterá dois painéis: um para inserção dos dados

pessoais do aluno e outro para cadastro de suas notas. Então coloque outro
painel abaixo do primeiro, execute os passos feitos acima, e em seguida insira
outro painel em seu programa. A Figura 4 - mostra como deve ficar, por
enquanto, o frame de nosso programa.

Figura 16. Inserindo segundo Painel na interface do programa

Como queremos distinguir os dados pessoais das notas dos alunos,

adicionaremos uma borda e um título aos nossos painéis. Para isso, clicamos
com o botão direito sobre o painel de cima, e escolhemos a opção
“Propriedades”. Será exibida uma tela como a mostrada na figura abaixo.

37
PROGRAMAÇÃO JAVA

Figura 17. Propriedade do Painel na interface do programa

O item “border”, que aprece em destaque na figura acima, define como

será esta borda que queremos alterar no painel. Para modificar este atributo,
devemos clicar no botão do item. Clicando nele, será exibida uma tela
mostrada na Figura 6.

Figura 18. Modificando a border do painel.

38
PROGRAMAÇÃO JAVA

Na figura anterior, escolhemos o tipo da borda como “Borda de título”, e

definimos o Título como “Dados pessoais do aluno”. Pode ser alterada a fonte
com a qual o título será escrito, para isso, clicando no botão ao lado do item
“Fonte”. Após clicar no botão do item “Fonte”, definimos a fonte com estilo
“Negrito” e de tamanho “12”, e clicamos em seguida em “OK”. Voltando à tela
da Figura 6, clicamos novamente em “OK”, depois no botão “Fechar”, e
visualizamos o painel com a borda e o título definidos nos passos anteriores. A
Figura 7 mostra a modificação na borda e no título do painel:

Figura 19. Borda do painel modificado.

16
É extremamente importante que você tente executar os
passos acima no painel de baixo, exatamente como no
painel de cima, só com o título “Notas do Aluno”.

39
PROGRAMAÇÃO JAVA

3.4. INCUINDO COMPONENTES NOS PAINEIS

Na opção “Controles Swing” da aba “Paleta”, encontramos os

componentes que iremos inserir em nossos painéis. O primeiro item a ser
preenchido pelo usuário será o nome do aluno. Para isso, iremos inserir um
“Rótulo”, que serve para explicação do que deve ser inserido no campo texto, e
um “Campo de Texto”, onde será digitado o nome do aluno. Para isso, clicamos
primeiro em “Label” (Rótulo) e definimos o local onde o rótulo será inserido,
para definirmos o texto que aparecerá no rótulo, clicamos com o botão direito
no mesmo e escolhemos a opção “Editar texto”, inserindo o texto “Nome do
aluno”. Ao lado do rótulo incluímos um “Campo de Texto”, Em seguida,
editamos o texto do “Campo de texto” (neste caso, deixamos o campo em
branco para que o usuário digite seu nome) e também escolhemos a opção
“Alterar o Nome da Variável”, colocando nome (nome da variável) como
mostrado na Figura 8.

Figura 20. Inserido rótulo e campo texto.

40
PROGRAMAÇÃO JAVA

17
Continue desenvolvendo a interface de nosso programa. Para isso,
crie uma tela semelhante à mostrada na Figura 9.

Figura 9. Tela do Exercício 17.

3.5. ADICIONANDO FUNCIONALIDADES AO PROGRAMA

Começamos a desenvolver a interface gráfica de nosso primeiro

programa em Java. Mas por enquanto, ele ainda não possui funcionalidades.
Para isso, vamos incluir um botão para que seja calculada a média final do
aluno. Clicando no item “Botão” da opção “Controles Swing” na aba “Paleta”
(ao lado do campo da média final). Incluímos então um botão ao lado do campo
de texto com a média final do aluno. De forma que seja exibida a frase
“Calcular Média”. Veja na Figura 12 - o botão inserido em nossa interface.

41
PROGRAMAÇÃO JAVA

Figura 21. Botão inserido em nossa interface.

Vamos colocar os campos de texto com as notas da prova final e da

média final indisponível para serem editados pelo usuário, então, clicamos com
o botão direito em cada um dos campos e escolhemos a opção
“Propriedades”. Em seguida, desmarcamos a opção “editable” (que faz com
que ele não seja editável).

Observe que a nota da prova final não esta editável, pois nem todos os
alunos fazem prova final. Com isso, retiramos o “rótulo” (Label) e
adicionaremos um componente do tipo “Caixa de seleção” (do inglês,
“CheckBox”) ao lado do campo com a nota da prova final. Como podemos
escrever o texto “Prova Final” ao lado da caixa de seleção, podemos excluir da
interface o rótulo “Prova Final”. Como na Figura 11.

42
PROGRAMAÇÃO JAVA

Figura 22. Incluindo uma caixa de seleção

A nota da prova final só será editável quando a caixa de seleção for

selecionada. Para isso, vamos definir uma ação a ser executada quando este
evento ocorrer (ou seja, quando o usuário selecionar a caixa de seleção).

Primeiro passo, é clicar com o botão direito do mouse sobre a caixa de

seleção que acabamos de criar, depois em “Eventos”, depois em “Action”
(ação) e depois na única opção disponível (actionPerformed). Repare que
agora o NetBeans está exibindo o código fonte da interface de nosso
programa. Por exemplo:

private void jCheckBox1ActionPerformed (java.awt.event.ActionEvent evt) {

// TODO add your handling code here:
}

.
Para alternamos entre o código-fonte e projeto, basta somente,
alternarmos entre os botões “Código-Fonte” e “Projeto” acima do código
(mostrados no topo das telas da Figura 2 - até a Figura 4 - deste capítulo).

43
PROGRAMAÇÃO JAVA

O trecho de código comentado acima é onde iremos inserir a ação a ser

realizada quando o evento ocorrer. O que iremos fazer é alterar o estado do
atributo “editable” do campo de texto da prova final. Para isso, iremos
adicionar os seguintes comandos:

private void jCheckBox1ActionPerformed(java.awt.event.ActionEvent evt) {

// TODO add your handling code here:
boolean estado = this.jTextField5.isEditable();
this.jTextField5.setEditable(!estado);
}

Na primeira linha adicionada ao código, verificamos se o campo

“jTextField5” atualmente é editável ou não, e o campo de texto que estamos
alterando se chama “jTextField5” porque foi o quinto a ser criado. Para
verificar o nome de um componente qualquer em seu programa, clique no
botão “Projeto”, que fica acima do código fonte do programa (para exibir o
Frame com sua interface); depois clique com o botão direto do mouse sobre o
componente cujo nome você deseja saber, e escolha a opção “Propriedades”.
O nome do componente aparecerá no topo e no final da janela “Propriedades”.

O método “isEditable()” retorna um valor lógico (verdadeiro ou falso),

indicando se o campo está editável ou não (verdadeiro para editável, e falso
caso contrário). O método “setEditable()” recebe um valor lógico como
parâmetro e modifica o estado “editável” do campo. O operador “!” em Java
equivale à negação (ou seja, transforma verdadeiro em falso, e falso em
verdadeiro). Portanto, se o campo for editável e clicarmos na caixa de seleção,
ele passa a não ser mais editável. Caso contrário, se clicarmos na caixa de
seleção, ele volta a ser editável.

Agora que o usuário já consegue incluir a nota da prova final de um aluno,

44
PROGRAMAÇÃO JAVA

podemos finalmente calcular sua média final. O cálculo deverá ser efetuado
quando o usuário clicar no botão “Calcular Média”. Portanto, precisamos
definir a ação que será executada quando ocorrer o evento. Para isso, volte à
tela de exibição do Frame, clique com o botão direito do mouse sobre o botão
adicionado ao Painel “Notas do aluno” e escolha a opção “Eventos”, depois
“Action” e, por fim, “actionPerformed”. Desta vez, foi incluído no código fonte
o seguinte trecho de código:

private void jButton1ActionPerformed (java.awt.event.ActionEvent evt) {

// TODO add your handling code here:
}

A seguir, vamos incluir o trecho de código necessário para efetuarmos o

cálculo da média final do aluno e:

private void jButton1ActionPerformed (java.awt.event.ActionEvent evt) {

double nota1 = 0, nota2 = 0, exec = 0;
double provaFinal = 0, media = 0;
nota1 = Double.parseDouble(jTextField2.getText());
nota2 = Double.parseDouble(jTextField3.getText());
exec = Double.parseDouble(jTextField4.getText());
provaFinal = Double.parseDouble(jTextField5.getText());
media = (nota1 + nota2 + exec)/3;
if (media >= 7) {
jTextField6.setText(Double.toString(media));
} else {
if (provaFinal > media) {
media = provaFinal;
}
jTextField6.setText(Double.toString(media));
}
}

45
PROGRAMAÇÃO JAVA

CAPÍTULO 4

CLASSES, OBJETOS E MÉTODOS.

4.1. INTRODUÇÃO A ORIENTAÇÃO A OBJETOS

Em grande parte de nosso entendimento e relacionamento com o mundo

se dá através do conceito de objetos. Ao vermos as coisas e seres que existem
ao nosso redor, existe uma natural tendência a tentarmos identificar o que é
cada uma dessas diferentes entidades. Ao vermos uma bola de futebol,
reconhecemos sua forma esférica, seu tamanho usual, colorido típico e
aplicação. Mas a bola que vimos não é a única que existe, inúmeras outras
estão “por aí” e, mesmo possuindo características idênticas, são objetos
distintos.

Como o próprio nome indica, a bola é de futebol, ou seja, para ser usada
no esporte que denominamos futebol, é um tipo de bola específica. Assim, bola
de futebol representa uma classe de objetos que apresentam características
próprias. Cada uma das bolas de futebol existentes é um objeto desta classe
de objetos. Existem outras bolas (outros tipos) que não são de futebol, mas
compartilham das mesmas características de uma bola, ou melhor, de uma
esfera.

4.2. CLASSE E OBJETO

Uma classe é um tipo de objeto que pode ser definido pelo programador
para descrever uma entidade real ou abstrata. Podemos entender uma classe
como um “modelo” ou como uma “especificação” para certos objetos, ou seja, a
descrição genérica dos objetos individuais pertencentes a um dado conjunto. A
bola de futebol pode ser uma classe que descreve os objetos bola de futebol. A

46
PROGRAMAÇÃO JAVA

definição de uma classe envolve a definição de variáveis às quais se associam

funções que controlam o acesso a esses objetos. Assim, a criação de uma
classe implica definir um tipo de objeto em termos de seus atributos (variáveis
que conterão os dados) e seus métodos (funções que manipulam tais dados).

Uma classe representa uma entidade e, como tal, define o seu

comportamento (métodos) e as suas características (propriedades). Os
acontecimentos que podem ocorrer para uma dada entidade em determinada
altura são chamados de eventos.

Classe é um componente de programa que descreve a

“estrutura” e o “comportamento” de um grupo de objetos
semelhantes – isto é, as informações que caracterizam o
estado desses objetos e as ações (ou operações) que eles
podem realizar.

Já um objeto é uma instância de uma classe. Ele é capaz de armazenar

estados através de seus atributos e reagir a mensagens enviadas a ele, assim
como se relacionar e enviar mensagens a outros objetos.

Objeto é a criação de uma instância da classe. Quando

instanciamos um objeto, criamos fisicamente uma
representação concreta de sua classe. “Ser Humano” é
uma classe, um molde, já “Roberto” é uma instância de
“Ser Humano”. Apesar de carregar todas as
características do molde Classe é um componente de
programa que descreve a “estrutura” e o “comportamento”
de um grupo de objetos semelhantes – isto é, as
informações que caracterizam o estado desses objetos e as
ações (ou operações) que eles podem realizar.

47
PROGRAMAÇÃO JAVA

Um outro exemplo: uma receita de bolo. Você come uma receita de bolo?
A resposta é “Não”. Precisamos instanciá-la, criar um objeto bolo a partir dessa
especificação (a classe) para utilizá-la. Podemos criar centenas de bolos a
partir dessa classe (a receita, no caso) e eles podem ser bem semelhantes,
alguns até idênticos, mas são objetos diferentes.

4.3. CLASSES E OBJETOS EM JAVA

Vamos criar uma classe que armazena os dados da conta de um usuário

no banco. Por enquanto, vamos escrever apenas o que a conta possui
(atributos), e não o que ela faz (métodos).

class Conta {
int matricula;
String nome;
double saldoConta;
double limConta;
}

Esses são os atributos que toda conta irá possuir. Repare que essas
variáveis foram declaradas fora de um bloco, diferente do que fizemos na
classe que possuía um método main. Quando uma variável é declarada
diretamente dentro do escopo da classe, ela é chamada de variável de objeto,
ou atributo.

A classe Conta especifica o que todos os objetos dessa classe devem

conter. Neste caso, ela não possuirá um método chamado main porque ela
não será a classe principal do nosso programa. Para isso, criaremos uma
classe (projeto) Programa, que criará um objeto da classe Conta.

48
PROGRAMAÇÃO JAVA

class Programa {
public static void main (String[] args) {
Conta conta = new Conta();
conta.nome = “Silvio”;
conta.saldoConta = 1000.0;

System.out.println(“Usuário da conta: “ + conta.nome);

System.out.println(“Saldo atual: “ + conta.saldoConta);

}

Preste atenção no ponto que foi utilizado em “conta.nome” e

“conta.saldoConta”. É assim que acessamos uma variável de objeto. Agora,
sempre que o programa for iniciado, a conta pertencerá ao usuário “Silvio” e
seu saldo será de mil reais.

A criação de um objeto a partir de uma classe é chamada de processo de

instanciação. Para realizar a instanciação de um objeto qualquer, é usado o
operador new (FURGERI, 2005). Se quiséssemos criar mais de uma conta,
bastaria criarmos vários objetos da classe conta com o operador new, dando
um nome diferente para cada conta. Cada uma delas teria um valor
independente para seus atributos.

18
Crie a classe Pessoa, contendo os atributos “nome”,
“altura” e “peso”, pelo menos. Crie alguns objetos dessa
classe e defina valores diferentes para os atributos de cada
um deles.

19
Crie 10 objetos da classe Pessoa e insira-os em um array
de objetos dessa classe. Utilize um for para imprimir todos
os atributos dos objetos do array.

49
PROGRAMAÇÃO JAVA

20
Crie uma classe para um “Funcionário”. Ela deve ter o
nome do funcionário, o departamento onde trabalha, seu
salário (double), a data de entrada no banco (String), seu
RG (String) e um valor booleano que indique se o
funcionário está na empresa no momento ou se já foi
embora.

21
Crie uma classe Empresa que possua “nome”, “cnpj”,
“qtde_de_funcionario” e um array de objetos da classe
Funcionario (o array pode armazenar até 100
funcionários).

4.4. MÉTODOS

Dentro da classe, também declaramos o que cada conta faz e como isso
é feito (os comportamentos que cada classe tem, isto é, o que ela faz).
As operações que um objeto oferece são chamadas de métodos. Andar,
Correr e Comer, por exemplo, pode ser métodos da classe Pessoa.

Métodos são comportamentos que os objetos de uma classe

podem possuir. A operação de ligar um objeto da classe
Moto, por exemplo, pode ser feita com o método ligar( ).

De que maneira uma quantia em dinheiro é sacada de uma conta?

Especificaremos isso dentro da própria classe Conta. É por isso que essas
“funções” são chamadas de métodos: pois esta é a maneira (o método) de

50
PROGRAMAÇÃO JAVA

fazermos alguma operação com um objeto.

Vamos agora adaptar a classe Conta criada anteriormente para incluir o

método “sacar”, para isso, colocaremos os códigos abaixo depois da linha do
double limite.

void sacar (double quantidade) {

this.saldoConta = this.saldoConta – quantidade;
}

O método “sacar” recebe como argumento (ou parâmetro) um valor do

tipo “double” contendo a quantidade de dinheiro a ser sacada da conta do
usuário. Sem o argumento, é impossível sabermos o quanto devemos subtrair
do saldo da conta. Essa variável chamada “quantidade” pode ser acessada
durante todo o método e deixa de existir ao final do método. A palavra “void”
indica que nenhum valor será retornado por esse método.

A palavra “this” permite que acessemos o valor de um atributo da própria

classe em questão, no nosso caso a classe Conta.

A palavra reservada this é muito importante e útil. Ela

referencia a própria instância de dentro de sua classe.
Cuidado, this não pode ser usada em métodos estáticos,
como veremos mais adiante.

Agora criaremos um método parecido com o anterior, mas para depositar

dinheiro na conta, acrescente o código depois de método sacar.

void depositar ( double quantidade) {

this.saldoConta += quantidade;
}

51
PROGRAMAÇÃO JAVA

O “+=” soma o valor de “quantidade” ao valor antigo do “saldoConta” e

guarda o resultado no próprio “saldoConta”. Para fazer com que um objeto
execute algum método, também colocamos um ( . ) ponto.

Vamos alterar a classe “Programa” para sacarmos dinheiro da conta e

depois depositarmos. Segue o exemplo abaixo:

class Programa {
public static void main (String[] args) {
Conta conta = new Conta();

conta.nome = “Silvio”;

conta.saldo = 1000.0;

conta.sacar(200);

conta.depositar(500);

System.out.println(“Usuário da conta: “ + conta.nome);

System.out.println(“Saldo atual: “ + conta.saldoConta);

}

22

Crie os seguintes métodos para a classe Funcionario,

criada anteriormente:

1) Método “bonificar”, que aumenta o salário do

funcionário de acordo com o parâmetro passado
como argumento.

2) Método “demitir”, que não recebe parâmetro

algum, apenas modifica o valor booleano
indicando que o funcionário não trabalha mais
na empresa.

3) Método “mostrarDados”, que simplesmente

imprime todos os atributos de um funcionário.

52
PROGRAMAÇÃO JAVA

23
Crie dois objetos da classe Funcionario com os mesmos
atributos. Compare os dois com o operador “==” e veja se o
resultado é true ou false.

24
Insira na classe Pessoa, também criada anteriormente, o
atributo “idade” e o método “aniversario”, que incrementa
sua “idade”. Crie um objeto desta classe, defina a “idade”,
chame o método “aniversario” algumas vezes e depois
imprima novamente a “idade”.

Na maioria das vezes no método devemos especificar o tipo de seu

retorno. Nos casos anteriores, utilizamos a palavra “void”, que significa que
não há um valor de retorno do método.

Quando um método possui um valor de retorno, esse valor é devolvido

para o código que o chamou. O método “sacar”, por exemplo, poderia retornar
um valor booleano indicando se a operação foi bem sucedida, se o valor a ser
sacada não for maior que o valor do saldo mais o limite da conta. Veja no
exemplo a seguir:

boolean sacar (double quantidade) {

if (quantidade > (this.saldoConta + this.limConta)) {
return false;
} else {
this.saldoConta = this.saldoConta – quantidade;
return true;
}
}

53
PROGRAMAÇÃO JAVA

Note que agora a declaração do método mudou. O retorno do método não

é mais “void”, e sim “boolean”. A palavra “ return ” indica que o método será
retornado ali, e o valor ao lado dela é que será devolvido como retorno.

Agora vamos mudar o código na classe “Programa” para testar o método

“sacar”:

conta.saldo = 1000.0;
boolean consegui = conta.sacar(2000);
if (consegui) {
System.out.println(“Operação realizada com sucesso.”);
} else {
System.out.println(“ERRO: Saldo insuficiente.”);
}

ou
conta.saldo = 1000.0;
if (conta.sacar(2000)) {
System.out.println(“Operação realizada com sucesso.”);
} else {
System.out.println(“ERRO: Saldo insuficiente.”);
}

Uma variável estática, declarada em uma determinada

classe, é compartilhada por todos os objetos dessa classe e é
criada uma única vez durante a execução do programa.

Uma variável de objeto, ao contrário, é criada a cada vez

que um novo objeto dessa classe é criado.

54
PROGRAMAÇÃO JAVA

Uma variável estática também é definida através da palavra static, como

e feito também em um método.

Segue link a baixo para complementar o aprendizado:

http://javafree.uol.com.br/artigo/871497/Tutorial-Java-3-
Orientacao-a-Objetos

55
PROGRAMAÇÃO JAVA

CAPÍTULO 5

MÉTODOS, ENCAPSULAMENTO, POLIMOFISMO E HERANÇA

Relembrando alguns conceitos importantes da programação orientada a objetos:

• Classe: É um tipo de objeto que pode ser definido pelo programador para descrever
uma entidade real ou abstrata.

• Objeto: É uma instância de uma classe. Por exemplo, vamos imaginar uma classe
chamada Moto. Cada moto existente é uma instância (ou um objeto) dessa classe.
Apesar de parecidas, cada moto possui características próprias, como cor, chassi,
arranhões, etc.

• Métodos são comportamentos que os objetos de uma classe podem possuir. Eles
definem as operações que podemos realizar com os objetos de uma classe.

5.1. CONSTRUTORES

Quando usamos a palavra “new”, como fizemos no código da classe

“Programa”, estamos construindo um novo objeto. Sempre que isso é feito, o
construtor da classe é executado. O construtor da classe é um bloco declarado
com o mesmo nome que a classe. Exemplo:

class Conta {
int matricula;
String nome;
double saldoConta;
double limConta;

56
PROGRAMAÇÃO JAVA

Conta () {
System.out.println(“Nova conta criada.”);
}
}

Sempre que um novo objeto da classe Conta for criado, a mensagem

“Nova conta criada” aparecerá na tela. É como uma rotina de inicialização que
é chamada sempre que um novo objeto é criado. Apesar de parecer, um
construtor não é um método.

Quando você não declara algum construtor na sua

classe, o Java cria um para você. Esse construtor é o
construtor padrão, que não recebe nenhum argumento e
cujo corpo é vazio.
A partir do momento em que você declara um
construtor, o construtor padrão não existe mais.

O interessante é que o construtor pode receber parâmetros, assim como

um método. Para aprimorar o construtor da classe Conta, por exemplo,
poderíamos receber o valor do “nome” do titular da conta como parâmetro.
Exemplo:

Conta (String nome) {

this.nome = nome;
}

Agora não precisamos mais atribuir os valores a esses parâmetros após

instanciarmos o objeto “conta” da classe “Programa”. Ao invés disso,
passamos os valores como parâmetro para o construtor da classe Conta ao
criarmos o objeto. Mudaremos a classe “Programa” para:
class Programa {
public static void main (String[] args) {
Conta conta = new Conta(“Silvio”);

57
PROGRAMAÇÃO JAVA

conta.saldo = 1000.0;

/* Deixe aqui as demais operações que foram inseridas no

programa */

Também é possível criar mais de um construtor em uma mesma classe,

cada um com um número diferente de parâmetros. Quando o objeto for criado,
o construtor apropriado será escolhido. Exemplo:

class Conta {
int matricula;
String nome;
double saldoConta;
double limConta;

Conta (String nome) {

this.nome = nome;
}

Conta (String nome, double valor) {

this.nome = nome;
this.saldoConta = valor;
}
}

A seguir, temos o exemplo de um trecho de código que cria dois objetos à

classe Conta. O primeiro passa uma String e um float como parâmetros na
criação do objeto, utilizando o segundo método construtor definido na classe
acima. O segundo passa apenas uma String como parâmetro, utilizando o
primeiro método construtor definido na classe:

Conta minhaConta = new Conta(“Hilário”, 1000.0);

Conta outraConta = new Conta( “Joãozinho”);

58
PROGRAMAÇÃO JAVA

System.out.print(“Usuário: “ + minhaConta.nome);
System.out.println(“ / Saldo: “ + minhaConta.saldo);
System.out.print(“Usuário: “ + outraConta.nome);
System.out.println(“ / Saldo: “ + outraConta.saldo);

Tendo como resultado:

Usuário: Hilário / Saldo: 1000.0

Usuário: Joãozinho / Saldo: 0

25
Crie um construtor para a classe Empresa, que recebe
como parâmetros um “nome” e um “cnpj” e o tamanho
do array de funcionários. O atributo
“qtde_de_funcionario” deve começar com o valor zero.
Crie também um construtor para a classe Empresa que não
receba o tamanho do array de funcionários. Neste caso,
defina que o padrão é criá-lo com tamanho 100.

26
Crie um construtor para a classe Funcionario que receba os
atributos “nome”, “departamento”, “salario” e RG. No
atributo booleano, considere que o funcionário está
empregado. Crie também um construtor para a classe
Funcionario que receba apenas nome e RG, e outro que não
receba parâmetros.

27
Crie um objeto da classe Empresa. Em seguida, crie vários
objetos da classe Funcionario e inclua-os na Empresa.
Demita alguns e depois imprima a quantidade de funcionários
da empresa utilizando o método “numeroDeFuncionarios”.

59
PROGRAMAÇÃO JAVA

5.2. ENCAPSULAMENTO

Em Java, existem atributos que modificam o nível de acesso às variáveis

definidas em uma classe, aos métodos, aos construtores e às próprias classes.
São eles: protected, private e public.

Public indica que uma classe, variável, método ou

construtor podem ser usados externamente ao pacote em
que foram definidos. Sem ele, o uso só pode ser feito
internamente ao pacote no qual ocorre a definição.

Private indica que uma variável, método ou construtor só

pode ser utilizado internamente à classe em que foi
declarado.

Protected indica que o uso só pode ser feito na classe ou

em uma subclasse.

Esses modificadores permitem a implementação do encapsulamento no

Java. O encapsulamento faz com que não seja permitido acessarmos
diretamente as propriedades de um objeto. Neste caso, precisamos mexer
sempre por meio dos métodos pertencentes a ele.

Encapsulamento consiste na separação entre os aspectos

externos de um objeto, acessíveis por outros objetos.

A melhor de fazermos é forçar o desenvolvedor seja sempre obrigado, por

exemplo, a utilizar o método “sacar”. Para fazer isso no Java, basta
declararmos que os atributos não podem ser acessados fora da classe,
utilizando o modificador de acesso private, da seguinte forma:

60
PROGRAMAÇÃO JAVA

class Conta { int numero;

String nome;
private double saldoConta;

private double limConta;

// métodos Sets

void setSalario ( double salario) {

this.salario = salario;
}

// métodos Sets
void getSalario () { return
this.salario;
}
}

Cada classe é responsável por controlar seus atributos, portanto ela deve
julgar se aquele novo valor é válido ou não. Essa validação não deve ser
controlada por quem está utilizando a classe, e sim por ela mesma
(centralizando essa responsabilidade e facilitando futuras mudanças no
sistema).

Sendo que, agora, quem chama o método “sacar” não faz a menor ideia
de que existe um limite que está sendo checado. Para quem for usar essa
classe, basta saber o que o método faz e não exatamente como ele o faz (“o
que” um método faz é sempre mais importante do que “como” ele faz: mudar a
implementação é fácil, já mudar a assinatura de um método vai gerar
problemas).

61
PROGRAMAÇÃO JAVA

A palavra-chave private também pode ser usada para modificar o acesso

a um método. Tal funcionalidade é normalmente utilizada quando existe um
método apenas auxiliar para a própria classe e não queremos que outras
pessoas o utilizem (ou apenas para seguir a boa prática de se expor ao
mínimo). Sempre devemos expor o mínimo possível de funcionalidades, para
criar um baixo acoplamento entre as nossas classes.

O que vimos acima é a ideia de encapsular, isto é, esconder todos os

membros de uma classe, além de esconder como funcionam as rotinas
(métodos) do nosso programa. Encapsular é fundamental para que seu sistema
seja suscetível a mudanças: não precisaremos mudar uma regra de negócio
em vários lugares, mas sim em apenas um único lugar, já que essa regra está
encapsulada (veja o caso do método “sacar”).

28
Adicione o modificador de visibilidade (private, se
necessário) para cada atributo e método da classe
Funcionario. Tente criar um Funcionario no “main” e
modificar ou ler um de seus atributos privados. O que
acontece?

62
PROGRAMAÇÃO JAVA

29

Crie métodos que alteram e que retornam cada atributo

da classe Funcionario. Exemplo:

void setSalario ( double salario) {

this.salario = salario;
}
void etSalario () {
return this.salario;
}

Modifique os códigos que acessavam atributos

da classe Funcionario e faça com que eles
passem a utilizar as funções acima. Exemplo:

f.salario = 100;

System.out.println(f.salario);

passa a ser:

f.setSalario(100);
System.out.println(f.getSalario());

5.3. POLIMOFISMO

Uma grande contribuição da orientação a objetos para o projeto e

desenvolvimento de sistemas é o polimorfismo. A palavra polimorfismo vem
do grego polimorfos e significa muitas formas. Na orientação a objetos, isso
representa uma característica em que se admite tratamento idêntico para
formas diferentes (baseado em relações de semelhança, isto é, entidades
diferentes podem ser tratadas de forma semelhante conferindo grande
versatilidade aos programas e classes que se beneficiam dessas

63
PROGRAMAÇÃO JAVA

características).

Polimorfismo é a capacidade de assumir várias formas.

5.3.1 HERANÇA

A ideia da herança é permitir que uma classe pudesse ser derivada de

outra classe. Um Aluno, por exemplo, é uma Pessoa. Dessa forma, um objeto
da classe Aluno (subclasse) deve “herdar” todos os atributos da classe Pessoa
(superclasse), como altura, peso, etc, bem como seus métodos (andar, correr,
etc).

Uma subclasse pode possuir tudo que está definido na superclasse, além
de ter suas características próprias. Todo Aluno, por exemplo, pode possuir
altura e peso, características de qualquer Pessoa, e também um Número de
Matrícula, característica que nem toda Pessoa possui. O diagrama da Erro!
Fonte de referência não encontrada. Abaixo é mostrado o relacionamento entre
essas duas classes.

64
PROGRAMAÇÃO JAVA

Pessoa
# altura : float
# peso : float

# Andar() : void
# Correr() : void

Aluno

# matricula : int

Figura 23. Primeira Herança

Herança é o compartilhamento de atributos e

operações entre classes com base em um
relacionamento hierárquico.

É o mecanismo que permite a uma subclasse possuir

tudo aquilo definido em sua superclasse, além de
atributos e operações localmente adicionados.

A grande vantagem da herança é o reuso. O conceito de herança, quando

utilizado corretamente, reduz o número de linhas de programação, gera maior
qualidade e facilita a programação, a verificação de erros e futuras correções.
Mais de uma subclasse, por exemplo, pode herdar de uma mesma
superclasse. Podemos criar uma classe Professor que também herda da classe

65
PROGRAMAÇÃO JAVA

Pessoa descrita acima. O diagrama da Figura 14 - mostra o relacionamento

entre as classes Professor, Aluno e Pessoa.

Pessoa

Aluno Professor

Figura 24. Segunda Herança

Herança pode ser entendida como uma técnica na

qual uma classe passa a utilizar atributos e operações
definidas em outra classe especificada como seu
ancestral. Rigorosamente falando, a herança é o
compartilhamento de atributos e operações entre
classes baseado num relacionamento hierárquico do
tipo pai e filho, ou seja, a classe pai contém definições
que podem ser utilizadas nas classes definidas como
filho.

A classe pai é chamada de classe base ou superclasse e as classes

filho são chamadas de classes derivadas ou subclasses. Este mecanismo
sugere que uma classe poderia ser definida em termos mais genéricos ou
amplos e depois refinada sucessivamente em uma ou mais subclasses
específicas. Daí a origem do termo técnico que descreve a herança:
especialização.

Vamos agora criar uma classe para os funcionários do nosso banco, e

outra específica para os gerentes. Um gerente guarda as mesmas informações

66
PROGRAMAÇÃO JAVA

que um funcionário comum, mas também possui informações e funcionalidades

próprias (por exemplo, uma senha que permite seu acesso ao sistema interno
do banco).

class Funcionario {
String nome;
String cpf;
double salario;
// métodos devem vir aqui
}

class Gerente {
String nome;
String cpf;
double salario;
int senha;

public boolean autentica(int senha) {

if (this.senha == senha) {
System.out.println(“Acesso Permitido!”); return true;
} else {
System.out.println(“Acesso Negado!”); return false;
}
}
// outros métodos
}

Nesse caso, o ideal seria fazer com que o Gerente possuísse tudo o que
um Funcionario possui sem reescrevermos códigos, ou seja, gostaríamos que
a segunda classe fosse uma extensão da primeira. Em Java, fazemos isso
utilizando a palavra-chave extends.

67
PROGRAMAÇÃO JAVA

class Gerente extends Funcionario {

int senha;

public boolean autentica(int senha) {

if (this.senha == senha) {
System.out.println(“Acesso Permitido!”);
return true;
} else {
System.out.println(“Acesso Negado!”);
return false;
}
}
}

Cada vez que criarmos um objeto do tipo Gerente, este objeto possuirá
também os atributos definidos na classe Funcionario, pois agora um Gerente é
um Funcionario.

Uma subclasse herda todos os atributos e métodos de uma superclasse.

Entretanto, não consegue acessar diretamente os atributos e métodos privados
(private) que foram herdados. Se quisermos que determinados atributos e
métodos de uma classe possam ser acessados diretamente por suas
subclasses, mas sem que eles sejam públicos (pois, neste caso, poderiam ser
alterados por qualquer um), podemos defini-los como protegidos (protected).
Um atributo protected só pode ser acessado pela própria classe ou suas
sublasses. Exemplo:

class Funcionario { protected String nome;

protected String cpf;
protected double salario;
// métodos devem vir aqui
}

68
PROGRAMAÇÃO JAVA

30
Implemente uma classe Aluno, em um novo projeto, que
herda de Pessoa e possui o atributo “matricula”. Em
seguida, implemente a classe Professor, que também
herda de aluno. Qual atributo próprio esta classe poderia
ter?

31
Implemente a classe Conta e adicione um método
chamado “atualizar”, que atualiza o saldo de uma conta de
acordo com uma “taxa” percentual, recebida como
parâmetro.

32
Crie duas subclasses que herdam da classe Conta:

ContaCorrente e Poupanca.

5.3.2 SOBRECARGA DE MÉTODOS

Outra forma de polimorfismo é a sobrecarga de métodos (method over-

load), que é a possibilidade de existirem vários métodos com o mesmo nome
em uma mesma classe. Esses métodos homônimos podem ser distinguidos,
por exemplo, pela quantidade e/ou tipo dos parâmetros que cada um deles
recebe.
Em outras palavras, para que esses métodos de mesmo nome possam
ser distinguidos, eles devem possuir uma assinatura diferente. A assinatura
(signature) de um método é uma lista que indica os tipos de todos os seus
argumentos. Exemplo:

// Sobrecarga.java

69
PROGRAMAÇÃO JAVA

public class Sobrecarga {

public long metodo (int x) {
return x+x;
}

public long metodo (long x, int y) {

return x+y;
}

public long metodo (String x) {

return x.length();
}
}

Quando criamos dois construtores para a classe “Conta”, estávamos

utilizando sobrecarga de métodos, mais especificamente sobrecarga de
construtores.

34
O método “aniversario” da classe Pessoa não recebia
parâmetros e incrementava a idade de um objeto dessa
classe. Crie agora outro método chamado “aniversario”
nessa mesma classe, que receba um inteiro como
parâmetro, indicando quantos aniversários a pessoa fez.

5.3.3 REESCRITA DE MÉTODOS

Outra forma de polimorfismo é a reescrita de métodos. Esta técnica

permite implementar um método em uma subclasse que tenha o
comportamento diferente do método na sua superclasse. Vamos supor que, no
final do ano, os funcionários comuns do banco recebem uma bonificação de
10% de seus salários, mas os gerentes recebem 15%. As classes ficariam da
seguinte forma:

70
PROGRAMAÇÃO JAVA

class Funcionario {
protected String nome;
protected String cpf;
protected double safari;

public double bonificacao() {

return this.salario * 0.10;
}
// métodos devem vir aqui
}

class Gerente extends Funcionario {

int senha;

public double bonificacao() {

return this.salario * 0.15;
}
// outros métodos
}
// outros métodos

Se for necessário acessar o método da superclasse que foi reescrito,

devemos fazê-lo com o comando “super.bonificacao( )”. A palavra “super” se
refere à superclasse herdada.

35
Reescreva o método “atualizar” da classe Conta nas
subclasses ContaCorrente e Poupanca. Na primeira, o
método atualizará o saldo com o dobro da taxa recebida
como parâmetro. Na segunda, atualizará com o triplo da
taxa (utilize super para acessar o valor do saldo na
superclasse). Reescreva também o método “depositar” na
classe ContaCorrente, descontando do saldo o valor de
0,35% do que foi depositado.

71
PROGRAMAÇÃO JAVA

36
Crie um objeto da classe Conta, um da classe Com
taCorrente e outro da classe Poupanca. Deposite
R$1000,00 em cada uma delas, chame em seguida o
método “atualizar” e depois veja o saldo final de cada uma.

5.3.4 PACOTES

Quando utilizamos códigos feitos por outros programadores, podemos

deparar com classes de mesmo nome, o que pode nos trazer problemas. Um
deles é que os sistemas operacionais não permitem que criemos arquivos com
o mesmo nome em um mesmo diretório; portanto, precisamos organizar essas
classes em diretórios diferentes.

Os diretórios estão diretamente relacionados aos chamados pacotes e

costumam agrupar classes de funcionalidades similares ou relacionadas. Por
exemplo, no pacote “java.util” temos as classes Date, Simple-DateFormat e
GregorianCalendar (todas elas trabalham com datas de formas diferentes).

Se quisermos que a classe Cliente esteja em um pacote chamado

“banco”, ela deverá estar em um diretório chamado “banco”. A classe Cliente,
que se localiza nesse último diretório mencionado, deve ser escrita da seguinte
forma:

A classe cliente:

72
PROGRAMAÇÃO JAVA

package banco;

class Cliente {
String nome;
String endereco;
}

E classe banco:

package banco;

class Banco {
String nome;
Cliente clientes[];
}

Note que Banco se referenciou a Cliente da mesma forma como

fazíamos quando colocávamos as classes em um mesmo arquivo. Para
utilizarmos classes definidas em outro pacote, utilizamos a palavra-chave
import. Exemplo:

package agencia;

import banco.Cliente

class Agencia {
String nome;
int id;
Cliente c[];
}

37
Separe as classes Empresa, Funcionario e Data em
arquivos diferentes, mas em um mesmo pacote.

73
PROGRAMAÇÃO JAVA

CAPÍTULO 6

CONTROLE DE ERROS

6.1. TRATAMENTO DE EXCEÇÕES

O Java oferece duas importantes estruturas para o controle de erros: try-

catch e try-finally. Ambas têm o propósito de evitar que o programador tenha
que realizar testes de verificação e avaliação antes da realização de certas
operações, desviando automaticamente o fluxo de execução para rotinas de
tratamento de erro.

6.2. TRY-CATCH

Quando ocorre um ou mais tipos de erros dentro de um trecho de código

delimitado, o TRY-CATCH desvia automaticamente a execução para uma
rotina designada para o tratamento específico desse erro. A sintaxe é a
seguinte:

try {
// código normal
} catch ( <exceção 1> ) {
// código de tratamento do primeiro tipo de erro }
catch ( <exceção 2> ) {
// código de tratamento do segundo tipo de erro
}
catch ( <exceção 3> ) {
// código de tratamento do terceiro tipo de erro
}

Podemos criar um programa que precisa receber um número inteiro da

linha de comando. Como os argumentos são passados em um vetor Strings,
precisamos transformar a String contendo o número para um inteiro. Se na

74
PROGRAMAÇÃO JAVA

conversão ocorrer um erro, significa que o argumento não é um número inteiro

válido. A exceção usada, neste caso, é a java.lang.NumberFormatException.

Outro erro que podemos tratar é, caso não for fornecido o argumento
desse mesmo programa, utilizando a exceção
ArrayIndexOutOfBoundsException. Sendo assim, ocorrerá um erro ao
tentarmos acessar o índice 0 do vetor (que está vazio). O código abaixo mostra
como fazemos esses dois tratamentos com o TRY-CATCH.

int j = 10;

try {

while (j > Integer.parseInt(args[0])) {

System.out.println(“”+j);

j--;
}

} catch (ArrayIndexOutOfBoundsException e) {

System.out.println(“Não foi fornecido um argumento.”);

} catch (java.lang.NumberFormatException e) {

System.out.println(“Argumento não é um inteiro válido.”);

6.3. TRY-FINALY

Com o TRY-FINALLY, podemos assegurar que uma rotina de finalização

seja garantida mente executada mesmo que ocorra um erro (isto é, o trecho de
código contido na cláusula FINALLY é executado sempre que o programa
passa pela cláusula TRY). Exemplo:

75
PROGRAMAÇÃO JAVA

try {

<código normal>;

} finally {

<código que sempre deve ser executado>;

Isso é particularmente interessante quando certos recursos do sistema ou

estruturas de dados devem ser liberadas, independentemente de sua
utilização.

6.4. TIPO DE ERRO

Existem 3 diferentes tipos de erros em Java:

1. Erro de Runtime (java.lang.Runtime): são causados por bugs do

programa que desconhecemos, ou seja, uma condição especial
que sequer havíamos imaginado. Os erros de Runtime são
subclasses da classe Runtime, que é subclasse de Exception.

2. Erro de Sistema (java.lang.Error): são erros imprevisíveis,

causados por falha do sistema, como acesso a disco, erro do
banco de dados, etc. Esses erros são subclasses da classe Error.

3. Erro Customizado (java.lang.Exception): são erros ou condições

especiais previstas no programa. Esses erros são subclasse da
classe Exception.

76
PROGRAMAÇÃO JAVA

Algumas exceções muito comuns são:

 ArithmeticException: Ocorre, por exemplo, quando dividimos um

valor por zero;

 NullPointerException: Ocorre quando utilizamos um objeto que

não foi instanciado.

 ArrayIndexOutOfBoundsException: Ocorre quando tento

acessar um elemento do array que não existe.

77
PROGRAMAÇÃO JAVA

CAPÍTULO 7

BANCO DE DADOS

7.1. COMO CONECTAR E INSERIR DADOS NO BD

Para conectarmos a um banco de dados em Java, precisamos importar a

biblioteca contendo o driver do banco de dados que será utilizado. Clique com
o botão direito do mouse sobre a aba “Bibliotecas”, que fica dentro da aba no
seu projeto, e escolha a opção “Adicionar biblioteca”. Como mostra figura 25:

Figura 25. Inserindo uma biblioteca no projeto.

Depois, procure a opção como o nome do Driver do banco de dados que

você vai usar, por exemplo, “Driver do Java DB” ou “JAVADB DRIVER LABEL”.
Em seguida, precisamos importar o pacote “java.sql.*” no arquivo em que
iremos realizar a conexão:

import java.sql.*;

78
PROGRAMAÇÃO JAVA

Em seguida, precisamos criar um método de conexão para carregar o

driver do banco, estabelecer uma conexão com o banco e realizar os
comandos SQL necessários. Como por exemplo:

import java.sql.DriverManager;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;

class Diversos() {

// Variaveis publicas
public Connection con = null;
public Statement stmt = null;

public void Conexao() {

String driver = “”, url = “”, userName = “”, passWord = “”;
try {
driver = "com.mysql.jdbc.Driver";
url = "jdbc:mysql://localhost:3306/estoque";
userName = "root";
passWord = “teste”;
Class.forName(driver);
con = DriverManager.getConnection (url,userName,passWord);
con.setAutoCommit(false);
stmt = con.createStatement();
} catch (Exception ex) {
ex.printStackTrace();
}
}
}

As strings “driver”, “url”, “userName” e “passWord” precisam estar corretas

para que a conexão seja estabelecida com sucesso, sendo:

79
PROGRAMAÇÃO JAVA

driver: é o driver correspondente ao seu banco de dados em uso;

url: é o tipo de conexão feita no seu banco de dados;
userName: é o nome do usuário usado ao criar o banco de dados;
passWord: é a senha usada ao criar o banco de dados.

Depois é só instância em sua classe o método de “conexao” e usa-lo

para se conectar ao seu banco e utilizar os comandos de manipulação do
banco de dados, por exemplo:

import java.sql.ResultSet;

class Funcionario() {

Conexao cn = new Conexao();

String nome;
String fone;
String celular;

public String getNome() {

return nome;
}

public void setNome(String nome) {

this.nome = nome;
}

public String getFone() {

return fone;
}

public void setFone(String fone) {

this.fone = fone;
}

80
PROGRAMAÇÃO JAVA

public String getCelular() {

return celular;
}

public void setCelular(String celular) {

this.celular = celular;
}

// Método de Inclusão de funcionário

public void IncluirFunc() throws Exception {
String sql = "";
try {
cn.Conexao();
sql = "Insert into funcionario(nome, telefone, celular)
values(‘"+nome+”’,’”+fone+”’,’”+celular+”’)”);
cn.stmt. statement.executeUpdate(sql);
cn.con.commit();
} catch (Exception e) {
cn.con.rollback();
msg = e.getMessage();
} finally {
try {
cn.con.close();
} catch (Exception ex) {
}
}
}

81
PROGRAMAÇÃO JAVA

7.2. COMO RECUPERAR DADOS NO BD

Para recuperarmos valores de uma tabela no banco de dados,

precisamos nos conectar a ela da mesma forma que fizemos na última seção.
Mas nesse caso, será necessário criamos um método em nossa classe anterior
que irar retornar uma matriz com dos dados pegos no banco de dados, como
exemplo a seguir.

// Metodo de listar dados

public Vector ListaFunc() throws Exception {
Vector v = new Vector();
String sql = "";
try {
Vector vRs = new Vector();
sql = "select codigo, nome, fone, celular from funcionario
order by nome "
cn.Conexao();
ResultSet rs = cn. stmt.executeQuery(sql);
vRs = dv.getRst();
while (rs.next()) {
Vector vAux = new Vector();
vAux.addElement(rs.getString(“nome”));
vAux.addElement(rs.getString(“fone”));
vAux.addElement(rs.getString(“celular”));
v.addElement(vAux);
}
} catch (Exception e) {
e.printStackTrace();
}
return v;
}

82
PROGRAMAÇÃO JAVA

No código-fonte da classe “ListaFunc”, foi criando um vetor “v” que irar

receber os dados recebido do banco de dados e quadrará na variável “rs” do
“ResultSet”.

Como visto no código acima, o conjunto de resultados de uma consulta

fica armazenado em um objeto do tipo “ResultSet”. Este objeto possui um
método “next( )” que nos permite percorrer cada linha da consulta resultante.
Para acessarmos cada coluna de cada linha, utilizamos os métodos
“getString” (para retornar uma String), etc. Cada um desses métodos recebe
como parâmetro o nome da coluna a ser retornada.

83
PROGRAMAÇÃO JAVA

REFERÊNCIAS

CAELUM. Java e Orientação a Objetos. [Apostila] Disponível em:

<http://www.caelum. com.br/downloads/apostila/caelum-java-objetos-
fj11.pdf>. Acesso em 21 mar. 2014.

CESTA, André Augusto. Tutorial: A linguagem de programação Java –

Orientação a Objetos. [Apostila] Campinas, SP: Unicamp, 1996.
Disponível em: <http://www.dcc. unicamp.br/~aacesta>. Acesso em 21
mar. 2014.

DEITEL, Harvey M., DEITEL, Paul J. (Tradução: FURMANKIEWICZ,

Edson) Java: Como Programar. São Paulo: Prentice-Hall, 2005.

HORSTMANN, Cay, CORNELL, Gary (Tradução: TORTELLO, João

Eduardo Nó- brega). Core Java 2, Fundamentos. São Paulo: Makron
Books, V. 1, 2000.

JANDL, Peter Jr. Introdução ao Java. [Apostila] Núcleo de Educação a

Distância, Universidade São Francisco, 1999. Disponível em:
<http://www.comp.pucpcaldas.br/~al550375261/programacao/Java/Curso
%20de%20Java.pdf>. Acesso em 21 mar. 2014.

JÚNIOR, Hilário Seibel – Linguagens de Programação. – Colatina: Ifes,

2009, 125p.

PAMPLONA, Vitor Fernando. Tutorial Java: O que é Java? [Tutorial]

Disponível em: <http://javafree.uol.com.br/artigo/871498/Tutorial-Java-O-
que-e-Java.html>. Acesso em 23 mar. 2014.

Tutorial Java 2: Características Básicas, [Tutorial] Disponível em: <http://

javafree.uol.com.br/artigo/871496/Tutorial-Java-2-Caracteristicas-

84
PROGRAMAÇÃO JAVA

Basicas.html>. Acesso em 01 mai. 2014.

Tutorial Java 3: Orientação a Objetos. [Tutorial] Disponível em:

<http://javafree.uol.com.br/artigo/871497/Tutorial-Java-3-Orientacao-a-
Objetos.html>. Acesso em 01 mai. 2014.

WALNUM, Clayton (Tradução: GRIESI, Ariovald). Java Em Exemplos. São

Paulo: Makron Books, 1997.

85