Beruflich Dokumente
Kultur Dokumente
Mini-Curso de Java
Esse mini-curso
apresenta uma
Introdução ao
mundo complexo,
dinâmico e
crescente da
linguagem JAVA.
Você pode
conhecer o que
significa cada
módulo no link:
http://java.sun.com/j2se/
Princípios da Linguagem JAVA
Maior facilidade na programação;
Escreva uma vez, execute em qualquer lugar;
Elimina preocupações comuns em outras linguagens
tais como ponteiros e gerenciamento de memória;
A sua natureza orientada a objetos ajuda na
visualização do programa;
Portabilidade do código;
Possibilidade de programas executarem mais de uma
tarefa (multithreading);
Verificação automática de código carregado para
garantir a segurança (ex: applets acessando disco);
Programação centrada na rede.
A Máquina Virtual JAVA
Máquina imaginária que é implementada pela sua
simulação em uma máquina real.
Fornece um conjunto de especificações de plataforma de
hardware para qual todo o código Java é compilado;
Interpreta byte codes (que são independentes de
plataforma de hardware);
Pode ser implementada tanto na forma de software como
de hardware
Possui código compacto;
Torna a linguagem JAVA portável para diversas
plataformas.
Qualquer interpretador JAVA (seja para desenvolvimento
de tecnologia JAVA ou um browser que rode applets) tem
sua máquina virtual.
O que há na Máquina Virtual JAVA
Conjunto de Instruções (equivalente a uma CPU)
Conjunto de registradores
Arquivos no formato class
Pilhas
Coletor de lixo
Área de memória
O formato do código da JVM se dá por byte codes compactos e
eficientes. A maioria da checagem de tipo é feita em tempo de
compilação.
Garbage Collection (Coletor de Lixo)
Toda a alocação de memória exige a sua liberação;
Nas linguagens tradicionais a liberação de memória
dinâmica é da responsabilidade do programador;
Java fornece um sistema a nível de thread para
registrar a alocação de memória;
Verifica e libera memória que não está sendo utilizada;
Para coletar a memória dinâmica não utilizada a MVJ
utiliza uma thread de baixa prioridade na biblioteca
System (System.gc()). Ela pode também ser chamada
de forma explícita pelo programador.
Visão Geral
Fase 1
O programa é criado
Editor Disco no editor e
armazenado em disco.
Fase 2
Compilador O compilador cria
Disco bytecodes e os
armazena em disco.
Fase 3
Carregador Memória Principal
de Classes
O carregador de classe
coloca bytecodes na
memória.
Disco
.
.
.
Fase 5
Intepretador Memória Principal
O interpretador lê os
bytecodes e os traduz
para uma linguagem que
o computador pode
. entender, possivelmente
.
armazenando valores dos
dados enquanto executa o
. programa.
Parâmetros. Parâmetros em
funções permitem que essas
Função Principal. Programas iniciem com valores recebidos
em Linguagem C e C++ buscam externamente, para variáveis
seu início pela função principal que utilizarão internamente.
(main()).
Programando JAVA
Elementos da Orientação a Objetos no Programa
// Nosso primeiro programa Java
// Conhecendo a estrutura de um programa Java
public class MeuPrimeiroPrograma {
public static void main (String arg[]) {
System.out.println("Olá Aluno de JAVA");
} // fim do método main
} // fim da classe MeuPrimeiroPrograma
Método. A impressão da
Classe. Como qualquer programa mensagem “Olá Aluno de
JAVA, esse programa exige uma Java” se deu pela execução do
classe (palavra reservada “class”). método “println” da classe
O fato de ser pública (palavra “System”.
“public”) garante visibilidade em
qualquer contexto de sua utilização Objeto. Para imprimirmos a
mensagem de saída de nosso
Biblioteca. A organização das programa precisamos de um objeto
classes JAVA se dá na forma de “out” da classe “System” da
bibliotecas. Nesse programa utilizamos a
biblioteca padrão java.lang
biblioteca padrão da linguagem JAVA
(biblioteca java.lang)
Estrutura de um Programa JAVA
package meupacote; Package. Utilizado quando o código do
programa deverá fazer parte de um pacote.
import java.lang.*; Import. Seção de importação de bibliotecas.
java MeuPrimeiroPrograma
• Executa o programa Java
set CLASSPATH=C:\dir1;C:\dir2;.
• Define os locais onde a JVM vai procurar por pacotes e
classes Java
Explorando o Programa JAVA
// Explorando nosso primeiro programa Java
// Para Trabalhar com Tela Gráfica
// Pacotes de extensão Java
import javax.swing.JOptionPane;
public class MeuPrimeiroPrograma4 {
// o método main inicia a execução do aplicativo Java
public static void main (String arg[]) {
JOptionPane.showMessageDialog(null, "\nBem-Vindo\nà Programação
Java\n\t\t por Janelas");
System.exit(0); // termina programa
} // fim do método main
} // fim da classe MeuPrimeiroPrograma
Lembre-se….
import javax.swing.JOptionPane;
• A Classe Java JOptionPane oferece caixas de diálogo predefinidas
que permitem aos programas exibir mensagens aos usuários;
• As classes predefinidas da linguagem Java são agrupadas em
categorias de classes chamadas pacotes (package), conhecidos como
bibliotecas de classes Java ou interface de programação de aplicativos
Java (Java API)
• Os nomes dos pacotes Java começam com Java (pacotes do núcleo da
linguagem) ou Javax (extensões ao núcleo)
• A instrução import é utilizada para identificar e carregar classes
utilizadas em um programa Java. As classes importadas pertencem a
pacotes do núcleo, extensões oficiais ou extensões fornecidas por
terceiros.
• As instruções import devem aparecer sempre antes da definição das
classes
• JOptionPane é uma classe da biblioteca de interfaces gráficas do Java
Lembre-se….
JOptionPane.showMessageDialog(null, "\nBem-Vindo\nà
Programação Java\n\t\t por Janelas");
• O método exibe dois argumentos (separados por vírgula, como se
faz em Java para todo método de múltiplos argumentos);
• O primeiro argumento é null, significando “vazio”. O primeiro
argumento do método showMessageDialog() é utilizado para
posicionamento da janela. Ao ser null é ignorado e a janela é
apresentada no centro da tela.
• A linha System.exit ( 0 ) é necessária em programas com interface
gráfica, terminando o aplicativo Java.
• O retorno Zero (‘0’) para o método exit() indica que o programa
finalizou com sucesso. Valores diferentes de zero significam erros na
execução e podem ser tratados por aplicativos que chamaram o
programa Java.
• A classe System faz parte do pacote padrão java.lang, que dispensa
a importação (comando import) por ser acrescida aos seus
programas por default
As Bibliotecas JAVA – rt.jar & tools.jar
O que há na Biblioteca Java?
A Biblioteca (API – Application Programming Interface) é
formada por conjunto de classes do JDK;
Exemplos de pacotes Java:
java.lang: Tipos e funcionalidades básicas da linguagem. Inclui,
entre outras, as classes String, Math, Integer e Thread. É
importada automaticamente em seus programas Java;
java.awt: componentes gráficos originais da linguagem (Abstract
Window Toolkit);
javax.swing: pacote de eXtensão aos componentes gráficos com
melhoramentos à biblioteca AWT
java.applet: classes específicas para tratamento de applets;
java.net: recursos de rede (sockets e URLs);
java.io: classes para escrita e leitura em arquivos;
java.util: classes para tarefas gerais, tais como vetores e string de
tokens.
Operadores Aritméticos
Operação de Operador Expressão Expressão em
Java aritmético algébrica Java
Adição + f+7 f+7
Substração - p-c p-c
Multiplicação * bm b*m
Divisão / x/y ou x÷y x/y
Módulo % r mod s r%s
Operador de
atribuição Exemplo Exemplificação Atribui
+= c += 7 c=c+7 10 a c
-= d -= 4 d=d-4 1ad
*= e *= 5 e=e*5 20 a e
/= f /= 3 f=f/3 2af
%= g %=9 g=g%9 3ag
Exemplos: int c = 3, d = 5, e = 4, f = 6, g = 12
Intervalo Positivo:
1,40129846432481707E-45 a
3,4028234663852886E+38 754)
double 64 Intervalo Negativo: (ponto flutuante IEEE
-1,7976931348623157E+308 a
-4,94065645841246544E-324
Intervalo Positivo:
4,94065645841246544E-324 a
1,7976931348623157E+308 754)
Estrutura de Seleção if
A estrutura if
• Necessária sempre que os programas encontrarem seqüências
alternativas de ações, dependendo do valor de determinada
condição.
• Exemplo:
Se a média das notas do aluno for maior ou igual a 6
Imprimir “Aprovado”
Sintaxe
if (condição)
comando Java;
[ou {bloco de comandos Java;}] verdadeiro
Media >=6 Imprimir “Aprovado”
O Exemplo em Java
if (media >= 6) falso
System.out.println(“Aprovado”);
if (media >= 6) {
System.out.print(“O Aluno está”);
System.out.println(“Aprovado”);
} // fim do bloco if
Estrutura de Seleção if/else
A estrutura if/else
• Necessária sempre o programa deve executar uma ou mais ações quando uma
condição for verdadeira ou, quando essa for falsa, executar outra ação ou
seqüência de ações.
• Exemplo:
Se a média das notas do aluno for maior ou igual a 6
Imprimir “Aprovado”
Senão
Imprimir “Reprovado”
Sintaxe
if (condição)
comando Java;
[ou {bloco de comandos Java;}]
else
comando Java;
[ou {bloco de comandos Java;}]
Estrutura de Seleção if/else
O Exemplo em Java
if (media >= 6){
System.out.print(“O Aluno está”);
System.out.println(“Aprovado”);
} // fim do bloco if
else {
System.out.print(“O Aluno está”);
System.out.println(“Reprovado”);
} // fim do bloco else
verdadeiro
Media >=6 Imprimir “Aprovado”
falso
Imprimir “Reprovado”
Operador Ternário Condicional ?:
Sintaxe
(condição) ? {ação ou bloco verdade} : {ação ou bloco falso}
O Exemplo em Java
System.out.println(media >= 6 ? “Aprovado” : “Reprovado”);
verdadeiro
Media >=6 Imprimir “Aprovado”
falso
Imprimir “Reprovado”
Estruturas if/else Aninhadas
Seqüência de estruturas if/else
• São utilizadas para o teste de múltiplos casos.
• Exemplo:
Se a média das notas do aluno for maior ou igual a 9 conceito = ‘A’
Senão
Se a média das notas do aluno for maior ou igual a 7 conceito = ‘B’
Senão
Se a média das notas do aluno for maior ou igual a 6 conceito = ‘C’
Senão conceito = ‘D’
Estruturas if/else Aninhadas
Em Java
if (media >= 9)
System.out.print(“O Conceito é A”);
verdadeiro
else
if (media >= 7) Media >=9 A
falso
D
Estrutura de Seleção Múltipla switch
switch/case
• Utilizada em programas em que uma
variável ou expressão pode assumir
diferentes valores e há uma ação (ou
bloco de ações) para cada valor
possível.
Pseudocódigo - Algoritmo
int contador = 1
falso
Instruções break e continue
• As instruções break e continue modificam o comportamento
das estruturas de repetição while, for, do/while ou switch. .
• A instrução break interrompe o laço (no caso das estruturas de
repetição) e impede a execução de outros casos de um
comando switch.
• Exemplo:
Enquanto verdade permanente
(ex: x == 1, sem mudar x)
realize as operações …..
se condição de fim for alcançada break;
Fim do Enquanto
• A instrução continue permite o salto do conjunto de operações,
com retorno à expressão condicional do laço, reiniciando o
mesmo (portanto, ao contrário do break, não interrompe o laço).
• Normalmente break e continue interrompem laços em que
estão inseridos. Para interromper um conjunto aninhado de
estruturas, deve-se utilizar break e continue rotulados (com
denominação de blocos).
Instrução continue – Exemplo
Problema
Faça um programa que apresente os números pares entre zero e o número
inteiro digitado pelo usuário e que indique quantos números mostrou.
Pseudocódigo - Algoritmo
Ajustar o total de pares para zero;
Ajustar o contador de pares para zero;
Ajuste o contador para zero;
Ler o número digitado pelo usuário
Faça
Se o contador/2 der resto zero
Adicione um ao contador de pares
Senão continue
Apresente o contador como número par
Enquanto (contador++ < número inteiro digitado pelo usuário)
Instrução continue – Exemplo
// Programa que demonstra utilização da instrução continue
import javax.swing.JOptionPane;
public class ContadorParesContinue {
public static void main (String args[]) {
String numeroInformado, saidaFinal = "";
int numero;
int contador = 0;
int pares = 0;
numeroInformado = JOptionPane.showInputDialog("Entre com um valor inteiro:");
numero = Integer.parseInt(numeroInformado);
do {
if ((contador % 2)!=0) // resto da divisão por dois não é zero
continue;
pares++;
saidaFinal += contador + " ";
} while (++contador<numero);
saidaFinal += "\nTotal de pares: " + pares;
// exibe números pares e total de pares
JOptionPane.showMessageDialog(null,saidaFinal);
System.exit(0);
} // fim do main()
} // fim da classe
Exercício (while)
// Programa que demonstra utilização da instrução continue e
while
import javax.swing.JOptionPane;
public class ContadorParesContinueWhile {
public static void main (String args[]) {
String numeroInformado, saidaFinal = "";
int numero = 0, contador = -1, pares = 0;
numeroInformado = JOptionPane.showInputDialog("Entre com
um valor inteiro:");
numero = Integer.parseInt(numeroInformado);
while (++contador<numero) {
if ((contador % 2)!=0) // resto da divisão por dois não
é zero
continue;
pares++;
saidaFinal += contador + " ";
}
saidaFinal += "\nTotal de pares: " + pares;
// exibe números pares e total de pares
JOptionPane.showMessageDialog(null,saidaFinal);
System.exit(0);
} // fim do main()
} // fim da classe
Exercício (for)
// Programa que demonstra utilização da instrução continue e for
import javax.swing.JOptionPane;
public class ContadorParesContinueFor {
public static void main (String args[]) {
String numeroInformado, saidaFinal = "";
int numero = 0, pares = 0;
numeroInformado = JOptionPane.showInputDialog("Entre com
um valor inteiro:");
numero = Integer.parseInt(numeroInformado);
for (int contador=0; contador < numero; contador++) {
if ((contador % 2)!=0) // resto da divisão por dois não
é zero
continue;
pares++;
saidaFinal += contador + " ";
}
saidaFinal += "\nTotal de pares: " + pares;
// exibe números pares e total de pares
JOptionPane.showMessageDialog(null,saidaFinal);
System.exit(0);
} // fim do main()
} // fim da classe
Métodos
O que são Métodos
Métodos são chamados por seu nome, com a relação de argumentos colocada entre
parênteses. Quando os métodos são estáticos, o nome inclui o nome da classe.
Métodos da Classe Math
Expressões Matemáticas
• Os métodos da classe Math permitem realizar cálculos
comuns necessários em expressões matemáticas.
• Exemplos de chamadas de métodos da classe Math:
– Função raiz quadrada: double y = Math.sqrt(10.0);
– Função mínimo. double z = Math.min(x,10);
C [ 0 ] - 128
C [ 1 ] 8
C [ 2 ] 0 ...
C [ 3 ] 82 public static void main (String args[]) {
C [ 4 ] 64
int c = new int[11];
C [ 5 ] - 12
...
c = {-128,8,0,82,64,-12,65,43,76,11};
C [ 6 ] 65
// c[11] é zero por default (inicialização)
C [ 7 ] 43
...
C [ 8 ] 76 c[4] += c[2]; // c[4] = 64 + 0 = 64
C [ 9 ] 11 }
C [ 10 ] 0
Número da posição do
elemento dentro de um array
(índice ou subscrito)
Arrays
Nunca esquecer que
Nome do array
int array1[][] = { { 1, 2, 3 }, { 4, 5, 6 } };
int array2[][] = { { 1, 2 }, { 3 }, { 4, 5, 6 } };
int b[][];
b = new int[3][4];
String[][] desenhos = {
{ "Flintstones", "Fred", "Wilma", "Pebbles", "Dino" },
{ "Rubbles", "Barney", "Betty", "Bam Bam" },
{ "Jetsons", "George", "Jane", "Elroy", "Judy", "Rosie", "Astro" },
{ "Scooby Doo", "Scooby Doo", "Shaggy", "Velma", "Fred", "Daphne" }
};
Arrays
// ArrayMultiDim_1.java
// Inicialização de arrays multidimensionais
// Deitel & Deitel
import javax.swing.*;
public class ArrayMultiDim_1 {
static JTextArea saidaArea = new JTextArea();
public static void main( String args[] ) {
int array1[][] = { { 1, 2, 3 }, { 4, 5, 6 } };
int array2[][] = { { 1, 2 }, { 3 }, { 4, 5, 6 } };
//Construtor
public Paciente(int pCodigo, String pNome, String pEndereco,
int pIdade, String pDocumento) {
setId(pCodigo); Métodos de
setNome(pNome);
setEndereco(pEndereco);
atribuição
setIdade(pIdade); de
documento = pDocumento; informação
}
set...()
Encapsulamento: //Métodos de atribuição
Todos os atributos public void setDocumento(String pDocumento) {
documento = pDocumento;
da classe Paciente }
são definidos como
privados “private” e //Métodos de recuperação
public String getDocumento() { Métodos de
somente podem ser return documento;
acessados através }
recuperação de
de métodos públicos } informação
“public”. get...()
Exemplo – Classe ControlePaciente
Cria o objeto paciente (instância da
Classe ControlePaciente classe Paciente) utilizando o construtor
import java.util.*; que recebe parâmetros
public class ControlePaciente {
private Vector listaPaciente = new Vector();
int escolha = 0;
//Instancia o Controlador
ControlePaciente ctrPac = new ControlePaciente();
do {
do {
escolha = Integer.parseInt(
JOptionPane.showInputDialog("Escolha uma opção do
menu:\n"+
"[1] Adiciona Pacientes\n"+
"[2] Altera Pacientes\n"+
"[3] Finaliza"));
} while ((escolha < 1) || (escolha > 3));
if (escolha == 3) System.exit(0);
....
Exercício I – Limite
Exemplo – Classe
(Classe LimiteCadPacienteI)
LimiteCadPaciente
....
Classe LimiteCadPaciente switch (escolha) {
case 1:
//Requisita o Código
id = Integer.parseInt(
JOptionPane.showInputDialog ("Informe o código"));
//Requisita o Nome
nome = JOptionPane.showInputDialog ("Informe o nome");
//Requisita o Endereco
endereco = JOptionPane.showInputDialog ("Informe o endereço");
//Requisita a Idade
idade = Integer.parseInt(
JOptionPane.showInputDialog ("Informe a idade"));
Chama os métodos //Requisita o Documento
da classe documento = JOptionPane.showInputDialog ("Informe o documento");
ControlePaciente //Adiciona o objeto para a lista de pacientes
ctrPac.inserePaciente(id, nome, endereco, idade, documento);
através do objeto break;
ctrPac case 2:
JOptionPane.showMessageDialog(null,
ctrPac.imprimePacientes(),
"Relação de Pacientes",
JOptionPane.INFORMATION_MESSAGE);
}
} while (true);
}
}
Tratamento de Exceções
A exceção é uma indicação de que ocorreu um problema
durante a execução do programa;
É uma condição anormal que surge em uma seqüência de
código ou operação realizada em tempo de execução;
Essa característica permite escrever programas mais
claros, mais robustos e tolerantes a falhas;
Pode ocorrer quando:
for realizada um tentativa de abrir um arquivo que não
existe;
uma conexão com a rede for interrompida;
ocorrer manipulação de estruturas fora de um intervalo;
problemas com um banco de dados.
Tratamento de Exceções (try e catch)
Utilizada para definir um conjunto de código que deve ser
protegido e tratado através de blocos catch;
Podem existir várias declarações catch.
try {
//bloco de código
} catch (TipoDeExceção referênciaParaExceção) {
//código a ser executado caso a exceção geral seja disparada
}
try {
//bloco de código
} catch (TipoDeExceção referênciaParaExceção) {
//código a ser executado caso a exceção geral seja disparada
} finally {
//código a ser executado independente da exceção
}
Tratamento de Exceções - Categorias
Error: indica um problema grave e as vezes
impossível de ser tratado;
RuntimeException: indicam problemas decorrentes
de projeto ou implementação. Uma exceção
bastante comum é ArrayIndexOfBoundsException
disparada porque o índice excede o limite de um
array ou vetor;
Exceções causadas em tempo de execução pelo
ambiente mas que podem ser tratadas;
Uma lista mais completa das exceções pode ser
encontrada na página 753 do livro do Deitel &
Deitel.
Capturando uma Exceção
Os tratadores de exceção estão contidos em
blocos catch;
Cada bloco catch inicia com a palavra-chave catch
seguida por parênteses que contêm um nome de
classe (especifica o tipo de exceção a ser
capturado) e um nome de parâmetro;
O tratador de exceção pode fazer referência ao
objeto disparado através desse parâmetro;
Após a chave pode-se descrever o código que irá
tratar a exceção.
Capturando uma Exceção
import java.util.*;
public ExemploException1() {
v.add("Disciplina 1");
v.add("Disciplina 2");
imprimeVetor();
}