Fecha y hora actual: Domingo 25 Ago 2019 04:19
Índice del Foro

Foros de programación informática, diseño gráfico y Web

En esta comunidad intentaremos dar soporte de programación a todos los niveles, desde principiantes a profesionales de la informática, desarrollo de programas, programación web y mucho más.

Lección 65: Tipos, operadores, declaraciones y selección.

Responder al Tema

Índice del Foro > Programación en general > Lección 65: Tipos, operadores, declaraciones y selección.

Autor Mensaje
Kyshuo Ayame
Moderador Global


Registrado: 07 Ene 2011
Mensajes: 1043

Mensaje Publicado: Jueves 02 Ago 2012 18:01

Título del mensaje: Lección 65: Tipos, operadores, declaraciones y selección.

Responder citando

En esta lección veremos las palabras reservadas de Java, un poco más sobre declaración de variables añadiendo además las constantes, tipos primitivos y sus rangos de datos, operadores aritméticos y relacionales para así llegar a la selección, es decir, a los if y a algo parecido al CASE.

Será básicamente un resumen de cómo migrar a la nueva sintaxis los aspectos que ya conocemos en Pascal y Modula.

=================================================

Palabras reservadas y tipos primitivos de Java

Al igual que cualquier lenguaje Java tiene sus propias palabras reservadas. Como estas tienen un significado propio para el lenguaje no pueden ser utilizadas como identificadores para nada que queramos usar, tal como variables, constantes, clases, operaciones, etc.
Les dejo un listado de las palabras reservadas que existen en Java hoy día simplemente para que lo tengan presente:

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


Asimismo tenemos también los tipos primitivos de datos de los cuales conocemos dos hasta ahora: int y double. Los tipos primitivos son aquellos tipos de datos predefinidos por el lenguaje. Estos datos se almacenan directamente en memoria ocupando un cierto espacio ya establecido. Normalmente estos tipos de datos refieren a números, caracteres y booleanos. Veamos entonces qué tipos de datos primitivos nos da Java para trabajar:


boolean: El típico booleano. Puede valer true o false. Ocupa 1 bit de memoria.
char: Un carácter Unicode, como los que ya conocemos. Ocupan 16 bits de memoria.
byte: Un número entero con signo. Va desde -128 hasta 128. Ocupan 8 bits de memoria.
short: Un número entero con signo. Este tipo es idéntico al tipo INTEGER de Pascal y Modula ya que tiene el mismo rango de valores y cada variable de este tipo ocupa también 16 bits de memoria. Va desde -32768 hasta 32767.
int: Un número entero con signo. Va desde -2147483648 hasta 214748647. Ocupan 32 bits de memoria. Como ven, ya tenemos un rango mucho mayor que en Pascal o Modula.
long: Un número entero con signo. Va desde -9223372036854775808 hasta 92233720368547707. Ocupan 64 bits de memoria. Un super rango numérico.
float: Un número de coma flotante. Este tipo es idéntico al tipo REAL de Pascal o Modula. Tienen un rango comprendido entre +-3.40282347E+38 y +-1.40239846E-45. Tiene una precisión simple. Ocupa 32 bits de memoria.
double: Un número de coma flotante con doble precisión. Va desde
+-1.79769313486231570E+308 hasta +-4.94065645841246544E-324. Ocupan 64 bits de memoria.


Como ven, los tipos numéricos nos dan mayores rangos con los que trabajar respecto a los que teníamos antes con Pascal y Modula. Hay que tener cuidado con la compatibilidad de estos tipos, pero me gustaría que ustedes mismos hicieran pequeñas pruebas declarando variables de distintos tipos y asignen a unas los valores de otras.

Por ejemplo, si yo me declaro una variable llamada real del tipo double y otra llamada entero del tipo int, puedo hacer esto:

Código:
real= entero;


Sin embargo, si lo hago a la inversa NetBeans subrayará en rojo la asignación y si posamos el cursor del mouse sobre ella veremos el mensaje:

Cita:
possible loss of precision
required: int
found: double



Tenemos una forma de que Java “vea” una variable double como int para poder hacer una asignación que en Pascal o Modula era simplemente incompatible. Esta forma se conoce como casteo, pero la veremos más adelante.

Algo a destacar es que el tipo String no aparece como tipo primitivo de datos y justamente es porque no lo es. Un String es una concatenación de caracteres, es decir que, un String es la unión de varios datos de tipo char, el cual sí es un dato primitivo.

===============================================

Operadores aritméticos de Java

Como era de esperarse y además como ya vimos, Java tiene sus operadores aritméticos, es decir, los símbolos que nos sirven para realizar operaciones matemáticas. Estos por lo general son los mismos en casi todos los lenguajes, siempre con alguna salvedad propia. En Java no tenemos mucha diferencia de lo que eran los operadores matemáticos de Pascal y Modula excepto por DIV y MOD que ahora ya no existen con esas palabras. Les pido que lean estos detalles porque hay sutilezas importantes y luego preguntan cosas que están explicadas aquí ¿si?:


• + (Suma): Simplemente realiza la suma de sus operandos.
• - (Resta): Simplemente realiza la del segundo operando al primer operando.
• * (Producto o multiplicación): Realiza el producto de sus operandos.
• / (División o cociente): Realiza la división de sus operandos. Esta operación funciona como división real (tal como en Pascal o Modula) si hay al menos un operando de tipo real (float y double en Java). Si ambos operandos son enteros (short, int y long en Java) esta operación funciona como si fuera la operación DIV de Pascal o Modula, es decir, división entera.
• % (Módulo o resto): Esta operación equivale a MOD en Pascal o Modula.


En las operaciones aritméticas siempre pueden estar presentes los paréntesis para dar precedencia a una operación u otra, tal como siempre ha sido. No me detendré a explicar eso.

Veamos en Java aquel ejemplo de Pascal que dado un número de cuatro cifras lo desglosaba y mostraba el resultado de dichas cifras. Recordemos el código Pascal:

Código:
1 {El siguiente programa desglosará un número de cuatro cifras
2 en sus cuatro números distintos, uno por cada cifra y realizará
3 la suma entre ellas}
4 PROGRAM SumaCifras;
5
6 Var
7     numero: integer; //El valor que será leído.
8     c1, c2, c3, c4: integer;//Una variable para cada cifra.
9
10 BEGIN
11    write('Ingresa un número de cuatro cifras: ');
12    readln(numero); //Leemos el número de 4 cifras.
13
14   (*Asignamos a cada variable el valor de la cifra que le corresponde*)
15   c1:= numero mod 10;
16   c2:= (numero mod 100) div 10;
17   c3:= (numero mod 1000) div 100;
18   c4:= numero div 1000;
19
20   //Mostramos el resultado al usuario.
21   write('El resultado de sumar ',c4,'+',c3,'+',c2,'+',c1,' es: ',c1+c2+c3+c4);
22 END.


Ahora veamos el código Java:

Código:
import java.util.Scanner;

/*El siguiente programa desglosará un número de cuatro cifras
en sus cuatro números distintos, uno por cada cifra y realizará
la suma entre ellas*/
public class EjemploMOD {
    public static void main(String[] args){
        Scanner entrada= new Scanner(System.in);
        int numero, c1, c2, c3, c4;
       
        System.out.print("Ingresa un número de cuatro cifras: ");
        numero= entrada.nextInt();
       
        c1= numero % 10;
        c2= (numero % 100)/10;
        c3= (numero % 1000) / 100;
        c4= numero / 1000;
       
        System.out.println("El resultado de sumar " + c4 + "+"
+ c3 + "+" + c2 + "+" + c1 + " es " + (c1+c2+c3+c4));
    }//Fin de main.
}//Fin de la clase EjemploMOD.


El código es casi exacto al de Pascal y creo yo que muy fácil de comprender. Comparen ambos y saquen sus propias conclusiones.

===============================================

Declaración de variables y constantes. Selección en Java

Ya hemos visto la declaración de variables en Java, solo nos queda un pequeño detalle acerca de esto y es que podemos declarar variables a la vez que las inicializamos (es lo que hacemos con la variable del tipo Scanner). También veremos como declarar constantes en Java para pasar luego a la selección, es decir, a los viejos y queridos if.

Declaración de variables con inicialización conjunta:


Como ya sabemos, las variables se declaran así:

Código:
TipoDeDatos identificadorVariable;


Podemos además declarar muchas variables del mismo tipo separadas por comas además de que Java nos permite declarar las variables por cualquier parte del código siempre que las declaremos antes de usarlas. Bien, como ya saben siempre que vamos a usar una variable para alguna operación y no sabemos qué valor tendrá ya que no lo leeremos de la entrada (por ejemplo un contador para iterar) debemos inicializarlas. Veamos un ejemplo donde me declaro una variable del tipo int llamada i y la inicializo en 0:

Código:
int i;
i= 0;


Bien, eso no tiene nada de nuevo, primero me declaré la variable y luego la inicialicé. Java también me permite hacer esto para simplificar el código:

Código:
int i=0;


Como ven he declara la variable y a la vez le he dado un valor inicial. Supongamos que quiero declarar muchas variables del tipo int y quiero inicializar algunas sí y otras no. Podemos hacer todo por separado o todo junto así:

Código:
int i=0, j=8, altura, base, suma= 0;


Java nos da una libertad total a la hora de declarar variables. Allí tenemos tres que han sido inicializadas y dos que no. No tenemos que respetar ningún orden ni mucho menos. Se suele declarar a las variables que no inicializamos por un lado, y por otro lado a las que sí para dejar el código más claro, es decir, algo como esto:

Código:
int i=0, j=8, suma= 0;
int altrua, base;


Esto es muy relativo ya que se pueden agrupar las variables según el uso que se les dará. En fin, cada uno escribe sus programas como más le guste. Dejen buenos comentarios y ya.

Algo importante es que a veces suele ser necesario en Java inicializar variables del tipo String dada la soltura de este lenguaje para el trabajo con cadenas de caracteres. ¿Con qué valor inicializo un String? Pues a menos que fuese lo que necesitamos podemos inicializar un String con algún valor que elijamos, pero Java nos provee la posibilidad de inicializar un String con un valor nulo el cual es “”. Sí, el String nulo es abrir y cerrar comillas. Por ejemplo:

Código:
String palabra= “”;


NOTA: El tipo char de Java utiliza comillas simples (como los Strings de Pascal) y no dobles porque sino serían Strings. Ejemplo:

Código:
char letra= ‘A’;




Declaración de constantes:

Como ya saben, las constantes son “variables” que no cambian de valor, por eso está mal llamarlas variables. En Pascal y Modula las declarábamos debajo de la palabra CONST. Como no variaban hacía falta inicializarlas en la misma declaración. Algo interesante es que no le asignábamos el tipo ya que este quedaba implícito en el valor que le dábamos a la constante.
En Java, al igual que no existe VAR tampoco existe CONST y al igual que con las variables podemos declarar las constantes en cualquier lado. Es necesario poner el tipo de datos que contendrá. La declaración de constantes es igual a la de variables solo que anteponemos la palabra reservada final:

Código:
final int MI_CONSTANTE= 20;



La declaración de constantes en Java sigue siendo una declaración de variables y por tanto respeta las mismas reglas salvo la excepción de que a las constantes hay que inicializarlas sí o sí. De este modo podemos declarar muchas constantes en una sola línea tal como con las variables. En Java entonces las constantes pasan a ser variables finales.

Algo importante es que las constantes suelen declararse siempre en mayúscula. Es una convención, algo que ayuda dentro del código a distinguirlas de las variables. Java nos deja darles el nombre que queramos.

Como dato interesante es que podemos declarar constantes del tipo String, por ejemplo:

Código:
final String MI_CADENA= “Alguna cadena útil”;



Ejercicio: Transcriban este código Pascal a Java:

Código:
1 PROGRAM preciosIVA;
2
3 Const
4    iva= 23;
5
6 Var
7    harina, leche, azucar, sal, arroz: real;//Precios de los productos.
8    porcentaje: real; //Para calcular cuanto se debe sumar al precio.
9
10 BEGIN
11
12   //Mostramos mensajes al usuario y leemos los datos desde la entrada.
13   write('Precio HARINA : ');
14   readln(harina);
15   write('Precio LECHE : ');
16   readln(leche);
17   write('Precio AZUCAR : ');
18   readln(azucar);
19   write('Precio SAL : ');
20   readln(sal);
21   write('Precio ARRÓZ : ');
22   readln(arroz);
23
24   //Dejamos una línea en blanco.
25   writeln;
26
27   //Calculamos el porcentaje de IVA para harina.
28   porcentaje:= harina*iva/100;
29   //Mostramos el nuevo precio al usuario.
30   writeln('HARINA + IVA : ',harina+porcentaje:2:2);
31
32   //Calculamos el porcentaje de IVA para leche.
33   porcentaje:= leche*iva/100;
34   //Mostramos el nuevo precio al usuario.
35   writeln('LECHE + IVA : ',leche+porcentaje:2:2);
36
37   //Calculamos el porcentaje de IVA para azucar.
38   porcentaje:= azucar*iva/100;
39   //Mostramos el nuevo precio al usuario.
40   writeln('AZUCAR + IVA : ',azucar+porcentaje:2:2);
41
42   //Calculamos el porcentaje de IVA para sal.
43   porcentaje:= sal*iva/100;
44   //Mostramos el nuevo precio al usuario.
45   writeln('SAL + IVA : ',sal+porcentaje:2:2);
46
47   //Calculamos el porcentaje de IVA para arroz.
48   porcentaje:= arroz*iva/100;
49   //Mostramos el nuevo precio al usuario.
50   writeln('ARROZ + IVA : ',arroz+porcentaje:2:2);
51 END.

En un programa muy sencillo.


Operadores relacionales de Java para expresiones booleanas:

Veamos como hacemos en Java para comparar números y demás:



Como ven solo han cambiado los operadores de igualdad y diferencia con respecto a los que teníamos en Pascal y Modula.


Selección simple con if:

En Java también tenemos el viejo y querido if, solo que ya no es IF…THEN como en Pascal o Modula, ahora es solo if. Su uso es así:

Código:
if (condición)
    instrucción;


Ese es un if super sencillo, es decir, con una sola instrucción. Si hacen memoria, en Pascal podíamos tener IF con una sola instrucción al que no teníamos que ponerle BEGIN y END porque no hacía falta. En Java es igual, si el if tiene una sola instrucción podemos poner un bloque de llaves {} o no, es decir que aquel if podía haber sido

Código:
if (condición){
      instrucción;
}


De este modo, la forma general de un if en Java sería:

Código:
if (condición){
      Instrucción1;
      Instrucción2;
      . . .
      InstrucciónN
}



Algo super importante en Java es que la condición SIEMPRE va entre paréntesis, no hay excepción a eso, de otro modo tendrán un error de sintaxis.

Veamos un ejemplo sencillo:

Código:
import java.util.Scanner;

public class EjemploIF {
    public static void main(String[] args){
        Scanner entrada= new Scanner(System.in);
        int n1, n2;
       
        System.out.print("Ingrese dos números enteros: ");
       
        n1= entrada.nextInt();
        n2= entrada.nextInt();
        entrada.nextLine();
       
        if(n1<n2)
            System.out.println("El primero es menor que el segundo.");
       
        if(n1==n2)
            System.out.println("Ambos números son iguales.");
       
        if(n1>n2)
            System.out.println("El primero es mayor que el segundo.");
    }//Fin de main.
}//Fin de EjemploIF.



Selección doble con if…else:

Como no podía ser de otro modo, si tenemos if tenemos else. Como ahora perdimos el THEN, en vez de IF…THEN e IF…THEN…ELSE tenemos if e if…else. La idea es exactamente la misma que en Pascal y Módula; dada una condición si esta se cumple hacemos lo que está en el bloque del if y sino lo que está en el else.

Cambien el código anterior por este:

Código:
if(n1<n2)
System.out.println("El primero es menor que el segundo.");
else if(n1==n2)
System.out.println("Ambos números son iguales.");
else
       System.out.println("El primero es mayor que el segundo.");



Como verán, ya no tenemos más ELSIF. En caso de necesitar más de una instrucción deben usar llaves para crear bloques de instrucciones.

Lo demás debería resultarles intuitivo. Prueben ustedes mismos.



Operadores lógicos en Java:

También conocidos como operadores booleanos. Estos no son más que aquellos operadores que nos permiten componer condiciones, es decir, los ya conocidos NOT, OR y AND. Veamos cómo escribimos estos operadores en Java, recordando a la vez las viejas y queridas tablas de verdad.

Operador NOT lógico (!):

Niega la condición que le sigue. Este operador se conoce como operador lógico de negación. En Pascal y Módula era NOT, ahora es !.




Operador AND condicional (&&):

Ahora el AND se ha transformado &&. Este operador funciona exactamente igual que AND en Pascal o Modula, incluso evaluando por circuito corto. Si no lo recuerdan, AND evalúa dos condiciones y devuelve TRUE si ambas condiciones son verdaderas. Como la evaluación es por circuito corto si la primera condición es FALSE entonces ya no se evalúa la segunda porque sin importar su valor el resultado será FALSE. Veamos la tabla de verdad:




Operador OR condicional (||):

Lo que antes era OR ahora se escribe con las dos barras verticales ||. Este operador funciona de forma idéntica que en Pascal o Modula, es decir, devuelve TRUE si al menos una de las condiciones es verdadera. Si la primera condición es TRUE ya no se evalúa la segunda porque sin importar su valor el resultado será TRUE; en contraparte, si la primera condición es FALSE entonces sí se evalúa la segunda.



Java introduce además tres operadores booleanos nuevos:


Operador AND lógico booleano (&):

Idéntico al operador && con la salvedad de que evalúa por circuito completo, es decir, siempre se evalúan ambos operandos sin importar sus valores. La tabla de verdad es idéntica a la de &&. Puede resultar útil en algunas circunstancias, aunque no lo usaremos mucho.


Operador OR inclusivo lógico booleano (|):

El mismo caso. Este operador es idéntico al operador || salvo que evalúa siempre por circuito completo. La tabla de verdad es exactamente la misma.

Operador OR exclusivo lógico booleano (^):

Ahora el operador ^ ya no se usará para punteros (porque Java no nos permite usarlos) sino que será un operador booleano. Este OR será TRUE sí y solo sí uno de los operandos es TRUE y el otro FALSE. Si ambos son TRUE o ambos son FALSE entonces devuelve FALSE. Veamos la tabla de verdad:



Este operador no tiene más remedio que evaluar por circuito completo.
¿Estamos de acuerdo en que podemos lograr este resultado componiendo || y && como lo hacíamos en Pascal y Modula?



Selección múltiple con switch:

Ya no tenemos más el CASE…ELSE, ahora tenemos switch. Esta instrucción es prácticamente idéntica al CASE de Pascal o el de Modula excepto por algún detalle que ya veremos. Recordemos las declaraciones que usábamos con CASE hasta ahora:


En Pascal:

Código:
CASE variable OF
Constante1: BEGIN
            Instrucciones;
             END;
   . . .
   ConstanteN: BEGIN
            Instrucciones;
         END;
   ELSE
      BEGIN
         Instrucciones;
      END;
END;


Debemos recordar que en cada etiqueta (constante) podíamos omitir los bloques BEGIN/END si tenían solo una instrucción. La variable debía ser de un tipo ordinal, por tanto no servían Strings, números reales ni tipos definidos por nosotros mismos a menos que fueran enumerados.


En Modula 2:

Código:
CASE variable OF
   Constante1:   Instruccion1;
             . . .
         InstrucciónX|
   . . .
   ConstanteN:   Instrucción1;
         . . .
         InstrucciónY|
   ELSE
         Instrucción1;
         . . .
         InstrucciónZ|
END;


Igual que el CASE de Pascal salvo que ya no existen los bloques BEGIN/END. Para cada etiqueta las instrucciones se separaban por punto y coma salvo la última que se cerraba con la barra vertical |. Por lo demás funcionaba igual.

En ambos casos la etiqueta ELSE no era obligatoria sino que servía para hacer algo en caso de que la variable no tomara el valor de ninguna de las etiquetas. Podíamos omitir perfectamente el ELSE y en caso de que sucediera lo anteriormente dicho el CASE no hacía nada.

La instrucción switch de Java hereda un aspecto del CASE de Modula: tenemos “algo” que cierra todas las etiquetas. En Modula era la barra |, en Java será la palabra reservada break. Veamos la declaración genérica de switch y luego transformaremos un CASE para que quede claro:

Código:
switch (variable){
   case etiqueta1: Instrucción(es);
            break;
   case etiqueta2: Intrucción(es);
            break;
   . . .

}


Como ven es casi lo mismo. La variable va entre paréntesis sí o sí. Antes de cada etiqueta debe ir la palabra case y luego los dos puntos. Por cada etiqueta podemos tener tantas instrucciones como queramos, incluyendo if y sentencias de repetición. Cada etiqueta debe (en realidad puede) finalizar con break.


Ejemplo:

Supongamos que la variable num es de tipo INTEGER en Pascal y Modula y de tipo int en Java:

CASE Pascal:

Código:
CASE num OF
1: WriteLn(‘El número es el 1.’);
   2: Begin
      WriteLn(‘El número es el 2.’);
      Write(‘No me gusta mucho ese número.’);
      End;
3: WriteLn(‘El tres también me gusta.’);
END;


CASE Modula:

Código:
CASE num OF
1: WriteString(“El número es el 1.”)|
   2: WriteString(“El número es el 2.”); WriteLn;
      WriteString(“No me gusta mucho ese número.”)|
3: WriteString(“El tres también me gusta.”)|
END;


Switch:

Código:
switch (num){
   case 1: System.out.println(“El número es el 1.”); break;
   case 2: System.out.println(“El número es el 2.”);
        System.out.println(“No me gusta mucho ese número.”);
        break;
   case 3: System.out.println(“El tres también me gusta.”); break;
}


¿Y el ELSE donde queda con switch? Pues switch en vez de ELSE tiene una instrucción llamada default que es exactamente lo mismo. Si la variable no toma el valor de ninguna de las etiquetas case entonces entramos en el default. Con el mismo ejemplo tendríamos:

Código:
switch (num){
   case 1: System.out.println(“El número es el 1.”); break;
   case 2: System.out.println(“El número es el 2.”);
        System.out.println(“No me gusta mucho ese número.”);
  break;
   case 3: System.out.println(“El tres también me gusta.”); break;
   default: System.out.println(“No se eligió ni 1, ni 2, ni 3.”);
         System.out.println(“Default y ELSE son lo mismo.”);
         break;
}




¿Qué pasa si no usamos break?

Si prueban escribir las etiquetas de switch sin usar break verán que el código compila perfectamente. Bien, a diferencia de la instrucción CASE de Pascal o Modula, donde se ejecuta únicamente el código correspondiente a la etiqueta en la que entramos, switch nos da la posibilidad de ejecutar más de una etiqueta. La sentencia break hace que al llegar a ella salgamos directamente de switch, por tanto, poniendo break en todas las etiquetas tendremos un comportamiento idéntico al CASE. Ahora bien, si en una etiqueta no ponemos break, el código seguirá hacia abajo y entrará en la siguiente etiqueta ya sin comprobar si el valor se corresponde con la variable del encabezado porque de hecho no lo hará.
Si escribimos un switch donde ninguna etiqueta tenga break, entonces al entrar en una se ejecutarán todas las demás que están por debajo. Por ejemplo:

Código:
switch(num){
   case 1: System.out.print(“1 “);
   case 2: System.out.print(“2 “);
   case 3: System.out.print(“3”); break;
   default: System.out.println(“No se eligió nada entre 1 y 3.”);
}



Si aquí num vale 1, entonces en la salida veremos 1 2 3 ya que entrará en la primera etiqueta, la ejecutará y como no tiene break entrará en la segunda la cual tampoco tiene break por lo cual entrará en la tercera que sí tiene break para evitar que el flujo siga de largo a la etiqueta default.

Podemos elegir a qué etiquetas poner break y a cuales no. Asimismo el órden de las etiqueta puede ser cualquiera, no tiene por que ser ascendente como el del ejemplo ni mucho menos.

Este comportamiento puede resultar útil para algunos casos.



Ejercicio:

Escriban un programa que muestre un menú al usuario donde pueda elegir si quiere calcular el área y el perímetro de un triángulo, un rectángulo o una circunferencia. Si el usuario no elije una de las opciones dadas entonces se le mostrará un mensaje de error. Las opciones serán numéricas y se leerán como enteros Veamos un ejemplo:

Cita:
Bienvenido a Áreas y Perímetros.

Seleccione una opción:

1-- Calcular área y perímetro de un triángulo.
2-- Calcular área y perímetro de un rectángulo.
3-- Calcular área y perímetro de una circunferencia.

Selección: 3

Ingrese el radio de la circunferencia: 2
El área es: 12.56
El perímetro es: 12.56


Es un programa super sencillo, pero servirá mucho de práctica para afianzar Java y dejar de lado los viejos vicios arraigados de Pascal y Modula.

===============================================

Hasta la próxima lección.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
yazminwse



Registrado: 08 Ago 2012
Mensajes: 7
Ubicación: colombia

Mensaje Publicado: Miércoles 08 Ago 2012 17:35

Título del mensaje: Re: Lección 65: Tipos, operadores, declaraciones y selección

Responder citando

Muchas gracias por compartir esta información.Saludos

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Sebastián Marcos
Usuario Inquieto


Registrado: 04 Oct 2011
Mensajes: 133

Mensaje Publicado: Lunes 13 Ago 2012 04:37

Título del mensaje: Re: Lección 65: Tipos, operadores, declaraciones y selección

Responder citando

Hola a todos !!!
Si bien me resta realizar el proyecto final en Modula 2, no me he resistido el seguir las lecciones de Java. Este es mi primer acercamiento a este tan afamado lenguaje, así que estoy aprendiendo su sintaxis y demás.
Vale la pena decir que para los que han seguido los cursos de Pascal y Modula, tendrán ventaja (una muy buena ventaja) sobre los que inicien el curso desde Java y no tengan conocimientos previos.
Así que como siempre animo, sobre todo a los que se quieran iniciar en la programación a leer el curso desde el principio, verán que no precisaran prácticamente nada más que las leeciones publicadas aquí para aprender a programar desde cero.

Yendo a la duda que se me presentó en esta lección, trataré de explicarla en principio sin publicar el código, haber si se entiende...
Es respecto al ejercicio del final de la lección: "Escriban un programa que muestre un menú al usuario..."

Bueno, a mi entender es para usar un switch (aunque se podria realizar con anidación de if).
Realicé el programa y funcionó correctamente, dentro del bloque de cada etiqueta pedía al usuario lo que correspondía, por ejemplo si la opción ingresada como entero era "1", se le pedía al usuario los valores de los lados del triángulo y la altura, luego calculaba el área y perímetro correspondientes y lo imprimía en pantalla. Todo esto lo hacía dentro del bloque de la correspondiente etiqueta.

Ahora bien, luego pensé en mostrar los resultados fuera del switch (el área y perímetro), para no repetir esta parte del código dentro del bloque de cada etiqueta.
Es ahí donde el IDE me dice que no inicialice las variables area y perimetro y salta un error de compilación.
Esto creo que se da, pues si bien en el bloque de cada etiqueta le asigno valores a area y perimetro, está la posibilidad que no se entre en ninguno de los bloques etiquetados, y es por eso que el IDE marca el error. ¿Estoy en lo cierto?.
De todos modos esto se arregla inicializando las variables area y perimetro antes de la declaración del switch (por ejemplo con cero).

Saludos a todos, y como siempre el agradecimiento al profesor Kyshuo por este curso fantástico.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Kyshuo Ayame
Moderador Global


Registrado: 07 Ene 2011
Mensajes: 1043

Mensaje Publicado: Martes 14 Ago 2012 23:08

Título del mensaje: Re: Lección 65: Tipos, operadores, declaraciones y selección

Responder citando

Justamente el problema es el que mencionas amigo. El IDE no puede determinar a priori que entremos en alguna de las etiquetas del switch, por tanto necesita que inicialicemos las variables antes o bien, colocar una etiqueta default que también las inicialice. Claro está que lo mejor es hacer lo que tú ya haz hecho.

Espero que de momento todo vaya resultando sencillo de comprender.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
xRoki
Usuario Inquieto


Registrado: 22 Ago 2013
Mensajes: 71

Mensaje Publicado: Sábado 09 Nov 2013 01:38

Título del mensaje: Re: Lección 65: Tipos, operadores, declaraciones y selección

Responder citando

buenassssss :DDD jajaj hice los dos ejercicios que pediste , gracias por esta nuensisisma leccion del mejorr profeeeeee !!!!! jajajaa xd

el del Precio de IVA
Código:
 import java.util.Scanner;

               
       
public class preciosIVA {
  public static void main(String[] args){
 
      Scanner Entrada= new Scanner(System.in);
      double harina,leche,azucar,sal,arroz, porcentaje ;
      final int iva=23;
     
      System.out.print("Precio HARINA :");
      harina= Entrada.nextDouble();
     
      System.out.print("\nPrecio LECHE :");
      leche= Entrada.nextDouble();
     
      System.out.print("\nPrecio AZUCAR :");
      azucar= Entrada.nextDouble();
             
      System.out.print("\nPrecio SAL :");
      sal= Entrada.nextDouble();
     
      System.out.print("\nPrecio ARROZ :");
      arroz= Entrada.nextDouble();
     
      porcentaje=harina*iva/100;
      System.out.print("\nHARINA + IVA :" + (harina+porcentaje));
     
      porcentaje=leche*iva/100;
      System.out.print("\nLECHE + IVA :" + (leche+porcentaje));
     
      porcentaje=azucar*iva/100;
      System.out.print("\nAZUCAR + IVA :" + (azucar+porcentaje));
     
      porcentaje=sal*iva/100;
      System.out.print("\nSAL + IVA :" + (sal+porcentaje));
     
      porcentaje=arroz*iva/100;
      System.out.print("\nARROZ + IVA :" + (arroz+porcentaje));
     
   
  } 
}


ahora el ejercicio que tiene que ver con switch xd

Código:
import java.util.Scanner;

public class AreasyPerimetros {

public static void main(String[] args){
 
   Scanner entradaEstandar= new Scanner(System.in);
   int a,b,c,altura,perimetro,opcion;
   double area,per;
   
   System.out.print("Bienvenid@ a Areas y Perimetros.\n\n" + "Elige una Opcion:\n\n"
                     + "1.Un triangulo. \n2.Un rectangulo.\n3.Una circunferencia\n\n"
                     + "\n\nSeleccion:"  );
   opcion=entradaEstandar.nextInt();
                     
     
     
      switch(opcion){
          case 1: System.out.print("\n\nVamos con el area del triangulo.\nLa base sera el primer lado ingresado \nIngresa la medida de sus lados y su altura:"
                  );
      a= entradaEstandar.nextInt();
      b= entradaEstandar.nextInt();
      c= entradaEstandar.nextInt();
      altura= entradaEstandar.nextInt();
     
             
              entradaEstandar.nextLine();
      System.out.print("\nLado a=" + a + "\nLado b=" + b + "\nLado c=" + c
              + "\nAltura=" + altura);
     
     
      area= a*altura/2.0;
      perimetro= a+b+c;
      entradaEstandar.nextLine();
      System.out.print("\nArea= "+ area + "\nPerimetro=" + perimetro); break;
             
          case 2: System.out.print("\n\nVamos con el area y el perimetro del rectangulo."
              + "\nIngresa la medida de la base y altura: "
                   );
     
      a= entradaEstandar.nextInt();
      b= entradaEstandar.nextInt();
     
      System.out.print("\n\nBase=" + a + "\nAltura=" + b);
     
      area=a*b;
      perimetro=2*(a+b);
     
      System.out.print("\n\nArea="+ area + "\nperimetro=" + perimetro); break;
         
          case 3: System.out.print("\n\nVamos con la circunferencia.\nIngresa la medida del radio: ");
      a= entradaEstandar.nextInt();
     
      area=a*a*3.14;
      per= a*2*3.14;
     
      System.out.print("\n\nRadio=" + a + "\n\nArea=" + area +"\nPerimetro=" + per);
     
      break;
             
             
      }
             
       

}   

}


GRACIAS :D

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Kyshuo Ayame
Moderador Global


Registrado: 07 Ene 2011
Mensajes: 1043

Mensaje Publicado: Sábado 09 Nov 2013 03:44

Título del mensaje: Re: Lección 65: Tipos, operadores, declaraciones y selección

Responder citando

Excelente, como siempre, un trabajo genial...

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Responder al Tema
Mostrar mensajes anteriores:   
Ir a:  
Todas las horas están en GMT + 2 Horas

Temas relacionados

Tema Autor Foros Respuestas Publicado
El foro no contiene ningún mensaje nuevo

Tipos de fichero compatibles con C++

dave.jason C, C#, Visual C++ 2 Jueves 23 Oct 2014 20:17 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Lección 101: Lectura/Escritura de archivos de t...

Kyshuo Ayame Programación en general 3 Sábado 26 Oct 2013 03:04 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Selección de ficheros con patrón

sapales Java 0 Martes 08 Oct 2013 18:54 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Lección 100: JMasterMind

Kyshuo Ayame Programación en general 7 Lunes 02 Sep 2013 20:29 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Lección 99: JBuscaminas - GUI - Mouse Event

Kyshuo Ayame Programación en general 2 Lunes 19 Ago 2013 16:55 Ver último mensaje
Panel de Control
No puede crear mensajes, No puede responder temas, No puede editar sus mensajes, No puede borrar sus mensajes, No puede votar en encuestas,