package ejercicios_Joan_V;
/* ENUNCIADO PRÁCTICA 1: Ejercicio 1
--------------------------------------------
Algunos datos del tipo primitivo han sido implementados
en java como una clase. Conocida como clase envolvente.
Así pues, tenemos:
(dato primitivo) ---> (su clase envolvente) (wrapper class)
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean No tiene
La creación de esta clase envolvente nos permite disponer de código adicional para realizar operaciones con este tipo de datos. Estas operaciones son métodos implementados para cada clase, así como constantes que nos permiten disponer de más capacidades la hora de programar.
La práctica consiste en conocer las constantes y métodos de interés a usar en cada tipo de dato. Así como las operaciones, conversiones de tipo , etc. sobre los datos primitivos o su equivalente clase envolvente.
*/
//Puedes ir comentando y descomentando las partes con el fin de centrar la ejecución en cada parte. Solo debes borrar ente parte las líneas indicadas.
// The main method must be in a class named "Main".public class Main
public class Practica_1_Ejercicio_1 {
public static void main(String[] args) {
/* PARTE 1
System.out.println("Parte 1: ");
System.out.println("----------------------");
// Byte
System.out.println("Tipo de dato Byte:");
System.out.println("SIZE: " + Byte.SIZE);
System.out.println("MAX_VALUE: " + Byte.MAX_VALUE);
System.out.println("MIN_VALUE: " + Byte.MIN_VALUE);
System.out.println();
// Short
System.out.println("Tipo de dato Short:");
System.out.println("SIZE: " + Short.SIZE);
System.out.println("MAX_VALUE: " + Short.MAX_VALUE);
System.out.println("MIN_VALUE: " + Short.MIN_VALUE);
System.out.println();
// Integer
System.out.println("Tipo de dato Integer:");
System.out.println("SIZE: " + Integer.SIZE);
System.out.println("MAX_VALUE: " + Integer.MAX_VALUE);
System.out.println("MIN_VALUE: " + Integer.MIN_VALUE);
System.out.println();
// Long
System.out.println("Tipo de dato Long:");
System.out.println("SIZE: " + Long.SIZE);
System.out.println("MAX_VALUE: " + Long.MAX_VALUE);
System.out.println("MIN_VALUE: " + Long.MIN_VALUE);
System.out.println();
// Float
System.out.println("Tipo de dato Float:");
System.out.println("SIZE: " + Float.SIZE);
System.out.println("MAX_VALUE: " + Float.MAX_VALUE);
System.out.println("MIN_VALUE: " + Float.MIN_VALUE);
System.out.println();
// Double
System.out.println("Tipo de dato Double:");
System.out.println("SIZE: " + Double.SIZE);
System.out.println("MAX_VALUE: " + Double.MAX_VALUE);
System.out.println("MIN_VALUE: " + Double.MIN_VALUE);
System.out.println();
// Character
System.out.println("Tipo de dato Character:");
System.out.println("SIZE: " + Character.SIZE);
System.out.println("MAX_VALUE (int): " + (int) Character.MAX_VALUE);
System.out.println("MIN_VALUE (int): " + (int) Character.MIN_VALUE);
System.out.println();
//¿Qué valor está proporcionando cada uno de ellos?
//SIZE: El tamaño ocupado en memoria en BITS por el tipo de dato primitivo.
//MAX_VALUE: El límite superior que puede almacenar el tipo.
//MIN_VALUE: El valor mínimo que puede almacenar el tipo.
//Borra esta línea para resolver la parte 1 */
/* PARTE 2
System.out.println("Parte 2: ");
System.out.println("----------------------");
//Vamos a dar formato a la salida para nombrar adecuadamente las constantes usadas.
//Ejemplo para la clase Byte.
System.out.println ("Un Short ocupa en memoria "+Short.SIZE+" bits");
System.out.println ("El valor maximo de un short es de "+Short.MAX_VALUE);
System.out.println ("El valor minimo de un short es de "+Short.MIN_VALUE);
System.out.println();
//Añade el resto del código aquí. Recuerda para todas las variables.
System.out.println ("Un Short ocupa en memoria "+Integer.SIZE+" bits");
System.out.println ("El valor maximo de un short es de "+Integer.MAX_VALUE);
System.out.println ("El valor minimo de un short es de "+Integer.MIN_VALUE);
System.out.println();
System.out.println ("Un Short ocupa en memoria "+Long.SIZE+" bits");
System.out.println ("El valor maximo de un short es de "+Long.MAX_VALUE);
System.out.println ("El valor minimo de un short es de "+Long.MIN_VALUE);
System.out.println();
System.out.println ("Un Short ocupa en memoria "+Float.SIZE+" bits");
System.out.println ("El valor maximo de un short es de "+Float.MAX_VALUE);
System.out.println ("El valor minimo de un short es de "+Float.MIN_VALUE);
System.out.println();
System.out.println ("Un Short ocupa en memoria "+Double.SIZE+" bits");
System.out.println ("El valor maximo de un short es de "+Double.MAX_VALUE);
System.out.println ("El valor minimo de un short es de "+Double.MIN_VALUE);
System.out.println();
//Borra esta línea para resolver la parte 2 */
/* Borra esta línea para resolver la parte 3
//Parte 3:
System.out.println("Parte 3: ");
System.out.println("----------------------");
//Operando con los números del tipo entero.
//Asígnale a la variable byte valorByte su valor máximo
byte valorByte = Byte.MAX_VALUE;
//Añade el código que imprime el valor al incremetar 1 dicha variable usando el operador ++. Cuidado, primero incrementar y luego imprimir.
System.out.println ("resultado de valorByte++");
System.out.println (++valorByte);
System.out.println ();
//¿Qué valor has obtenido. ¿Por qué?
// He obtenido -128 ya que al llegar al máximo a pasado de 127 a -128
valorByte=Byte.MAX_VALUE; //Volvemos a su valor original
//imprime valorByte+1;
System.out.println ("resultado de valorByte+1");
System.out.println(valorByte+1);
System.out.println ();
//¿Por qué el resultado no es el mismo?
//Porque al usar '+' con el valorByte, Java cambia automáticamente el byte a un tipo 'int'
//Ejecuta el código descomentando la siguiente línea de código
//byte vB=valorByte;
//Estos dos siguientes dan error
//byte vB;
//vB=valorByte+1;
//Vuelve a ejecutar comentando la línea anterior y descomentando la siguiente
//byte vB=valorByte++;
//System.out.println (vB);
//¿Por qué una da error y la otra no? ¿Entiendes ahora porqué el resultado es distinto al usar la orden de incremento frente a la de sumar 1.
//Si quieres incrementar la variable en 3 manteniendo el tipo de dato inicial debes usar +=. Prueba..
valorByte=126;
//Añade aquí la instrucción con +=
System.out.println ("Resultado de valor byte+=3");
valorByte+=3;
System.out.println(valorByte);
//Comparamos
valorByte=126;
System.out.println(valorByte+3);
//Borra esta línea para resolver la parte 3 */
/* Borra esta línea para resolver la parte 4
//Parte 4:
System.out.println("Parte 4: ");
System.out.println("----------------------");
//Parte 4:
System.out.println("Parte 4: ");
System.out.println("----------------------");
//Sabemos que el signo + provoca si los datos son numéricos la suma de ambos, pero si los datos son del tipo String concatena ambas cadenas.
//Crea una varible del tipo int llamada x con valor 12;
int x=12;
//Crea una variable del tipo int llamada y con valor 13;
int y=13;
//Imprime la suma
System.out.println(x+y);
//Crea una variable del tipo String llamada str1 de valor "13";
String str1="13";
//Imprime x+str
System.out.println(x+str1);
// ¿Por qué se obtiene 1213 en vez de dar un error? ¿Qué sucede pues?
// Porque al juntar un número con un texto, Java los une uno detrás de otro en lugar de sumarlos matemáticamente.
//De las siguientes instrucciones comentadas, descomenta las que son correctas, e indica el error que se dará en las incorrectas.
byte b1,b2,b3;
short s1,s2,s3;
int n1,n2,n3;
long l1,l2,l3;
float f1,f2,f3;
double d1,d2,d3;
//Comenta y descomenta de una en una para verificar tu respuesta.
//b1=1;b2=5;b3=b2+b3;System.out.println("El valor de b3 es: "+b3);
// Error: al sumar bytes Java los pasa automáticamente a int y ya no cabe en una variable byte.
//s1=1; s2=5; s3=s1+s2; System.out.println("El valor de s3 es: "+s3);
// Error: pasa lo mismo que con los bytes, el resultado pasa a ser int y el short se queja.
n1=1; n2=5; n3=n1+n2; System.out.println("El valor de n3 es: "+n3);
//n1=1L;
// Error: no puedes meter un long en un int porque ocupa más espacio.
l1=1L; l2=5L; l3=l1+l2; System.out.println("El valor de l3 es: "+l3);
l1=100;
f1=5.3f; f2=4.6F; f3=f2+f1; System.out.println("El valor de f3 es: "+f3);
//f1=5.4;
// Error: los números con decimales sueltos Java los trata como double y no caben en un float.
f1=5.4f; f2=4.6f; d3=f1+f2; System.out.println("El valor de d3 es: "+d3);
d1=5.8f;
d1=5.8; d2=3.45; d3=d1+d2; System.out.println("El valor de d3 es: " +d3);
//Sustituye el (*) por (b3 o s3 o n3 o l3 o f3 o d3). Criterio el tipo de dato de menor memoria da validez a la asignación. Descomenta previamente.
b1=5; l3 = b1+1L; System.out.println("Debe ser del tipo long");
d1=4.6; d3 = 2.4F/d1+3L; System.out.println("Debe ser del tipo double");
Borra esta línea para resolver la parte 4*/
/* Borra esta línea para resolver la parte 5
//Parte 5:
System.out.println("Parte 5: ");
System.out.println("----------------------");
//Observa el resultado de estas operaciones:
float f4=5f/0.0f; System.out.println(f4);
float f5=-5f/0.0F; System.out.println(f5);
float f6=0.0f/0.0f; System.out.println(f6);
float f7=Float.MAX_VALUE*10; System.out.println(f7);
System.out.println("----------------------");
// ¿Hay desbordamiento?¿La ejecución del programa se ha parado?
// Procede de la misma forma con datos del tipo double. Añade las líneas de código
//para crear d4,d5,d6 y d7 del tipo double.
double d4=5f/0.0f; System.out.println(d4);
float d5=-5f/0.0F; System.out.println(d5);
float d6=0.0f/0.0f; System.out.println(d6);
float d7=Float.MAX_VALUE*10; System.out.println(d7);
System.out.println("----------------------");
//Métodos de las clases envolventes Float y Double para gestionar estos valores. Analiza el valor que devuelve. Y piensa su futura utilidad //
System.out.println("¿Que es f6?");
System.out.println("¿Es indeterminado? " + Float.isNaN(f6));
System.out.println("¿Es finito? " + Float.isFinite(f6));
System.out.println("¿Es infinito? " + Float.isInfinite(f6));
System.out.println("----------------------");
System.out.println("¿Que es f4?");
System.out.println("¿Es indeterminado? " + Float.isNaN(f4));
System.out.println("¿Es finito? " + Float.isFinite(f4));
System.out.println("¿Es infinito? " + Float.isInfinite(f4));
System.out.println("----------------------");
System.out.println("¿Que es f5?");
System.out.println("¿Es indeterminado? " + Float.isNaN(f5));
System.out.println("¿Es finito? " + Float.isFinite(f5));
System.out.println("¿Es infinito? " + Float.isInfinite(f5));
System.out.println("----------------------");
System.out.println("¿Que es f7?");
System.out.println("¿Es indeterminado? " + Float.isNaN(f7));
System.out.println("¿Es finito? " + Float.isFinite(f7));
System.out.println("¿Es infinito? " + Float.isInfinite(f7));
//Si además queremos saber si es +Infinito o -Infinito qué podemos hacer. La clase envolvente también nos los facilita en ese caso comparamos con la constante Float.NEGATIVE_INFINITY
System.out.println("----------------------");
System.out.println(f5==Float.NEGATIVE_INFINITY);
//Cómo evaluarías sí d4, d5 d6 y d7 son +infinite. Añade a continuación el código.
System.out.println("¿Son ininitos negativos d4, d5, d6 y d7?");
System.out.println("d4 es infinito negativo? " + (d4==Float.NEGATIVE_INFINITY));
System.out.println("d5 es infinito negativo? " + (d5==Float.NEGATIVE_INFINITY));
System.out.println("d6 es infinito negativo? " + (d6==Float.NEGATIVE_INFINITY));
System.out.println("d7 es infinito negativo? " + (d7==Float.NEGATIVE_INFINITY));
//Borra esta línea para resolver la parte 5*/
//*Borra esta línea para resolver la parte 6
//Parte 6:
System.out.println("Parte 6: ");
System.out.println("----------------------");
//Crea una variable del tipo int llamada e1 de valor 7 y otra llamada e2 de valor 2
int e1=7;
int e2=2;
//Imprime el resultado de división, ¿Es el resultado el esperado, por qué?
System.out.println ("e1/e2 = "+e1/e2);
// ¿Puedes afirmar que el resultado obtenido es el cociente? Para ello cambia los valores asignados a e1 y e2.
//No, me a dado la divion sin el numero decimal dando un int
//Imprime el resultado de e1%e2. ¿Qué has obtenido?
System.out.println ("e1%e2 = "+e1%e2); //El resto
//Imprime la siguiente operación 1.0*e1/e2. ¿Por qué el resultado es un número real?
System.out.println ("1.0*e1/e2 = "+ 1.0*e1/e2); // Porque he forzado a la multiplicacion a que me de los decimales con el 1.0
//Dada las siguientes operaciones determina antes de comprobar (descomentando y ejecutando) si el resultado es int o double. Y cuál será el resultado numérico. Explica el porqué del resultado en cada caso insertado como comentario.
//Descomenta todo de una vez hayas pensado las respuestas en cada caso
System.out.println("**************");
System.out.println(e1+e2+2.5);
int e3=3; System.out.println(e1+e2/e3);
System.out.println((e1+e2)/e3);
double dd1=3.5; System.out.println((int)dd1);
System.out.println((int)dd1*3);
System.out.println((int)(dd1*3));
System.out.println(3.5*e1/8+12);
System.out.println((double)e1);
//Quitar está línea también para descomentar la parte 6*/
}
}
To embed this project on your website, copy the following code and paste it into your website's HTML: