POO 8 operadores final

Prévia do material em texto

OPERADORES E 
MODIFICADOR FINAL
Thaís Alves Burity Rocha
Agenda
 Operadores
 Operador de Atribuição
 Operadores Aritméticos
 Operador de Aritméticos e de Atribuição
 Operador de Comparação
 Operadores Lógicos
 Operador Unário
 Modificador final
Operador de Atribuição
 =
 Exemplos:
 Lembrar
 Em se tratando de tipos primitivos, tamanho importa
 Em se tratando de referências, tipo importa
int x = 0; int a,b,c;
a = b = c = -1;
Operadores Aritméticos
 Aplicam-se a tipos numéricos (inteiro e ponto-
flutuante)
Operador Operação
- Menos unário (inversão de sinal)
+ Adição
- Subtração
* Multiplicação
/ Divisão inteira
% Resto da divisão inteira (módulo)
Operadores Aritméticos
 Exemplos
 2 + 45  47
 34 – 4  30
 - (5 + 2)  - 7
 3 * 4  12
 1/2  0
 6/2  3
 16 % 5  1
Operadores Aritméticos
 Expressões são avaliadas da esquerda para a 
direita
 Por default, os operadores *, / e % possuem maior
precedência do que + e –
 É possível alterar a ordem usando parêntese
 Qual o resultado desta operação?
int y = 1 * 4 * 4 + 2 * 5 + 9;
Operadores Aritméticos
 Como calcular a média aritmética?
 Como garantir que o somatório vai ocorrer antes da 
divisão?
 Faz diferença m ser um tipo inteiro ou de ponto
flutuante?
int a=1, b=2, c=3, d=4, e=6;
int m = a+b+c+d+e/5;
Operadores Aritméticos
 Não importa o tipo de m, o resultado é sempre um 
valor inteiro
 Os operandos da divisão são inteiros
 Para não haver perda, é preciso fazer o casting
int m = (a+b+c+d+e)/5;
double m = (a+b+c+d+e)/5;
double m = (double)(a+b+c+d+e)/5;
 Aplicam-se a tipos numéricos (inteiros e ponto-
flutuante)
Operadores Aritméticos de Atribuição
Operador Equivalente a
a += b a = a + b
a -= b a = a - b
a *= b a = a * b
a /= b a = a / b
a %= b a = a % b
Operadores Aritméticos de Atribuição
 Exemplos
 int a = 5, b=3;
 a+=b;
 a  8
 b  3
 a*=b;
 a  15
 b  3
Operadores Aritméticos de Atribuição
 Qual é o resultado?


int x = 2;
x *= 2 + 5;
x = (x*2) + 5; //9
x = x * (2+5); //14
Operadores Aritméticos de Atribuição


int x = 2;
x *= 2 + 5;
x = (x*2) + 5; //9
x = x * (2+5); //14
Resolve primeiro a 
expressão à direita do 
operador de atribuição
Operadores de Incremento e 
Decremento
Operação Denominação Efeito Colateral Comportamento
x++
incremento 
sufixo
adiciona 1 a x
Usa o valor na expressão
e depois incrementa
x--
decremento 
sufixo
subtrai 1 de x
Usa o valor na expressão
e depois decrementa
++x
incremento 
prefixo
adiciona 1 a x
Icrementa e depois usa o 
valor na expressão
--x
decremento 
prefixo
subtrai 1 de x
Decrementa e depois usa
o valor na expressão
Operadores de Incremento e 
Decremento: Exemplo
 Qual é o resultado o programa?
public class TestandoOperador{
public static void main(String[] x){
int a=5, b=5;
System.out.println(++a);
System.out.println(b++);
}
}
Operador de Concatenação
 O operador + é polimórfico e aceita Strings
 Funciona como concatenação
String nome = “Marcos”;
String sobrenome = “Silva”;
String nomeCompleto = nome + “ ” + sobrenome;
int x = 3;
String mensagem = “Este é o cliente número” + x;
Faz conversão 
implícita para String
Operador de Concatenação
int a = 10;
int b = 2;
System.out.println(a+b);
//saída: 12
System.out.println("numero "+a+b); 
//saída: numero 102
System.out.println("numero "+(a+b)); 
//numero 12
System.out.println(a+b+" numero");
//saída: 12 numero
Operadores de Comparação
 Também chamados de operadores relacionais
 Usados com valores/tipos numéricos, incluindo char
 Comparação entre os valores Unicode correspondentes
Operador Denominação Aplicação Resultado
> maior do que a > b
true se a é maior do b;
false, caso contrário
>= maior do que ou igual a a >= b
true se a é maior que ou igual a b;
false, caso contrário
< menor do que a < b
true se a é menor do b;
false, caso contrário
<= menor do que ou igual a a <= b
true se a é menor que ou igual a b;
false, caso contrário
Operadores de Comparação
 Operadores de igualdade, um subtipo de 
operadores relacionais
 Podem ser usados com valores/tipos numéricos
(incluindo char), booleanos e variáveis de 
referência
Operador Denominação Aplicação Resultado
== igual a a == b
true se a é igual a b;
false, caso contrário
!= diferente de a != b
true se a é diferente de b;
false, caso contrário
Operadores de Comparação
 Exemplos
 5 > 6  false
 7 <= 18  true
 x = 5
 5 == x  true
 y = 3
 y != 3  false
Comparação entre Referências
 Cuidado ao utilizar o operador ==
 Compara endereços de memória e não conteúdo de 
objetos
 Exceção: Strings
111
30.0
x y==
?
111
30.0
111
30.0
yx ==
?
Comparação entre Referências
 Para comparar o conteúdo dos objetos, utilize o 
método equals()
 Só iremos estudar esse método para outros tipos
além String quando outros conceitos forem
apresentados…
 Por hora, é suficiente saber que:
 equals() 
 Comparações dentro do Heap da JVM
 ==
 Comparações fora do Heap da JVM
Comparação entre Strings
 Se duas Strings foram criadas como literais, 
compará-las com == ou equals() resultará no 
mesmo valor
 De fato, só existe um objeto
 Quando uma ou ambas as Strings comparadas
foram criadas com o operador new, o resultado
será diferente
 Existem 2 objetos distintos
 == compara as referências
 equals() compara o conteúdo dos objetos
Comparação entre Strings: Exemplo
String s1 = “casa”;
String s2 = “casa”;
String s3 = new String(“casa”);
s1 == s2; //true
s1.equals(s2); //true
s1 == s3; // false
s1.equals(s3); //true
Logo, é mais seguro comparar Strings com equals()
Operadores Lógicos
 Aplicam-se apenas à valores booleanos 
(expressões que resultem em true ou false)
 Operadores booleanos
Operador Símbolo Descrição
Negação (NOT) ! -
Conjunção condicional (AND) && Operador de abreviação
(Nem sempre verifica os dois lados
da expressão)
Disjunção condicional (OR) || Operador de abreviação
Conjunção lógica (AND) & Verifica os dois lados da expressão
Disjunção lógica (OR) | Verifica os dois lados da expressão
Disjunção exclusiva (XOR) ^ Verifica os dois lados da expressão
Operadores Lógicos: Tabela Verdade
X Y X && Y X & Y X || Y X | Y X ^ Y
false false false false false false false
false true false false true true true
true false false false true true true
true true true true true true false
X !X
false true
true false
O resultado é true se exatamente 
um dos operandos for true
Operadores Lógicos: Exemplo
int x = 10, y = 5;
if( y%2==0 && x>++y){}
System.out.println("x = "+x); //x = 10
System.out.println("y = "+y); //y = 5
if( y%2==0 & x>++y){}
System.out.println("x = "+x); //x = 10
System.out.println("y = "+y); //y = 6
Como a 1ª expressão é 
false, a 2ª nem é avaliada
Mesmo a 1ª expressão 
sendo false, a 2ª é avaliada
Modificador final
 Aplicável à classes, métodos e variáveis
 Por hora, veremos apenas aplicado à variáveis
 Uma variável final não pode ser alterada após ser 
inicializada
 Se for atributo, precisa ser explicitamente inicializada na
declaração ou no construtor (em todos eles)
 Se for variável local, pode ser declarada e posteriormente
inicializada
Atributo final: Exemplo
public class Cliente {
private String nome;
private final String cpf; 
private Enderecoendereco;
public Cliente (String n, String cod, Endereco end){
this.nome = n;
this.cpf = cod;
this.endereco = end;
} 
cpf não pode ser 
modificado depois 
que é inicializado
Atributo final: Atenção!
public class Conta{
private String numero;
private double saldo;
private final Cliente titular; 
//titular vai ser inicializado no construtor
} 
O titular da conta não 
pode ser alterado
public class Cliente{
private String nome;
private final String cpf;
...
public void setNome(String n){
nome = n;
}
} 
O objeto referenciado por 
titular pode ser alterado! 
Logo, é possível chamar o 
método setNome()
Constante de Classe
 Quando o atributo também é final e static, é 
denominado uma constante (de classe)
 Por convenção, o identificador de uma constante
deve ter todas as letras maiúsculas
 Junção de palavras com “_”
 A constante deverá ser inicializada na declaração
public class Conta{
public static final int AGENCIA = 236;
...
}
Modificar final: Atenção!
 Variáveis marcadas como final não podem ser 
incrementas ou decrementadas
final int x = 5;
int y = x++;