Prof. Rodrigo Noll @ IFRS Canoas
Em Java, a declaração de novas classes é feita através da construção class.
class Pessoa{
}
class Pessoa {
private String nome;
public String getNome() {
return this.nome;
}
public void setNome(String nomeP) {
this.nome = nomeP;
}
}
[package pacote;]
[import bibliotecas;]
[modificador] class NomeClasse {
[modificador] [tipo] nomeAtributo;
[modificador] [tipoRetorno] nomeMetodo ( [parametros] ) {
// corpo do metodo
}
}
A palavra-chave “package”:
package pacote;
public class Classe{
...
}
A palavra-chave “import”:
import java.util.ArrayList;
public class Classe{
ArrayList lista;
...
}
[modificador] [tipo] nomeAtributo;
int idade;
São exemplos de atributos válidos:
São exemplos de atributos inválidos:
Um método em Java é equivalente a uma função, subrotina ou procedimento em outras linguagens de programação. Não existe em Java o conceito de métodos globais, portanto todos os métodos pertencem a uma classe.
[modificador] [tipoRetorno] nomeMetodo ( [parametros] ) {
// corpo do metodo
}
A linha a seguir é a tradução de “idade deve valer agora quinze”.
idade = 15;
O código a seguir declara novamente a variável idade com valor 15 e imprime seu valor na saída padrão através da chamada a System.out.println:
//declara a idade
int idade; idade = 15;
// imprime a idade
System.out.println(idade);
Pode-se utilizar o valor de uma variável para algum outro propósito, como alterar ou definir uma segunda variável:
//gera a idade no ano seguinte
int idadeNoAnoQueVem;
idadeNoAnoQueVem = idade + 1;
Pode-se declarar uma variável a iniciando:
int idade = 15;
Pode-se usar os operadores +, -, /, * e %:
int quatro = 2 + 2;
int tres = 5 – 2;
int oito = 4 * 2;
int dezesseis = 64 / 4;
int um = 5 % 2;
...
int i;
int j;
i = j + 5;
...
...
int i;
int j = 3;
i = j + 5;
...
A instrução i = j + 5; irá gerar um erro de compilação
Um tipo primitivo em Java armazena o real conteúdo da variável (o operador de atribuição “=” copia o valor)
int i = 5;
int j = i;
i = i + 1;
Qual o valor das variáveis i e j?
Analise o código:
double d = 3.1415;
int i = d;
i = 3.14;
O que pode acontecer?
E se alterarmos para?
double d = 5;
int i = d;
Como resolver?
int i = (int) 3.14;
Analise o código:
float x = 0.0;
O que pode acontecer?
float x = 0.0f;
/*letra f (maiusc ou minusc.) indica que o literal deve ser tratado como float)*/
Tipo | Precisão (bit) |
---|---|
boolean | 1 |
byte | 8 |
int | 32 |
short | 16 |
long | 64 |
float | 32 |
double | 64 |
char | 16 |
Crie uma classe Java e declare e imprima variáveis inteiras, com ponto flutuante (tipo double), valores verdadeiro e falso (tipo boolean) e caracteres (tipo char)
Operador | Resultado |
---|---|
+ | Adição |
- | Subtração |
* | Multiplicação |
/ | Divisão |
% | Módulo |
Operadores | Resultado |
---|---|
Pelo menos um operando é long e nenhum é float ou double | long |
Nenhum operando é float, double ou long | int |
Pelo menos um operando é double | double |
Pelo menos um operando é float, nenhum é double | float |
Operador | Resultado |
---|---|
++ | Incremento |
-- | Decremento |
+ | Indica que o valor é positivo |
- | Indica que o valor é negativo |
! | Inverte o valor de um boleano |
~ | Inverte um padrão de bits |
() | Organiza a precedência em uma operação |
Operador | Resultado |
---|---|
== | Igual a |
!= | Diferente de |
> | Maior que |
< | Menor que |
>= | Maior que ou igual a |
<= | Menor que ou igual a |
instanceof | instância de |
Operador | Resultado |
---|---|
&& | AND |
|| | OR |
& | Bitwise AND |
| | Bitwise OR |
identificador = valor
Exemplo:
x = 10;
x = y = 15;
Operador | Resultado | Exemplo | Operação Equivalente |
---|---|---|---|
+= | Adição com atribuição | x += y | x = x + y |
-= | Subtração com atribuição | x -= y | x = x - y |
*= | Multiplicação com atribuição | x *= y | x = x * y |
/= | Divisão com atribuição | x /= y | x = x / y |
%= | Módulo com atribuição | x %= y | x = x % y |
expr1 ? expr2 : expr3
Exemplo:
razao = denom == 0 ? 0 : num / denom;
O operador “?” não é propriamente um comando, mas um operador que realiza avaliação seletiva de seus operandos mediante o valor de uma expressão booleana semelhante a do comando if-else. Se esta expressão for true, então um primeiro operando é avaliado; se for false, então o segundo operando é avaliado.
if (condição) {
bloco
} else if (condição) {
bloco
} else {
bloco
}
A forma mais simples de controle de fluxo é o comando if-else. Ele é empregado para executar seletivamente ou condicionalmente um outro comando mediante um critério de seleção. Este critério é dado por uma expressão, cujo valor resultante deve ser um dado do tipo booleano, isto é, true ou false. Se esse valor for true, então o outro comando é executado; se for false, a execução do programa segue adiante.
Exemplo:
if (x>10) a = 2;
else b = 5;
if ((y >= 10) && (x < 5))
b = 5;
else {
a = 5; b *=b;
}
int idade = 15;
if (idade < 18) {
System.out.println("Não pode entrar");
}
else {
System.out.println("Pode entrar");
}
Você pode concatenar expressões booleanas através dos operadores lógicos “E” e “OU”. O “E” é representado pelo & e o “OU” é representado pelo |.
int idade = 15;
boolean amigoDoDono = true;
if (idade < 18 & amigoDoDono == false) {
System.out.println("Não pode entrar");
}
else {
System.out.println("Pode entrar");
}
int idade = 15;
boolean amigoDoDono = true;
if (idade < 18 & !amigoDoDono) {
System.out.println("Não pode entrar");
}
else {
System.out.println("Pode entrar");
}
switch ([expressão])
{
case [constante 1] : [comando1]
break;
case [constante 2] : [comando 2]
break;
...
case [constante n] : [comando n]
break;
default : [comando]
}
switch ( sex ) {
case 'm' :
name = "Male";
a = 1;
break;
case 'f' :
name = "Female"
break;
}
int idade = 15;
while(idade < 18) {
System.out.println(idade);
idade = idade + 1;
}
int i = 0;
while(i < 10) {
System.out.println(i);
i = i + 1;
}
while ( (cont > 0) || a < 3) {
a = n * 3;
cont += 4;
}
while ( (cont > 0) || a < 3)
cont ++;
do {
j++;
n = j * 6;
} while ( n < 0 );
do
n *= 6;
while ( n < 0 );
ERRO: Não esquecer as chaves “{}”.
for (int i = 0; i < 10; i++) {
n += i;
}
É equivalente à:
int i = 0;
while(i< 10) {
n += i;
i++;
}
for (int i = 0; i < 10; i++) n += i;
boolean achou= false;
for (a = 1; !achou; a ++) {
// comandos
if ( a == 10) achou = true;
}
int a, b;
b = 4;
for (a = 1; a < b; a ++) {
// comandos
b --;
}
int a, b;
for (a = 1, b=4; a < b; a ++, b --) {
// comandos
}
Quanto vale x e i?
int i = 5;
int x = i++;
E agora?
int i = 5;
int x = ++i;
while (x > 10) {
a = x + 10;
if (a == 50 || (a > x))
break;
}
a = -30;
...
while (a != 10) {
// comandos
b++;
if (b % 2 == 0)
continue;
a++;
}
for (int i = x; i < y; i++) {
if (i % 19 == 0{
System.out.println("Achei um número divisível por 19 entre x e y");
break;
}
}
for (int i = 0; i < 100; i++) {
if(i > 50 && i < 60) {
continue;
}
System.out.println(i);
}
//aqui a variável i não existe
int i = 5;
// a partir daqui ela existe
//aqui a variável i não existe
int i = 5;
// a partir daqui ela existe
while (condição) {
// o i ainda vale aqui
int j = 7;
// o j passa a existir
}
// aqui o j não existe mais, mas o i continua a valer
if (algumBooleano) {
int i = 5;
}
else {
int i = 10;
}
System.out.println(i);
for (int i = 0; i < 10; i++) { System.out.println("olá!");}
System.out.println(i);
Orientação a objetos é uma maneira de programar que ajuda na organização e resolve
muitos problemas enfrentados pela programação procedural, como a distribuição e/ou replicação
da lógica em diversos pontos do código fonte.
A OO busca uma solução ideal para concentrar todas características e responsabilidades
em um único lugar (classe) e não espalhadas no código.
class Conta {
int numero;
String nome;
double saldo;
double limite;
// ..
}
class Programa {
public static void main(String[] args) {
new Conta();
}
}
class Programa {
public static void main(String[] args) {
Conta minhaConta;
minhaConta = new Conta();
//E agora se pode utilizar as variáveis:
minhaConta.nome = "Rodrigo";
minhaConta.saldo = 1000.0;
System.out.println("Saldo atual: " + minhaConta.saldo);
}
}
class Conta {
int numero;
String nome;
double saldo;
double limite;
void saca(double quantidade) {
double novoSaldo =
this.saldo - quantidade;
this.saldo = novoSaldo;
}
}
class Conta {
int numero;
String nome;
double saldo;
double limite;
void saca(double quantidade) {
double novoSaldo =
this.saldo - quantidade;
this.saldo = novoSaldo;
}
void deposita(double quantidade) {
this.saldo += quantidade;
}
}
class SacaEDepositaTest {
public static void main(String[] args) {
// criando a conta
Conta minhaConta;
minhaConta = new Conta();
// alterando os valores de minhaConta
minhaConta.nome = "Rodrigo";
minhaConta.saldo = 1000;
minhaConta.saca(200); // saca 200 reais
minhaConta.deposita(500); //deposita 500 reais
System.out.println(minhaConta.saldo);
}
}
Qual é o resultado da execução do código acima?
class SacaEDeposita {
public static void main(String[] args) {
// criando a conta
Conta minhaConta = new Conta();
minhaConta.saldo = 1000;
System.out.println(minhaConta.saca(2000));
}
}
class Conta {
int numero;
String nome;
double saldo;
double limite;
boolean saca(double valor) {
if (this.saldo < valor) {
return false;
} else {
this.saldo = this.saldo - valor;
return true;
}
}
void deposita(double quantidade) {
this.saldo += quantidade;
}
}
public static void main(String args[]) {
Conta minhaConta;
minhaConta = new Conta();
Conta minhaContaDosSonhos;
minhaContaDosSonhos = new Conta();
}
public class Conta {
int numero;
String nome;
double saldo;
double limite;
boolean saca(double valor) {
if (this.saldo < valor) {
return false;
} else {
this.saldo = this.saldo - valor;
return true;
}
}
void deposita(double quantidade) {
this.saldo += quantidade;
}
boolean transfere(Conta destino, double valor) {
boolean retirou = this.saca(valor);
if (retirou == false) {
// não foi possível sacar
return false;
} else {
destino.deposita(valor);
return true;
}
}
}
class Programa {
public static void main(String[] args) {
// criando a conta
Conta minhaConta;
minhaConta = new Conta();
minhaConta.nome="Rodrigo";
minhaConta.saldo=1000;
Conta outraConta = new Conta();
outraConta.nome="Rodrigo";
outraConta.saldo=1000;
//minhaConta transfere para outraConta 100 reais
minhaConta.transfere(outraConta, 100);
System.out.println("Saldo da Minha Conta = "+minhaConta.saldo);
System.out.println("Saldo da Outra Conta = "+outraConta.saldo);
}
}
//Saldo da Minha Conta = 900.0
//Saldo da Outra Conta = 1100.0
public class Conta {
int numero=1234;
String nome="Rodrigo";
double saldo=1000;
double limite=1000;
}
public class Conta{
int numero;
double saldo;
double limite;
Cliente titular;
}
public class Cliente{
String nome;
String sobrenome;
String cpf;
}
class Programa {
public static void main(String[] args) {
// criando a conta
Conta minhaConta = new Conta();
Cliente cliente = new Cliente();
minhaConta.titular = cliente;
minhaConta.titular.nome = "Rodrigo";
cliente.nome = "Fulano";
System.out.println(minhaConta.titular.nome);
}
}
public class Conta{
int numero;
double saldo;
double limite;
Cliente titular = new Cliente();
}
public class Cliente{
String nome;
String sobrenome;
String cpf;
}