poo - 07 - operadores do java

Fundamentos da Linguagem Java

Programação Orientada a Objetos

Ludimila Monjardim Casagrande 2012

Operadores, literais, estruturas de

decisão e de controle.

Fundamentos do Java ©2012 Ludimila Monjardim Casagrande 2

Literais

Um literal é um valor definido no código-fonte,

ao contrário de um valor definido em tempo de

execução.

Literais podem representar strings (arrays de

caracteres) ou tipos primitivos.

Literais aparecem do lado direito de uma

atribuição ou em chamadas de métodos.


Literais

Literais boolean:

Os únicos literais válidos para o tipo boolean são

true e false.

Exemplo:

boolean isEmpty = true;

boolean isEmpty = false;

Uso incorreto:

boolean isEmpty = “true”; // erro de compilação


Literais

Literais char:

São representados entre ‘ ’.

Um literal char pode ser qualquer caracter Unicode.

Exemplos:

char c = ‘z’;

char c2 = ‘\n’;

char c3 = ‘\t’;

char c1 = ‘\u0041’; // equivale ao caracter ‘A’

‘\u????’: substituir ???? pelos 4 dígitos hexadecimais

correspondentes ao caracter na tabela Unicode.


Literais

Literais do tipo String:

String não é um tipo primitivo e sim uma classe.

A classe String pertence à package java.lang.

Literais do tipo String são representados entre “ ”.

Exemplo:

String str = “Olá!”;

Uso incorreto:

String str = ‘Olá!’; // erro de compilação


Literais

Literais inteiros:

Podem ser expressos em decimal, octal e hexadecimal. O default é a base decimal.

O prefixo 0 indica a base octal.

O prefixo 0x ou 0X indica a base hexadecimal.

Exemplos:

int i = 28;

int i = 034;

int i = 0x1C;

int i = 0X1c;


Literais

Literais ponto-flutuante:

Um literal ponto-fluante deve conter casas

decimais (ex.: 1.0) ou:

a letra E ou e, indicando notação científica: 4.3E+21

o sufixo F ou f, indicando um literal float: 1.83f

o sufixo D ou d, indicando um literal double: 123d

Um número com casas decimais sem o prefixo f ou

d é considerado por default double.


Intervalos de Valores dos Primitivos

Intervalos de valores dos tipos primitivos inteiros do Java:

*

* byte: -128 a 127 e short: -32768 a 32767, por exemplo

*

Considerações sobre Tipos Primitivos


public class Primitivos {

public static void main(String[ ] args) {

byte b = 1;

short s = 1;

int i1 = 1;

int i2 = 2147483647;

int i3 = 2147483648; //erro de compilação

long l1 = 2147483648; //erro de compilação, inteiro muito longo

long l2 = 2147483648l;

float f1 = 1.0; //erro de compilação

float f2 = 1.0f;

double d1 = 1.0;

double d2 = 1.0f;

}

}

As demais linhas não

geram erros.


Operadores da Linguagem Java

Os principais operadores da linguagem Java

são os:

Unários

Aritméticos

de Comparação

Lógicos (ou Booleanos)

de Atribuição

Condicionais


Operador de Atribuição

Após uma variável ser declarada, ela pode ser inicializada com diferentes valores. Para isso, usamos o operador de atribuição =.

Exemplos:

int x = 10;

boolean condicao = false;

char c = ‘A’;

long l = 1234L;

float f = 1.23f;

double d = 1.23d;


Operador de Atribuição

A ordem de avaliação dos operandos em uma expressão é sempre da esquerda para a direita.

A ordem de execução da operação de atribuição é sempre da direita para a esquerda.

A avaliação dos operandos sempre antecede a execução das operações.

Sendo assim, qual é o resultado do código abaixo?

1. int[ ] a = {4, 4};

2. int b = 1;

3. a[b] = b = 0;

Resultado:

a[1] = 0;

então a = {4, 0}


Operadores Unários

Os principais operadores unários do Java

são:

Operadores de incremento e decremento: ++ , --

Operadores mais e menos: + , -

Operador de negação: !


Operadores de Incremento e Decremento

Os operadores para incremento e decremento

são, respectivamente, ++ e --.

Tais operadores podem ser usados na forma

pós-fixada (x++) ou pré-fixada (++x).

A diferença só existe quando o operador

aparece em expressões. A forma pré-fixada faz

a adição/subtração primeiro; a pós-fixada avalia

o valor antigo, depois incrementa/decrementa a

variável.


Operadores de Incremento e Decremento

Valor inicial de x Expressão

5 y = x++;

5 y = ++x;

5 y = x--;

5 y = --x;

Valor final de y Valor final de x

5 6

6 6

5 4

4 4


Operadores Unários Mais e Menos

Os operadores unários + e – somente indicam se o valor é positivo ou negativo, respectivamente.

Tais operadores não se aplicam a booleanos.

Podem ser aplicados a expressões e a variáveis do tipo char.

Exemplos:

char c = 10;

int i = -c;

int j = - (i + 6);


Operadores Unários Mais e Menos

Os operadores unários + e – promovem a

expressão para int.

Sendo assim, o trecho de código abaixo

apresentaria um erro na linha 3:

1. byte b1 = 1;

2. byte b2 = 127;

3. byte b3 = -b1; //erro: o operador – promoveu a

//expressão para int


Operador de Negação

O operador unário ! causa a negação de uma

expressão booleana.

Sendo assim, só se aplica a variáveis e

expressões booleanas.

Exemplo:

boolean a, b, c;

a = true;

b = !a;

c = !(a && b);

Resultado:

c = true


Operadores Aritméticos

Os operadores aritméticos habituais: +, -, * e /,

são usados para adição, subtração,

multiplicação e divisão, respectivamente.

O operador / denota divisão inteira, se os dois

argumentos forem inteiros, e divisão de ponto

flutuante, caso contrário.

Existe ainda o operador % usado para se obter

o resto da divisão inteira entre dois números.


Operadores Aritméticos

Os operadores aritméticos aplicam-se a todos

os tipos primitivos numéricos e ao tipo char.

A divisão inteira por zero (incluindo a operação

de módulo) gera uma ArithmeticException.

Divisões por zero incluindo tipos ponto-flutuante

não geram exceções.

O uso dos operadores aritméticos promovem a

expressão para, no mínimo, int.


Operadores de Comparação

Os operadores de igualdade e desigualdade em

Java são, respectivamente, == e !=.

Exemplos:

(3 == 4) resulta em false

(3 != 4) resulta em true

Observe que esses operadores também podem

ser aplicados a operandos booleanos.


Operadores de Comparação

Os outros operadores de comparação são:

> maior que

>= maior ou igual que

< menor que

<= menor ou igual que

Observe que não faz sentido aplicar tais

operadores a operandos booleanos.

O resultado de uma comparação em Java é

sempre um valor booleano.


Operadores Lógicos

Os operadores lógicos em Java são:

&& e lógico

| | ou lógico

Esses operadores são aplicáveis somente a

operandos ou expressões booleanas e o

resultado também é sempre booleano.


Operadores Lógicos

Com o uso dos operadores && e I I é possível obter o resultado sem que a expressão completa tenha sido avaliada, isto é, fazendo somente uma avaliação parcial.

Exemplo:

(a && b)

Se a for avaliado como falso, então b não precisa e não será avaliado, pois se a é falso já é possível afirmar que a && b é falso.


Operador Condicional

Existe um operador condicional em Java que sintetiza a função do comando if/else.

Esse operador é ? :, que é considerado um operador ternário por necessitar de três operandos.

Exemplo:

a ? b : c;

o primeiro operando, no caso a, deve ser um valor ou expressão booleana

se a for verdadeiro, o resultado será b

caso contrário, o resultado será c


Operador Condicional

Exemplo: if (Character.isUpperCase(aChar)) {

System.out.println(“O caractere " + aChar + " é upper case.");

} else {

System.out.println(" O caractere " + aChar + " é lower case.");

}

Usando o operador condicional o código ficaria assim:

System.out.println(" O caractere " + aChar + " é " + (Character.isUpperCase(aChar) ? "upper" : "lower") + "case.");


Precedência de Operadores em Java

Ordem descendente de precedência:

Categoria Operador

Unários ++ -- + - !

Aritméticos * / %

+ -

Comparação

< <= > >=

== !=

Lógicos && | |

Condicional ? :

Atribuição =


Escopo de um Bloco

O controle de fluxo de aplicações Java é organizado em

blocos. Um bloco ou conjunto de instruções/comandos em

Java é delimitado por { e }.

Uma variável declarada dentro de um bloco é visível somente

dentro do bloco.

Exemplo: ...

{

int i = 0;

i = i + x;

...

}

x = i; // erro, pois i foi declarada dentro do bloco anterior a

// essa linha, e não é visível fora do bloco.


Estrutura Condicional

A estrutura condicional mais simples em Java é:

if (condição)

instrução;

Quando for necessário executar um conjunto de instruções, dada uma condição, usamos um bloco de instruções ou bloco de código.

if (condição) {

instrução 1;

instrução 2;

...

instrução n;

}



Assim como a maioria das linguagens, Java

também possui a construção if com o else

associado.

if (condição)

instrução; //se a condição for verdadeira

else

instrução; //se a condição for falsa

O else é sempre uma parte opcional neste

comando.



Exemplo:

double nota;

nota = 6.0;

if (nota < 0.0) {

System.out.println(“Erro: A nota não pode ser negativa.”);

} else if (nota >= 6.0) {

System.out.println(“Aluno aprovado.”);

} else {

System.out.println(“Aluno reprovado.”);

}


Estrutura para Seleção Múltipla

Há casos em que vários

testes têm que ser feitos

em sequência, e vários

comandos if podem ser

substituídos pelo comando

switch.

O comando switch também

expressa alternativas de

execução, mas nesse caso

as condições estão restritas

à comparação de uma

variável inteira com valores

constantes.

Sintaxe:

switch(variável){ case 1: ... break; case 2: ... break; ... case n: ... break; default: ... }



Exemplo: int x = 0;

switch(x){

case 1:

System.out.println(“Obteve um 1.”);

break;

case 2:

case 3:

System.out.println(“Obteve um 2 ou 3.”);

break;

default:

System.out.println(“Não obteve 1 nem 2 nem 3.”);

}



O switch faz a avaliação da variável inteira procurando por um case que coincida com o seu valor. Uma vez encontrado um case, todos os demais comandos case serão executados a menos que um comando break seja encontrado.

A cláusula default é opcional e suas instruções são executadas caso nenhuma opção de case tenha sido executada.

O comando switch pode ser executado com operando do tipo char, byte, short ou int.


Estruturas Iterativas (laços)

Java possui três comandos iterativos:

while,

do-while e

for


Estruturas Iterativas

Sintaxe do comando while: while (condição)

instrução;

Nesse caso, a instrução é executada se e enquanto a condição for verdadeira.

Exemplo:

int x = 0;

while (x < 10) {

System.out.println(x++);

}



Sintaxe do comando do-while: do {

instrução;

} while (condição);

Semelhante ao while, a diferença é que nesse caso a instrução sempre será executada pelo menos uma vez. Exemplo:

int x = 0;

do {

System.out.println(x++);

} while (x < 10);



Sintaxe básica do comando for:

for (inicialização; condição; incremento)

instrução;

Exemplo:

for (int i = 0; i < 10; i++){

System.out.println(i);

}



Exemplo:

for (int i = 0; i < 10; i++){


}

Observe que a variável i é declarada dentro do

for, sendo assim essa variável só é acessível

dentro do bloco definido para o for.

Uma variável de nome i pode até ser declarada

depois do for que não haverá problema.



Os comandos continue e break permitem

expressar a quebra de um fluxo de execução.

O uso de break já foi utilizado juntamente com

switch para delimitar bloco de comandos de

cada case.

No corpo de uma iteração, a ocorrência do

comando break interrompe a iteração, passando

o controle para o próximo comando após o

comando de iteração.



O comando continue também interrompe a

execução da iteração, mas apenas da iteração

corrente.

Como efeito da execução de continue, a

condição de iteração é reavaliada e, se for

verdadeira, o comando de iteração continua

executando.



Exemplo:

for (int i = 0; i < 10; i++){

if( i % 3 == 0) {

System.out.println(i + “ é múltiplo de 3”);

continue;

}


}


Tutoriais do Java

The Java Tutorials

Getting Started

http://java.sun.com/docs/books/tutorial/getStarted/

Learning the Java Language

http://java.sun.com/docs/books/tutorial/java/

http://java.sun.com/docs/books/tutorial/getStarted/

http://java.sun.com/docs/books/tutorial/java/


Referências

Complete Java 2 Certification

Study Guide

Sybex

Java: Como programar

Autores: H. M. Deitel e P. J. Deitel

Editora: Pearson – 6ª Edição

poo - 07 - operadores do java

Technology