Conversión de tipo de datos NO.A.0005-day02, operador

1. Conversión de tipos de datos 1. Conversión
automática de tipos (implícita) Demo01DataType.java

/*
当数据类型不一样时，将会发生数据类型转换，
自动类型转换（隐式）
    1、特点：代码不需要进行特殊处理，自动完成。
    2、规则：数据范围从小到大。
*/

public class Demon01DayaType{
    public static viod main(String[] args){
        System.out.println(1024);// 这是一个整数，默认是int类型
        System.out.println(3.14);// 这是一个浮点数，默认就是double类型

        // 左边是long类型，右边是默认的int类型，左右不一样，
        //一个等号代表赋值，将右侧的int常量，交给左侧的long变量进行存储
        //int --> long，符合了数据范围从小到大的要求。
        //这一行代码发生了自动类型转换。
        long num1 = 100L；//没有L也是可以的
        System.out.println(num1);// 100

        // 左边是double类型，右边是float类型，左右不一样。
        // float --> double，符合从小到大的规则。
        // 也发生了自动类型转换。
        double num2 = 2.5F;
        System.out.println（num2）；//2.5

        // 左边是float类型，右边是long类型，左右不一样。
        // long --> flaot;范围是float更大一些，符合从小到大的规则；
        // 也发生了自动类型转换。
        float   num3 = 30L；
        System.out.println(num3); // 30.3
    }
}

2. Conversión de tipo forzada (visualización) Demo02DataType.java

/*
强制类型转换
    1. 特点：代码需要进行特殊的格式处理，不能自动完成。
    2. 格式：范围小的类型 范围小的变量名 = (范围小的类型) 原本范围大的数据;

注意事项：
    1. 强制类型转换一般不推荐使用，因为有可能发生精度损失、数据溢出。
    2. byte/short/char这三种类型都可以发生数学运算，例如加法“+”.
    3. byte/short/char这三种类型在运算的时候，都会被首先提升成为int类型，然后再计算。
    4. boolean类型不能发生数据类型转换
*/
public class Demo02DataType {
    public static void main(String[] args) {
        // 左边是int类型，右边是long类型，不一样
        // long --> int，不是从小到大
        // 不能发生自动类型转换！
        // 格式：范围小的类型 范围小的变量名 = (范围小的类型) 原本范围大的数据;
        int num = (int) 100L;
        System.out.println(num);

        // long强制转换成为int类型
        int num2 = (int) 6000000000L;
        System.out.println(num2); // 1705032704（此时发生了数据溢出）

        // double --> int，强制类型转换
        int num3 = (int) 3.99;
        System.out.println(num3); // 3，这并不是四舍五入，所有的小数位都会被舍弃掉

        char zifu1 = 'A'; // 这是一个字符型变量，里面是大写字母A
        System.out.println(zifu1 + 1); // 66，也就是大写字母A被当做65进行处理
        // 计算机的底层会用一个数字（二进制）来代表字符A，就是65
        // 一旦char类型进行了数学运算，那么字符就会按照一定的规则翻译成为一个数字

        byte num4 = 40; // 注意！右侧的数值大小不能超过左侧的类型范围
        byte num5 = 50;
        // byte + byte --> int + int --> int
        int result1 = num4 + num5;
        System.out.println(result1); // 90

        short num6 = 60;
        // byte + short --> int + int --> int
        // int强制转换为short：注意必须保证逻辑上真实大小本来就没有超过short范围，否则会发生数据
        溢出
        short result2 = (short) (num4 + num6);
        System.out.println(result2); // 100
    }
}

3. Desbordamiento de datos:

4. Tabla de códigos ASCII:
48 -> 0
65 -> A
97 -> una
biblioteca de códigos: Demo03DataTypeChar.java

/*
数字和字符的对照关系表（编码表）：

ASCII码表：American Standard Code for Information Interchange，美国信息交换标准代码。
Unicode码表：万国码。也是数字和符号的对照关系，开头0-127部分和ASCII完全一样，但是从128开始包含有更
多字符。

48 - '0'
65 - 'A'
97 - 'a'
*/
public class Demo03DataTypeChar {
    public static void main(String[] args) {
        char zifu1 = '1';
        System.out.println(zifu1 + 0); // 49

        char zifu2 = 'A'; // 其实底层保存的是65数字

        char zifu3 = 'c';
        // 左侧是int类型，右边是char类型，
        // char --> int，确实是从小到大
        // 发生了自动类型转换
        int num = zifu3;
        System.out.println(num); // 99

        char zifu4 = '中'; // 正确写法
        System.out.println(zifu4 + 0); // 20013
    }
}

2. Operador:
1. Operador:

Los operadores aritméticos incluyen:
+	Operación de suma, operación de concatenación de cadenas
-	Operación de resta
*	Multiplicación
/	Operación de división
%	Operación de módulo, divida dos números para obtener el resto
++ 、 -	Incremento y decremento

Biblioteca de códigos: Demo04Operator.java

/* 
运算符：进行特定操作的符号。例如：+
表达式：用运算符连起来的十字叫做表达式。例如： 20 + 5 、 又例如：a + b

四则运算：
加： +
减： -
乘： *
除： /

取模（取余数）：%

首先计算得到表达式的结果，然后在打印输出这个结果。
复习一下小学一年级的除法公式。
被除数 / 除数 = 商 ... 余数

对于一个整数的表达式来说，除法用的是整除；整数除以整数。结果仍然是整数；只看商。不看余数；
只有对于整数的除法来说，取模运算符才有余数的意义。

注意事项：
    1、一旦运算当中有不同类型的数据，那么结果将会是数据类型范围大的那种。
*/
public class Demo04perator(
    public static void main(Stringp[] args){
    // 两个常量之间可以进行数学运算
    System.out.println(20 + 30);

    // 两个变量之间也可以进行数学运算
    int a = 20;
    int b = 30;
    System.out.println( a - b ); // -10

    // 变量和常量之间可以混合使用
    System.out.println(a * 10); // -200

    int x = 10;
    int y = 3;

    int resultl = x / y;
    System.out.println(resultl); // 3 

    int result2 = 2 % y ;
    System.out.println(result2); // 余数、摸，1

    // int + double --> double + double --> double 
    double result3 = x + 2.5;
    System.out.println(result3); // 12.5
    }
}

2.
Biblioteca de códigos para múltiples usos del operador aritmético _ signo más : Demo05Plus.java

/*
四则运算当中的加号“+”有常见的三种用法：

1. 对于数值来说，那就是加法。
2. 对于字符char类型来说，在计算之前，char会被提升成为int，然后再计算。
char类型字符，和int类型数字，之间的对照关系表：ASCII、Unicode
3. 对于字符串String（首字母大写，并不是关键字）来说，加号代表字符串连接操作。
任何数据类型和字符串进行连接的时候，结果都会变成字符串
*/
public class Demo05Plus {
    public static void main(String[] args) {
        // 字符串类型的变量基本使用
        // 数据类型 变量名称 = 数据值;
        String str1 = "Hello";
        System.out.println(str1); // Hello

        System.out.println("Hello" + "World"); // HelloWorld

        String str2 = "Java";
        // String + int --> String
        System.out.println(str2 + 20); // Java20

        // 优先级问题
        // String + int + int
        // String       + int
        // String
        System.out.println(str2 + 20 + 30); // Java2030

        System.out.println(str2 + (20 + 30)); // Java50
    }
}

3. Operador aritmético _ operador de incremento y decremento: Demo06Operator.java

/*
自增运算符：++
自减运算符：--

基本含义：让一个变量涨一个数字1，或者让一个变量降一个数字1
使用格式：写在变量名称之前，或者写在变量名称之后。例如：++num，也可以num++
使用方式：
    1. 单独使用：不和其他任何操作混合，自己独立成为一个步骤。
    2. 混合使用：和其他操作混合，例如与赋值混合，或者与打印操作混合，等。
使用区别：
    1. 在单独使用的时候，前++和后++没有任何区别。也就是：++num;和num++;是完全一样的。
    2. 在混合的时候，有【重大区别】
        A. 如果是【前++】，那么变量【立刻马上+1】，然后拿着结果进行使用。    【先加后用】
        B. 如果是【后++】，那么首先使用变量本来的数值，【然后再让变量+1】。   【先用后加】

注意事项：
    只有变量才能使用自增、自减运算符。常量不可发生改变，所以不能用。
*/
public class Demo06Operator {
    public static void main(String[] args) {
        int num1 = 10;
        System.out.println(num1); // 10
        ++num1; // 单独使用，前++
        System.out.println(num1); // 11
        num1++; // 单独使用，后++
        System.out.println(num1); // 12
        System.out.println("=================");

        // 与打印操作混合的时候
        int num2 = 20;
        // 混合使用，先++，变量立刻马上变成21，然后打印结果21
        System.out.println(++num2); // 21
        System.out.println(num2); // 21
        System.out.println("=================");

        int num3 = 30;
        // 混合使用，后++，首先使用变量本来的30，然后再让变量+1得到31
        System.out.println(num3++); // 30
        System.out.println(num3); // 31
        System.out.println("=================");

        int num4 = 40;
        // 和赋值操作混合
        int result1 = --num4; // 混合使用，前--，变量立刻马上-1变成39，然后将结果39交给result1
        变量
        System.out.println(result1); // 39
        System.out.println(num4); // 39
        System.out.println("=================");

        int num5 = 50;
        // 混合使用，后--，首先把本来的数字50交给result2，然后我自己再-1变成49
        int result2 = num5--;
        System.out.println(result2); // 50
        System.out.println(num5); // 49
        System.out.println("=================");

        int x = 10;
        int y = 20;
        // 11 + 20 = 31
        int result3 = ++x + y--;
        System.out.println(result3); // 31
        System.out.println(x); // 11
        System.out.println(y); // 19

        // 30++; // 错误写法！常量不可以使用++或者--
    }
}

4. Operador de asignación: Demo07Operator.java

/*
赋值运算符分为：

基本赋值运算符：就是一个等号“=”，代表将右侧的数据交给左侧的变量。
    int a = 30;

复合赋值运算符：
    +=      a += 3      相当于     a = a + 3
    -=      b -= 4      相当于     b = b - 4
    *=      c *= 5      相当于     c = c * 5
    /=      d /= 6      相当于     d = d / 6
    %=      e %= 7      相当于     e = e % 7

注意事项：
    1. 只有变量才能使用赋值运算符，常量不能进行赋值。
    2. 复合赋值运算符其中隐含了一个强制类型转换。
*/
public class Demo07Operator {
    public static void main(String[] args) {
        int a = 10;
        // 按照公式进行翻译：a = a + 5
        // a = 10 + 5;
        // a = 15;
        // a本来是10，现在重新赋值得到15
        a += 5; 
        System.out.println(a); // 15

        int x = 10;
        // x = x % 3;
        // x = 10 % 3;
        // x = 1;
        // x本来是10，现在重新赋值得到1
        x %= 3;
        System.out.println(x); // 1

        // 50 = 30; // 常量不能进行赋值，不能写在赋值运算符的左边。错误写法！

        byte num = 30;
        // num = num + 5;
        // num = byte + int
        // num = int + int
        // num = int
        // num = (byte) int
        num += 5;
        System.out.println(num); // 35
    }
}

5. Operador de comparación:	Los operadores de comparación incluyen
==	Si los datos en ambos lados del operador de comparación son iguales, el resultado de la igualdad es verdadero
<	Si los datos a la izquierda del símbolo de comparación son menores que los datos a la derecha, si son menores que el resultado es verdadero
>	Compare si los datos del lado izquierdo del símbolo son mayores que los datos de la derecha y el resultado es verdadero si es mayor.
<=	Si los datos del lado izquierdo del símbolo de comparación son menores o iguales que los datos del lado derecho, si es menor que el resultado es verdadero
> =	Si los datos de la izquierda del símbolo de comparación son mayores o iguales que los datos de la derecha, si son menores que el resultado es verdadero
！ =	No es igual al signo, si los datos en ambos lados del signo no son iguales, el resultado es verdadero

El operador de comparación es una operación de comparación entre dos datos. El resultado de la operación es booleano verdadero o falso.
Biblioteca de código: Demo08Operator.java

/*
比较运算符：
大于：     >
小于：     <
大于等于：   >=
小于等于：   <=
相等：     ==  【两个等号连写才是相等，一个等号代表的是赋值】
不相等：    !=

注意事项：
1. 比较运算符的结果一定是一个boolean值，成立就是true，不成立就是false
2. 如果进行多次判断，不能连着写。
数学当中的写法，例如：1 < x < 3
程序当中【不允许】这种写法。
*/
public class Demo08Operator {
    public static void main(String[] args) {
        System.out.println(10 > 5); // true
        int num1 = 10;
        int num2 = 12;
        System.out.println(num1 < num2); // true
        System.out.println(num2 >= 100); // false
        System.out.println(num2 <= 100); // true
        System.out.println(num2 <= 12); // true
        System.out.println("===============");

        System.out.println(10 == 10); // true
        System.out.println(20 != 25); // true
        System.out.println(20 != 20); // false

        int x = 2;
        // System.out.println(1 < x < 3); // 错误写法！编译报错！不能连着写。
    }
}

6. Operadores lógicos:	Los operadores lógicos incluyen:
&& cortocircuito con	1. Ambos lados son verdaderos, el resultado es verdadero 2. Una vez que es falso, el resultado es falso Características de cortocircuito: el lado izquierdo del símbolo es falso y el lado derecho no está en funcionamiento
Línea vertical doble + cortocircuito o	1. Ambos lados son falsos, el resultado es falso 2. Un lado es verdadero, el resultado es verdadero, características de cortocircuito: el lado izquierdo del símbolo es verdadero y el lado derecho ya no se calcula
Línea vertical única +!	Invertir 1 ,! ¡El resultado verdadero es falso 2! el resultado falso es cierto

Operador lógico: Es un operador que se utiliza para vincular dos resultados booleanos. El resultado del operador es booleano verdadero o falso.
Biblioteca de código: Demo09Logic.java

/*
与（并且）       &&  全部是true，才是true，负责否则就是false
或（或者）       ||  只要有至少一个是true，就是true。全都是false。才是false
非（取反）       ！   本来是true，变成false，本来是false，变成true

与 “&&” 或“||” 具有短路效果；如果根据左边已经可以判断得到最终结果，那么右边的代码将不在执行，从而节
省一定的性能。

注意事项：
        1、逻辑运算符，只能用于Boolean值。
        2、与、或需要左右有一个Boolean值，但是取反只要有唯一的一个Boolean值即可
        3、与、或两种运算符，如果有多个条件，可以连续写。
            两个条件；条件A && 条件B
            多个条件；条件A && 条件B && 条件C

        TIPS：
        对于1 < x < 3的情况，应该拆成两个部分，然后使用与运算符链接起来；
        int x =2;
        1 < x && x < 3
*/

public class Demo09Logic{
    public static vodi main(string[] args){
        System.out.println(true && false);  // false
        // true && true --> true
        System.out.println(3 < 4 &&  10 > 5);   // true 
        System.out.println("=================");

        System.out.println(true || false); // true
        System.out.println(true || true);   // true
        System.out.println(false || false); // false
        System.out.println("=================");

        System.out.println(true); // true
        System.out.println(!true); // false
       System.out.println("=================");

        int a = 10;
        System.out.println(3 > 4 && ++a < 100); // false
        System.out.println(a); // 10
        System.out.println("=================");

        int b = 20
        // true || ----
        System.out.println(3 < 4 || ++b < 100); // true
        System.out.println(b); // 20      
    }
}

7. Operador ternario:
Biblioteca de códigos: Demo10Operator.java

/*
一元运算符：只需要一个数据就可以进行操作的运算符。例如：取反!、自增++、自减--
二元运算符：需要两个数据才可以进行操作的运算符。例如：加法+、赋值=
三元运算符：需要三个数据才可以进行操作的运算符。

格式：
数据类型 变量名称 = 条件判断 ? 表达式A : 表达式B;

流程：
首先判断条件是否成立：
    如果成立为true，那么将表达式A的值赋值给左侧的变量；
    如果不成立为false，那么将表达式B的值赋值给左侧的变量；
二者选其一。

注意事项：
1. 必须同时保证表达式A和表达式B都符合左侧数据类型的要求。
2. 三元运算符的结果必须被使用。
*/
public class Demo10Operator {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;

        // 数据类型 变量名称 = 条件判断 ? 表达式A : 表达式B;
        // 判断a > b是否成立，如果成立将a的值赋值给max；如果不成立将b的值赋值给max。二者选其一
        int max = a > b ? a : b; // 最大值的变量
        System.out.println("最大值：" + max); // 20

        // int result = 3 > 4 ? 2.5 : 10; // 错误写法！

        System.out.println(a > b ? a : b); // 正确写法！

        // a > b ? a : b; // 错误写法！
    }
}