Java: conversión de tipo de datos, problema de desbordamiento

identificador

Los nombres de clases, nombres de variables y nombres de métodos se denominan identificadores.
Las palabras clave no se pueden usar como nombres de variables y los nombres de métodos
distinguen entre mayúsculas y minúsculas
y comienzan con letras, $, _

Tipo de idioma
Idioma fuertemente tipado
Requiere que se definan las variables antes de usar
Idioma débilmente tipado
Idioma donde los tipos de datos pueden ignorarse

tipo de datos

Tipo básico (tipo primitivo)
tipo de datos básico: entero, coma flotante, carácter, booleano
tipo entero - byte, corto, int, largo
tipo de coma flotante - flotante, doble
tipo de carácter - char
tipo booleano - booleano
p. ej.: bandera especial

long num1 = 30L;
float num2 = 30.1F;
tipo de referencia (tipo de interfaz)
tipo de datos de referencia: interfaz (interfaz), matriz ([ ]), clase (clase)

Expansión de tipos de datos

public class Demo1 {
    
    
    public static void main(String[] args) {
    
    
//整数拓展： 进制  二进制 0b  八进制 0   十进制    十六进制 0x

        int a1 = 10;              //十进制
        int a2 = 0b10;            //二进制
        int a3 = 010;             //八进制
        int a4 = 0x10;            //十六进制

        System.out.println(a1);   // 输出10
        System.out.println(a2);   // 输出2
        System.out.println(a3);   // 输出8
        System.out.println(a4);   // 输出16
//浮点数拓展  float double （最好完全避免使用浮点数进行比较）
/*  有限的 有误差 接近但不等于
   如果有银行业务表示 使用数学工具类 BigDecimal
 */

        float b1 = 0.1f;
        double b2 = 1.0/10;
        double b3 = 1/10;
        System.out.println(b1);  //输出0.1
        System.out.println(b2);  //0.1
        System.out.println(b3);  //0.0  先按照整型数运算，所以运算结果是整型数0，而结果要求是double，则将0转换为double类型0.0
        System.out.println(b1==b2);//false
        float c1 = 999999999999f;
        float c2 = 1+c1;
        System.out.println(c1==c2); //true

//字符拓展  所有字符的本质还是数字
//编码： Unicode   范围 U0000~UFFFF
        char d1 = 'a';
        char d2 = '聪';
        char d3 = '\u0069';
        System.out.println(d1);     //输出a
        System.out.println((int)d1);  //97 （强制转换int型）
        System.out.println(d2);       //聪
        System.out.println((int)d2); //32874
        System.out.println(d3);   //i
    }
}

conversión de tipo

Dado que Java es un lenguaje fuertemente tipado, algunas conversiones de tipo deben realizarse
de byte bajo a byte alto, corto, char->int->long->float->double (nota: la prioridad de los decimales debe ser mayor que los enteros)
obligatorio conversión (tipo) nombre de variable
alto – bajo

int i =128；
byte =(byte)i;//内存溢出  范围-128~127
System.out.println(e2);//输出-128
//强制转换丢失精度
System.out.println((int)9.8);//输出9
System.out.println((int)56.23f);//输出56

problema de desbordamiento

int money = 10_0000_0000;
int year = 200;
long total = year*money;//默认是int
System.out.println(total);//溢出错误
long total1 =(long)money*year;
System.out.println(total1);//计算正确

Conversión automática bajo – alto, el sistema ejecuta automáticamente

variable de alcance variable
de clase variable
de instancia variable
local

public class Demo2 {
    
    
    static int a = 32; //类变量
    int b = 32;//实例变量，全局变量

    public static void main(String[] args) {
    
    
        int c = 32;//局部变量
        System.out.println(a);//类变量直接输出
        Demo2 demo2 = new Demo2();
        System.out.println(demo2.b);//全局变量 new一个对象 引用输出
        System.out.println(c);//局部变量 只能在这个方法里面 直接输出
    }

}

Convención de nomenclatura
Variables: primera letra minúscula, camel case
Constante: mayúscula, guión bajo
Nombre de la clase: primera letra mayúscula, camel case
Nombre del método: primera letra minúscula, camel case

operación

Compatibilidad ascendente con
byte short int Después de operaciones mutuas, int es el último;
si hay long en el operando, long es el último;
si float está en el operando, float es el último;

auto-incremento

        int d =1;
        int e =d++; //先赋值 再自增  e=1 d=2
        int f =++d;//先自增 再赋值  d=3 f=3
        System.out.println(d);//输出3
        System.out.println(e);//输出1
        System.out.println(f);//输出3
i++ 先赋值 后自增
++i 先自增 后赋值

Operación de bits Alta eficiencia El tratamiento con la capa inferior se utiliza principalmente para operar en los bits binarios del
operando Desplazamiento a la izquierda<< desplazamiento a la derecha>>

  /*
    <<  *2
    >>  /2
    2*8 = 16  2*2^3
     */
    System.out.println(2<<3);

concatenación de cadenas

int z =10;
int x =20;
System.out.println(""+z+x); //salida 1020
System.out.println(z+x+"");//salida 30

mecanismo de paquetes

Para organizar mejor las clases, Java proporciona un mecanismo de paquete para distinguir el formato del espacio de nombres de los nombres de clase
:

package pak1.pak2;

Generalmente, la inversión del nombre de dominio de la empresa se utiliza como nombre del paquete;
por ejemplo, el nombre del paquete de Baidu www.baidu.com es com.baidu.www
Para poder utilizar los miembros de un determinado paquete, necesita importar explícitamente el paquete en el programa Java y usar la declaración de importación para completar esta función.