No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Curso de Introducci贸n a Java SE

Curso de Introducci贸n a Java SE

Anah铆 Salgado D铆az de la Vega

Anah铆 Salgado D铆az de la Vega

Tipos de datos num茅ricos

14/39
Recursos

Tipos de datos para n煤meros enteros (sin decimales):

  • byte: Ocupa 1 byte de memoria y su rango es de -128 hasta 127.
  • short: Ocupa 2 bytes de memoria y su rango es de -32,768 hasta 32,727.
  • int: Ocupa 4 bytes de memoria y su rango es de -2,147,483,648 hasta 2,147,483,647. Es muy c贸modo de usar, ya que no es tan peque帽o para que no quepan nuestros n煤meros ni tan grande como para desperdiciar mucha memoria. Puede almacenar hasta 10 d铆gitos.
  • long: Ocupa 8 bytes de memoria y su rango es de -9,223,372,036,854,775,808 hasta 9,223,372,036,854,775,807. Para diferenciarlo de un tipo de dato long debemos terminar el n煤mero con la letra L.

Por ejemplo:

// Int:
int n = 1234567890;

// Long:
long nL = 123456789012345L;

Tipos de datos para n煤meros flotantes (con decimales):

  • float: Ocupan 4 bytes de memoria y su rango es de 1.40129846432481707e-45 hasta 3.40282346638528860e+38. As铆 como long, debemos colocar una letra F al final.
  • double: Ocupan 8 bytes de memoria y su rango es de 4.94065645841246544e-324d hasta 1.79769313486231570e+308d.

Por ejemplo:

// Double:
double nD = 123.456123456;

// Float
float nF = 123.456F;

Aportes 98

Preguntas 23

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
       //byte, short, int, long
        System.out.println("bits tipo byte:" + Byte.SIZE);
        System.out.println("bytes tipo byte:" + Byte.BYTES);
        System.out.println("valor minimo tipo byte:" + Byte.MIN_VALUE);
        System.out.println("valor maximo tipo byte:" + Byte.MAX_VALUE);
        System.out.println();
        System.out.println("bits tipo short:" + Short.SIZE);
        System.out.println("bytes tipo short:" + Short.BYTES);
        System.out.println("valor minimo tipo short:" + Short.MIN_VALUE);
        System.out.println("valor maximo tipo short:" + Short.MAX_VALUE);
        System.out.println();
        System.out.println("bits tipo int:" + Integer.SIZE);
        System.out.println("bytes tipo int:" + Integer.BYTES);
        System.out.println("valor minimo tipo int:" + Integer.MIN_VALUE);
        System.out.println("valor maximo tipo int:" + Integer.MAX_VALUE);
        System.out.println();
        System.out.println("bits tipo long:" + Long.SIZE);
        System.out.println("bytes tipo long:" + Long.BYTES);
        System.out.println("valor minimo tipo long:" + Long.MIN_VALUE);
        System.out.println("valor maximo tipo long:" + Long.MAX_VALUE);

        byte byteVar = 15;
        System.out.println("byteVar = " + byteVar);
        short shortVar = 100;
        System.out.println("shortVar = " + shortVar);
        int intVar = 500;
        System.out.println("intVar = " + intVar);
        long longVar = 1000;
        System.out.println("longVar = " + longVar);

        var numero = 10;
        System.out.println("numero = " + numero);

    }
}```

Bien, explicado. Esos detalles que en la universidad ni explicaron :'V y Platzi me informa y ense帽a.

Me es incre铆ble como en el plan de estudios de mi carrera, en la materia de Java, s贸lo se limitaron a ense帽arnos 鈥渋nt鈥 sin siquiera decirnos que exist铆an otros tipos de datos. Por eso es bueno complementar la educaci贸n universitaria, para no quedarnos estancados y seguir aprendiendo鈥 Grande Platzi.

隆Hola!
Aqu铆 les dejo el c贸digo comentado, para que lo tengan de recordatorio 馃槂

public class DataTypes {
    public static void main(String[] args) {
        // Numero entero (max. 10 numeros)
        int n = 1234567890;

        //Para diferenciarlo de Int colocar una L al final
        long nL = 12345678901L;

        //Numero grande en decimales
        double nD = 123.456;
        
        //Para diferenciarlo de Double colocar una F al final
        float nF = 123.456F;

    }
}

byte: 1 byte
short: 2 bytes
int: 4 bytes
double : 4 bytes
long: 8 bytes

Obtener valor m谩ximo de int
No necesitas memorizar el valor m谩ximo o m铆nimo de un determinado tipo de dato num茅rico.
Una manera mas sencilla de saberlo es haciendo que Java nos lo diga:

System.out.println(Integer.MAX_VALUE);
System.out.println(Integer.MIN_VALUE);

Se hace uso de la clase equivalente al tipo de datos. Esto tambi茅n aplica para los dem谩s tipos de datos.

En Java los valores num茅ricos enteros se eval煤an como tipo int y los valores num茅ricos decimales como tipo ** double** es por eso que la siguiente sentencia marca error de compilaci贸n :

float decimalNumber = 5.3;

por eso se debe de colocar la letra 鈥渇鈥 para forzar que sea evaluada como float

float decimalNumber = 5.3f;

Estupenda clase instructora Anah铆, ahora noto la raz贸n por la que siempre usaba double en mis proyectos, ya que cuando usaba float me sal铆a error y no sab铆a que lo causaba as铆 que cambiaba al otro tipo de variable num茅rica. En adelante tendr茅 cuidado con esos detalles de las variable float y long.
Por cierto, para la persona que necesite el c贸digo ac谩 lo coloco:

public class DataTypes {
    public static void main(String[] args) {
        //int
        int n = 1234567890;
        //long
        long nL = 12345678901L;
        //double
        double nD = 123.456123456;
        //float
        float nF = 123.456F;
    }
}

ya sea para long o para float, se puede usar la L o F ya sea may煤scula o min煤scula.

long nL = 1234567890l;
float nF = 123.456f;

馃摝 Utilizar los tipos de datos de manera adecuada en Java, permite optimizar la memoria que utilizara la aplicaci贸n.

Una correcci贸n a esta clase y es que el tipo int no precisamente se usa para n煤meros de 10 caracteres sino para n煤meros comprendidos en el rango -2,147,483,648 a 2,147,483,648, por ejemplo no podrias tratar un n煤mero de celular como int en Colombia porque dar铆a error. Ejemplo:

int cel = 3110000000 // Integer number too large

Aplica para bases de datos, alguna vez tuve que trabajar una tabla donde todos los celulares eran 2147483648 y es porque se exced铆a el limite superior.

Creo que el que hizo Java dijo: 鈥淨uiero hacer todo de la manera mas complicada posible鈥

Al declarar un dato tipo long y float:
entero
long numero = 12345L;
Decimal
float numero2 = 123.12345F;

los demas byte, short, int y double son de la forma normal:
int numero2 = 123;

Gracias por lo datos adicionales y esos detalles que hacen la vida mas facil de llevar, la leta al final (que a muchos se nos olvida y estamos ahi, rompiendonos la cabeza) o cosas que simplemente no nos habian dicho antes.

Tipos de datos num茅ricos

En Java, se pueden utilizar los siguientes tipos de datos num茅ricos para n煤meros enteros

  1. Byte: ocupa 1 byte de memoria.
  2. Short: ocupa 2 bytes de memoria.
  3. int: ocupa 4 bytes de memoria
  4. long: ocupa 8 bytes de memoria.
    Nota: Para diferenciar un int de un long es necesario poner una 鈥楲鈥 al final del n煤mero de tipo long. Ejemplo:
long numLong = 1234L;

Para datos num茅ricos con punto decimal existen dos opciones: float y double.

  1. float: ocupa 4 bytes de memoria y no tiene tanta precisi贸n como double.
  2. double: ocupa 8 bytes de memoria y tiene m谩s precisi贸n que float.
    Para hacer la distinci贸n entre estos, es necesario poner una 鈥楩鈥 al final del n煤mero flotante. Ejemplo:
float numf = 1234F;

El bot贸n crear apuntes es algo que hab铆a pedido, hacia falta y esta muy bueno, estar铆a mucho mejor si cuando estoy viendo en pagina completa el video estuviera un bot贸n flotante mas chico tipo chat en la pantalla y al darle grabar al apunte se pusiera en play autom谩ticamente, seria mas practico y mas eficiente, gracias

No se menciona, pero, hay diferencia si se pone la letra L y/o F en mayuscula o minuscula?

Byte: (1 byte de memoria Ram) rango -128 a 127.
Short: (2 bytes de memoria Ram) rango -32,768 a 32,767.
Int: (4 bytes de memoria Ram) rango -2,147,483,648 a 2,147,483,647
long: (8 bytes de memoria Ram) rango -9,223,372,036,854,775,808 a -9,223,372,036,854,775,807

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
       //byte, short, int, long
        System.out.println("bits tipo byte:" + Byte.SIZE);
        System.out.println("bytes tipo byte:" + Byte.BYTES);
        System.out.println("valor minimo tipo byte:" + Byte.MIN_VALUE);
        System.out.println("valor maximo tipo byte:" + Byte.MAX_VALUE);
        System.out.println();
        System.out.println("bits tipo short:" + Short.SIZE);
        System.out.println("bytes tipo short:" + Short.BYTES);
        System.out.println("valor minimo tipo short:" + Short.MIN_VALUE);
        System.out.println("valor maximo tipo short:" + Short.MAX_VALUE);
        System.out.println();
        System.out.println("bits tipo int:" + Integer.SIZE);
        System.out.println("bytes tipo int:" + Integer.BYTES);
        System.out.println("valor minimo tipo int:" + Integer.MIN_VALUE);
        System.out.println("valor maximo tipo int:" + Integer.MAX_VALUE);
        System.out.println();
        System.out.println("bits tipo long:" + Long.SIZE);
        System.out.println("bytes tipo long:" + Long.BYTES);
        System.out.println("valor minimo tipo long:" + Long.MIN_VALUE);
        System.out.println("valor maximo tipo long:" + Long.MAX_VALUE);

        byte byteVar = 15;
        System.out.println("byteVar = " + byteVar);
        short shortVar = 100;
        System.out.println("shortVar = " + shortVar);
        int intVar = 500;
        System.out.println("intVar = " + intVar);
        long longVar = 1000;
        System.out.println("longVar = " + longVar);

        var numero = 10;
        System.out.println("numero = " + numero);

    }
}
public class DataTypes {
    public static void main(String[] args) {
        //byte, short, int, long
        System.out.println("==========TIPOS DE DATOS ENTEROS==========");
        System.out.println();

        System.out.println("BYTE");
        System.out.println("Ocupa una capacidad de: " + Byte.SIZE + " bits 贸 " + Byte.BYTES + " byte");
        System.out.println("Comprende desde " + Byte.MIN_VALUE + " hasta " + Byte.MAX_VALUE);
        System.out.println();

        System.out.println("SHORT");
        System.out.println("Ocupa una capacidad de: " + Short.SIZE + " bits 贸 " + Short.BYTES + " byte");
        System.out.println("Comprende desde " + Short.MIN_VALUE + " hasta " + Short.MAX_VALUE);
        System.out.println();

        System.out.println("INTEGER");
        System.out.println("Ocupa una capacidad de: " + Integer.SIZE + " bits 贸 " + Integer.BYTES + " byte");
        System.out.println("Comprende desde " + Integer.MIN_VALUE + " hasta " + Integer.MAX_VALUE);
        System.out.println();

        System.out.println("LONG");
        System.out.println("Ocupa una capacidad de: " + Long.SIZE + " bits 贸 " + Long.BYTES + " byte");
        System.out.println("Comprende desde " + Long.MIN_VALUE + " hasta " + Long.MAX_VALUE);
        System.out.println();

        //float,double
        System.out.println("==========TIPOS DE DATOS DE PUNTO FLOTANTE==========");
        System.out.println();

        System.out.println("FLOAT");
        System.out.println("Ocupa una capacidad de: " + Float.SIZE + " bits 贸 " + Float.BYTES + " byte");
        System.out.println("Comprende desde " + Float.MIN_VALUE + " hasta " + Float.MAX_VALUE);
        System.out.println();

        System.out.println("DOUBLE");
        System.out.println("Ocupa una capacidad de: " + Double.SIZE + " bits 贸 " + Double.BYTES + " byte");
        System.out.println("Comprende desde " + Double.MIN_VALUE + " hasta " + Double.MAX_VALUE);
        System.out.println();
        System.out.println();

        //float,double
        System.out.println("EJEMPLOS====================");
        System.out.println();

        byte byteVar = 15;
        System.out.println("byteVar = " + byteVar);
        short shortVar = 100;
        System.out.println("shortVar = " + shortVar);
        int intVar = 500;
        System.out.println("intVar = " + intVar);
        long longVar = 1000;
        System.out.println("longVar = " + longVar);
        float floatVar = 1.618033f;
        System.out.println("floatVar = " + floatVar);
        double doubleVar = 3.141592654;
        System.out.println("doubleVar = " + doubleVar);

        var numero = 10;
        System.out.println("numero = " + numero);

    }
}

Estaba jugando con el tipo de dato byte y me paso algo curioso.

Segun los rangos el valor minimo es -128 y el maximo es 127, as铆 que coloque en el IDE el valor 150 a ver como era el error pero el IDE me suguirio hacer un casteo o conversi贸n a byte de la siguiente forma

byte b3 = (byte) 150;

Pero al ejecutar un print la consola me arroja esto

System.out.println("B3: " + b3);
B3: -106

Enteros
Byte - 1 byte
short - 2 bytes
int - 4 bytes
long - 8 bytes

Punto flotante
float - 4 bytes
double - 8 bytes

Nunca llegue a pensar que colocando, o una L o una F en esos respectivos datos Long y Float, podieran hacer que se consideren como tal.

Un punto importante que le铆 es que los programas escritos en versiones anteriores de java (7, 8, etc) son compatibles con los jdk nuevos(11, 12, etc), pero no puedes correr un programa escrito con un jdk de java 11 en un entorno de jdk de java anterior, d铆gase 9, 8 etc. 馃槃

Si usan Linux y trabajn todo desde la consola, vean esta p谩gina. En la p谩gina van a ver como cambiar la version de Java que se est谩 usando, TODO DESDE LA TERMINAL!!
Les adelonto algo, este es el comando
update-alternatives --config java
den enter y leccionen el numero de la version y luego <Enter> otra vez. Listo!

Yo lo puse en un alias en mi ~/.bashrc que se ve as铆:
#change Java version
alias cjava=鈥榰pdate-alternatives --config java鈥
#note: cjava es porque en ingl茅s ser铆a tercnicamente 鈥渃hange java鈥

 byte b; // -128 a 127
        short s; // -32,768 a 32,767
        int i = 1234567890; // -2,147,483,648 a 2,147,483,648
        long l = 12345678901L; // -9223372036854775808 a 9223372036854775807

        double d = 123.123;
        float f = 123.123F;

en java como es un lenguaje fuertemente estereotipado el manejo de los tipos de variable es muy importante seg煤n hasta donde tengo entendido

esto lo vi hace mucho tiempo atras

No recordaba lo de la letra al final, muchas gracias 馃槃

Me interesa mucho.
Me lo hab铆an explicado mal antes 馃槂 , solo por esto te pongo carita feliz 馃槂

Para aquellos que precisan el codigo:

public class DataTypes {
    public static void main(String[] args) {
        int n = 1234567890;
        long nL = 12345678901L;

        double nD = 123.456;
        float nF = 123.456F;
    }
}

Slds!```

Es importante recordar que cuando utlizamos double o float debemos colocar la letra en may煤scula al final de los digitos. Es decir: float nF = 123.452F y long nL = 123.452L

Punto Flotante / double - 8 bytes / float - 4 bytes.

Tipos de datos num茅ricos, int, long, utillizar L may煤scula al final de declarar la variable.

Me encanto tu explicaci贸n sobre los tipos de datos.

Muy clara la explicacion.

  • Para el caso de datos con punto decimal (punto flotante) Java tambi茅n maneja una categor铆a interesante y es que tenemos dos tipos de datos que podemos utilizarlos como punto flotante o punto decimal, el m谩s com煤n es y nuestro comod铆n ser谩 el double:
  1. float
    Rango: 1.40129846432481707e-45 a 3.40282346638528860e+38 (4bytes)
  2. double
    Rango: 4.94065645841246544e-324d a 1.79769313486231570e+308d (8 bytes)
  • Gran variedad de tipos datos que existen en Java para clasificar a los datos de tipo entero; vamos a decir que un tipo de dato entero va a ser un n煤mero que no sea decimal; aqu铆 puede ser un n煤mero positivo o un n煤mero negativo que tenga un signo de menos al principio de ese n煤mero, pero siempre deber铆an ser enteros no deber铆an ser de punto con punto decimal, siempre enteros.

  • Dentro de los enteros hay:

  1. byte
    rango: ( -128 a 127) 1 byte
  2. short
    rango: (-32,768 a 32,767) 2bytes.
  3. int
    rango: (-2,147,483,648 a 2,147,483,647) 4 bytes
  4. long
    rango: (-9,223,372,036,854,775,808 a +9,223,372,036,854,775,807) 8 bytes
  • Tipos de variables que hemos visto:
  1. Variables tipo num茅ricas.
  2. Variables tipo string de cadenas de texto.

No conoc铆a lo de poner las letras al final

lo bueno que la casi todos los lenguajes usan los mismos tipos de variables

Realice una clase Family y modele las principales caracteristicas que puede tener un familiar, solo defini los parametros y en otra clase coloque el psvm donde imprimo las caracteristicas.

Comparto mi ejercicio realizado de esta clase.

y sobre todo con un buen sabor de boca ya que al comprender esto me permite poder entender que dependiendo de lo que har谩 el programa puedo usar un dato para que no se consuma mas memoria de lo necesario.

 // numeric types
        //type byte
        byte isByte = 12; //byte 1 byte  -128 to 127
        //type short
        short isShort = -32756; //short 2 bytes  -32,768 to 32,767
        //type int
        int isInt = 2147483647; //int 4 bytes -2,147,483,648 to 2,147,483,647
        //type long
        long myLong = -999999999L; //long 8 bytes -9,223,372,036,854,775,808 to 9,223,372,036,854,775,80

Aprendan bien sobre los tipos de datos y sus impactos en la memoria. Saber de esto les puede ahorrar dolores de cabeza.
Aqui un ejemplo:
Esto da falso. 驴Saben porque?

public class Variables {
    public static void main(String[] args) {
        float a = (float) 5.7;

        if(a == 5.7){
            System.out.println("Verdadero");
        }else {
            System.out.println("Falso");
        }
    }
}

Empec茅 a aprender Java SE en en mi primer semestre de la U y no me hab铆an explicado factores importantes como estos, aqu铆 se aprende m谩s a detalle.

[

Tipos de datos num茅rcios:
byte | -128 a 127
short | -32,728 a 32,797
int | -2,147,483,548 a 2,147,483,647
long | -9,223,372,035,854,775,808 a 9,223,372,036,854,775,807

es interesante saber esto pero la verdad siempre uso int y double

//int tiene un limite de 10 digitos
int n = 1234567890;

//solucion de twiter varaible LONG y s debe poner una "L" al final
long nl = 12345678901;
long nl = 12345678901L;

//Punto Flotante
double nD = 234.53459438508340;
//pro defecto detecta que es del tipo double
float xF = 234.53459438508340;
//deberemos agregar F al fnial
float nF = 234.53459438508340F;
  • Enteros:

  • Punto Flotante:

Cada variable utiliza espacio en memoria, por eso, es importante elegir el tipo de dato correcto para agilizar el funcionamiento del programa. 馃挌

Por cierto
Yo se que tiene que ver por el tipo de curso pero el Boolean es el m谩s peque帽o por solo contar con 1 bit (true y false).

public class TipoDatosNumericos {
    public static void main(String[] args) {
        //LOs tipos de datos tienen un limite
        byte numeroByte = 127;
        System.out.println("La cantidad de un byte a bites es de: " + Byte.SIZE);
        System.out.println("La cantidad de un byte a bytes es de: " + Byte.BYTES);
        System.out.println("El valor maximo de un byte es de: " + Byte.MAX_VALUE);
        System.out.println("El valor minimo de un byte es de: " + Byte.MIN_VALUE);

        short numeroShort = 32767;
        System.out.println("La cantidad de un short a bites es de: " + Short.SIZE);
        System.out.println("La cantidad de un short a bytes es de: " + Short.BYTES);
        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);

        int numeroInt = 2147483647;
        System.out.println("La cantidad de un int a bites es de: " + Integer.SIZE);
        System.out.println("La cantidad de un int a bytes es de: " + Integer.BYTES);
        System.out.println("El valor maximo de un int es de: " + Integer.MAX_VALUE);
        System.out.println("El valor minimo de un int es de: " + Integer.MIN_VALUE);

        long numeroLong = 9223372036854775807L;
        System.out.println("La cantidad de un long a bites es de: " + Long.SIZE);
        System.out.println("La cantidad de un long a bytes es de: " + Long.BYTES);
        System.out.println("El valor maximo de un long es de: " + Long.MAX_VALUE);
        System.out.println("El valor minimo de un long es de: " + Long.MIN_VALUE);

    }
}

Para ampliar los conceptos sobre los tipos de datos en Java y sus usos m谩s comunes.

https://javadesdecero.es/basico/tipos-datos-java-ejemplos/

Byte, Short, int, long
el tipo long permite mas datos numericos

Me gust贸 la ense帽anza con la empresa de Twitter me gustar铆a leer en post de todas la historia (que se comenta en la clase sobre las variables de los usuarios ). long (l). float(f).
public class DataTypes {
    public static void main(String[] args) {
        int n=1234567890;//digitos del 10 numeros
        long nL=12345678901L;//digitos de longitud de diferencia con la L al final
        Double nD=123.456;//digitos de tipo Double
        float nF=123.456F;//digito de tipo float se identicfica con la letra F al final

    }
}

long hay que escribir 鈥淟鈥 al final de la los n煤meros, mientras que para float se escribe una 鈥淔鈥.

byte: 1 byte
short: 2 bytes
int: 4 bytes
double : 4 bytes
long: 8 bytes

excelente no sabia que tenia que agregar las letras al final al menos en la universidad nunca me dijeron eso

Cosas que no sabias y ya las estas aprendiendo po eso nunca paren de aprender 鉂わ笍

int n = 1234567890;
long nL = 12345678901L;

    double nD = 123.456;
    float nF = 123.456F;

Super!!

indetificar tipo de datos colocando un idicador al final del valor de la variable.

package pkg01_variables;

public class Variables {

    /*
        Crea una variable de cada tipo:
            - byte
            - short
            - int
            - long
            - char
            - double
            - float
            - String
            - boolean
    
    */
    public static void main(String[] args) {
       
        //numeros enteros
        byte a=5;
        short b = 200;
        int c = 1000000;
        long d = 10000000000L;
        
        //caracter
        char e = 'a';
        
        double f = 4.5;
        float g = 4.5f;
        
        String h = "Hola mundo";
        
        boolean i = 5 > 10;
        
        
    }
    
}

鈥渆l secreto鈥 que menciona se ve en el proximo video y鈥 pues si que sorprendi贸.

Excelente recordatorio de los tipos de datos, en java que es un lenguaje fuertemente tipado

REPASO DE LA CLASE ANTERIOR;

-upper camel case,hacemos referencias a nombre de cosas SUPERIORES(UPPERS) en java

Comienza el mundo de los lenguajes tipados 馃槈

Genial! me recordaron cosas que hacia mucho no usaba y que son muy 煤tiles y adicionalemente aprend铆 a trabajar mejor los tipos de datos. Gracias!

no recordaba esto y vaya que si es muy importante

Aunque no da error si no lo ponemos, double necesita la letra d ya sea may/min al final de los decimales. Ejemplo:

double numDecimal = .1234567890D;

Excelente clase, no sab铆a que ten铆amos que agregar la letra L al tipo de dato long.

public class DataTypes {
public static void main(String[] args) {

    int n = 1234567890;

    long nL = 12345678901L;

    double nD = 123.456123456;

    float nF = 123.456F;
}

}

Todo muy claro hasta ahora.

Creo que est谩 es la primera raz贸n por la cual no me encantar谩 Java, eso de ponerle L o F a los tipos de datos Long o Double para que no salte errores se e hace feo.

Todo muy claro.

Excelente clase.

Muy claro todo

Todo claro鈥 gracias 馃槂

Tipos de datos num茅ricos:
Para n煤meros enteros
byte
short
int
long (se coloca una L al final de los d铆gitos)
Para n煤meros con decimales (flotantes)
double
float (se coloca una F al final de los d铆gitos)

馃槂

Genial, corregi un error que me genero de inmediato 馃槂

En lenguajes como C si sabemos que solo vamos a usar n煤meros positivos podemos especificarle al tipo de dato que todo lo que ocupe en memoria ram sea para n煤meros positivos. Se hace con 鈥渦nsigned鈥.

Entonces, en vez de que se puedan usar n煤meros negativos, todo el espacio disponible de la variable se va a usar solo para n煤meros positivos.

La p谩gina de Arduino lo explica muy bien: https://www.arduino.cc/reference/en/language/variables/data-types/unsignedint/

excelente explicacion y didactica鈥

Todo clar铆simo. Gracias

public class DataType {
    public static void main(String[] args) {

        //Tipos de datos
        //Byte -> de -128 a 127 (1 byte)
        //short -> -32768 a 32767 (2 bytes)
        //int -> -2147483648 a 2147483648 (4 bytes)
        //long -> -9223372036854775808 a 9223372036854775807 (8 bytes)
        //float -> 1.401 E-45 a 3.402 E38 (4 bytes)
        //double -> 4.9406 E-324 a 1.7976 E308 (8 bytes)

        int n = 1234567890; //El tipo de dato int soporta hasta 10 digitos
        long nL = 12134567890L; //Para identificar el long es necesario poner 'L' al final del n煤mero

        double nD = 123.456789123; //Se utiliza para c谩lculos matem谩ticos para m谩s precisi贸n, as铆 m铆smo utiliza m谩s memoria
        float nF = 123.456f; //Para identificar el float es necesario poner 'f' al final del n煤mero
    }
}

La 鈥淟鈥 que se pone al final para declarar el long va con may煤scula;

continuando con la clase

<public class DataTypes {
    public static void main(String[] args) {
        int n=1234567890;
        long nL=12345678901L;
        double nD=12121.50;
        float nF=1212.058F;

    }
}
>

geniaaal

Lo interesante entre el double y el flotante es que aunque tengas el mismo valor, float lo que hace es redondear (aproximar) el valor.
En el siguiente ejemplo vemos las 2 variables con el mismo valor pero lo que se imprime es diferente.
__



Esto es solo en la version 11 de JAVA?