introdução ao java - deinf/ufmageraldo/poo/2.0introjava.pdf · javascript: linguagem script sem...
TRANSCRIPT
Programação Orientada a Objetos Java
Introdução ao Java
Prof. Anselmo Cardoso Paiva
Prof. Geraldo Braz Junior
Tecnologia Java Java é tanto uma linguagem de programação
de alto nível quanto uma plataforma de desenvolvimento de aplicações
Java como linguagem de programação
Aplicações locais, centralizadas e distribuídas
Aplicações cliente/servidor que executam em browsers
Java como ambiente de execução
Ambiente neutro (JRE – Java Runtime Environment) para diferentes plataformas: SOs, browsers, celulares, palmtops, eletrodomésticos...
2
Características Java Linguagem de programação orientada a objetos
Familiar (sintaxe parecida com C)
Simples e robusta (minimiza bugs, aumenta produtividade)
Suporte nativo a threads (+ simples, maior portabilidade)
Dinâmica (módulos, acoplamento em tempo de execução)
Com coleta de lixo (menos bugs, mais produtividade)
Independente de plataforma
3
Características Java Segura (vários mecanismos para controlar
segurança)
Código intermediário de máquina virtual
interpretado (compilação rápida,
execução + “lenta”, + produtividade no
desenvolvimento)
Sintaxe uniforme, rigorosa quanto a
tipos (código mais consistente)
4
SIMULA1967
SmallTalk1980
ALGOL1960
Java1995
C++1985
C1972
Pascal1973
ADA1983
ADA1995
Linguagens OO: genealogia
5
código
fonte
processador
da linguagem
código
objeto
linkingcódigo
executável
Desenvolvimento de programas
6
Implementação de LP Compilação geração de código executável
dependente da plataforma de execução
tradução lenta X execução rápida
Interpretação pura sem geração de código
execução lenta, independente de plataforma
Híbrida geração de código intermediário
independente de plataforma de execução
tradução rápida X execução não muito rápida
7
fonte
Compilador
JAVA
bytecode
Interpretador
JAVA
plataforma
local
Browser
{HTML}
interpretador
JAVA
INTERNET
plataforma
remota
Ambiente de compilação e execução Compilação: Programa Java é compilado para um
código intermediário conhecido como bytecode
Execução: Bytecodes são interpretados pela JVM (Java Virtual Machine) executada no ambiente hospedeiro – arquitetura neutra
8
Compilação x Interpretação Problema: Para ter flexibilidade e segurança, abre-se mão
do tempo de execução Um programa Java típico roda 10 vezes mais
lento que um programa equivalente em linguagem nativa
Solução: JIT (Just-in-time compiling) Compiladores JIT convertem programas Java
para linguagem de máquina nativa assim que os mesmos são lidos
Penalidade: a leitura dos programas se torna mais lenta
Vantagem: execuções subseqüentes são mais rápidas
9
Ambientes de execução e desenvolvimento Java 2 System Development Kit (J2SDK)
Coleção de ferramentas de linha de comando para, entre outras tarefas, compilar, executar e depurar aplicações Java
Para habilitar o ambiente via linha de comando é preciso colocar o caminho $JAVA_HOME/bin no PATH do sistema
Java Runtime Environment (JRE)
Ambiente mínimo para executar aplicações Java
Faz parte do J2SDK e das principais distribuições Linux, MacOS X, AIX, Solaris, Windows 98/ME/2000 (exceto XP)
10
Interfaces de Programação de Aplicações – APIs Java possui uma coleção de APIs (bibliotecas)
padrão que podem ser usadas para construir aplicações: Organizadas em pacotes (java.*, javax.* e
extensões)
Usadas pelos ambientes de execução (JRE) e de desenvolvimento (SDK)
As principais APIs são distribuídas juntamente com os produtos para desenvolvimento de aplicações: Java 2 Standard Edition (J2SE)
Java 2 Enterprise Edition (J2EE)
Java 2 Micro Edition (J2ME)
11
Ambientes Integrados de Desenvolvimento – IDEs Existem diversos IDEs construídos a partir
das ferramentas básicas de desenvolvimento:
ambientes baseados em janelas
editores, visualizadores de classes, prototipação ...
Exemplos: Eclipse, NetBeans (Sun), Visual Studio (Microsoft), JBuilder (Borland), Visual Café (Symantec), JCreator, BlueJ, jGRASP...
12
CLASSE
Nome
CLASSE Nome1
CLASSE
Nome2
CLASSE
Nome1
Nome.java
Nome1.java
Um arquivo pode conter
várias classes
mesmo Nome
Programa Java: Classe Uma classe é um arquivo fonte (texto)
13
Arquivo fonte : Escola.java
public class Escola {{
class Aluno {
bytecodes
bytecodes
Escola.class
Aluno.class
Arquivos executáveis: class
Arquivos fonte e executáveis
14
Convenção para Nomes Java, como C/C++, distingue entre letras
maiúsculas e minúsculas Exemplo: escola é diferente de Escola
Nomes de classes iniciam com maiúscula Exemplo: class Bemvindo
Nomes de variáveis iniciam com minúsculas Exemplo: int peso;
Nomes de métodos são verbos que iniciam com minúscula e depois usam maiúsculas Exemplo: alteraPeso
Representação: Unicode (16 bits - 65.536 caracteres)
15
Compilação e Execução: SDK – linha de comando Compilação: javac A partir do
diretório local:
javac Nome.java
Vai produzir: Arquivos .class
separados para cada classe no arquivo .java
coloca arquivos no diretório corrente
Execução: java A partir do
diretório local:java Nome
sendo Nome = nome do arquivo .class que contém o main()
Executa a partir de main(): java Nome
arg1,arg2, ...
16
Verificação de bytecode Etapa que antecede a execução do código em
classes carregadas através da rede Class Loader distingue classes locais (seguras) de
classes remotas (potencialmente inseguras)
Verificação garante: Aderência à especificação da JVM
Não-violação de políticas de acesso estabelecidas pela aplicação
Não-violação da integridade do sistema
Ausência de estouros de pilha
Tipos de parâmetros corretamente especificados
Ausência de conversões ilegais de tipos
18
Editordisco
Programa é criado em um editor e armazenado no disco
Compiladordisco
Compilador gera os bytecodes e os armazena no disco
Carregador de classes
disco
O carregador de classes – Class Loader – coloca os bytecodes na memória
______________________________
memória
Verificador de bytecodes
O verificador de bytecodes –Bytecodes Verifier –confirma se todos os bytecodes estão corretos e não violam as restrições de segurança da linguagem Java
______________________________
memória
Interpretador O interpretador lê os bytecodes e executa o programa
______________________________
memória
Pro
cesso d
e E
xecução
19
Programas JAVA Aplicações (puras)
são programas carregados e executados localmente pelo interpretador Java
possuem acesso a todos os recursos do ambiente local: diretórios, arquivos
sempre contêm um método principal (main), de onde se inicia a execução do programa
podem fazer chamadas a programas em código nativo (outras linguagens, como C, C++)
20
Programas Cliente/Servidor Applets: cliente
são programas inseridos em páginas HTML e executados pelo browser (interpretador Java)
programas (classes) podem ser carregados remotamente
restrições de segurança: não podem acessar recursos locais, só podem comunicar-se com o servidor de onde foram “baixados”
Servlets: servidor
executados sob o controle do servidor
classe carregada dinamicamente por requisição de um cliente
21
Applets Java X JavaScript Ambos são códigos executáveis inseridos
em páginas HTML
Código Java: classes compiladas e carregadas remotamente
Código JavaScript: instruções fisicamente dispersas ao longo da página HTML
Java é uma LP de uso geral, orientada a objetos: classes, objetos, encapsulamento, herança e polimorfismo
JavaScript: linguagem script sem classes, sem herança e sem polimorfismo
22
class Bemvindo {public static void main (String[]
args) {System.out.println(“Bem-
vindo!”);}
}
Método main(): onde se inicia a execução
Atenção a maiúsculas
e minúsculas!
Classe Java: apenas o método main()
24
System.out.println (“Bem-vindo!”);
objeto método parâmetro
System.out.print (“Bem-vindo!”);
objeto método parâmetro
Exemplo de chamada de métodos
25
class Bemvindo {public static void main (String[] args) {
System.out.println(“Bem-vindo ” + args[0]);
}}
Método main(): aceita argumentos para execução
Linha de comando: java Bemvindo Pedro
Chamada parametrizada
26
class Bemvindo2 {static void imprime() {
System.out.println(“Bem-vindo!”);
}
public static void main (String[] args) {
imprime();}}
método static: método de classe, não aplicável sobre objetos
Classe Java: dois métodos
27
Introdução a Java
class Bemvindo3 {void imprime(){
System.out.println(“Bem-vindo!”);}
public static void main(String[] args) {Bemvindo3 obj = new
Bemvindo3();// imprime(); // erro! obj.imprime();
}}
método de instância, somente aplicável sobre objetos
Classe Java: instanciando um objeto
28
class Bemvindo3{void imprime(){System.out.println("Bem-vindo!");
}public static void main(String[] args){Bemvindo3 obj=new Bemvindo3();Welcome outro=new Welcome();obj.imprime();outro.imprime();
} // main} // Bemvindo3
class Bemvindo3{
imprime()
main(...) }
class Welcome{
imprime()
}
class Welcome{void imprime(){System.out.println("Welcome!");
}} // Welcome
Duas classes: composição
29
Streams de entrada/saída Em um programa, dados são lidos/gravados
através de streams (fluxos) de E/S
Fontes e destinos: console, arquivos, rede...
Um programa pode gerenciar diversos streams
30
Chamada Parametrizada X Entrada/Saída via Console Chamada parametrizada: programa inicia com valores armazenados
em um array de Strings
não é uma forma usual de entrada de dados
Ao iniciar a execução de um programa, são criados automaticamente os seguintes streams: System.in - standard input (teclado)
System.out - standard output (vídeo)
System.err - standard error (vídeo) Podem ser redirecionados para disco, por exemplo
31
Entrada via Console Classe BufferedReader
usada para leitura de um stream de caracteres para um buffer
definida no pacote java.io
Método readLine()
definido em BufferedReader
faz a leitura de uma linha de texto até um caracter „\n‟
causa uma exceção se ocorrer um erro enquanto lê os dados da entrada
32
72 101 108 108 111 13
String msg = stdin.readLine();
InputStream
72 101 108 108 111 13
leitura de bytes
InputStreamReader
H e l l o \n
buffer de caracteres
BufferedReader
H e l l o
msg
String
Entendendo Entrada via Console
33
L i n h a i n f o r m a d a = H e l l o
System.out.println(“Linha informada = ”+ msg);
PrintStream
vídeo
Entendendo Saída via Console
34
Entrada via Console: String
1. import java.io.*;
2. class Leitura {3. public static void main(String[] args) throws 4. IOException{
5. BufferedReader stdin = new BufferedReader(6. new InputStreamReader(System.in));
7. System.out.println(“Entre uma linha:”);8. String msg = stdin.readLine();9. System.out.println(“Linha informada = ”+ msg);10. }11. }
35
Entrada via Console: int1. import java.io.*;
2. class Leitura {3. public static void main(String[] args) throws 4. IOException{
5. BufferedReader stdin = new BufferedReader(6. new InputStreamReader(System.in));
7. System.out.println(“Entre um número:”);8. int i = Integer.parseInt(stdin.readLine());9. System.out.println(“Número = ”+ i);10. }11. }
36
Usando Scanner() e printf()JDK 1.51. import java.io.*;2. import java.util.Scanner;
3. public class LeScanner {4. public static void main(String[] args) {5. Scanner input = new Scanner(System.in);6. System.out.print("Digite seu nome: ");7. String nome = input.next();8. System.out.print("Digite sua idade: ");9. int idade = input.nextInt();
10. System.out.printf("%s tem %d anos\n", nome, idade);
11. } }
37
Estruturas de Controle
Estruturas de seleção if, if-else, switch
Estruturas de repetição for, while, do-while
Desvios (somente em estruturas de repetição)
continue, break, rótulos
Java não possui um comando goto, porém “goto” é uma palavra reservada
39
Expressões Booleanas
Uma condição usa operadores relacionais e resulta em um valor booleano (true ou false):
== equal to
!= not equal to
< less than
> greater than
<= less than or equal to
>= greater than or equal to
40
O operador condicional ? :
Mesma semântica da estrutura if-else
Único operador ternário da linguagem Java
o primeiro operando é uma expressão booleana
retorna o segundo operando se a expressão condicional
for true ou o terceiro operando se for false
Exemplos:
System.out.println( (media >= 7) ? “Aprovado” : “Reprovado” );
int x = (y != 0) ? 50 : 500;
String titulo = (sex == 'f') ? "Sra." : "Sr.“ ;
41
Sintaxe da instrução switch
switch(expr1) {
case expr2:
instruções;
break;
case expr3:
instruções;
break;
default:
instruções;
}
Na instrução switch (expr1),
expr1 deve ser compatível com
atribuições do tipo int, sendo
permitidos os tipos de dados
short, int, byte ou char, pois pode
ser feita a coerção (cast) para o
tipo int, o que não é possível
com os tipos long ou de ponto
flutuante.
42
Exemplos while/do-while
int x = 0;
while (x < 10) {
System.out.println ("item " + x);
x++;
}
int x = 0;
do {
System.out.println ("item " + x);
x++;
} while (x < 10);
// loop infinito
while ( true ) {
...
}
43
Exemplos for
for ( int x = 0; x < 10; x++ ) {
System.out.println ("item " + x);
}
for ( int x = 0, int y = 25;
x < 10 && (y % 2 == 0);
x++, y = y - 1 ) {
System.out.println (x + y);
}
// loop infinito
for ( ; ; ) {
...
}
44
45
Comandos de desvio: break e continue
break: interrompe a execução do bloco de repetição Continua com a próxima instrução após o bloco
continue: interrompe a iteração atual Ignora as instruções restantes no bloco, testa a condição e
reinicia com a próxima iteração
46
Usando rótulos
break e continue sempre atuam sobre o bloco de repetição onde são chamados
Em blocos de repetição contidos em outros blocos, pode-se usar rótulos para fazer break e continue atuarem em blocos externos
Os rótulos só podem ser usados antes de do, while e for
As chamadas só podem ocorrer dentro de blocos de repetição
Identificadores
São palavras utilizadas para nomear variáveis,
métodos e classes
Na linguagem Java, o identificador sempre
começa por letra, sublinhado(_) ou cifrão ($)
Não podem começar por números
São “case sensitive”
Do segundo caractere em diante, pode conter
qualquer seqüência de letras, dígitos, sublinhados
ou cifrões
48
Identificadores Exemplos de identificadores válidos:
nomeAluno
saldo
lâmpada // não recomendável
User_name // fora do padrão
_sys_var1
Class // não recomendável
Java utiliza o padrão Unicode (16 bits)
49
Palavras reservadas em Java
abstract boolean break byte case
catch char class continue default
do double else extends
final finally float for if
implements import instanceof int interface
long native new return package
private protected public synchronized short
static super switch this try
throw throws transient void volatile
while enum
true, false e null não são palavras reservadas e sim literais
OBS: Todas as palavras reservadas são escritas com letras minúsculas
50
Palavras reservadas Modificadores de Acesso private, protected, public
Modificadores de classe, método e variável abstract, class, extends, final, implements,
interface, native, new, static, synchronized, transient, volatile
Controle de fluxo break, case, continue, default, do, else, for, if,
instanceof, return, switch, while
51
Palavras reservadas
Tratamento de Erros catch, finally, throw, throws, try, assert
Controle de Pacotes import, package
Tipos de Dados boolean, byte, char, double, float, int, long, short,
void (somente retorno)
52
Tipos primitivos em Java
Armazenados na pilha (acesso rápido)
Não são objetos. Classe 'wrapper' faz transformação, se necessário (encapsula valor em um objeto)
53
Coerção (cast) As variáveis podem ser convertidas em tipos maiores
de maneira automática, mas não em tipos menores
Desta forma, uma expressão int pode ser tratada como long, mas uma expressão long não poderá ser tratada como int sem que haja uma coerção explicita
Uma coerção é utilizada para persuadir o compilador a reconhecer uma atribuição
Esse procedimento pode ser adotado, por exemplo, para “comprimir” um valor long em uma variável int
Na coerção, o programador assume os riscos da conversão de dados
65
public class Test {
public static void main(String args[]) {
int i = 16777473;
short s = (short) i;
byte b = (byte) i;
System.out.println(“Valor int:” + i);
System.out.println(“Valor short:” + s);
System.out.println(“Valor byte:” + b);
}
}
A execução de código provoca duas conversões. Em ambas ocorre perda de informação
Coerção - Exemplo
i = 00000001 00000000 00000001 00000001
(int (4 bytes) - valor: 16777473)
s = 00000001 00000000 00000001 00000001
(short (2 bytes) - valor: 257)
b = 00000001 00000000 00000001 00000001
(byte (1 byte) - valor: 1)66
Coerção – Exemplo com objetos
Array v = new Array( );
v.add(“Hello”);
String s = (String)v.get(0);
Como o método get sempre retorna um elemento
do tipo Object, que não pode ser atribuído a uma
String, torna-se necessário fazer o cast antes da
atribuição
Caso fosse feita a atribuição direta, teríamos um
erro de compilação:
String s = v.get(0); // erro
67