Programação Orientada a Objetos e a Linguagem Java

(1)

Programação Orientada a Objetos e a Linguagem Java

Rodrigo da Cruz Fujioka rodrigofujioka@gmail.com

(2)

Operadores e controle de Fluxo da

Execução

(3)

Operadores e controle de Fluxo da

Execução

(4)

Operadores e controle de Fluxo da Execução

• Este módulo explora as estruturas procedurais da linguagem Java

• Operadores

– Aritméticos, lógicos, binários, booleanos, de deslocamento, de concatenação, de conversão, ...

• Conversão de tipos

– Promoção

– Coerção (cast)

• Estruturas de controle de execução

– if-else

– for, while, do-while

– break, continue, rótulos – switch (case)

(5)

Identificadores.

• Identificadores são palavras utilizadas para nomear variáveis, métodos e classes.

• Não se pode utilizar palavras reservadas, devendo começar com

uma letra, $ ou _, podendo contudo utilizar números como parte do identificador.

Válidos: louco intGrande $valor1

• Válidos: louco intGrande $valor1

• Inválidos: 3_variavel !verdade

• Java é uma linguagem “case-sensitive”, ou seja, MAIÚSCULAS minúsculas

• Total e total são identificadores distintos

(6)

Palavras Reservadas.

• Palavras que não podem ser utilizadas como

identificadores.

(7)

Tipos de Dados

• Java é uma linguagem fortemente tipada. Assim, cada variável declarada no escopo da aplicação deve ter um tipo definido, seja ele primitivo ou objeto.

– Tipos Primitivos – São unidades indivisíveis de dados, que possuem tamanho fixo

que possuem tamanho fixo

– Tipos Objetos – São estruturas complexas, que representam diversos dados

• Algumas classes são utilizadas para representar

tipos primitivos sob forma de objeto, estas são

denominadas classes Wrappers.

(8)

Tipos Primitivos de Dados

• Um tipo primitivo é definido por um conjuntode valores.

– Exemplo: int = conjunto dos números inteiros

• As seguintes palavras reservadas definem oito tipos primitivos de dados:

tipos primitivos de dados:

– byte, short, int, long – float, double

– char

– boolean

(9)

Tipos Primitivos - Inteiros

(10)

Wrappers - Inteiros

• Alguns Métodos – Integer:

– parseInt(String s) – transforma uma string em inteiro – toString(int i) – transforma um inteiro em string

– toHexString(int i) – transforma um long em hexadecimal

hexadecimal

• Alguns Métodos – Long:

– parseLong(String s) – transforma uma string em long – toString(long l) –

transforma um long em string

– toHexString(long l) –

transforma um long em hexadecimal

(11)

Tipos Primitivos - Reais.

(12)

Wrappers - Reais

• Alguns Métodos – Float:

– parseFloat(String s) – transforma uma string em float – toString(float f) – transforma um float em String

• Alguns Métodos – Double:

– parseDouble(double d) – transforma uma string em double – toString(double d) – transforma um double em String

(13)

Tipos Primitivos - Caracteres

• Em Java, utiliza-se o padrão Unicode

– Conjunto de caracteres de 16 bits = 65536 caracteres são disponíveis!

– Atualmente, ele foi expandido para 32bits = 4 bilhões

• Caracteres Unicode são gravados em arquivos

• Caracteres Unicode são gravados em arquivos usando um formato chamado UTF-8, UTF-16 ou UTF-32

• É possível inserir caracteres Unicode no código fonte utilizando-se do formato \uXXX

– Ex.: \u0057 = W

(14)

Tipos Primitivos - Caracteres

• Um char armazena um caractere do conjunto Unicode.

• O Unicode é um conjunto internacional, contendo os

caracteres de várias línguas no mundo.

(15)

Wrappers - Caracteres

• Alguns Métodos - Character:

– isLowerCase(char ch) – verifica se é uma letra minúscula – isUpperCase(char ch) – verifica se é uma letra maiúscula – isDigit(char ch) – verifica se é um dígito numérico

– isDigit(char ch) – verifica se é um dígito numérico – isLetter(char ch) – verifica se é uma letra

– isWhiteSpace(char ch) – verifica se é um espaço – toLowerCase(char ch) – transforma para minúscula – toUpperCase(char ch) – transforma para maiúscula

(16)

Tipos Primitivos - Booleanos

• Um valor booleano representa uma condição Verdadeira ou Falsa.

• As palavras reservadas true e false, são os únicos valores válidos.

(17)

Tipos Primitivos - Booleanos

• Classe Boolean

–Duas constantes:

• Boolean.TRUE

• Boolean.FALSE

–Alguns Métodos:

• parseBoolean(String s) – transforma uma string em booleano

• toString(boolean b) – transforma um booleano em string

(18)

Variável

• Uma variável é um identificador que representa uma posição na memória capaz de armazenar um tipo específico de dado

• As variáveis devem ser declaradas antes de serem utilizadas:

TipoVariavel nomeVariavel;

• Variáveis podem ser declaradas na mesma linha

• Variáveis podem ser inicializadas no momento da declaração

int total, count, sum;

double unitPrice = 57.25;

(19)

A Palavra Reservada final

• A palavra final é usada para limitar o uso das classes, variáveis e métodos.

– Impede que implementações ou valores sejam alterados.

• Utilizada para definir:

– Constantes – Constantes – Métodos – Classes

(20)

A Palavra Reservada final - Constantes

• Constantes são especificadas utilizando-se a palavra reservada final.

public static final double TAXA_JUROS = 0.5;

• Uma constante é similar a uma variável, com exceção de que o seu valor não pode ser alterado.

• Constantes são úteis pois:

– Tornam a leitura do código mais fácil

– Facilitam mudanças, uma vez que o valor é especificado apenas em um único lugar

• Qualquer variável declarada como final tem que ser inicializada no momento da declaração

(21)

A Palavra Reservada final - Constantes

(22)

A Palavra Reservada final - Métodos

• Método cujas implementações não podem ser redefinidas nas sub-classes.

• O final impede que o método seja sobrescrito (overriding) na subclasse

(23)

A Palavra Reservada final - Classes

• Uma classe também pode ser declarada como final public final class MinhaClasse { ... }

• Não é possível estender (herdar de) uma classe final.

• Útil em classes cujo o comportamento é bem definido e que não faz sentido modificá-las.

– Ex: classes que implementam funções matemáticas.

(24)

A Palavra Reservada final - Classes

• Uma classe também pode ser declarada como final public final class MinhaClasse { ... }

• Não é possível estender (herdar de) uma classe final.

• Útil em classes cujo o comportamento é bem definido e que não faz sentido modificá-las.

– Ex: classes que implementam funções matemáticas.

(25)

Operadores

• Um operador produz um novo valor a partir de um ou mais argumentos

• Os operadores em Java são praticamente os mesmos encontrados em outras linguagens

+, -, /, *, =, ==, <, >, >=, &&, etc.

• A maior parte dos operadores só trabalha com valores de tipos primitivos

• Exceções:

+ e += são usados na concatenação de Strings

!=, = e == são usados também com objetos (embora não funcionem da mesma forma quanto aos valores armazenados nos objetos

(26)

Operadores

(27)

Tabela de Precedência Java.

(28)

Literais de Caracteres Java.

(29)

Operadores

• A precedência determina em que ordem as operações em uma expressão serão realizadas

– Por exemplo, as operações de multiplicação são realizadas antes de operações de soma:

int x = 2 + 2 * 3 – 9 / 3; // 2+6-3 = 5

• Parênteses podem ser usados para sobrepor a precedência

precedência

int x = (2 + 2) * (3 – 9) / 3; // 4*(-6)/3 = -8

• A maior parte das expressões de mesma precedência é calculada da esquerda para a direita

int y = 13 + 2 + 4 + 6; // (((13 + 2) + 4) + 6)

– Há exceções. Por exemplo, atribuição.

(30)

Operadores de Atribuição

• Uma atribuição segue a seguinte sintaxe:

– variable-name = expression;

• A expressão é avaliada e o resultado é armazenado na variável, sobrescrevendo o valor existente.

• ‘=’ serve apenas para atribuição, em comparações usa- se ‘==’.

– Copia o valor da variável ou constante do lado direito para a variável do lado esquerdo

x = 13; // copia a constante inteira 13 para x y = x; // copia o valor contido em x para y

(31)

Operadores Aritméticos

+ adição

- subtração

* multiplicação / divisão

Operadores unários Operadores unários

-n

e

+n

(ex.: -23) (em uma expressão: 13+ -12) Melhor usar parênteses: 13 + (-12)

Atribuição com operação

+=, -=, *=, /=, %=

x = x + 1

; equivale a

^{x += 1;}

(32)

Operadores Aritméticos

(33)

Operadores Aritméticos

• Atribuições abreviadas

– x += 4 equivale a x = x + 4, – existem ainda -=, *=, /= e %=

• Cuidado: o resultado da divisão depende do tipo dos operandos.

operandos.

– Tipo inteiro: o resultado é a divisão inteira int resultado = 10/4 //igual a 2

– Tipo ponto flutuante: o resultado é a divisão

“normal”

float resultado = 10f/4f // igual a 2,5

(34)

Operadores Aritméticos

• Menos unário e mais unário

– Criação de números negativos ou positivos

– x = +a * -b;

– x = a * (-b);

(35)

Operadores de Incremento

• Exemplo

int a = 10;

int b = 5;

• Incrementa ou decrementa antes de usar a variável

int x = ++a; // a contém 11, x contém 11 int y = --b; // b contém 4, y contém 4 int y = --b; // b contém 4, y contém 4

– a atribuição foi feita DEPOIS!

• Incrementa ou decrementa depois de usar a variável

int x = a++; // a contém 11, x contém 10 int y = b--; // b contém 4, y contém 5

– a atribuição foi feita ANTES!

(36)

Operadores de Incremento

• Exemplo

int a = 10;

int b = 5;

• Incrementa ou decrementa antes de usar a variável

int x = ++a; // a contém 11, x contém 11 int y = --b; // b contém 4, y contém 4 int y = --b; // b contém 4, y contém 4

– a atribuição foi feita DEPOIS!

• Incrementa ou decrementa depois de usar a variável

int x = a++; // a contém 11, x contém 10 int y = b--; // b contém 4, y contém 5

– a atribuição foi feita ANTES!

(37)