Tipos de datos y variables y conversión de tipos, promoción (Java)

Uno: constantes literales

Cuando aprendemos un idioma, la primera constante literal que encontramos es "¡Hola mundo!"
Constantes: Durante la ejecución del programa, las cantidades fijas se denominan constantes.

public class Demo{
    
    
 public static void main(String[] args){
    
    
     System.Out.println("hello world!");
     System.Out.println(100);
     System.Out.println(3.14);
     System.Out.println('a');
     System.Out.println(true);
     System.Out.println(false);

Entre ellas, ¡hola mundo!, 100, 3.14, a, verdadero y falso son todas constantes literales. Las
constantes se pueden dividir en 6 categorías:
1. Constantes de cadena: encerradas por " ", como "¡Hola mundo!", etc.
2 .Constantes enteras: números escritos directamente, como: 100, etc.
3. Constantes de punto flotante: decimales escritos directamente, como: 3.14, etc.
4. Constantes de carácter: un solo carácter encerrado por ' ', como 'a ' Etc.
5. Constante booleana: solo verdadero y falso
6. Constante vacía: nulo

Dos: tipo de datos

Primero comprendamos qué es un tipo de datos.
Un tipo de datos es un alias para una memoria de tamaño fijo.
~~ Al definir una variable, debe elegir un tipo apropiado para definir de acuerdo con los diferentes valores que contendrá la variable en el futuro; en Java, los tipos de datos se dividen principalmente en datos básicos Hay dos . Hay cuatro tipos
de tipos de datos básicos : cuatro tipos: entero, punto flotante, carácter y booleano. Ocho tipos : byte, entero corto, entero, entero largo, punto flotante de precisión simple, punto flotante de precisión doble, carácter, booleano, como se muestra a continuación:

Nota:
1. Ya sea en un sistema de 16 bits o de 32 bits, int ocupa 4 bytes, ya sea en un sistema de 32 bits o en un sistema de 64 bits, long ocupa 8 bytes
2. Tanto el entero como el punto flotante son
3. El tipo entero es int por defecto, y el tipo de punto flotante es double por defecto
. 4. Las cadenas son tipos de referencia. Suplemento
: Byte es la unidad básica para representar el espacio en una computadora. Las computadoras usan binario para representar datos. Creemos que 8 Un bit es un byte (byte)
.Entre ellos: 1KB=1024Byte, 1M=1024KB, 1G=1024M, 1T=1024G.

Tres: Variables

3.1 Concepto

En el programa, además de las constantes constantes, algunos contenidos pueden cambiar con frecuencia, como: la edad de las personas, la altura, las calificaciones, los resultados de cálculos de funciones matemáticas, etc. A estos contenidos que cambian con frecuencia, en los programas Java, se les llama variables. Los tipos de datos se utilizan para definir diferentes tipos de variables.

3.2 Formato de sintaxis

tipo de datos nombre de variable = valor inicial;

int a=10;
double b=3.14;

3.3 Variables enteras

3.3.1 Definición de variables enteras

//在定义时给出初值,在任何的系统下都占有4个字节.
int a=10;
//定义前没有给初始值,使用前必须设置初始值.
//范围:-2147483648 ～ 2147483647  (-2^31 --> 2^31-1)
int b;
b=10

3.3.2 Definición de variables enteras largas

//为了区分int和long类型,一般在long类型变量的初始值之后加L或l
//long在任何的系统下都占有8个字节.
//L更好区分一点.
//long的表示范围为:-2^63 - 2^63-1 
long a=	10;
long b=10L;
long c=10L;

3.3.3 Definición de variables enteras cortas

//short表示的范围为:-32768~32767,-2^15 - 2^15-1 
//在任何的系统下都占有2个字节.
//short一般使用的比较少
short a=10;

3.3.4 Variable de bytes:

//byte在任何的系统下都占1个字节
//byte的范围是:-128~127,-2^7 ~ 2^7-1
byte a=10;

3.3.5 Punto flotante de precisión simple

//float 在任何系统下都占用4个字节,一般在数字后加上f或者F.
//float 的范围是:-2^31 - 2^31-1
float num=1.0f;

3.3.6 Punto flotante de doble precisión

//double在任何的系统下都占有8个字节.
//double的范围是:-2^63 - 2^63-1 
double a=1.0;
double b=2.0;
System.out.println(a/b);//输出0.5

double num=1.1;
System.out.println(num*num);//输出结果为:1.2100000000000002

3.3.7 Variables de carácter

//char占用2个字节,表示的范围是:-32768~32767,-2^15 - 2^15-1
//Java中使用 单引号+单个字母 的形式表示字符字面值
char c1= 'A';
char c2= '1';
//Java的字符型可以存放整型.
char c3= '牛';

3.3.8 Variables booleanas:

/* 1.   Java的虚拟机规范中,并没有明确规定boolean占几个字节,
		也没有专门用来处理boolean的字节码指令,
		在Oracle公司的虚拟机实现中,boolean占用1个字节.
   2.boolean 类型的变量只有两种取值, true 表示真, false 表示假
   3.Java 的 boolean 类型和 int 不能相互转换~~~
     不存在 1 表示 true, 0 表示 false 这样的用法.*/
boolean a=true;
boolean b=false;

4. Conversión de tipos de datos y promoción de tipos

4.1 Conversión de tipos de datos

En pocas palabras, es convertir una variable de un tipo de datos a otro tipo de datos. En el proceso de conversión, se deben seguir ciertas reglas y no se puede convertir a voluntad.La
idea básica: solo el mismo tipo se puede convertir arbitrariamente, y la conversión de bajo nivel a alto nivel se puede convertir automáticamente, pero la conversión de alto nivel a bajo nivel debe ser forzada.
La conversión de tipo en Java se divide en dos categorías: conversión de tipo automática (conversión de tipo implícita, es decir, tipo pequeño -> tipo grande) y conversión de tipo forzada (conversión de tipo explícita, es decir, tipo grande -> tipo pequeño).

4.1.1 Conversión automática de tipos (conversión implícita de tipos)

La conversión de tipo automática significa que el código no necesita someterse a ningún procesamiento, y el compilador lo procesará automáticamente cuando se compile el código.

byte b=10;
int c=100;
c=b
System.out.println(c);
/*b是小类型,c大类型的,进行隐式类型转换,
  将小类型的byte自动转换为大类型的int进行赋值*/
//例子:
float f=13.14f;
double d=99.99;
d=f;
System.out.println(d);

4.1.2 Coerción (Conversión de tipo explícita)

Cuando se realiza la operación, el código debe procesarse en un formato determinado y no puede completarse automáticamente.

byte b=10;
int c=100;
b=c;
/*
  此时代码会报错,因为b是byte型,是小类型的,而c是int型,相对与b来说是大类型的,
  当b=c时,相当于将大类型赋值给小类型,会出现数据的丢失,所以程序会报错.
  这个时候就需要强制类型转换.将b=c改为 b=(byte)c,程序就可以正常运行了;
*/
b=(byte)c;
System.out.println(b);
//例子:

float f=13.14f;
double d=99.99;
f=float(d);
System.out.println(f);

4.2 Tipo de promoción

Cuando diferentes tipos de datos se operan entre sí, el tipo de datos más pequeño se promoverá al tipo de datos más grande.

//例一:
byte b1=10;
byte b2=20;
int ret1=b1+b2;
System.out.println(ret1);  //30
byte ret2=b1+b2;//此行会报错:从int到byte会有数据的丢失
/*
   原因:在做加法运算时,b1,b2被提升为int类型了
   byte+byte===>int+int---->int
   解决方法:进行强制类型转换,把int型强转为byte型
   即:byte ret2=(byte)(b1+b2);
*/
byte ret2=(byte)(b1+b2);
System.out.println(ret2);
//例二:
byte ret3=10+20;//此行不会出错,编译通过.
System.out.println(ret3);
/*
	不会报错的原因:
	10+20===>int+int--->int.
	编译器在编译时,会直接计算10+20的结果
	相当于 byte ret3=30;
	30没有超过byte的取值范围,因此可以通过.
	但是在例一当中,b1,b2是变量,加完之后结果是否会超过byte的取值范围就不知道了.
*/

Conversión de cadenas:

String s1="hello";
String s2="1234";
System.out.println(s1);
System.out.println(s2);

String s3=" world!!!";
s1=s1+s3;
System.out.println(s1);//输出:hello world!!!

int a=1234;
//需求:将a转换为字符串类型
String s4=""+a;   //""为空字符串
System.out.println(s4);  //输出1234

String s5=String.valueof(a);
System.out.println(s5);  //输出1234
//需求:将数字类型字符串转换为整型数字
int b=Inteage.parseInt(s2);
System.out.println(b);  //输出1234