Java es un lenguaje fuertemente tipado, a diferencia de C, Java tiene una verificación de tipos muy estricta. Por ejemplo, en el lenguaje C, cuando imprime una variable de tipo doble como tipo int, el compilador del lenguaje C solo informará una advertencia, pero aún puede pasar. Java no funciona, informará directamente de un error, indicando que no se puede pasar la compilación. A continuación, introduzca los operadores y tipos de datos simples en Java.
Al introducir tipos de datos básicos (simples), primero presentamos dos cantidades: constantes y variables.
1.1, constantes
Las constantes son constantes que permanecen constantes mientras se ejecuta el programa. Por ejemplo, 12 meses al año, la gente tiene 10 dedos y así sucesivamente. También hay un concepto llamado constantes literales.
int a = 10;//a是常量，10是字面常量
String str = "hello world!";//str是常量，等号右边的量是字面常量。字面常量只能作为右值Las constantes literales son:
(1) Constantes de cadena: entre "", como "12345", "hola".
(2) Constante entera: el número escrito directamente en el programa (tenga en cuenta que no hay punto decimal), como: 100.
(3) Constantes de coma flotante: números decimales escritos directamente en el programa, como: 3.14, 0.49.
(4) Constante de carácter: un carácter encerrado entre comillas simples, como 'A', '1'.
(5) Constantes booleanas: solo hay dos tipos de verdadero y falso.
(6) Constante vacía: nula.
1.2, Variables
Una variable se refiere a una cantidad que se puede cambiar mientras se ejecuta un programa . Es equivalente a abrir un espacio de memoria para guardar algunos datos. En C, se puede crear una variable sin inicializarla, pero en Java no está permitido. Una vez que cree una nueva variable sin inicializarla, Java informará un error directamente. Y esto también demuestra que Java es un lenguaje con alta seguridad.
En Java, 1. Un nombre de variable solo puede contener números, letras y guiones bajos, 2. Los números no pueden comenzar, 3. Los nombres de las variables distinguen entre mayúsculas y minúsculas, es decir, num y Num son dos variables diferentes. Nota: aunque se permite sintácticamente el signo chino/dólar ($) para nombrar variables, se desaconseja enfáticamente . Las variables creadas deben nombrarse en forma de camello pequeño, como max, maxNum, foundMaxNum... Al nombrar, debe saber el nombre. Por ejemplo, la variable foundMaxNum significa encontrar el número más grande.
El tipo divide los tipos de variables, y los diferentes tipos de variables tienen diferentes características. En Java, según el número de bytes ocupados, los nombres de tipo de menor a mayor son: byte[tipo de byte](1) <= char[tipo de carácter](2) <= short(2) <= int(4) Además de <= float(4) <= long(8) <= double(8), también hay boolean[Boolean type](no se especifica el tamaño), String[String type]. En Java, estos tipos son independientes de los sistemas operativos de 32 y 64 bits.
1.3, Introducción a los tipos de datos básicos
En java, los tipos de datos se dividen principalmente en dos categorías: tipos de datos básicos y tipos de datos de referencia.
Expliquemos la situación de estos tipos de datos básicos en Java uno por uno.
Solo se da la asignación en int, las demás son de tipo int, y lo único que hay que explicar es la diferencia.
1.4, variables enteras
1.4.1 Variable entera int
// 方式一：在定义时给出初始值
int a = 10;
System.out.println(a);//10
// 方式二：在定义时没有给初始值，但使用前必须设置初值
int b;
b = 10;
System.out.println(b);//10Debe inicializarse o asignarse antes de su uso; de lo contrario, se informará de un error.
// 使用方式二定义后，在使用前如果没有赋值，则编译期间会报错
int c;
System.out.println(c);
c = 100;
Rango de int:
// int型变量所能表示的范围：
System.Out.println(Integer.MIN_VALUE);
System.Out.println(Integer.MAX_VALUE);
El Integer anterior es una clase contenedora para int, que es simplemente una versión mejorada de int. En función de por qué lo tiene, puede buscar genéricos de Java si está interesado. Utilice este método para conocer el rango de int.
El rango es - 2^31 ~ (2^31) - 1.
Precauciones:
(1) Int es de 4 bytes independientemente del sistema.
(2) Se recomienda utilizar la primera definición, si no hay un valor inicial adecuado, se puede establecer en 0.
(3) Al configurar el valor inicial de la variable, el valor no puede exceder el rango de representación de int, de lo contrario causará un desbordamiento.
(4) A la variable se le debe asignar un valor inicial antes de su uso, de lo contrario la compilación reportará un error.
(5) El tipo de empaquetado de int es Integer.
Para (3), ingresamos un número que no está en su rango, y el resultado será:
reportar un error directamente. Esto significa que al asignar un valor a una variable, Java comprueba el tamaño del valor. Si excede el rango, se informará un error, lo que demuestra que Java es un lenguaje muy seguro.
1.4.2 variable entera larga larga
int a = 10;
long b = 10; //long定义的长整型变量，虽然是long，但是编译器认为是int。需要加L。
System.out.println(a);//10
System.out.println(b);//10
long c = 10L; // 为了区分int和long类型，一般建议：long类型变量的初始值之后加L或者l
System.out.println(c);//10
long d = 10l; // 一般更加以加大写L，因为小写l与1不好区分，这里会报一个警告
System.out.println(d);//10de largo alcance:
// long型变量所能表示的范围：这个数据范围远超过 int 的表示范围. 足够绝大部分的工程场景使用.
System.out.println(Long.MIN_VALUE);
System.out.println(Long.MAX_VALUE);
Este es un rango muy grande, -2^63 ~ (2^63)-1.
Precauciones:
(1) Agregue L o l después del valor inicial de la variable entera larga, y se recomienda agregar L.
(2) Los enteros largos ocupan 8 bytes independientemente del sistema.
(3) El tipo de embalaje de largo es Largo.
1.4.3 entero corto corto
short a = 10;
System.Out.println(a);//10El rango es:
es -2^15 ~ (2^15) - 1.
Precauciones:
(1) Short ocupa 2 bytes bajo cualquier sistema.
(2) Tenga cuidado de no exceder el rango cuando lo use (generalmente menos usado).
(3) El tipo de empaque de corto es Corto.
1.4.4 Byte variable byte
byte b = 10;
System.Out.println(b);//10
// byte型变量所能表示的范围：
System.Out.println(Byte.MIN_VALUE);
System.Out.println(Byte.MAX_VALUE);
Este byte es un poco como char en lenguaje C, y su tamaño es -128 ~ 127. ¿Qué pasa con el carbón? Introducido más tarde.
Precauciones:
(1) byte ocupa 1 byte en cualquier sistema.
(2) El rango de bytes es: -128 ~ 127.
(3) El tipo de empaquetado de bytes es Byte.
1.5, flotador
1.5.1 Doble punto flotante de precisión doble
double d = 3.14;
System.Out.println(d);Mira un código como este:
double num = 1.1;
System.out.println(num * num); // 输出1.21吗？
Precauciones:
(1) double ocupa 8 bytes bajo cualquier sistema.
(2) Los números de coma flotante y los enteros se almacenan de diferentes maneras en la memoria y no se pueden calcular simplemente en forma de 2^n.
(3) El tipo de embalaje de doble es Doble.
(4) El diseño de la memoria del tipo doble sigue el estándar IEEE 754 (igual que el lenguaje C). Intentar usar un espacio de memoria limitado para representar decimales posiblemente infinitos inevitablemente tendrá un cierto error de precisión, por lo que los números de punto flotante son valores aproximados , no valores exactos. Solo puedo decir cuántos dígitos después del punto decimal son exactos.
1.5.2 Flotador de punto flotante de precisión simple
float num = 1.0f; // 写作 1.0F 也可以
System.out.println(num);//1.0Si está escrito como 1.0, el compilador pensará que es un tipo doble y reportará un error porque los tipos izquierdo y derecho no coinciden.
Precauciones:
(1) El tipo flotante ocupa cuatro bytes en Java.
(2) También cumple con el estándar IEEE 754.
(3) Debido al pequeño rango de precisión de los datos representados, generalmente se prefiere el doble cuando se usan números de coma flotante en ingeniería, y no se recomienda el uso de coma flotante.
(4) El tipo de embalaje de flotador es Flotador.
1.6, carácter variable char
char a = 'A'; // 大写字母
char b = '1'; // 数字字符
System.out.println(a);//A
System.out.println(b);//1
// 注意：java中的字符可以存放整形
char c = '字';
System.out.println(c);//字Precauciones:
(1) El carácter en Java es esencialmente un número entero. En el lenguaje C, el carácter está representado por el código ACSII, mientras que el carácter en Java está representado por Unicode. Por lo tanto, un carácter ocupa dos bytes, lo que representa más tipos de caracteres, incluido el chino.
(2) El tipo de empaque de char es Carácter
(3) El rango es 0 ~ 65535, que es completamente diferente de char en lenguaje C.
1.7, variable booleana booleana
El tipo booleano se utiliza para representar verdadero y falso.
boolean b = true;
System.out.println(b);//true
b = false;
System.out.println(b);//false
Precauciones:
(1) Solo hay dos valores para las variables de tipo booleano, verdadero significa verdadero y falso significa falso. No existe tal declaración en Java de que 0 es verdadero y no 0 es falso.
(2) El tipo booleano y el int de Java no se pueden convertir entre sí.
(3) En la especificación de la máquina virtual de Java, no se especifica claramente cuántos bytes ocupa el valor booleano, y no existe una instrucción de código de bytes especialmente utilizada para procesar el valor booleano. En la implementación de la máquina virtual de Oracle, el valor booleano ocupa 1 palabra. Festival.
(4) El tipo de empaquetado de booleano es booleano.
1.8, conversión de tipo
Java es un lenguaje de programación fuertemente tipado, cuando variables de diferentes tipos se asignan entre sí, hay una verificación más estricta. En Java, si el tipo de operación es incoherente, se realiza la conversión de tipo. Hay conversiones y moldes de tipo implícitos.
La conversión de tipo invisible generalmente ocurre cuando el rango de datos se cambia de un rango de datos pequeño a un rango de datos grande.
System.Out.println(1024); // 整型默认情况下是int
System.Out.println(3.14); // 浮点型默认情况下是double
int a = 100;
long b = 10L;
b = a; // a和b都是整形，a的范围小，b的范围大，当将a赋值给b时，编译器会自动将a提升为long类型，然后赋值
a = b; // 编译报错，long的范围比int范围大，会有数据丢失，不安全Lo mismo ocurre con otros tipos.
La conversión de tipo coercitivo ocurre cuando el código necesita procesar un cierto formato, que es la conversión de un rango de datos grande a un rango de datos pequeño.
int a = 10;
long b = 100L;
b = a; // int-->long，数据范围由小到大，隐式转换
a = (int)b; // long-->int, 数据范围由大到小，需要强转，否则编译失败Precauciones:
(1) La asignación entre variables de diferentes tipos digitales significa que un tipo con un rango más pequeño se puede convertir implícitamente en un tipo con un rango más grande.
(2) Si necesita asignar un tipo con un rango grande a un rango pequeño, debe convertir el tipo, pero se puede perder la precisión.
(3) Al asignar una constante de valor literal, Java verificará automáticamente el rango de números.
(4) Es posible que la conversión de tipos forzados no tenga éxito, y los tipos irrelevantes no se pueden convertir entre sí, como Boolean y otros tipos no se pueden convertir entre sí.
1.9, tipo promoción
Cuando se operan diferentes datos, el tipo de datos más pequeño se promoverá al tipo de datos más grande.
int a = 10;
long b = 10;
int c = a + b; // 编译出错: a + b ==> int + long --> long + long 赋值给int时会丢失数据
long d = a + b; // 编译成功：a + b ==> int + long --> long + long 赋值给longAhora echemos un vistazo al caso de los bytes.
byte a = 10;
byte b = 20;
byte c = a + b;
System.out.println(c);//结果是？
Encontramos que la idea reportó un error debido a tipos incompatibles. El valor l es de tipo byte y el valor r es de tipo int.
Al calcular, debido a que la computadora generalmente lee datos en unidades de 4 bytes, para la conveniencia del cálculo de hardware, el tipo con menos de 4 bytes se actualizará a int primero durante la operación y luego calculará. Los dos tipos de bytes del valor anterior igual a r se promocionan a int y el resultado también es int. Para lograr tal cálculo, es necesario realizar moldes.
Para el tipo de cadena de tipo de referencia, su situación es más complicada y necesita una explicación especial. Al escribir preguntas en Java, la entrada de datos generalmente se obtiene convirtiendo cadenas en varios tipos de datos. Los siguientes artículos son algunos resúmenes de la entrada de Java cuando elimino las preguntas. Si estás interesado, puedes ir y echar un vistazo.
Entrada y salida de tipos de datos comunes en 
Java
Para el tipo de cadena en Java, hay muchos métodos.El siguiente artículo es un resumen de lo que estoy haciendo. Si estás interesado, puedes ir y echar un vistazo.
Operaciones comunes de Java Strings_Naion's Blog-CSDN Blog_java String Operations
1.10, Resumen
