Laboratório de Java
Programação Básica em Java
(Lab I)
Prof. Guido Araújo
Tipos de Dados
• Tipos primitivos
–
–
–
–
–
–
Lógico: boolean
Caracter: char (16)
Byte: byte (8)
Inteiros: short (16) < int (32) < long (64)
Floating-point: float (32) < double (64)
Void: void
Declarações e Definições
• Declaração de variáveis
– Tipo da variável e o seu nome
int a;
String s = “abcd”;
– Pode-se criar uma referência para um objeto
String s = new String(“abcd”);
– Ou mesmo um invólucro
Character c = new Character(letra);
Declarações e Definições (cont.)
• Campos
float saldoAtual;
String titular;
• Métodos
float getSaldo () {
código
}
Escopo
• Escopos encaixados são permitidos
{
int x = 12;
// somente x está disponível
{
int q = 96;
// ambos x & q disponíveis
}
// somente x disponível
// q fora de escopo
}
Escopo (cont.)
• Mas não é uma festa, como em C/C++ !
{
int x = 12;
{
int x = 96;
}
}
NÃO PODE !!
Escopo (cont.)
• Vida das variáveis
– São criadas
– Continuam vivas enquanto estiverem dentro do escopo
– Depois o coletor-de-lixo se livra delas. Aleluia !!!
{
String s = new String(“oba”);
} // fim do escopo
s morre
s nasce
Coletor de Lixo
• De tempos em tempos varre o espaço livre
jogando fora o que está fora de escopo
Operadores
• Operadores
– Os mesmos comuns em outras linguagens: + – Precedência é matemática
– Parênteses para forçar precedência e legibilidade
*
/
=
Mais Operadores (cont.)
• Atribuição: =
• Relacionais:
>
< >=
<=
• Bitwise (bit-a-bit): & (AND)
• Lógicos:
||
==
!=
| (OR)
~ (NOT)
^ (XOR)
&&
• Operador shift (deslocamento)
x << y
• Auto-incremento: i++ (pos) --i (pré)
,
x >> y
Mais Operadores (cont.)
• Erro comum
– Confundir
= com ==
Mais Operadores (cont.)
• Concatenação de cadeias
int x = 0, y = 1, z = 2;
String s = "x, y, z ";
System.out.println (s + x + y + z);
Controle da Execução
• if-else
– Tipo boolean somente possue valores true ou false
– expression é avaliado como boolean
– expression pode ser qualquer expressão
Controle da Execução (cont.)
;
• while
– expression é avaliada como tipo boolean
– statement executa enquanto expression for true
– Pode fazer operações dentro de expression
Controle da Execução (cont.)
• do-while
– expression é avaliada como tipo boolean
– statement executa sempre uma primeira vez
– Enquanto expression for true execução continua
Controle da Execução (cont.)
• for-loop
– initialization: inicializar o controle do laço
– conditional: se true laço statement continua a executar
– step: incrementa o controle do laço mais uma interação
Controle da Execução (cont.)
• switch
–
–
–
–
selector é avaliado como tipo int
statement selecionada executa de acordo com selector
break (opcional) faz saltar para o final da sentença
Se não for nenhum dos casos executa sentença em
default
Tipos Agregados de Dados (cont.)
• Arrays
Início em zero
– Declaração: int a[10];
– Acesso:
a[5] = 47;
– Inicialização :
a[] = { 13, 25, 83, 90 }
b[] = { “casa”, “muito”, “bonita” }
O que é um objeto ?
• Empacotando funções e dados em class
• A class torna-se capaz de descrever
características e comportamento
• Tipos de dados abstratos
– A class permite definir um novo tipo de dado
– Ela permite o programador abstrair o problema
– O compilador trata o novo tipo da mesma maneira que
os tipos built-in
– É como se a linguagem estivesse se adequando ao
problema…..
Classes
class ContaCor {
• Campos
float saldoAtual;
void creditaValor (float val) {
• Métodos
saldoAtual = saldoAtual + val;
– Diferente de C/C++
– Definição interna
}
}
Instanciando, Criando e Acessando
class ContaCor {
float saldoAtual;
void creditaValor (float val) {
saldoAtual = saldoAtual + val;
}
}
:
Instancia objeto
ContaCor conta = new ContaCor();
Acessa campo
conta.saldoAtual = 0.0f;
Acessa método
conta.creditaValor (10.0f);
Um Programa Simples
// INF-300 Laboratório de Java
Importando utilitários
// HelloWorld.java
import java.util.*;
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, it's: ");
Imprimindo
System.out.println(new Date());
}
}
Compilando e Executando
pedro> javac HelloWorld.java
pedro> java HelloWorld
EXECUTA !!
HelloWorld.class
Exercício 1
Do diretório acesso
•
Implemente o programa HelloWorld.java
•
Implemente um programa CriaConta.java que
instancia uma conta, credita R$ 10 e imprime o
saldo. Compile e execute.
Controle de Acesso
• Três modos de acessar membros de uma classe
– public todas as declarações a seguir estão
disponíveis para todos
– private só o criador do tipo pode acessar estes
membros
– protected mais tarde !!
Controle de Acesso (cont.)
class ContaCor {
private float saldoAtual;
}
Não funciona !!
:
ContaCor conta = new ContaCor();
conta.saldoAtual = 0;
:
Controle de Acesso (cont.)
class ContaCor {
public float saldoAtual;
}
Agora sim !!
:
ContaCor conta = new ContaCor();
conta.saldoAtual = 0;
Controle de Acesso (cont.)
public class ContaCor {
int saldoAtual;
Tudo público
String titular;
}
Métodos de Acesso (cont.)
class ContaCor {
private float saldoAtual;
void creditaValor (float val) {
saldoAtual = saldoAtual + val;
Acessa saldo
}
}
Exercício 2
Do diretório acesso
•
Leia o programa TestaAcesso.java
•
Faça saldoAtual ser privado. O que ocorreu ?
•
Faça saldoAtual ser public. O que ocorreu ?
•
(Extra) Estude o programa MetodoAcesso.java. Que
vantagem ele oferece em relação à TestaAcesso.java ?
Armazenamento Estático
• static mantém o valor da variável durante execução
– Variável é inicializada somente na primeira chamada
da função
– O valor que for armazenado permanece entre chamadas
– Variável não é disponível fora do escopo
Armazenamento Estático
class ContaCor {
static private float saldoAtual;
void creditaValor (float val) {
Variável estática
saldoAtual = saldoAtual + val;
}
}
Armazenamento Estático (cont.)
ContaCor conta1 = new ContaCor();
ContaCor conta2 = new ContaCor();
:
conta2
conta1
conta1.creditaValor (10.0f);
10.0
conta2.creditaValor (5.0f);
:
Armazenamento Estático (cont.)
ContaCor conta1 = new ContaCor();
ContaCor conta2 = new ContaCor();
:
conta2
conta1
conta1.creditaValor (10.0f);
10.0
conta2.creditaValor (5.0f);
:
Armazenamento Estático (cont.)
ContaCor conta1 = new ContaCor();
ContaCor conta2 = new ContaCor();
:
conta2
conta1
conta1.creditaValor (10.0f);
15.0
conta2.creditaValor (5.0f);
:
Método Estático
class ContaCor {
static private float saldoAtual;
static void getSaldo () {
return saldoAtual;
}
Chamada da classe
}
:
ContaCor.getSaldo();
:
Exercício 3
Do diretório acesso
1. Leia o programa StaticVar.java. Compile e
execute. O que ocorreu ?
2. Altere saldoAtual para saldo estático e execute.
O que ocorreu ?
3. (Extra) Estude o programa StaticMetodo.java. O
que significa o método ser estático ?
Construtor
class ContaCor {
float saldoAtual;
}
Incializa saldo
:
ContaCor conta = new ContaCor();
conta.saldoAtual = 0.0;
:
Construtor (cont.)
class ContaCor {
float saldoAtual;
ContaCor (int val) {
Cria objeto e
Inicializa saldo
saldoAtual = val;
}
}
:
ContaCor conta = new ContaCor(10.0f);
Exercício 4
Do diretório acesso
1. Adicione um construtor a CriaConta.java que
inicializa a conta com R$ 35. Compile e execute.