Orientação a Objetos e a Linguagem Java

(1)

Orientação a Objetos e a Linguagem Java

Afrânio Assis [email protected]

(2)

Novembro/2006 2

(3)

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 • Inválidos: 3_variavel !verdade

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

(4)

Novembro/2006 4

Palavras reservadas

• Palavras reservadas que não podem ser utilizadas como identificadores.

abstract assert boolean break byte case catch char class const continue default do double else extends final finally float for goto if implements import instanceof int interface long native new package private protected public return short static super switch synchronized this throw throws transient try void volatile while

(5)

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

– 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.

(6)

Novembro/2006 6

Tipos Primitivos de Dados

• Um tipo primitivo é definido por um conjunto

de valores.

– Exemplo: int = conjunto dos números inteiros

• As seguintes palavras reservadas definem

oito tipos primitivos de dados:

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

– char

(7)

Tipos Primitivos - Inteiros

Tipo Formato Descrição / Tamanho

byte 8-bits Inteiro de 1 byte

-128 a +127 (-27 _{a 2}7 _{– 1)} short 16-bits Inteiro curto ( 2 bytes)

-32.768 a +32.767 (-215 _{a 2}15 _{– 1)}

int 32-bits Inteiro (-2,147,483,648 a +2,147,483,647) (-231 _{a 2}31 _{– 1)}

long 64-bits Inteiro longo (-9.223.372.036.854.775.808 a) +9.223.372.036.854.775.807 (-263 _{a 2}63 _{– 1)}

(8)

Novembro/2006 8

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

• 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

(9)

Tipos Primitivos - Reais

float 32-bits Números reais, precisão simples

-3.4 x 1038 _{a 3.4 x 10}38 (6-7 dígitos) double 64-bits Ponto flutuante, precisão dupla

(10)

Novembro/2006 10

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

(11)

Tipos Primitivos - Caracteres

• Um char armazena um caractere do conjunto Unicode.

• O Unicode utiliza 16 bits para representar um caractere, possibilitando 65.536 caracteres

distintos.

• O Unicode é um conjunto internacional, contendo os caracteres de várias línguas no mundo.

(12)

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 – 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

(13)

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.

(14)

Novembro/2006 14 Wrappers - 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

(15)

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;

(16)

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 – Métodos

(17)

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

(18)

Digite o valor do Raio: 5

Circunferencia: 31.415927 Area: 78.5398175

(19)

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

public class Circulo {

public final double calcularArea ( ) { ...

} }

(20)

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.

(21)

Operadores

• Um operador combina um ou mais valores em um único valor.

• Exemplos: +, -, *, /, = • Operadores Java:

– Operadores Unários: apenas um operando – Operadores Binários: dois operandos

• Notação:

(22)

Operador 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 ‘==’.

(23)

class Number {

int i; }

public class Assignment {

public static void main(String[] args) { Number n1 = new Number();

Number n2 = new Number(); n1.i = 9;

n2.i = 47;

System.out.println("1: n1.i: " + n1.i +

", n2.i: " + n2.i); n1 = n2;

", n2.i: " + n2.i); n1.i = 27;

(24)

Operador de Atribuição

• Atribuição de primitivos

– a = b, cópia de valores de b para a

• Atribuição de objetos

– obj2 = obj1, cópia de referências para objetos

– obj2 e obj1 agora referenciam o mesmo objeto que

(25)

C:\...>javac Assignment.java C:\...>java Assignment

1: n1.i: 9, n2.i: 47 2: n1.i: 47, n2.i: 47 3: n1.i: 27, n2.i: 27

(26)

Operador Utilização Descrição

+ op1 + op2 Soma op1 e op2 - op1 - op2 Subtrai op2 de op1 * op1 * op2 Multiplica op1 por op2 / op1 / op2 Divide op1 por op2

% op1 % op2 Calcula o resto da divisão de op1 por op2

(27)

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.

– 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

(28)

Operadores Aritméticos

• Menos unário e mais unário

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

x = +a * -b; x = a * (-b);

(29)

Operadores de Incremento e Decremento

• Operadores unários – Incremento e Decremento

– variável++ equivalente a variável = variável + 1 – variável-- equivalente a variável = variável – 1

• Notação posfixa: Incrementa ou decrementa depois de usar a variável

– variável++ variável

--• Notação prefixa: Incrementa ou decrementa antes de usar a variável

(30)

Operadores de Incremento e Decremento

• Exemplo:

int a = 10; int b = 5;

int x = ++a; // a contém 11, x contém 11

int y = --b; // b contém 4, y contém 4

A atribuição é realizada DEPOIS!

int x = a++; // a contém 11, x contém 10

int y = b--; // b contém 4, y contém 5

(31)

Operadores Relacionais

Operador Utilização Retorna True se

> op1 > op2 op1 é maior que op2

>= op1 >= op2 op1 é maior ou igual a op2 < op1 < op2 op1 é menor que op2

<= op1 <= op2 op1 é menor ou igual a op2 == op1 == op2 op1 e op2 são iguais

(32)

• Sempre geram um valor boolean

• Operadores >, <, >=, <= não funcionam para boolean

• Operadores == e != funcionam para objetos, mas CUIDADO: eles comparam as referências!

(33)

Operador Utilização Significado

&& op1 && op2 Faz o “e” lógico entre op1 e op2 || op1 || op2 Faz o “ou” lógico entre op1 e op2

(34)

• Aplicáveis apenas para valores boolean. • Observe que o ! é um operador unário

• Curto-circuito de avaliação de expressões

– Vai avaliando até que o resultado possa ser determinado sem ambigüidades

boolean b = true;

int i = 1;

if (b || i++ > 2)

...

(35)

Operador de Concatenação

• Se uma expressão contém uma string todos os tipos após a string são convertidos para o tipo string

– Tipos primitivos: conversão interna do compilador

– Tipos referência: executa método toString() herdado da classe Object

String s = 1 + 2 + 3 + “=” + 4 + 5 + 6;

(36)

Expressões

• Uma expressão consiste em uma combinação de operadores e operandos.

• Exemplos:

4 + 5 x * 2.73 a - (7 - b)

(37)

Expressões - Precedência

• 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 impor precedência

(38)

Novembro/2006 38 Expressões - Precedência =, +=, -=, *=, /=, %= Atribuição &&, ||, ! Lógicos >, <, ==, <=, >=, != Relacionais *, /, %, +, -Aritméticos e Deslocamento de bits +, -, ++, --Unários Operador Categoria do Operador

(39)

Expressões - Precedência a + b + c + d + e 1 2 3 4 a + b * c - d / e 3 1 4 2 a / (b + c) - d % e 2 1 4 3 4 3 2 1 a / (b * (c + (d - e)))

(40)

Conversão de Tipos Primitivos

• Promoção:

– Expressões com dois ou mais operandos de tipos distintos passarão por uma conversão automática, onde os operandos são convertidos para o tipo mais abrangente.

• Em outros casos, a JVM também pode realizar conversões automáticas, sempre com a garantia de que não haverá perca de informação.

(41)

(42)

Conversão Explícita

• Em casos como:

int a = 1234;

long b = a;

• A conversão ocorre de forma implícita, pois o tipo de b é mais abrangente.

• Algumas vezes é necessário fazer uma

conversão de forma explicita, denominada casting.

float b = 1.4f;

int c = (int) b;

int d = (int) (b/0.7f);

• Nesses casos o programador assume os riscos de perda de informação

(43)

Controle de Fluxo

• Por padrão, a ordem de execução de um

programa é linear: um comando após o outro.

• Entretanto, podemos alterar essa ordem, através de instruções que controlam o fluxo de

execução:

– Decisão: if-else, switch-case – Repetição: for, while, do-while

– Desvios (somente em estruturas de repetição): continue, break

• Não existe o comando goto, porém, esta é uma palavra reservada (keyword) da linguagem

(44)

Novembro/2006 44 Estrutura if condição avaliada false comando true condição avaliada comando 1 true false comando 2

(45)

Estrutura if

• Possui a forma • ou a forma

• Onde “comando” pode ser um comando simples ou um bloco de comandos (conjunto de

comandos delimitado por { } ) if (expressao_booleana) comando else comando if (expressao_booleana) comando

(46)

public class ExemploIfElse {

static int test(int testval, int target) {

int result = 0;

if(testval > target)

return +1;

else if(testval < target)

return -1;

else

return 0; // Match

public static void main(String[] args) { System.out.println(test(10, 5));

System.out.println(test(5, 10)); System.out.println(test(5, 5)); }

(47)

(48)

Estrutura switch

• O break é utilizado como último comando de cada bloco case.

• O break causa o desvio do controle de execução para o final do comando switch.

• Se o break não for utilizado, o fluxo de controle continua no próximo case.

• O switch pode ter uma clausula opcional default, que será executada se nenhuma das clausulas case forem satisfeitas.

(49)

import java.io.IOException;

public class Vogais {

public static void main(String[] args) throws IOException{

char c = (char) System.in.read(); c = Character.toLowerCase(c); switch(c) { case 'a': case 'e': case 'i': case 'o':

case 'u': System.out.println("Vogal");

break;

default: System.out.println("Não é uma vogal"); }

(50)

Estruturas de Repetição

• Estruturas de repetição possibilitam executar uma série de comandos inúmeras vezes,

normalmente referenciadas como loops. • Java possui três estruturas de repetição:

– while

– do while – for

(51)

A Estrutura while comando true condição avaliada false

(52)

A Estrutura while

while (expressao_booleana) comando

• Possui a forma:

• Onde “comando” pode ser um comando simples ou um bloco de comandos

(53)

(54)

Novembro/2006 54 A Estrutura do while true condição avaliada comando false

(55)

A Estrutura do while

• Possui a forma:

• Onde “comando” pode ser um comando simples ou um bloco de comandos

• A declaração do do-while é executada pelo menos uma vez.

do

comando

(56)

A Estrutura for

for (icialização; condição; passo) comando;

A inicialização contém

declarações e inicializações de variáveis, que são

executadas antes do início do loop

Os comandos são executados até que a condição se torne falsa

O passo é executado no final de cada iteração

(57)

comando true condição avaliada false incremento inicialização A Estrutura for

(58)

A Estrutura for

• Variáveis podem ser declaradas apenas para o escopo do comando for

• Na inicialização e no passo, instruções são separadas por vírgula

for(int i=0, j=1; i<10 && j != 11; i++, j++){ ...

(59)

(60)

break e continue

• break: interrompe a execução da estrutura (repetição ou switch) atual

– Continua com a próxima instrução, logo após o estrutura

• continue: interrompe a execução de uma iteração

– Testa a condição e reinicia o bloco com a próxima iteração

(61)

(62)

break e continue com Rótulos

• break e continue sempre atuam sobre o bloco de

repetição onde são chamados

• Em blocos de repetição contidos em outros blocos,

pode-se usar rótulos para fazer o break e continue

atuarem sobre blocos externos

• Os rótulos só podem ser usados antes de do, while e

for

• As chamadas só podem ocorrem dentro dos blocos de repetição

(63)

(64)

Comando return

• A palavra chave return tem duas finalidades

– Especifica que um método irá retornar (se o método não tiver sido declarado como void)

– Causa o retorno imediato a linha de controle imediatamente posterior à chamada do método