{"id":114,"date":"2026-10-01T17:53:57","date_gmt":"2026-10-01T17:53:57","guid":{"rendered":"https:\/\/java.nosoyia.es\/?page_id=114"},"modified":"2026-10-01T17:53:57","modified_gmt":"2026-10-01T17:53:57","slug":"variables-y-datos-numericos","status":"publish","type":"page","link":"https:\/\/java.nosoyia.es\/?page_id=114","title":{"rendered":"Variables y datos num\u00e9ricos"},"content":{"rendered":"\n
\n
\n

Correspondencia en Python —><\/p>\n<\/div>\n\n\n\n

\n
\"\"<\/a><\/figure>\n<\/div>\n<\/div>\n\n\n\n

Existen principalmente dos tipos de datos num\u00e9ricos en Java:<\/p>\n\n\n\n

    \n
  • Los enteros (int). Pueden ser positivos, negativos o el cero.<\/li>\n\n\n\n
  • Los float, que permiten almacenar datos decimales. En los entornos de programaci\u00f3n de Java es frecuente que al escribir en c\u00f3digo estos datos, debamos de a\u00f1adir al final de la cifra la letra F para que el compilador los reconozca como tipo float. De no existir la F, los tomar\u00e1 como tipo double.<\/li>\n\n\n\n
  • Los double, decimales de mayor precisi\u00f3n.<\/li>\n<\/ul>\n\n\n\n

    Con este tipo de datos, se pueden efectuar operaciones que normalmente se almacenar\u00e1n en una variable.<\/p>\n\n\n\n

    Operaciones con datos num\u00e9ricos<\/mark>.<\/em><\/strong> Adem\u00e1s de las operaciones b\u00e1sicas (suma, resta, multiplicaci\u00f3n o divisi\u00f3n), con los datos tipo num\u00e9ricos se pueden hacer otras operaciones. Debemos de tener en cuenta, que en Java el resultado de dividir dos enteros ser\u00e1 siempre un entero, y el resultado de dividir dos float ser\u00e1 siempre un dato float. <\/p>\n\n\n\n

      \n
    • Math.pow (base, exponente)<\/em><\/strong> <\/mark>. Es la operaci\u00f3n de potencia. Elevamos la base al exponente. El resultado ser\u00e1 siempre un n\u00famero tipo double.<\/li>\n\n\n\n
    • Math.sqrt(numero)<\/mark><\/em><\/strong> . Nos facilita la ra\u00edz cuadrada de un n\u00famero. El resultado ser\u00e1 double.<\/li>\n\n\n\n
    • Math.cbrt(numero)<\/mark><\/em><\/strong>. Que dar\u00e1 la ra\u00edz c\u00fabica.<\/li>\n\n\n\n
    • Math.pow (base, exponente)<\/mark><\/em><\/strong> Eleva la base al exponente indicado.<\/li>\n\n\n\n
    • Math.pow (base, 1\/ exponente)<\/em><\/strong> <\/mark>Nos permite averiguar la ra\u00edz en\u00e9sima de cualquier n\u00famero.<\/li>\n\n\n\n
    • %<\/mark><\/em><\/strong> Es el operador m\u00f3dulo. Entre n\u00famero positivos, representa el resto de la divisi\u00f3n de los dos n\u00fameros. Si alguno de los dos n\u00fameros es de tipo decimal, el resultado ser\u00e1 tambi\u00e9n un resto decimal. Debemos de tener en cuenta, que entre n\u00fameros negativos la divisi\u00f3n modular ofrece resultados que pueden parecernos diferentes a la divisi\u00f3n modular entre dos n\u00fameros positivos. Importante: no confundir con el tanto por ciento.<\/strong><\/li>\n<\/ul>\n\n\n\n
      public class Dividir {\n    public static void main(String[] args) {\n        int entero1=20;\n        int entero2=6;\n        int division_int=entero1\/entero2;\n        System.out.println(division_int);  \n\n        float numero1=20;\n        float numero2=6;\n        float division_float=numero1\/numero2;  \n        System.out.println(division_float);\n                        \n        double potencia=Math.pow(3,2);\n        System.out.println(potencia);     \n    }\n}<\/code><\/pre><\/div>\n\n\n\n
      3\n3.3333333\n9.0<\/code><\/pre><\/div>\n\n\n\n
      En una operaci\u00f3n con varios operadores, se guarda en orden establecido de las operaciones matem\u00e1ticas. Primero se efect\u00faan los par\u00e9ntesis, luego las ra\u00edces y potencias, luego multiplicaciones y divisiones, y por \u00faltimo las sumas y restas. Siempre de izquierda a derecha.<\/p>\n\n\n\n
      Si el tipo de dato que se espera como respuesta no coincide con el tipo de dato de los operadores, java intentar\u00e1 hacer la conversi\u00f3n al tipo de dato esperado, siempre y cuando no se pierda precisi\u00f3n. Esto no siempre es posible, por ejemplo, en el caso de las potencias y ra\u00edces, el dato esperado siempre ser\u00e1 de tipo double.<\/p>\n\n\n\n
      public class Dividir {\n    public static void main(String[] args) {\n        int a=-5;\n        double b=26;\n        int c=14;\n        double d=3;\n\n        double e=Math.pow(b,3);\n        double f=Math.pow(16,1\/4);\n\n        System.out.println(a+b-c*d); \n        System.out.println(b\/a); \n        System.out.println(b\/d); \n        System.out.println(e); \n        System.out.println(f); \n        System.out.println(b%d); \n    }\n}<\/code><\/pre><\/div>\n\n\n\n
      -21.0\n-5.2\n8.666666666666666\n17576.0\n1.0\n2.0<\/code><\/pre><\/div>\n\n\n\n
      Cuando a una variable num\u00e9rica se le suma, resta, divide o multiplica por un n\u00famero, y el resultado lo queremos asignar como valor de la misma variable, podemos usar los operadores \u201c+=\u201d \u201c-=\u201d \u201c*=\u201d \u201c\/=\u201d<\/p>\n\n\n\n
      public class Operar {\n    public static void main(String[] args) {\n        int a=400;\n        a+=3;\n        System.out.println(a);\n        a-=2; \n        System.out.println(a);\n        a*=4;\n        System.out.println(a);\n        a\/=5;\n        System.out.println(a);\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
      403\n401\n1604\n320<\/code><\/pre><\/div>\n\n\n\n
      Math.round(mi_decimal)<\/mark><\/em><\/strong> . Este m\u00e9todo permite obtener el entero m\u00e1s pr\u00f3ximo al decimal que se pasa como par\u00e1metro.<\/p>\n\n\n\n
      <\/p>\n\n\n\n
      Math.round(mi_decimal * 100.0) \/ 100.0<\/mark><\/em><\/strong> . Con este truco basado en el m\u00e9todo anterior, podemos obtener un decimal redondeado a dos decimales. Si queremos obtener tres decimales, basta con sustituir las dos apariciones de 100.0 por 1000.0, igualmente si queremos el redondeo a un solo decimal, lo sustituir\u00edamos por 10.0<\/p>\n\n\n\n
      public class Dividir {\n    public static void main(String[] args) {\n        double kilometros = 12.25;\n        double millas = 7.02;\n\n        double millas_a_kilometros;\n        double kilometros_a_millas;\n        double mi_decimal=34.521;\n\n        millas_a_kilometros = millas*1.61;\n        kilometros_a_millas = kilometros\/1.61;\n\n        System.out.println(Math.round(mi_decimal));\n\n        System.out.println(millas+" millas son "+ millas_a_kilometros+" kil\u00f3metros");\n        System.out.println(kilometros+" kil\u00f3metros son "+kilometros_a_millas+" millas.");\n\n        millas_a_kilometros = Math.round(millas*1.61*1000.0)\/1000.0;\n        kilometros_a_millas = Math.round(kilometros\/1.61*1000.0)\/1000.0;\n\n        System.out.println(millas+ " millas son "+ millas_a_kilometros+" kil\u00f3metros.");\n        System.out.println(kilometros+ " kil\u00f3metros son "+kilometros_a_millas+" millas.");\n    }\n }<\/code><\/pre><\/div>\n\n\n\n
      35\n7.02 millas son 11.3022 kil\u00f3metros\n12.25 kil\u00f3metros son 7.608695652173912 millas.\n7.02 millas son 11.302 kil\u00f3metros.\n12.25 kil\u00f3metros son 7.609 millas.<\/code><\/pre><\/div>\n\n\n\n
      Las funciones Math.floor(double)<\/mark><\/em><\/strong> y Math.ceil(double)<\/mark><\/em><\/strong> facilitan un n\u00famero decimal redondeado a su entero m\u00e1s pr\u00f3ximo por lo alto y por lo bajo respectivamente. <\/p>\n\n\n\n
      public class Prueba2 {\n    public static void main(String[] args) {\n        double mi_decimal=34.521;\n        double redondeo=Math.round(mi_decimal);\n        double redondeo_bajo=Math.floor(mi_decimal);\n        double redondeo_alto=Math.ceil(mi_decimal);\n\n        System.out.println("N\u00famero: "+mi_decimal);\n        System.out.println("Redondeado: "+redondeo);\n        System.out.println("Redondeado por abajo: "+redondeo_bajo);\n        System.out.println("Redondeado por arriba: "+redondeo_alto);\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
      Resultado:\n\nN\u00famero: 34.521\nRedondeado: 35.0\nRedondeado por abajo: 34.0\nRedondeado por arriba: 35.0<\/code><\/pre><\/div>\n\n\n\n
      La funci\u00f3n Math.abs(numero)<\/mark><\/em><\/strong> nos facilita el valor absoluto del valor num\u00e9rico pasado como par\u00e1metro:<\/p>\n\n\n\n
      public class Prueba2 {\n    public static void main(String[] args) {\n        double mi_decimal=-34.521;\n        double mi_absoluto=Math.abs(mi_decimal);\n\n        System.out.println("N\u00famero: "+mi_decimal);\n        System.out.println("Su valor absoluto: "+mi_absoluto);\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
      Resultado:\n\nN\u00famero: -34.521\nSu valor absoluto: 34.521\n<\/code><\/pre><\/div>\n\n\n\n
      String.valueOf (numero)<\/mark><\/em><\/strong> . Con este m\u00e9todo conseguimos obtener un dato tipo String a partir de cualquier dato de tipo num\u00e9rico.<\/p>\n\n\n\n
      public class Dividir {\n    public static void main(String[] args) {\n        int numero1=8;\n        int numero2=14;\n        int c=numero1+numero2;\n\n        String cadena1=String.valueOf(numero1);\n        String cadena2=String.valueOf(numero2);\n        String suma_cadenas=cadena1+cadena2;\n\n        System.out.println("La suma de los numeros es "+c);\n        System.out.println("La suma de las cadenas es "+suma_cadenas);\n    }\n }<\/code><\/pre><\/div>\n\n\n\n
      La suma de los numeros es 22\nLa suma de las cadenas es 814<\/code><\/pre><\/div>\n\n\n\n
      Si tenemos una cadena que contiene un dato num\u00e9rico, podemos obtener el dato que encierra aplicando a la cadena el m\u00e9todo adecuado. Dependiendo el tipo de dato num\u00e9rico que deseemos obtener debemos de utilizar un m\u00e9todo u otro.<\/p>\n\n\n\n
      Integer.parseInt(cadena)<\/mark><\/em><\/strong> Nos permite obtener un dato entero a partir de una cadena que representa un entero.<\/p>\n\n\n\n
      public class Suma_Int {\n    public static void main(String[] args) {\n        String cadena1="348";\n        String cadena2="43";\n        String suma_cadenas=cadena1+cadena2;\n        System.out.println("La suma de las cadenas es "+suma_cadenas);\n\n        int entero1=Integer.parseInt(cadena1);\n        int entero2=Integer.parseInt(cadena2);\n        int suma_enteros=entero1+entero2;\n        System.out.println("La suma de los n\u00fameros es "+suma_enteros);\n    }\n }<\/code><\/pre><\/div>\n\n\n\n
      La suma de las cadenas es 34843\nLa suma de los n\u00fameros es 391<\/code><\/pre><\/div>\n\n\n\n
      Double.parseDouble(cadena)<\/mark><\/em><\/strong> De la misma manera, podemos obtener con este otro m\u00e9todo un dato decimal tipo double.<\/p>\n\n\n\n
      public class Suma_Double {\n    public static void main(String[] args) {\n        String cadena1="0.23";\n        String cadena2="6.789";\n        String suma_cadenas=cadena1+cadena2;\n        System.out.println("La suma de las cadenas es "+suma_cadenas);\n\n        double decimal_1=Double.parseDouble(cadena1);\n        double decimal_2=Double.parseDouble(cadena2);\n        double suma_decimales=decimal_1+decimal_2;\n        System.out.println("La suma de los n\u00fameros es "+suma_decimales);\n    }\n }<\/code><\/pre><\/div>\n\n\n\n
      La suma de las cadenas es 0.236.789\nLa suma de los n\u00fameros es 7.019<\/code><\/pre><\/div>\n\n\n\n
      Float.parseFloat(cadena)<\/mark><\/em><\/strong> Y este otro m\u00e9todo ser\u00e1 valido si deseamos obtener un decimal tipo float.<\/p>\n\n\n\n
      public class Suma_Float {\n    public static void main(String[] args) {\n        String cadena1="23.41";\n        String cadena2="78.245";\n        String suma_cadenas=cadena1+cadena2;\n        System.out.println("La suma de las cadenas es "+suma_cadenas);\n\n        float decimal_1=Float.parseFloat(cadena1);\n        float decimal_2=Float.parseFloat(cadena2);\n        float suma_decimales=decimal_1+decimal_2;\n        System.out.println("La suma de los n\u00fameros es "+suma_decimales);\n    }\n }<\/code><\/pre><\/div>\n\n\n\n
      La suma de las cadenas es 23.4178.245\nLa suma de los n\u00fameros es 101.655<\/code><\/pre><\/div>\n\n\n\n
      Debemos tener cuidado al utilizar estados m\u00e9todos anteriores, ya que, si intentamos obtener un tipo de dato de una cadena que no puede transformarse en ese tipo de dato, al ejecutar el c\u00f3digo obtendremos un error de c\u00f3digo.<\/p>\n\n\n\n
      public class Dividir {\n    public static void main(String[] args) {\n        String cadena1="23.41";\n        int mi_entero=Integer.parseInt(cadena1);\n        System.out.println(mi_entero);\n    }\n }<\/code><\/pre><\/div>\n\n\n\n
      Exception in thread "main" java.lang.NumberFormatException: For input string: "23.41"<\/code><\/pre><\/div>\n\n\n\n
      Una variable de un tipo num\u00e9rico puede contener un dato num\u00e9rico de otro tipo con algunas restricciones.<\/p>\n\n\n\n
      Si el tipo de dato num\u00e9rico de origen tiene menor precisi\u00f3n que el dato que vamos a obtener no habr\u00e1 ning\u00fan problema, ya que el dato no va a perder precisi\u00f3n con el cambio. Por ejemplo, una variable tipo double puede contener un dato tipo int o float,  y una variable tipo float puede contener un dato tipo int.<\/p>\n\n\n\n
      En cambio si intentamos cambiar el sentido de la conversi\u00f3n, por ejemplo pasar a una variable tipo int un dato tipo double, en este caso s\u00ed que habr\u00e1 problemas, ya que estamos perdiendo precisi\u00f3n en el dato.<\/p>\n\n\n\n
      Veamos el siguiente ejemplo:<\/p>\n\n\n\n
      public class Prueba3 {\n    public static void main(String[] args) {\n        int a=4;\n        int b=3;\n        int c= Math.pow(a,b);\n        System.out.println(c);\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
      Si intentamos compilar el c\u00f3digo anterior, nos saltar\u00e1 una incompatibilidad de variables. Esto es debido a que la funci\u00f3n Math.pow siempre devuelve un dato tipo double, que no podr\u00e1 ser asignado directamente a un dato tipo int.<\/p>\n\n\n\n
      Para poder compilar el c\u00f3digo anterior, necesitamos hacer una conversi\u00f3n expl\u00edcita:<\/p>\n\n\n\n
      public class Prueba3 {\n    public static void main(String[] args) {\n        int a=4;\n        int b=3;\n        int c= (int)Math.pow(a,b);\n        System.out.println(c);\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
      Resultado:\n\n64<\/code><\/pre><\/div>\n\n\n\n
      Le hemos pedido a java que convierta el tipo double a int anteponiendo al dato (o variable) el c\u00f3digo \u00ab(int). En ocasiones se puede perder precisi\u00f3n con el cambio, por ejemplo si el dato num\u00e9rico contiene decimales.<\/p>\n\n\n\n
      public class Prueba3 {\n    public static void main(String[] args) {\n        double a=4.34;\n        double b=3.17;\n        int c= (int)(a+b);\n        System.out.println(c);\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
      Resultado:\n\n7<\/code><\/pre><\/div>\n\n\n\n
      El resultado que nos da de tipo int es 7, sin embargo 4.34+3.17=7.51<\/p>\n\n\n\n
      Amb\u00edto de las variables<\/mark><\/em><\/strong>. Un dato muy importante es el lugar donde est\u00e1 declarada una variable, tanto si es num\u00e9rica como si es de tipo String.<\/p>\n\n\n\n
      Una variable ser\u00e1 v\u00e1lida dentro del \u00e1mbito donde est\u00e9 definida. Este \u00e1mbito quedar\u00e1 limitado generalmente por el par de llaves m\u00e1s pr\u00f3ximo al que pertenezca.<\/p>\n\n\n\n
      public class Prueba3 {\n    public static void main(String[] args) {\n        String dia="Lunes";\n        if (dia=="Lunes"){\n            int dia_semana=1;\n            System.out.println("D\u00eda semana: "+dia_semana);\n        }\n        int dia_despues=dia_semana+1;\n        System.out.println("D\u00eda despues: "+dia_despues);\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
      El c\u00f3digo anterior nos dar\u00e1 error al compilarse. Detectar\u00e1 que la variable dia_semana pertenece al bloque if, y hemos tratado de utilizarla fuera de dicho bloque.<\/p>\n\n\n\n
      La soluci\u00f3n estar\u00eda en declarar la misma variable fuera del bloque.<\/p>\n\n\n\n
      public class Prueba3 {\n    public static void main(String[] args) {\n        int dia_semana=0;\n        String dia="Lunes";\n        if (dia=="Lunes"){\n            dia_semana=1;\n            System.out.println("D\u00eda semana: "+dia_semana);\n        }\n        int dia_despues=dia_semana+1;\n        System.out.println("D\u00eda despues: "+dia_despues);\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
      Resultado:\n\nD\u00eda semana: 1\nD\u00eda despues: 2<\/code><\/pre><\/div>\n\n\n\n
      <\/p>\n\n\n\n
      Inicio<\/a><\/td>Comandos Java<\/a><\/td>Bloques de c\u00f3digo.<\/a><\/td><\/tr>
      Comentar c\u00f3digo<\/a><\/td>System.out.print<\/a><\/td>Scanner (System.in)<\/a><\/td><\/tr>
      Captura de errores<\/a><\/td>String<\/a><\/td>Datos  Num\u00e9ricos<\/a><\/td><\/tr>
      Elementos aleatorios<\/a><\/td>Datos Fecha\/hora<\/a><\/td>Constantes<\/a><\/td><\/tr>
      Bucles for<\/a><\/td>Bucles while<\/a><\/td>Bloque if<\/a><\/td><\/tr>
      Arrays<\/a><\/td>ArrayList<\/a><\/td>switch case<\/a><\/td><\/tr>
      HashSet<\/a><\/td>HashMap<\/a><\/td>M\u00e9todos.<\/a><\/td><\/tr>
      Clases<\/a><\/td>Archivos<\/a><\/td>Entorno gr\u00e1fico Swing<\/a><\/td><\/tr>
      JFrame (Ventanas)<\/a><\/td>Componentes b\u00e1sicos.<\/a><\/td><\/td><\/tr><\/tbody><\/table><\/figure>\n","protected":false},"excerpt":{"rendered":"
      Correspondencia en Python —> Existen principalmente dos tipos de datos num\u00e9ricos en Java: Con este tipo de datos, se pueden efectuar operaciones que normalmente se almacenar\u00e1n en una variable. Operaciones con datos num\u00e9ricos. Adem\u00e1s de las operaciones b\u00e1sicas (suma, resta, multiplicaci\u00f3n o divisi\u00f3n), con los datos tipo num\u00e9ricos se pueden hacer otras operaciones. Debemos de tener […]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":0,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"","meta":{"footnotes":""},"class_list":["post-114","page","type-page","status-publish","hentry"],"_links":{"self":[{"href":"https:\/\/java.nosoyia.es\/index.php?rest_route=\/wp\/v2\/pages\/114","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/java.nosoyia.es\/index.php?rest_route=\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/java.nosoyia.es\/index.php?rest_route=\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/java.nosoyia.es\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/java.nosoyia.es\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=114"}],"version-history":[{"count":12,"href":"https:\/\/java.nosoyia.es\/index.php?rest_route=\/wp\/v2\/pages\/114\/revisions"}],"predecessor-version":[{"id":298,"href":"https:\/\/java.nosoyia.es\/index.php?rest_route=\/wp\/v2\/pages\/114\/revisions\/298"}],"wp:attachment":[{"href":"https:\/\/java.nosoyia.es\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=114"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}