Bienvenidos a otro capítulo de este Curso Gratis de Java para Hackers – Tipos de Datos Primarios. Comparte este articulo y síguenos para recibir más capítulos, guías y cursos gratis.
Este curso está en constante actualización. Tendrá revisiones y actualizaciones anuales y correcciones y mejoras mensuales. Este curso está en un ciclo de crecimiento y mejora constante, agradecemos su apoyo difundiendo, compartiendo, comentando o simplemente leyéndolo.
¿Te gustaría enterarte de cuando lanzamos descuentos y nuevos cursos?
El tipo de datos de bytes
El tipo de datos de byte es un entero en complemento a dos con signo de 8 bits. Es útil para ahorrar memoria en matrices grandes.
Sintaxis:
byte byteVar;
- El tipo de datos de byte es un entero en complemento a dos con signo de 8 bits
- El valor mínimo es -128 (-2^7)
- El valor máximo es 127 (inclusive)(2^7 -1)
- El valor predeterminado es 0
- El tipo de datos byte se utiliza para ahorrar espacio en matrices grandes, principalmente en lugar de números enteros, ya que un byte es cuatro veces más pequeño que un número entero.
- Ejemplo: byte a = 100, byte b = -50
El tipo de datos short (cortos)
El tipo de datos cortos es un entero en complemento a dos con signo de 16 bits. De forma similar al byte, utilice un short para ahorrar memoria en matrices grandes, en situaciones en las que el ahorro de memoria realmente importa.
Sintaxis:
short shortVar;
- El tipo de datos cortos es un entero en complemento a dos con signo de 16 bits.
- El valor mínimo es -32.768 (-2^15)
- El valor máximo es 32.767 (inclusive) (2^15 -1)
- El tipo de datos corto también se puede utilizar para ahorrar memoria como tipo de datos de byte. Un corto es 2 veces más pequeño que un número entero.
- El valor predeterminado es 0.
- Ejemplo: s corta = 10000, r corta = -20000
El tipo de datos int (Enteros)
Es un entero en complemento a dos con signo de 32 bits.
Recuerde: en Java SE 8 y posteriores, podemos usar el tipo de datos int para representar un entero de 32 bits sin signo, que tiene un valor en el rango [0, 2 32 -1]. Utilice la clase Integer para utilizar el tipo de datos int como un entero sin signo.
Sintaxis:
int intVar;
- El tipo de datos int es un entero en complemento a dos con signo de 32 bits.
- El valor mínimo es – 2.147.483.648 (-2^31)
- El valor máximo es 2.147.483.647 (inclusive) (2^31 -1)
- El número entero se utiliza generalmente como tipo de datos predeterminado para valores integrales, a menos que exista preocupación por la memoria.
- El valor predeterminado es 0
- Ejemplo − int a = 100000, int b = -200000
El tipo de datos Long (largos)
El alcance de un largo es bastante grande. El tipo de datos long es un entero en complemento a dos de 64 bits y es útil para aquellas ocasiones en las que un tipo int no es lo suficientemente grande para contener el valor deseado. El tamaño del tipo de datos largo es de 8 bytes (64 bits).
Sintaxis:
long longVar;
Recuerde: en Java SE 8 y versiones posteriores, puede utilizar el tipo de datos largo para representar una longitud de 64 bits sin signo, que tiene un valor mínimo de 0 y un valor máximo de 2 64 -1. La clase Long también contiene métodos como comparar sin firmar, dividir sin firmar, etc. para admitir operaciones aritméticas durante largos sin firmar.
- El tipo de datos largos es un entero en complemento a dos con signo de 64 bits
- El valor mínimo es -9.223.372.036.854.775.808(-2^63)
- El valor máximo es 9.223.372.036.854.775.807 (inclusive)(2^63 -1)
- Este tipo se utiliza cuando se necesita un rango más amplio que int
- El valor predeterminado es 0L
- Ejemplo: largo a = 100000L, largo b = -200000L
El tipo de datos flotante
El tipo de datos flotante es un punto flotante IEEE 754 de 32 bits de precisión simple. Utilice un flotante (en lugar de un doble) si necesita ahorrar memoria en grandes matrices de números de punto flotante. El tamaño del tipo de datos flotante es de 4 bytes (32 bits).
Sintaxis:
float floatVar;
- El tipo de datos flotante es un punto flotante IEEE 754 de 32 bits de precisión simple
- Float se utiliza principalmente para ahorrar memoria en grandes matrices de números de punto flotante.
- El valor predeterminado es 0.0f
- El tipo de datos flotante nunca se utiliza para valores precisos como la moneda.
- Ejemplo: flotador f1 = 234,5f
El tipo de datos doble
El tipo de datos doble es un punto flotante IEEE 754 de 64 bits de doble precisión. Para valores decimales, este tipo de datos suele ser la opción predeterminada. El tamaño del tipo de datos doble es de 8 bytes o 64 bits.
Sintaxis:
double doubleVar;
Nota: Tanto el tipo de datos flotante como el doble se diseñaron especialmente para cálculos científicos, donde los errores de aproximación son aceptables. Si la precisión es la preocupación más importante, se recomienda no utilizar estos tipos de datos y utilizar la clase BigDecimal en su lugar.
- El tipo de datos doble es un punto flotante IEEE 754 de 64 bits de doble precisión.
- Este tipo de datos se utiliza generalmente como tipo de datos predeterminado para valores decimales, generalmente la opción predeterminada
- El tipo de datos doble nunca debe usarse para valores precisos como la moneda.
- El valor predeterminado es 0.0d
- Ejemplo − doble d1 = 123,4
El tipo de datos booleano
El tipo de datos booleano representa solo un bit de información, ya sea verdadero o falso , que pretende representar los dos valores de verdad de la lógica y el álgebra booleana, pero el tamaño del tipo de datos booleano depende de la máquina virtual . Los valores de tipo booleano no se convierten implícita o explícitamente (con conversiones) a ningún otro tipo. Pero el programador puede escribir fácilmente código de conversión.
Sintaxis:
boolean booleanVar;
- El tipo de datos booleano representa un bit de información.
- Sólo hay dos valores posibles: verdadero y falso.
- Este tipo de datos se utiliza para indicadores simples que rastrean condiciones de verdadero/falso.
- El valor predeterminado es falso
- Ejemplo − booleano = verdadero
El tipo de datos char (Carácter)
El tipo de datos char es un único carácter Unicode de 16 bits con un tamaño de 2 bytes (16 bits).
Sintaxis:
charcharVar;
- El tipo de datos char es un único carácter Unicode de 16 bits.
- El valor mínimo es ‘\u0000’ (o 0)
- El valor máximo es ‘\uffff’ (o 65.535 inclusive)
- El tipo de datos Char se utiliza para almacenar cualquier carácter.
- Ejemplo: letra de carácter A = ‘A’
Ejemplo: demostración de diferentes tipos de datos primitivos
Los siguientes ejemplos muestran el uso de varios tipos de datos primitivos que hemos discutido anteriormente. Hemos utilizado operaciones de suma en tipos de datos numéricos, mientras que las variables booleanas y de caracteres se imprimen como tales.
public class JavaTester {
public static void main(String args[]) {
byte byteValue1 = 2;
byte byteValue2 = 4;
byte byteResult = (byte)(byteValue1 + byteValue2);
System.out.println("Byte: " + byteResult);
short shortValue1 = 2;
short shortValue2 = 4;
short shortResult = (short)(shortValue1 + shortValue2);
System.out.println("Short: " + shortResult);
int intValue1 = 2;
int intValue2 = 4;
int intResult = intValue1 + intValue2;
System.out.println("Int: " + intResult);
long longValue1 = 2L;
long longValue2 = 4L;
long longResult = longValue1 + longValue2;
System.out.println("Long: " + longResult);
float floatValue1 = 2.0f;
float floatValue2 = 4.0f;
float floatResult = floatValue1 + floatValue2;
System.out.println("Float: " + floatResult);
double doubleValue1 = 2.0;
double doubleValue2 = 4.0;
double doubleResult = doubleValue1 + doubleValue2;
System.out.println("Double: " + doubleResult);
boolean booleanValue = true;
System.out.println("Boolean: " + booleanValue);
char charValue = 'A';
System.out.println("Char: " + charValue);
}
}Producción
Byte: 6
Short: 6
Int: 6
Long: 6
Float: 6.0
Double: 6.0
Boolean: true
Char: A
Ejemplo
Ya estamos en condiciones de diseñar programas sencillos que usen números enteros. Computémosla suma de los primeros cinco números naturales. Un entero o int, i, mantiene el valor del número entero que debe ser acumulado a la suma y otro entero, sum, mantiene los valores intermedios de la suma.
Es bastante tedioso que para un programa tan sencillo se deba tipear tanto, más aún cuando repetimos dos instrucciones (i = i+1 y sum = sum + i) cinco veces cada una.
existen varios métodos para realizar estas repeticiones en forma concisa (observa que este problema se resuelve matemáticamente en forma más sencilla: la suma de los primeros n números naturales es: n(n + 1)/2).
El rango de intes lo suficientemente grande como para abarcar casi todos los casos que necesitaremos. de hacer falta, Java provee el tipo Long para números mucho más grandes. Los enteros de tipo Long reciben los valores con una L al final del número, por ejemplo:
Ejemplo
final long VELOCIDADLUZ = 300000000L //velocidad de la luz en metros por segundo
La anterior esuna declaración válida. No es conveniente trabajar con longsi no es necesario, puesto que ocupan mucho más lugar en memoria que los int. Los números de tipo longpermiten escribir todos los números enteros de hasta 18 cifras.
Veamos ahora formas equivalentes de realizar asignaciones. La expresión sum += i es equivalenteasum = sum + i. Las expresiones -= i y *=i son expresiones análogas para la resta y el producto.
Finalmente, incrementar o decrecer una variable en uno se puede escribir como i++ o i–, respectivamente. Si la variable ocurre en una expresión, entonces esta es cambiada después de ser usada.
En cambio, cuando ponemos ++i o –i, la variable se incrementa (o la hacemos decrecer) antes de ser usada. Con estas convenciones, el programa anterior se puede reescribir:
Ejemplos
//Ejemplo de promocion de valores de diferentes tipos
class Ejemplo25 {
public static void main(String args[]) {
byte b = 42;
char c = ‘a’;
short s = 1024;
int i = 50000;
float f = 5.67f;
double d =0.1234;
double resultado = (f * b) + (i / c) – (d * s);
System.out.println((f * b) + » + » + (i / c) + » – » + (d * s));
System.out.println(«resultado = » + resultado);
}
}
Tipo de datos boolean
Java permiten hacer preguntas sobre los estados (variables) y obtener como respuesta un verdadero o falso (true o false, respectivamente). Un caso típico es cuando queremos repetir un bloque de instrucciones cierta cantidad de veces, digamos, por ejemplo, cincuenta veces.
Cada vez que el programa termina de ejecutar el bloque, debe preguntar si ya ha hecho la repetición cincuenta veces, y en base a la respuesta, tomar la acción adecuada.
Para lograr lo anterior, usualmente se define una variable, digamos cuenta, que se inicializa en 1 y luego se ejecuta el bloque repetidas veces.
Cada vez que se termina de ejecutar el bloque, el programa pregunta si cuenta < 50, si es así (es decir si el programa devuelve true), se le suma uno a cuenta (cuenta = cuenta + 1) y se ejecuta el bloque de nuevo.
Cuando cuenta < 50 es false, el programa continúa con las instrucciones que siguen al bloque. Todos los tipos de datos primitivos Java pueden ser comparados usando el test de igualdad (==) o el de desigualdad (!=).
Los tipos numéricos o el tipo carácter tiene un orden y pueden ser comparados usando relaciones de orden: < (menor que), <= (menor igual que), > (mayor que), >= (mayor igual que).
Todas las condiciones anteriores devuelven true cuando el test se verifica, y devuelven false en caso de que no se verifique. Una expresión booleana es una expresión para la cual tiene sentido preguntar si es verdadera o falsa (por ejemplo, contar < 50).
Para declarar expresiones booleanas, usamos la palabra reservada boolean. El operador unario ! invierte el valor de la expresión booleana, es decir !true es false y viceversa.
Resultado de las operaciones lógicas con dos variables Boolean P y Q
| P | Q | !P | P==Q | P!=Q | P||Q | P&&Q |
| true | true | False | true | False | true | true |
| true | false | false | false | True | true | false |
| false | true | false | false | True | true | false |
| false | false | false | true | False | false | false |
Dadas las declaraciones
boolean result;
int a, b;
cada una de las siguientes expresiones booleanas hacen que result sea true
// las siguientes son verdaderas:
result = 42 == (41+1); // mismo valor: 42
result = 42 >= 42; // 42 y 42 son iguales
result = ’A’ < ’B’; // ’B’ esta después en el alfabeto
result = ’A’ == 65; // en ASCII el codigo de ’A’ es 65
result = Math.sqrt(4.0) == 2.0;
result = ((a/b)*b + (a%b)) == a;// siempre verdadero
result = a == a; // cualquier valor es igual a si mismo
result = (a != a) == false;
result = !false;
result = true == true; // true es igual a truemientras que las siguientes hacen que result sea false
// las siguientes son falsas:
result = 42 != 42;
result = !(42 == 42);
result = ’a’ == ’A’; //minúscula y mayúscula son
//diferentes
result = !true;
result = true == false;Serie de operaciones
Hay una serie de operaciones que combinan expresiones booleanas para obtener otras más complejas:
|| (o lógico) y && (y lógico). Estos operadores toman dos valores
booleanos y nos devuelven otro. El operador o devuelve true si alguna de las dos expresiones es true. El operador y devuelve true solo si las dos expresiones son true. Podemos ver, por ejemplo, si un valor se encuentre entre 100 y 200, combinado dos test:
boolean entre = (100 < a) && (a < 200);
El resultado es true cuando a es más grande que 100 y más pequeño que 200. Podemos hacer una expresión cuyo valor es false de la siguiente manera:
result = (100 > a) && (a > 200);
Esto no es posible, pues ningún valor puede ser menor que 100 y mayor que 200. Una expresión que siempre es falsa es llamada una falacia. Una expresión que siempre es verdadera es llamada una tautología. La siguiente expresión es una tautología:
result = (100 < a) || (a < 200);
Esta expresión siempre es verdadera, pues cualquier entero es mayor que 100 o menor que 200. Debemos evitar incluir tautologías o falacias en los programas, es mejor asignar el valor (true o false) directamente. Un error muy común es tratar de escribir expresiones lógicas usando
abreviaturas de las expresiones matemáticas. Por ejemplo,
entre = 100 < a < 200; // queremos ver si 100 < a y a < 200
El compilador interpreta esta instrucción como
entre = ((100 < a) < 200);
La primera comparación genera un boolean, por lo tanto, la segunda comparación no tiene sentido.
Veamos un poco más
Al escribir expresiones lógicas complicadas, debemos asegurarnos de representar lo que queremos decir. Es bueno seguir el siguiente principio: Use paréntesis para hacer explícito el orden de evaluación.
una expresión booleana larga puede ser simplificada con poco trabajo. tener en cuenta que como true es el elemento neutro del test de igualdad, una expresión del tipo a == true, se puede reemplazar por a. Por otro lado, la expresión a == false, se puede reemplazar por !a.
Recuerde, ambas palabras han sido declaradas como palabra clave. El tipo booleano se indica con la palabra clave booleano y utiliza solo 1 bit de almacenamiento.
public class Demo {
public static void main(String[] args) {
boolean t = true;
System.out.println(t);
boolean f = false;
System.out.println(f);
}}
Producción:
true
false
Tipo de datos de caracteres.
Los tipos de dato char nos permiten representar los caracteres simples. Los valores a, B, 3 y & son todos caracteres válidos. Los valores de los caracteres siempre aparecerán entre los símbolos y.
Luego, a se refiere a un carácter, mientras que a se podría referir a una constante o una variable. El siguiente bloque de programa Java
har grade;
grade = ’A’;
System.out.println( grade );
Imprimirá
A
Los caracteres simples no son en realidad demasiado útiles por sí mismos. Las que son más útiles son las palabras o cadenas de caracteres. Veremos esa clase de expresiones que serán de tipo string. Quizás lo más interesante del tipo char es que es casi un sinónimo del tipo int.
A cada carácter se le asigna un entero, el 97 a la a, el 98 a la b y así sucesivamente hasta la z. Luego seguimos con las mayúsculas en el orden alfabético. Todas las operaciones que hemos definido para enteros también valen para el tipo char. El fragmento de programa:
char firstLetter = ’a’;
System.out.println((int)firstLetter);
System.out.println(firstLetter);
genera como salida:
97
a
Este sencillo programa muestra que a es representado en la computadora por el número 97. Observemos que si queremos escribir con caracteres la palabra no, debemos poner las instrucciones
System.out.print(’n’);
System.out.print(’o’);
¿Por qué el tamaño del carácter es de 2 bytes en Java?
Por lo tanto, otros lenguajes como C/C++ usan solo caracteres ASCII, y para representar todos los caracteres ASCII son suficientes 8 bits. Pero Java usa el sistema Unicode, no el sistema de código ASCII , y para representar el sistema Unicode, 8 bits no son suficientes para representar todos los caracteres, por lo que Java usa 2 bytes para los caracteres. Unicode define un conjunto de caracteres totalmente internacional que puede representar la mayoría de los idiomas escritos del mundo. Es una unificación de docenas de conjuntos de caracteres, como el latín, el griego, el cirílico, el katakana, el árabe y muchos más.
Ejemplo:
// Java Program to Demonstrate Char Primitive Data Type
// Class
class laprovittera {
// Main driver method
public static void main(String args[])
{
// Creating and initializing custom character
char a = 'G';
// Integer data type is generally
// used for numeric values
int i = 89;
// use byte and short
// if memory is a constraint
byte b = 4;
// this will give error as number is
// larger than byte range
// byte b1 = 7888888955;
short s = 56;
// this will give error as number is
// larger than short range
// short s1 = 87878787878;
// by default fraction value
// is double in java
double d = 4.355453532;
// for float use 'f' as suffix as standard
float f = 4.7333434f;
// need to hold big range of numbers then we need
// this data type
long l = 12121;
System.out.println("char: " + a);
System.out.println("integer: " + i);
System.out.println("byte: " + b);
System.out.println("short: " + s);
System.out.println("float: " + f);
System.out.println("double: " + d);
System.out.println("long: " + l);
}
}Producción
char: G
integer: 89
byte: 4
short: 56
float: 4.7333436
double: 4.355453532
long: 12121
Caracteres: este grupo representa caracteres, que representan símbolos en un conjunto de caracteres, como letras y números. char: es un carácter Unicode sin firmar de 2 bytes (16 bits). Rango de 0 a 65.535.
ejemplo: char c=’a’;
Ejemplo
public class Demo {
public static void main(String[] args) {
char ch = ‘S’;
System.out.println(ch);
char ch2 = ‘&’;
System.out.println(ch2);
char ch3 = ‘$’;
System.out.println(ch3);
}
}
Producción:
S
&
$
Tipo de datos numéricos de punto flotante
Los números de punto flotante son aquellos que escribimos con decimales. Java usa la convención de escribir los decimales después de un punto (.). Por ejemplo, nosotros diríamos tres coma veinticinco; en Java lo escribimos 3.25.
la notación científica: los números son expresados de la forma a × 10n donde a es un decimal y n es un número entero. Por ejemplo, la luz viaja en el vacío a una velocidad aproximada de 3,00 × 108 metros por segundo. Podemos escribir el número 12/10000000000 como 1,20 × 10-9.
La notación en Java para la cantidad de días que tarda la Tierra en dar una vuelta alrededor del Sol es 365.2422 o 3.652422E2. Java provee dos tipos para números decimales, el tipo float y el tipo double.
El tipo float tiene un rango que va desde -3,4028 × 1038 a 3,4028 × 1038. permiten escribir decimales con hasta 45 decimales (y algunos más) y deben tener una f o F al final.
Los de tipo doublé, el rango va desde -1,7977 × 10308 a 1,7977 × 10308. pueden tener (es optativa) una d o D al final.
Ejemplo
float velocidad = 3E8F // velocidad de la luz
float velocidad = 3E+8F // velocidad de la luz
float nanoseg = 0.000000001F o float nanoseg = 1.00E-9F
// 1/1000000000 partes de un segundo
double pi = 3.14159265358979323E0D
double DIASDELAÑO = 3.652422e+2Por supuesto que en estos casos también contamos con los operadores numéricos habituales: +, -, *, / (aquí / produce el cociente exacto).
podemos manejar números enteros dentro de los tipos float o double, pero si estamos en esta situación y queremos trabajar dentro del tipo int, Java nos provee un método llamado moldeado o casting en inglés, para poder realizar esto.
El casting permite convertir un tipo en otro, su sintaxis general es:
( <tipo> ) <valor>
Los paréntesis angulosos se usan para remarcar un componente lógico y no se usan en la declaración real. A continuación, se presenta una sucesión de castings:
double r = 3.0E+2; // el valor de r (300) es declarado double float p;
int q;
q = (int)r; // es sin pérdida de información
p = (float)r; // r no es grande, luego no se pierde información
Java también hace moldeado automático, por ejemplo, si 3 es de tipo int y hacemos 3 + 5.5, entonces el compilador convierte 3 a tipo double y realiza la suma. Sin embargo, aunque la suma 3.5 + 5.5 de entera, Java no hace, en este caso, moldeado automático.
Número de coma flotante:
- Este grupo incluye flotador, doble
- float: Es un tipo de datos flotante de 4 bytes (32 bits). Valor predeterminado 0,0f. ejemplo: flotador ff=10.3f;
- doble: es un tipo de datos flotante de 8 bytes (64 bits). Valor predeterminado 0,0d. ejemplo: doble db=11.123;
Java
public class Demo {
public static void main(String[] args)
{
// float type
float f = 20.25f;
System.out.println(«f= » + f);
// double type
double d = 20.25;
System.out.println(«d= » + d);
}
}
Producción
f= 20,25
d= 20,25
Tipo de datos entero
Computemos la suma de los primeros cinco números naturales. Un entero o int, i, mantiene el valor del número entero que debe ser acumulado a la suma y otro entero, sum, mantiene los valores intermedios de la suma.
Ejemplo
Archivo CalculoSuma.java
// Calcula la suma de los primeros cinco numeros naturales
public class CalculoSuma {
public static void main(String args[])
{
int suma = 0;
int a = 1;
suma = suma + a; // suma vale 1
a = a+1; // a vale 2
suma = suma + i; // suma vale 3
a = a+1; // ahora a vale 3
suma = suma + a; // suma vale 6
a = a+1; // ahora a vale 4
suma = suma + a; // ahora suma vale 10
a = a+1; // ahora a vale 5
suma = suma + a; // ahora suma vale 15
System.out.println(suma); // muestra el valor de suma
}
}Es bastante tedioso que para un programa tan sencillo se deba tipear tanto, más aún cuando repetimos dos instrucciones (i = i + 1 y sum = sum + i) cinco veces cada una. (este problema se resuelve en forma más sencilla: la suma de los primeros n números naturales es: n(n + 1)/2).
El rango de int es lo suficientemente grande como para abarcar casi todos los casos que necesitaremos. Sin embargo, de hacer falta, Java provee el tipo long para números mucho más grandes. Los enteros de tipo long reciben los valores con una L al final del número, por ejemplo:
final long VELOCIDADLUZ = 300000000L //velocidad de la luz en metros por segundo
La anterior es una declaración válida. No es conveniente trabajar con long si no es necesario, puesto que ocupan mucho más lugar en memoria que los int. Los números de tipo long permiten escribir todos los números enteros de hasta 18 cifras.
Veamos ahora formas equivalentes de realizar asignaciones. La expresión
sum += i es equivalente a sum = sum + i.
Las expresiones -= i y *=i son expresiones análogas para la resta y el producto. Finalmente, incrementar o decrecer una variable en uno se puede escribir como i++ o i–, respectivamente.
Si la variable ocurre en una expresión, entonces esta es cambiada después de ser usada. En cambio, cuando ponemos ++i o –i, la variable se incrementa (o la hacemos decrecer) antes de ser usada. Con estas convenciones, el programa anterior se puede reescribir:
Ejemplo
archivo Suma.java
// Calculara la adicion de los primeros cinco números naturales
public class Suma {
public static void main(String args[])
{
int suma = 0;
int i = 1;
suma += i; // la suma vale 1
i++; // i vale 2
suma += i; // la suma vale 3
i++; // i vale 3
suma += i; // la suma vale 6
i++; // i vale 4
suma += i; // la suma vale 10
i++; // i vale 5
suma += i; // suma vale 15
System.out.println(sum);
}
}Entero: este grupo incluye byte, short, int, long
- byte: es un tipo de datos entero de 1 byte (8 bits). Rango de valores de -128 a 127. Valor predeterminado cero. ejemplo: byte b=10;
- breve: es un tipo de datos entero de 2 bytes (16 bits). Rango de valores de -32768 a 32767. Valor predeterminado cero. ejemplo: s corta=11;
- int: Es un tipo de datos entero de 4 bytes (32 bits). Rango de valores de -2147483648 a 2147483647. Valor predeterminado cero. ejemplo: int i=10;
- long: es un tipo de datos entero de 8 bytes (64 bits). El valor oscila entre -9.223.372.036.854.775.808 y 9.223.372.036.854.775.807. Valor predeterminado cero. ejemplo: largo l=100012;
Ejemplo:
public class Demo {
public static void main(String[] args)
{
// byte type
byte b = 20;
System.out.println(«b= » + b);
// short type
short s = 20;
System.out.println(«s= » + s);
// int type
int i = 20;
System.out.println(«i= » + i);
// long type
long l = 20;
System.out.println(«l= » + l);
}
}
Producción
b = 20
s = 20
i = 20
l = 20
Conclusión:
Toda variable en Java está asociada a un tipo. Esta asociación es llamada una declaración y ayuda al compilador a determinar el uso correcto de la variable en el programa.
Los tipos de datos primitivos tienen un rango de valores predeterminado.
Cualquier intento de asignarle a una variable un valor fuera del rango producirá un error de compilación.
Tipos diferentes tienen operaciones diferentes. Algunos operadores tienen diferente significado cuando se aplican a variables de diferentes tipos. Por ejemplo, / realiza la división entera en int o long y realiza la división exacta en float o double.
Valores primitivos de un tipo se convierten automáticamente (si fuera necesario) a un tipo de mayor precisión. Por ejemplo, una operación entre un int y un double hace que el valor int se convierta a double y después se realice la operación, dando por resultado un double.
También, podemos convertir datos de un tipo en otro usando casting.
No te detengas, sigue avanzando
Aquí tienes un propósito para este 2024 que debes considerar seriamente: si has querido mejorar tus habilidades en hacking, Ciberseguridad y programación ahora es definitivamente el momento de dar el siguiente paso. ¡Desarrolla tus habilidades aprovechando nuestros cursos a un precio increíble y avanza en tu carrera! El mundo necesita más hackers…
Universidad Hacking. Todo en Ciberseguridad. Curso Completo
Aprende Hacking Ético y Ciberseguridad sin necesitar conocimientos Previos. Practica Hacking Ético y Ciberseguridad aquí
Calificación: 4,6 de 5 (2.877 calificaciones) 15.284 estudiantes Creado por Alvaro Chirou • 1.800.000+ Enrollments Worldwide
Lo que aprenderás
- Seguridad informática
- Hacking Ético en profundidad
- Redes
- Programación (Python) (Hacking con Python)
- Análisis de Malware con laboratorios, practicas y ejecución de Malware para que veas su comportamiento.
- Cómo reforzar tu Privacidad y Anonimato
- Uso avanzado de Metasploit
- Top 10 de Owasp Web, Top 10 de Owasp mobile y Top 10 de Owasp API
- Seguridad informática para empresas
- Kali linux de 0 a 100, Veremos su suite de herramientas de hacking y como explotar fallos en sistemas.
- Termux y como hackear desde el celular
- Seguridad informática server/web, profundizaremos en WordPress
- Análisis de trafico en Wireshark
- Y mucho, pero mucho más
¿Esto que significa?
Hoy más que nunca, se necesitan personas capacitadas en este rubro para trabajar.
Por esa razón cree esta formación profesional para compartirte mis conocimientos y experiencia en la materia y puedas iniciar en este mundo del Hacking Ético y Ciberseguridad.
Te voy a estar acompañando en el proceso de aprendizaje, donde si estas empezando desde 0, sin conocimientos previos, no es un impedimento ya que iniciaremos como si no supieras nada de la materia.
Si sos una persona con conocimientos, podrás iniciar directamente en el nivel más avanzado o en el que tu elijas.
Como en todos mis cursos en udemy, tendrás muchísima practica para que materialices lo que vas aprendiendo.
Aprende con nuestros más de 100 cursos que tenemos disponibles para vos
No solo te enseñamos, tambien te guíamos para que puedas conseguir trabajo como desarrollador y hacker…
¿Te gustaría enterarte de cuando lanzamos descuentos y nuevos cursos?
Sobre los autores
Álvaro Chirou
Yo soy Álvaro Chirou, tengo más de 20 Años de experiencia trabajando en Tecnología, eh dado disertaciones en eventos internacionales como OWASP, tengo más de 1.800.000 estudiantes en Udemy y 100 formaciones profesionales impartidas en la misma. Puedes serguirme en mis redes:
Laprovittera Carlos
Soy Laprovittera Carlos. Con más de 20 años de experiencia en IT brindo Educación y Consultoría en Seguridad de la Información para profesionales, bancos y empresas. Puedes saber más de mi y de mis servicios en mi sitio web: laprovittera.com y seguirme en mis redes:
¿Quieres iniciarte en hacking y ciberseguridad pero no sabes por dónde empezar? Inicia leyendo nuestra guia gratuita: https://achirou.com/como-iniciarse-en-ciberseguridad-y-hacking-en-2024/ que te lleva de 0 a 100. Desde los fundamentos más básicos, pasando por cursos, recursos y certificaciones hasta cómo obtener tu primer empleo.