sexta-feira, 10 de abril de 2015

0.0.0.17.8.0 - Métodos e globais

001 import java.util.Scanner;
002 /**
003     Caso considere-se que o problema seja apenas usar métodos, o mais intuitivo (na minha opinião) Ã© separar cada conversor em um método.
004     As variáveis são declaradas em um ou em outro de acordo com o uso.
005     Em escopos disjuntos (como em dois métodos), pode-se declarar variáveis
006     locais de mesmo nome. Cada uma pertencerá ao respectivo escopo.
007     Em escopos aninhados, Ã© permitido caso um seja de classe e outro de
008     método. Não Ã© permitido caso um seja de método e outro de bloco dentro
009     do método (por exemplo num for ou num if).
010     Ã‰ alternativa também declarar as variáveis compartilhadas no escopo
011     da classe (o que nas condições adequadas pode ser chamado "variável
012     global"). Porém o uso de variáveis globais quando Ã© possível usar
013     variáveis locais não Ã© boa prática de programação pois permite que 
014     métodos interfiram uns com os outros.
015     
016     Há vários pontos em usar métodos:
017     1-) ter blocos de código reutilizáveis, evitando reescrever código;
018     2-) facilitar depuração de código (os métodos podem ser testados
019         individualmente);
020     3-) facilitar o entendimento do código (métodos que já sabemos O QUE
021         fazem ou que não precisamos saber COMO fazem não são de leitura
022         obrigatória);
023     4-) distribuir a tarefa de codificação (cada programador Ã© encarregado
024         por um método);
025     5-) substituir métodos Ã© fácil (se dois métodos A e B fazem a mesma
026         coisa e tem a mesma assinatura, podemos substituir um pelo outro
027         quase sem esforço)
028 
029     Não há metodologia que resulte na "melhor" partição do código em métodos.
030     Há heurísticas (mas todas elas podem ser violadas): 
031     1-) Quanto menos variáveis em comum há entre dois trechos de
032     código, maior a chance de que eles possam ser separados em métodos
033     distintos.
034     2-) Caso as tarefas sejam distintas (CUIDADO - isto Ã© subjetivo), por
035     exemplo receber dados, calcular e escrever o resultado, a semântica 
036     permite separar o exemplo em três partes que "contém uma idéia" e por
037     isso "faz sentido" individualmente.
038     3-) Caso deseje-se codificar algo que tenha analogia com uma coisa ou
039     uma idéia já existente, Ã© mais intuitivo que o código seja dividido
040     segundo essa analogia (por exemplo num simulador de vôo, que exista algo no código que represente o altímetro, o manche, a alavanca de
041     aceleração,....)
042 
043     Note que a leitura do código melhora.
044     
045     Vamos ao jeito fácil:
046 */
047 
048 public class Conversor2 {
049     static int opt=0; // opcao de conversao
050     static int num10; // numero base 10 - destruido na conversao
051     static String num12; // numero base 12;
052     static int len;// comprimento do número base 12
053     static int m;  // digito para conversor 10->12
054     static int i;  // contador para conversor 12 ->10
055     static char c; // caracter corrente para conversor 12->10
056     static boolean numErr; // flag de erro no numero base 12
057     static Scanner sc=new Scanner (System.in); // leitor de teclado
058 
059     /**
060         Este Ã© o ponto de entrada do programa: o método que Ã© invocado
061         pela JVM.
062         Pergunta ao usuário que conversor ele deseja usar e invoca
063         o método que faz a conversão. Permite também que o usuário
064         termine o programa e que refaça a escolha caso tenha digitado
065         uma opção que não existe.
066     */
067     public static void main (String[] args){
068         do {
069             System.out.println ("1 para 10->12; 2 para 12->10; 3 para sair");
070             System.out.println ("(inteiros - tipo diferente dá pau.)");
071             opt=sc.nextInt();
072             switch (opt) {
073                 case 1: // 10->12;
074                     dez2doze();   // invocação do método
075                     break;
076                 case 2: // 12->10;
077                     doze2dez();    // invocação do método
078                     break;
079                 case 3: break;
080                 default:
081                     System.out.println ("Digite novamente.");
082             }
083         } while (opt!=3);
084     }
085     
086     /** Esta Ã© a declaração, ou definição do método. Dizemos como deve
087     ser a invocação (a assinatura do método) e o que ele deve fazer 
088     (o bloco de código do método).
089     Este método pergunta ao usuário o valor inteiro na base 10 que
090     o usuário deseja converter, converte-o para um String que 
091     representa o número na base 12 e o escreve na tela.
092     A conversão Ã© feita por divisões sucessivas.
093     */
094     public static void dez2doze () {
095         System.out.println ("Digite o número decimal.");
096         System.out.println ("(inteiros - tipo diferente dá pau.)");
097         num10=sc.nextInt();
098         num12="";
099         while (num10>0) {
100             m=num10%12;
101             num10/=12;
102             switch (m) {
103                 case 0:
104                     num12='A'+num12;
105                     break;
106                 case 1:
107                     num12='B'+num12;
108                     break;
109                 case 2:
110                     num12='C'+num12;
111                     break;
112                 case 3:
113                     num12='D'+num12;
114                     break;
115                 case 4:
116                     num12='E'+num12;
117                     break;
118                 case 5:
119                     num12='F'+num12;
120                     break;
121                 case 6:
122                     num12='G'+num12;
123                     break;
124                 case 7:
125                     num12='H'+num12;
126                     break;
127                 case 8:
128                     num12='I'+num12;
129                     break;
130                 case 9:
131                     num12='J'+num12;
132                     break;
133                 case 10:
134                     num12='K'+num12;
135                     break;
136                 case 11:
137                     num12='L'+num12;
138                     break;
139                 default: 
140                     System.out.println ("Erro desconhecido.");
141             }
142         }
143         System.out.println ("Resultado:" + num12);
144     }
145 
146     /**
147     Este método pergunta ao usuário o valor na base 12 que
148     o usuário deseja converter, recebe-o como String, converte-o em 
149     número inteiro na base 10 e o escreve na tela.
150     A conversão Ã© feita por soma de produto do dígito por potência.
151     */
152     public static void doze2dez () {
153         System.out.println ("Digite o número base 12.");
154         num12=sc.next();
155         len=num12.length();
156         numErr=false;
157         num10=0;
158         i=0;
159         while ((i<len)&&(!numErr)){
160             c=num12.charAt(i);
161             i++;
162             num10*=12;
163             switch (c) {
164                 case 'A':
165                     num10+=0;
166                     break;
167                 case 'B':
168                     num10+=1;
169                     break;
170                 case 'C':
171                     num10+=2;
172                     break;
173                 case 'D':
174                     num10+=3;
175                     break;
176                 case 'E':
177                     num10+=4;
178                     break;
179                 case 'F':
180                     num10+=5;
181                     break;
182                 case 'G':
183                     num10+=6;
184                     break;
185                 case 'H':
186                     num10+=7;
187                     break;
188                 case 'I':
189                     num10+=8;
190                     break;
191                 case 'J':
192                     num10+=9;
193                     break;
194                 case 'K':
195                     num10+=10;
196                     break;
197                 case 'L':
198                     num10+=11;
199                     break;
200                 default: 
201                     System.out.println ("Erro dígito não corresponde a número.");
202                     numErr=true;
203             }
204         }
205         if (!numErr) System.out.println ("Resultado:" + num10);
206     }
207 
208 }
Java2html
Postado por às Nenhum comentário:
Marcadores: ,

segunda-feira, 6 de abril de 2015

0.0.0.17.8 - Aula 9 - 09.04

Revisar teorema da programação estruturada:

~ 0.0.0.3 - Teoria - teorema da programação estruturada

Estudar teoria:
~ 0.0.0.10 - Métodos
Estudar solução proposta para problema da semana passada:http://fabionakano.blogspot.com.br/2015/04/0001770-proposta-de-programa-para.html

Objetivo: melhorar a estrutura da solução proposta usando métodos.

Material sobre orientação a objetos, UML, e projeto de software no xerox, pasta 12.

Veja propostas de programas em:

~ 0.0.0.17.8 - Aula 9 - 09.04
Postado por às Nenhum comentário:
Marcadores: , ,

0.0.0.17.7.0 - Proposta de programa para resolver o problema

001 import java.util.Scanner;
002 
003 public class Conversor {
004     public static void main (String[] args){
005         int opt=0; // opcao de conversao
006         int num10; // numero base 10 - destruido na conversao
007         String num12; // numero base 12;
008         int len;// comprimento do número base 12
009         int m;  // digito para conversor 10->12
010         int i;  // contador para conversor 12 ->10
011         char c; // caracter corrente para conversor 12->10
012         boolean numErr; // flag de erro no numero base 12
013         Scanner sc=new Scanner (System.in); // leitor de teclado
014 
015         do {
016             System.out.println ("1 para 10->12; 2 para 12->10; 3 para sair");
017             System.out.println ("(inteiros - tipo diferente dá pau.)");
018             opt=sc.nextInt();
019             switch (opt) {
020                 case 1: // 10->12;
021                     System.out.println ("Digite o número decimal.");
022                     System.out.println ("(inteiros - tipo diferente dá pau.)");
023                     num10=sc.nextInt();
024                     num12="";
025                     while (num10>0) {
026                         m=num10%12;
027                         num10/=12;
028                         switch (m) {
029                             case 0:
030                                 num12='A'+num12;
031                                 break;
032                             case 1:
033                                 num12='B'+num12;
034                                 break;
035                             case 2:
036                                 num12='C'+num12;
037                                 break;
038                             case 3:
039                                 num12='D'+num12;
040                                 break;
041                             case 4:
042                                 num12='E'+num12;
043                                 break;
044                             case 5:
045                                 num12='F'+num12;
046                                 break;
047                             case 6:
048                                 num12='G'+num12;
049                                 break;
050                             case 7:
051                                 num12='H'+num12;
052                                 break;
053                             case 8:
054                                 num12='I'+num12;
055                                 break;
056                             case 9:
057                                 num12='J'+num12;
058                                 break;
059                             case 10:
060                                 num12='K'+num12;
061                                 break;
062                             case 11:
063                                 num12='L'+num12;
064                                 break;
065                             default: 
066                                 System.out.println ("Erro desconhecido.");
067                         }
068                     }
069                     System.out.println ("Resultado:" + num12);
070                     break;
071                 case 2: // 12->10;
072                     System.out.println ("Digite o número base 12.");
073                     num12=sc.next();
074                     len=num12.length();
075                     numErr=false;
076                     num10=0;
077                     i=0;
078                     while ((i<len)&&(!numErr)){
079                         c=num12.charAt(i);
080                         i++;
081                         num10*=12;
082                         switch (c) {
083                             case 'A':
084                                 num10+=0;
085                                 break;
086                             case 'B':
087                                 num10+=1;
088                                 break;
089                             case 'C':
090                                 num10+=2;
091                                 break;
092                             case 'D':
093                                 num10+=3;
094                                 break;
095                             case 'E':
096                                 num10+=4;
097                                 break;
098                             case 'F':
099                                 num10+=5;
100                                 break;
101                             case 'G':
102                                 num10+=6;
103                                 break;
104                             case 'H':
105                                 num10+=7;
106                                 break;
107                             case 'I':
108                                 num10+=8;
109                                 break;
110                             case 'J':
111                                 num10+=9;
112                                 break;
113                             case 'K':
114                                 num10+=10;
115                                 break;
116                             case 'L':
117                                 num10+=11;
118                                 break;
119                             default: 
120                                 System.out.println ("Erro dígito não corresponde a número.");
121                                 numErr=true;
122                         }
123                     }
124                     if (!numErr) System.out.println ("Resultado:" + num10);
125                     break;
126                 case 3: break;
127                 default:
128                     System.out.println ("Digite novamente.");
129             }
130         } while (opt!=3);
131     }
132 }
Java2html
Postado por às 2 comentários:
Marcadores: , ,
Assinar: Postagens (Atom)