Aula - 23.04.2015

1 public interface Despesa { 2     /** retorna a despesa mensal total */ 3     double getDespesaMensal(); 4     /** le da tela todos os dados para calculo da despesa */ 5     void setDados(); 6 }

Java2html

1 public class TestaDespesa { 2     public static void main (String[] args) { 3         Despesa d = new TransporteEAlimentacao(); 4         d.setDados(); 5         System.out.println (d.getDespesaMensal()); 6     } 7 }

Java2html

01 import java.util.Scanner; 02  03 public class Transporte implements Despesa { 04     double transporteMensal; 05     public double getDespesaMensal(){ 06         return transporteMensal; 07     } 08     public void setDados() { 09         Scanner sc=new Scanner (System.in); 10         System.out.println ("Quantas vezes você vai aa EACH no mes?"); 11         int n=sc.nextInt(); 12         System.out.println ("Quanto custa cada ida-e-volta?"); 13         double v=sc.nextDouble(); 14         transporteMensal=(double) n * v; 15     } 16 }

Java2html

01 import java.util.Scanner; 02  03 public class TransporteEAlimentacao extends Transporte { 04     double alimentacaoMensal; 05     public double getDespesaMensal(){ 06         return super.getDespesaMensal() + alimentacaoMensal; 07     } 08     public void setDados() { 09         super.setDados(); 10         Scanner sc=new Scanner (System.in); 11         System.out.println ("Quantas vezes você almoca na EACH no mes?"); 12         int n=sc.nextInt(); 13         System.out.println ("Quanto custa cada refeicao?"); 14         double v=sc.nextDouble(); 15         alimentacaoMensal=(double) n * v; 16     } 17 }

Java2html

Anotações

Perguntar aos alunos onde eles pesquisam sobre a linguagem.

Diferença entre retornar e imprimir na tela:
- Imprimir na tela é feito por System.out.println(...);
- retornar ocorre quando um método termina e a execução retorna ao fluxo de execução anterior. Neste momento é possível retornar um valor.

Caso o autor do método não deseje retornar nenhum valor, ele declara o método com tipo de retorno void. O retorno ocorre quando chega-se ao final do método ou quando for executado o comando return.

Caso deseje retornar um valor, ele declara o método com o tipo desejado. Desta forma ele se obriga a dizer o que quer retornar. Isto é feito passando um argumento no comando, ou seja: return <valor de retorno>. Todos os caminhos de computação existentes no código, inclusive os não usados, exigem return. Por exemplo:

int met (int a) {
    if (a>0) return 3;  // teste 1
    if (a<=0) return -3;  // teste 2
}

Ocorre erro na compilação do método acima pois há três caminhos de computação possíveis:

1-) teste 1 é true;
2-) teste 1 é false e teste 2 é true;
3-) teste1 e false e teste2 é false;

O caminho de computação 3 não tem return.

Alguém poderia dizer que o caminho 3 não ocorre pois a não pode assumir nenhum valor que torne os dois testes falsos. Concordo, MAS o compilador não analisa a lógica do código até esse nível, logo ele foi construído para exigir esse return.

Então o que retornar?? Já que não é executado, pode ser um valor qualquer?
Não é boa prática retornar um valor qualquer pois a maioria dos programadores espera que valores de retorno signifiquem algo, logo isto atrapalha o entendimento do código;
Nem sempre é tão fácil decidir se um caminho de computação será executado ou não (geralmente é difícil);
Programadores erram (e você também), embora sempre presumam que o que fazem funcionará corretamente. retornar um valor qualquer dificulta a localização de erros, fazendo você perder tempo e passar raiva.

Então o que é melhor fazer?
Reescrever o código para que ele não tenha caminhos que não são executados. Isto sempre é possível. No exemplo acima:


int met (int a) {
    if (a>0) return 3;  // teste 1
    return -3;  // se teste 1 é false, teste2 não é necessário pois será sempre true.
}
-----

Quero retornar mais de um valor (primitivo) com um return. Isso é possível?
Sim, você cria um objeto que contenha todos os valores e faz o método "retornar esse objeto".

------

Referências são variáveis através das quais acessa-se alguma outra entidade (por exemplo a instância de uma classe, um método ou outra variável).

Uma variável de tipo primitivo contém um valor que o tipo primitivo pode assumir. Por exemplo em
int a=125;

declaramos uma variável com identificador (nome) a, que contém 125.

Em objetos e tipos abstratos, por exemplo o Scanner normalmente faz-se:

Scanner sc= new Scanner( System.in );

esta linha especifica dois conjuntos de ações, por isso vou separá-la em duas:

Scanner sc;
sc=new Scanner( System.in );

a primeira linha é a declaração de uma variável com identificador (nome) sc, do tipo Scanner;

a segunda linha especifica dois subconjuntos de ações.
O operador de atribuição '=' opera sobre duas entidades (é binário) e armazena no operando da esquerda o valor contido no operando da direita.

O operando da direita é um comando 'new' aplicado a um método 'Scanner ( System.in )'.
O comando 'new' aloca quantidade de memória necessária para armazenar uma instância da classe  Scanner, inicializa estruturas de controle, invoca o método e retorna o ENDEREÇO para acessar o local de memória onde foi armazenada a instância.

0.0.0.17.8.3 - Usando particularidades da codificação de caracteres

001 import java.util.Scanner; 002 /** 003     Esta Ã© o aperfeiçoamento do código do Conversor4.  004     Usa uma particularidade da codificação de caracteres 005     para encurtar o código. 006 */ 007  008 public class Conversor5 { 009  010     /** 011         Este Ã© o ponto de entrada do programa: o método que Ã© invocado 012         pela JVM. 013         Pergunta ao usuário que conversor ele deseja usar e invoca 014         o método que faz a conversão. Permite também que o usuário 015         termine o programa e que refaça a escolha caso tenha digitado 016         uma opção que não existe. 017     */ 018     public static void main (String[] args){ 019         int opt=0; // opcao de conversao - usada somente neste método. 020  021         /* Valores não precisam sair do método. */ 022         Scanner sc=new Scanner (System.in); // leitor de teclado 023         do { 024             System.out.println ("1 para 10->12; 2 para 12->10; 3 para sair"); 025             System.out.println ("(inteiros - tipo diferente dá pau.)"); 026             opt=sc.nextInt(); 027             switch (opt) { 028                 case 1: // 10->12; 029                     dez2doze();   // invocação do método 030                     break; 031                 case 2: // 12->10; 032                     doze2dez();    // invocação do método 033                     break; 034                 case 3: break; 035                 default: 036                     System.out.println ("Digite novamente."); 037             } 038         } while (opt!=3); 039     } 040      041     /** Esta Ã© a declaração, ou definição do método. Dizemos como deve 042     ser a invocação (a assinatura do método) e o que ele deve fazer  043     (o bloco de código do método). 044     Este método pergunta ao usuário o valor inteiro na base 10 que 045     o usuário deseja converter, converte-o para um String que  046     representa o número na base 12 e o escreve na tela. 047     A conversão Ã© feita por divisões sucessivas. 048     */ 049     public static void dez2doze () { 050         int m;  // digito para conversor 10->12 - usado somente neste método 051  052         /* Valores não precisam sair do método. */ 053         int num10; // numero base 10 - destruido na conversao 054         String num12; // numero base 12; 055         Scanner sc=new Scanner (System.in); // leitor de teclado 056  057         System.out.println ("Digite o número decimal."); 058         System.out.println ("(inteiros - tipo diferente dá pau.)"); 059         num10=sc.nextInt(); 060         num12=""; 061         while (num10>0) { 062             m=num10%12; 063             num10/=12; 064             num12=(char)('A'+m)+num12; 065         } 066         System.out.println ("Resultado:" + num12); 067     } 068  069     /** 070     Este método pergunta ao usuário o valor na base 12 que 071     o usuário deseja converter, recebe-o como String, converte-o em  072     número inteiro na base 10 e o escreve na tela. 073     A conversão Ã© feita por soma de produto do dígito por potência. 074     */ 075     public static void doze2dez () { 076         /*i, c, numErr, len são usados somente neste método. */ 077         int i;  // contador para conversor 12 ->10 078         char c; // caracter corrente para conversor 12->10 079         boolean numErr; // flag de erro no numero base 12 080         int len;// comprimento do número base 12 081  082         /* Valores não precisam sair do método. */ 083  084         int num10; // numero base 10 - destruido na conversao 085         String num12; // numero base 12; 086         Scanner sc=new Scanner (System.in); // leitor de teclado 087  088         System.out.println ("Digite o número base 12."); 089         num12=sc.next(); 090         len=num12.length(); 091         numErr=false; 092         num10=0; 093         i=0; 094         while ((i<len)&&(!numErr)){ 095             c=num12.charAt(i); 096             i++; 097             num10*=12; 098             if ((c<'A')||(c>'L')) { 099                 System.out.println ("Erro dígito não corresponde a número."); 100                 numErr=true; 101             } 102             num10+=c-'A'; 103         } 104         if (!numErr) System.out.println ("Resultado:" + num10); 105     } 106  107 }

Java2html

0.0.0.17.8.2 - Métodos e locais por persistência de valor

001 import java.util.Scanner; 002 /** 003     Esta Ã© o aperfeiçoamento do código do Conversor3. Converter as variáveis 004     globais em locais caso o valor armazenado não precise ser mantido fora 005     do método.  006 */ 007  008 public class Conversor4 { 009  010     /** 011         Este Ã© o ponto de entrada do programa: o método que Ã© invocado 012         pela JVM. 013         Pergunta ao usuário que conversor ele deseja usar e invoca 014         o método que faz a conversão. Permite também que o usuário 015         termine o programa e que refaça a escolha caso tenha digitado 016         uma opção que não existe. 017     */ 018     public static void main (String[] args){ 019         int opt=0; // opcao de conversao - usada somente neste método. 020  021         /* Valores não precisam sair do método. */ 022         Scanner sc=new Scanner (System.in); // leitor de teclado 023         do { 024             System.out.println ("1 para 10->12; 2 para 12->10; 3 para sair"); 025             System.out.println ("(inteiros - tipo diferente dá pau.)"); 026             opt=sc.nextInt(); 027             switch (opt) { 028                 case 1: // 10->12; 029                     dez2doze();   // invocação do método 030                     break; 031                 case 2: // 12->10; 032                     doze2dez();    // invocação do método 033                     break; 034                 case 3: break; 035                 default: 036                     System.out.println ("Digite novamente."); 037             } 038         } while (opt!=3); 039     } 040      041     /** Esta Ã© a declaração, ou definição do método. Dizemos como deve 042     ser a invocação (a assinatura do método) e o que ele deve fazer  043     (o bloco de código do método). 044     Este método pergunta ao usuário o valor inteiro na base 10 que 045     o usuário deseja converter, converte-o para um String que  046     representa o número na base 12 e o escreve na tela. 047     A conversão Ã© feita por divisões sucessivas. 048     */ 049     public static void dez2doze () { 050         int m;  // digito para conversor 10->12 - usado somente neste método 051  052         /* Valores não precisam sair do método. */ 053         int num10; // numero base 10 - destruido na conversao 054         String num12; // numero base 12; 055         Scanner sc=new Scanner (System.in); // leitor de teclado 056  057         System.out.println ("Digite o número decimal."); 058         System.out.println ("(inteiros - tipo diferente dá pau.)"); 059         num10=sc.nextInt(); 060         num12=""; 061         while (num10>0) { 062             m=num10%12; 063             num10/=12; 064             switch (m) { 065                 case 0: 066                     num12='A'+num12; 067                     break; 068                 case 1: 069                     num12='B'+num12; 070                     break; 071                 case 2: 072                     num12='C'+num12; 073                     break; 074                 case 3: 075                     num12='D'+num12; 076                     break; 077                 case 4: 078                     num12='E'+num12; 079                     break; 080                 case 5: 081                     num12='F'+num12; 082                     break; 083                 case 6: 084                     num12='G'+num12; 085                     break; 086                 case 7: 087                     num12='H'+num12; 088                     break; 089                 case 8: 090                     num12='I'+num12; 091                     break; 092                 case 9: 093                     num12='J'+num12; 094                     break; 095                 case 10: 096                     num12='K'+num12; 097                     break; 098                 case 11: 099                     num12='L'+num12; 100                     break; 101                 default:  102                     System.out.println ("Erro desconhecido."); 103             } 104         } 105         System.out.println ("Resultado:" + num12); 106     } 107  108     /** 109     Este método pergunta ao usuário o valor na base 12 que 110     o usuário deseja converter, recebe-o como String, converte-o em  111     número inteiro na base 10 e o escreve na tela. 112     A conversão Ã© feita por soma de produto do dígito por potência. 113     */ 114     public static void doze2dez () { 115         /*i, c, numErr, len são usados somente neste método. */ 116         int i;  // contador para conversor 12 ->10 117         char c; // caracter corrente para conversor 12->10 118         boolean numErr; // flag de erro no numero base 12 119         int len;// comprimento do número base 12 120  121         /* Valores não precisam sair do método. */ 122  123         int num10; // numero base 10 - destruido na conversao 124         String num12; // numero base 12; 125         Scanner sc=new Scanner (System.in); // leitor de teclado 126  127         System.out.println ("Digite o número base 12."); 128         num12=sc.next(); 129         len=num12.length(); 130         numErr=false; 131         num10=0; 132         i=0; 133         while ((i<len)&&(!numErr)){ 134             c=num12.charAt(i); 135             i++; 136             num10*=12; 137             switch (c) { 138                 case 'A': 139                     num10+=0; 140                     break; 141                 case 'B': 142                     num10+=1; 143                     break; 144                 case 'C': 145                     num10+=2; 146                     break; 147                 case 'D': 148                     num10+=3; 149                     break; 150                 case 'E': 151                     num10+=4; 152                     break; 153                 case 'F': 154                     num10+=5; 155                     break; 156                 case 'G': 157                     num10+=6; 158                     break; 159                 case 'H': 160                     num10+=7; 161                     break; 162                 case 'I': 163                     num10+=8; 164                     break; 165                 case 'J': 166                     num10+=9; 167                     break; 168                 case 'K': 169                     num10+=10; 170                     break; 171                 case 'L': 172                     num10+=11; 173                     break; 174                 default:  175                     System.out.println ("Erro dígito não corresponde a número."); 176                     numErr=true; 177             } 178         } 179         if (!numErr) System.out.println ("Resultado:" + num10); 180     } 181  182 }

Java2html

0.0.0.17.8.1 - Métodos e locais por uso

001 import java.util.Scanner; 002 /** 003     Esta Ã© o aperfeiçoamento do código do Conversor2. Converter as variáveis 004     globais em locais pelo critério de uso: o que Ã© usado somente em um 005     método deve ser local ao método.  006 */ 007  008 public class Conversor3 { 009     static int num10; // numero base 10 - destruido na conversao 010     static String num12; // numero base 12; 011     static Scanner sc=new Scanner (System.in); // leitor de teclado 012  013     /** 014         Este Ã© o ponto de entrada do programa: o método que Ã© invocado 015         pela JVM. 016         Pergunta ao usuário que conversor ele deseja usar e invoca 017         o método que faz a conversão. Permite também que o usuário 018         termine o programa e que refaça a escolha caso tenha digitado 019         uma opção que não existe. 020     */ 021     public static void main (String[] args){ 022         int opt=0; // opcao de conversao - usada somente neste método. 023         do { 024             System.out.println ("1 para 10->12; 2 para 12->10; 3 para sair"); 025             System.out.println ("(inteiros - tipo diferente dá pau.)"); 026             opt=sc.nextInt(); 027             switch (opt) { 028                 case 1: // 10->12; 029                     dez2doze();   // invocação do método 030                     break; 031                 case 2: // 12->10; 032                     doze2dez();    // invocação do método 033                     break; 034                 case 3: break; 035                 default: 036                     System.out.println ("Digite novamente."); 037             } 038         } while (opt!=3); 039     } 040      041     /** Esta Ã© a declaração, ou definição do método. Dizemos como deve 042     ser a invocação (a assinatura do método) e o que ele deve fazer  043     (o bloco de código do método). 044     Este método pergunta ao usuário o valor inteiro na base 10 que 045     o usuário deseja converter, converte-o para um String que  046     representa o número na base 12 e o escreve na tela. 047     A conversão Ã© feita por divisões sucessivas. 048     */ 049     public static void dez2doze () { 050         int m;  // digito para conversor 10->12 - usado somente neste método 051         System.out.println ("Digite o número decimal."); 052         System.out.println ("(inteiros - tipo diferente dá pau.)"); 053         num10=sc.nextInt(); 054         num12=""; 055         while (num10>0) { 056             m=num10%12; 057             num10/=12; 058             switch (m) { 059                 case 0: 060                     num12='A'+num12; 061                     break; 062                 case 1: 063                     num12='B'+num12; 064                     break; 065                 case 2: 066                     num12='C'+num12; 067                     break; 068                 case 3: 069                     num12='D'+num12; 070                     break; 071                 case 4: 072                     num12='E'+num12; 073                     break; 074                 case 5: 075                     num12='F'+num12; 076                     break; 077                 case 6: 078                     num12='G'+num12; 079                     break; 080                 case 7: 081                     num12='H'+num12; 082                     break; 083                 case 8: 084                     num12='I'+num12; 085                     break; 086                 case 9: 087                     num12='J'+num12; 088                     break; 089                 case 10: 090                     num12='K'+num12; 091                     break; 092                 case 11: 093                     num12='L'+num12; 094                     break; 095                 default:  096                     System.out.println ("Erro desconhecido."); 097             } 098         } 099         System.out.println ("Resultado:" + num12); 100     } 101  102     /** 103     Este método pergunta ao usuário o valor na base 12 que 104     o usuário deseja converter, recebe-o como String, converte-o em  105     número inteiro na base 10 e o escreve na tela. 106     A conversão Ã© feita por soma de produto do dígito por potência. 107     */ 108     public static void doze2dez () { 109         /*i, c, numErr, len são usados somente neste método. */ 110         int i;  // contador para conversor 12 ->10 111         char c; // caracter corrente para conversor 12->10 112         boolean numErr; // flag de erro no numero base 12 113         int len;// comprimento do número base 12 114  115         System.out.println ("Digite o número base 12."); 116         num12=sc.next(); 117         len=num12.length(); 118         numErr=false; 119         num10=0; 120         i=0; 121         while ((i<len)&&(!numErr)){ 122             c=num12.charAt(i); 123             i++; 124             num10*=12; 125             switch (c) { 126                 case 'A': 127                     num10+=0; 128                     break; 129                 case 'B': 130                     num10+=1; 131                     break; 132                 case 'C': 133                     num10+=2; 134                     break; 135                 case 'D': 136                     num10+=3; 137                     break; 138                 case 'E': 139                     num10+=4; 140                     break; 141                 case 'F': 142                     num10+=5; 143                     break; 144                 case 'G': 145                     num10+=6; 146                     break; 147                 case 'H': 148                     num10+=7; 149                     break; 150                 case 'I': 151                     num10+=8; 152                     break; 153                 case 'J': 154                     num10+=9; 155                     break; 156                 case 'K': 157                     num10+=10; 158                     break; 159                 case 'L': 160                     num10+=11; 161                     break; 162                 default:  163                     System.out.println ("Erro dígito não corresponde a número."); 164                     numErr=true; 165             } 166         } 167         if (!numErr) System.out.println ("Resultado:" + num10); 168     } 169  170 }

Java2html