Orientação a Objetos e a Linguagem Java

Transcrição

1 Orientação a Objetos e a Linguagem Java Afrânio Assis afranio@gmail.com Novembro/2006 1

2 Tipos, Literais, Operadores e Controle de Fluxo 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 Total e total são identificadores distintos Novembro/2006 3

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 Novembro/2006 4

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. Novembro/2006 5

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 boolean Novembro/2006 6

7 Tipos Primitivos - Inteiros Tipo Formato Descrição / Tamanho byte 8-bits Inteiro de 1 byte -128 a +127 (-2 7 a 2 7 1) short 16-bits Inteiro curto ( 2 bytes) a (-2 15 a ) int 32-bits Inteiro (-2,147,483,648 a +2,147,483,647) (-2 31 a ) long 64-bits Inteiro longo ( a) (-2 63 a ) Novembro/2006 7

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 Novembro/2006 8

9 Tipos Primitivos - Reais Tipo Formato Descrição / Tamanho float 32-bits Números reais, precisão simples -3.4 x a 3.4 x (6-7 dígitos) double 64-bits Ponto flutuante, precisão dupla -1.7 x a 1.7 x (15 dígitos) Novembro/2006 9

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 tostring(double d) transforma um double em string Novembro/

11 Tipos Primitivos - Caracteres Um char armazena um caractere do conjunto Unicode. O Unicode utiliza 16 bits para representar um caractere, possibilitando caracteres distintos. O Unicode é um conjunto internacional, contendo os caracteres de várias línguas no mundo. Tipo Formato Descrição / Tamanho char 16-bits Unicode Um caractere UNICODE Novembro/

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 Novembro/

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. Tipo Formato Descrição / Tamanho boolean Depende da JVM Valor booleano true ou false Novembro/

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 Novembro/

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; double unitprice = 57.25; Novembro/

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 Classes Novembro/

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 Novembro/

18 Digite o valor do Raio: 5 Circunferencia: Area: Novembro/

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 ( ) {... } } Novembro/

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. Ex: classes que implementam funções matemáticas. Novembro/

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: operando1 operador operando2 Novembro/

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 ==. Novembro/

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; System.out.println("2: n1.i: " + n1.i + ", n2.i: " + n2.i); n1.i = 27; System.out.println("3: n1.i: " + n1.i + ", n2.i: " + n2.i); } } Novembro/

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 antes apenas obj1 referenciava Novembro/

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 Novembro/

26 Operadores Aritméticos 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 Novembro/

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 Novembro/

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); Novembro/

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 ++ variável --variável Novembro/

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 A atribuição é realizada ANTES! Novembro/

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!= op1!= op2 op1 e op2 não são iguais Novembro/

32 Operadores Relacionais Sempre geram um valor boolean Operadores >, <, >=, <= não funcionam para boolean Operadores == e!= funcionam para objetos, mas CUIDADO: eles comparam as referências! Novembro/

33 Operadores Relacionais 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!! op Negação lógica de op Novembro/

34 Operadores Relacionais 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)... Qual o valor de i? Novembro/

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 = = ; Resultado: s contém a String 6=456 Novembro/

36 Expressões Uma expressão consiste em uma combinação de operadores e operandos. Exemplos: x * 2.73 a - (7 - b) Novembro/

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 = * 3 9 / 3; // = 5 Parênteses podem ser usados para impor precedência int x = (2 + 2)*(3 9)/3; // 4*(-6)/3 = -8 Novembro/

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

39 Expressões - Precedência a + b + c + d + e a + b * c - d / e a / (b + c) - d % e a / (b * (c + (d - e))) Novembro/

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. Ex: passagem de parâmetros Novembro/

41 Conversão de Tipos Primitivos Novembro/

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 Novembro/

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 Novembro/

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

45 Estrutura if Possui a forma if (expressao_booleana) comando ou a forma if (expressao_booleana) comando else comando Onde comando pode ser um comando simples ou um bloco de comandos (conjunto de comandos delimitado por { } ) Novembro/

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)); } } Novembro/

47 Estrutura switch Novembro/

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. Novembro/

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"); } } } Novembro/

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 Novembro/

51 A Estrutura while condição avaliada true false comando Novembro/

52 A Estrutura while Possui a forma: while (expressao_booleana) comando Onde comando pode ser um comando simples ou um bloco de comandos Novembro/

53 A Estrutura while Novembro/

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

55 A Estrutura do while Possui a forma: do comando while (expr_booleana); Onde comando pode ser um comando simples ou um bloco de comandos A declaração do do-while é executada pelo menos uma vez. Novembro/

56 A Estrutura for A inicialização contém declarações e inicializações de variáveis, que são executadas antes do início do loop O passo é executado no final de cada iteração for (icialização; condição; passo) comando; Os comandos são executados até que a condição se torne falsa Novembro/

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

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++){... } Novembro/

59 A Estrutura for Novembro/

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 Novembro/

61 break e continue Novembro/

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 Novembro/

63 break e continue com Rótulos Novembro/

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 Exemplos de sintaxe: Novembro/