Aulas
Java
Prof. Marcelo Heitor
Síntese das aulas:
Capacitar os alunos na compreensão da linguagem java.
Durante o curso será estudado parte do fundamento de java baseando-se
no conceito de orientação a objetos.
Tópicos gerais:
# História e anatomia java;
# Sintaxe e primitivos;
# Condicionais;
# Estruturas de repetição;
# Conceitos de Orientação a Objetos;
# Manipulação de arquivos (projeto em sala);
Sobre o professor:
Marcelo Heitor Teixeira – [email protected]
# Certificações em tecnologia Java:
SCJP – Sun Certified Java Programmer;
SCWCD – Sun Certified Web Component Developer;
SCJA – Sun Certified Java Associate;
# Analista de Infraestrutura Sênior – Capgemini –
atuando no Complexo Tecnológico Banco do Brasil;
# Consultor na plataforma Java desde 2004;
# 13 anos de experiência em análise e
desenvolvimento para web;
# Últimos 6 anos trabalhando com arquitetura e infra-estrutura
para aplicações Java;
# Professor Faciplac;
Sobre a turma:
# Perfil da turma;
# Experiência com desenvolvimento;
# Razões pela qual está fazendo o curso;
# Expectativas;
O universo java:
MIDP
POO
JNDI
Front
Controller
SCEA
JNI
Classe
Struts
javac
SCBCD
JRE
Swing
Netbeans
RFID
Weblogic
WEB.xml
JDK
Model 1
Model 2
DAO
Desktop
JMX
AWT
POJO
SCJA
SCJP
Framework
JSP
JAD
JEE
Eclipse
Entity
Manger
Java
Maven
JBOSS
Servlet
Applet
Toplink
Interface
E muito
mais...
Card
JSF
Design
Pattern
Data
source
Tomcat
JPA
WEB
FX
Websphere
Glassfish
Facelets
RMIC
Midlet
SCWCD
context
.xml
MVC
Hibernate
API
JME
Web
services
Mobile e
TV
CDC
EJB
JAR
Entity
Bean
CLDC
JSE
JDBC
História e anatomia java
# História e anatomia java:
Genealogia java:
Java
Década de 1990
C++
Década 1980
C
Década de 1970
BCPL e B
Década 1960
# História e anatomia java:
O grande impacto na
indústria de dispositivos
eletrônicos pessoais foi
causado pelo surgimento
do micro-processador.
Nasce então a linguagem “Java”, baseada
no C++, que seria executada de forma a
convergir computadores e dispositivos
eletrônicos criados por diferentes
fabricantes. (tentativa de antecipar o
mundo digital)
Década de 1991, a Sun
Microsystems (hoje da
Oracle) resolveu financiar um
projeto liderado por James
Gosling.
# História e anatomia java:
Entretanto, esse mercado
não decolou da forma
que a empresa esperava.
Por isso os dias da java
estavam contados.
Surge então a idéia de
aproveitar a linguagem para
agregar conteúdo dinâmico
nos navegadores de internet
da época.
Atualmente java é usada como
linguagem e plataforma nos mais
variados tipos de computadores, como:
Desktops, dispositivos móveis, cartões
inteligentes, RFID e servidores de
aplicações.
Em 1995, java é oficialmente
apresentada para o mercado
mundial.
# História e anatomia java:
Java é composta por uma grande biblioteca de classes que juntas formam a JavaAPI (Application Programing Interface) organizada em chamados pacotes.
A documentação da linguagem pode ser estudada em:
java.sun.com/javase/downloads/
JAVA - API
Pacote A
classe X {
metodo1(){}
metodo2(){}
}
Pacote B
classe Y {
metodo1(){}
metodo2(){}
}
# História e anatomia java:
Evolução da Java-API:
A evolução da java é controlada pelo JCP – Java
Community Process (jcp.org) e pela própria
Oracle e usuários java.
Veio em 3 versões:
J2ME – Java Micro Edition;
J2SE – Java Standard Edition;
J2EE – Java Enterprise Edition;
# História e anatomia java:
A Java-API é usada pelo SDK e pelo JRE.
O SDK é o kit de desenvolvimento de software java, ou seja, o ambiente de
desenvolvimento java. Nele, existe uma coleção de ferramentas de linha de
comando que executam tarefas como compilar, executar e depurar aplicações
escritas em java.
Para que o SDK possa ser usado via linha de comando, é necessário configurar
algumas variáveis de ambiente que serão vistas em breve.
O JRE é o ambiente de execução, a API do JRE contém tudo que é necessário
para executar aplicações java.
# História e anatomia java:
Um programa java passa por 5 fases:
Edição – Compilação – Carregamento – Verificação e Execução.
Fase 1
Edição
O class-loader lê os
bytecodes do .class
e carrega na
memória.
Fase 3
Carregador de
Classe
É criado em um editor um
arquivo com a extensão .java
Fase 2
Compilação
O verificador confirma se
os bytecodes não violam
nenhuma restrição de
segurança java
Fase 4
Verificador de
Bytecodes
O compilador cria os
bytecodes a partir do
.java gerando um
arquivo .class
JVM lê os bytecodes
e os traduz para uma
linguagem que a
máquina entenda.
Execução pela
JVM
# História e anatomia java:
E por falar em JVM…
Java Virtual Machine!
É o mecanismo que recebe os créditos pela frase:
“escreva uma vez, rode em qualquer lugar!”
A JVM manipula os bytecodes gerados pelo compilador java e conversa com a
máquina real. Isso permite à java ser multi-plataforma.
# História e anatomia java:
Compilador Java
Bytecodes…
JVM
Código executável de máquina…
Hardware
# História e anatomia java:
Código Java
Executável
Máquina Virtual Java - JVM
Windows
Linux
# História e anatomia java:
Enquanto isso, na JVM…
Bytecode
PrimeiraClasse.class
SIM
class
loader
JIT – Just-In-Time é a parte da
JVM usada para acelerar o
tempo de execução
compilando (traduzindo) partes
dos bytecodes que tem
algorítmos parecidos, ao
mesmo tempo…
verificador de
bytecodes
classe
remota?
NÃO
Em tempo de execução…
interpretador
tradutor JIT gera
código nativo…
Hardware
# História e anatomia java:
O Class Loader ou Carregador de Classes é a primeira tarefa executada pela
JVM e figura responsável por carregar as classes na hora da execução da
aplicação. Além disso é o mecanismo que efetua a verificação se os bytecodes
de classes remotas não ofendem as regras de segurança da API Java.
A ordem de carregamento das classes obedece a seguinte sequência:
1 – Carrega classes nativas do JRE (API);
2 – Carrega extensões do JRE, por exemplo os arquivos “.jar” que estão
mapeados em $JAVA_HOME/jre/lib/ext; e classes em
$JAVA_HOME/jre/lib/classes;
3 – Carrega classes do sistema local (a ordem dos caminhos no CLASSPATH
indica a ordem);
4 – Classes remotas se existirem;
# História e anatomia java:
Pilha e Heap!
São o que os programadores java precisam saber diferenciar com relação a
utilização de memória.
Na pilha, ficam as chamadas de métodos e variáveis locais.
Na heap é onde residem os objetos.
Os valores literais dos primitivos são armazenados em bytes na pilha ao passo
que uma variável de referência a um objeto contem os bytes que permitem o
acesso ao objeto que está na heap.
PILHA
HEAP
Ref. objeto A
A
Primitivo int
010011
Ref. objeto B
B
# História e anatomia java:
→ Durante muito tempo o gerenciamento de memória, nas aplicações, era um
grande problema pois os programadores eram os responsáveis por controlar a
alocação e a liberação da memória;
→ Hoje, com plataformas modernas como java, o gerenciamento é automático
e a alocação e liberação de memória é dinâmica, por meio de algorítmos
específicos;
→ Garbage Collector (coletor de lixo) é a parte da JVM responsável por
liberar a memória alocada por um objeto da heap.
→ O GC é um dos principais componentes da jvm;
→ O coletor de lixo não pode ser invocado diretamente pelo programador. Sua
execução é feita por uma thread controlada pela própria JVM. Para que o GC
libere memória, um objeto deve estar no status de elegível:
# História e anatomia java:
Código java hipotético!
Objeto obj = new Objeto();
obj.fazAlgo();
obj = null;
Objeto tornando-se elegível
para o coletor de lixo!
“Configurar uma referência
para um objeto como null é
uma boa prática de
programação.”
# História e anatomia java:
Tipos primitivos:
→ originam outros tipos em java;
→ em java existem 8 tipos;
boolean → true/false → default false;
char → inteiro unicode 16 bits → (sem sinal);
byte → inteiro 8 bits → -128 a 127;
short → inteiro 16 bits → -2^15 a 2^15 -1;
int → inteiro 32 bits → -2^31 a 2^31 -1;
long → inteiro 64 bits → -2^63 a 2^63 -1;
float → flutuante 32 bits → norma IEEE 754-1985;
double → flutuante 64 bits → norma IEEE 754-1985;
# História e anatomia java:
private:
acesso apenas
dentro
da classe;
synchronized:indica
que
um método
só podequalquer
ser acessado
porque
uma
return:
retorna
de
um
método
sem executar
código
venha
boolean:um
valor
indicando
verdadeiro
ou falso;
protected:
acesso
por
classes
no
mesmo
pacote
e
subclasses;
thread
de
cadalinha
vez; (também pode retornar uma variável);
depois
desta
byte:
um
inteiro
de 8 bits classe;
(signed);
public:
acesso
de qualquer
transient:
impede
a
serialização
de campos;
switch:indica
a variável
a ser
comparada
nas expressões case;
char: um
caracter
unicode
(16-bit
unsigned);
abstract:
classe
que
não
pode
ser
instanciada
ou método
que
precisa
volatile:indica
que
uma
variável
poderepetidamente
ser alterada
durante
ouma
uso
de
while:
executa
um
bloco
de
código
até
que
certa
double:
um
número
de
ponto
flutuante
de
64
bits
(signed);
ser
implementado por uma subclasse não abstrata;
threads;
condição
verdadeira;
float:
um seja
número
declasse;
ponto flutuante de 32 bits (signed);
class:
especifica
uma
break:
sai
do
bloco
de
codigo condicional
em que está;para verificar uma suposição;
assert:
testa
uma
expressão
int: umindica
inteiro
de
32 bits (signed);
extends:
a
superclasse
que
adependendo
subclasse está
estendendo;
case:
executa
um
bloco
de
código
do
teste
do switch;
do
programador;
long:
um
inteiro
de
64
bits
(signed);
final:
impossibilita
que umado
classe
seja
estendida,
umlinha
método
continue:pula
a oexecução
código
que
viria tratar
apósque
essa
e vaiseja
para
catch:
declara
bloco
de
código
usado
para
uma
exceção;
short: umou
inteiro
de 16variável
bits (signed);
sobrescrito
que
uma
seja
reinicializada;
afinally:bloco
próxima passagem
do loop;
de código,
após umimediata;
try-catch, que é executado;
super:
refere-se
a
superclasse
implements:
indica
as
interfaces
que
uma
classe
irá implementar;
default:executa
esse bloco
de de
codigo
caso
nenhum
dos
teste
de uma
independentemente
do
fluxo
programa
seguido
ao lidar
com
this: refere-se
a instância
atual do objeto;
interface:
especifica
uma
interface;
switch-case
seja verdadeiro;
exceção;
void:indica
indicaque
queum
o método
não
tem
retorno;
native:
método
está
escrito
em
umarealiza
linguagem
do:executa
um
bloco
de
código
uma
vez,
e
então
umoteste
em
throw:usado
para passar
uma exceção
para ouse
método
que
chamou;
const:
Não
utilize
para
declarar
constantes;
public
static
final;
dependente
de o
plataforma,
como
o C; se o bloco deverá ser executado
conjunto
com
while
para
determinar
throws:
indica
que
um
método
pode
passar
uma
exceção
para o
goto:
não implementada
na linguagem
Java
por
ser considerada
new:
instancia
um
novo
objeto,
chamando
seu
construtor;
novamente;
método
que o chamou;
prejudicial;
static:
faz
um método
oude
variável
à classe
invés
de às
else:
executa
bloco
códigopertencer
alternativo
caso
oao
teste
if seja
falso;
try: bloco
de um
código
que tentará
ser
executado,
mas
que pode
causar
instâncias;
for:usado
para realizar um loop condicional de um bloco de código;
uma exceção;
strictfp:
usado
frente
a teste
um método
ou
paraoindicar
if:import:importa
usado
para em
realizar
um
lógico
de classe
verdadeiro
falso; que os
pacotes
ou
classes
para
dentro
do
código;
null, true
false flutuante
são valores
literais.
números
de eponto
seguirão
regras
de ponto
flutuante em
instanceof:
determina
se
um
objeto
éas
uma
de um
determinada
package: especifica a que pacote todas
asinstância
classes de
arquivo
todas
as
expressões;
classe,
superclasse ou interface;
pertencem;
# História e anatomia java:
Instalar e configurar a java para ser usada em linha de comando é simples:
Usaremos a versão 6 do Java que pode ser baixada em:
java.sun.com/javase/downloads/
Em seguida basta seguir os seguinte passos:
Após baixado o JDK ou Kit de Desenvolvimento Java, dispare o instalador e vá
configurando de acordo com o que se pede. [bastante simples].
Após isso acesse as variáveis de ambiente no windows e proceda da forma
que segue:
# História e anatomia java:
Nas variáveis de ambiente [windows] crie:
JAVA_HOME
C:\jdk6
CLASSPATH
.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\jre\lib\rt.jar;%JAVA_HOME%\lib\t
ools.jar;
Em seguida edite:
PATH
%JAVA_HOME%\bin;
Após isso, abra o editor de linha de comando e digite: java –version você deve
ver a versão do java instalado.
# História e anatomia java:
Alguns detalhes sobre o ambiente de desenvolvimento e execução java:
Depois de instalado e devidamente configurado devemos observar 2
programas em especial.
javac: Esse é o programa compilador da linguagem java:
javac nome_da_classe.java
Onde:
Para ver mais opções do comando javac, digite javac e tecle enter (na linha
de comando)
# História e anatomia java:
java: Esse é o programa que executa o programa java a partir do .class.
java nome_da_classe
Para ver mais opções do comando java, digite java e tecle enter (na linha de
comando)
# História e anatomia java:
Anatomia de uma classe em java:
Visibilidade
Nome da classe usando
CamelCase…
Indica que é
uma classe
Chave de abertura
da classe
public class PrimeiraClasse {
Abertura de
método
public static void main(String [] args) {
Fechamento
de método
}
}
Argumentos
Não precisa
de um objeto
instanciado
para ser
usado.
Fechamento
da classe!
Tipo de
retorno. Esse
indica que não
há valor de
retorno
Nome do
método…
# História e anatomia java:
O primeiro programa em java!!!
1 – crie [e salve] um arquivo com o nome PrimeiraClasse.java. Em seguida
digite o seguinte código:
public class PrimeiraClasse {
public static void main(String[] args) {
System.out.println(“Primeira Classe Java!”);
}
}
2 – abra o editor de linha de comando e entre no diretório onde salvou o
arquivo. [windows = menu iniciar  executar  digite cmd]
3 - Em seguida digite o comando: javac PrimeiraClasse.java
Se a sintaxe estiver correta será gerado um PrimeiraClasse.class…
# História e anatomia java:
4 - em seguida digite: java PrimeiraClasse
Observe o resultado na saída padrão!!!
# História e anatomia java:
Referências:
[Lindholm-Yellin] Tim Lindholm, Frank Yellin. The Java Virtual Machine
Specification - Second Edition.
[Silveira-... et. al. 2012] Paulo Silveira, … . Introdução à arquitetura e design de
software;
[Deitel-Deitel 2010] Paul Deitel, Harvey Deitel. Java Como Programar – Oitava
Edição.
[Sierra-Bates 2005] Kathy Sierra, Bert Bates. Head First Java – Second Edition.