1、算数运算：

Java编程语言中，使用算术表达式（如加法、减法、乘法、除法等）时，如果表达式中包含了不同的基本数据类型（如byte、short、char、int、long、float、double），则这些类型会按照特定的规则进行类型转换（也称为类型提升规则）。这些规则确保算术运算能够以一种一致且可预测的方式进行，同时避免数据丢失或溢出等问题。

类型提升的具体规则如下：
byte、short、char 类型自动提升到 int：无论表达式中是否还包含其他类型，byte、short和char类型的值都会首先被提升为int类型。这是因为这些类型在内存中的表示范围较小，直接进行运算可能会导致结果无法正确表示。
整个表达式的类型提升到与表达式中最高等级的操作数相同的类型：如果表达式中包含了多种类型，并且这些类型在被提升为int之后还包含更高精度的类型（如long、float、double），则整个表达式的类型会进一步被提升到这些类型中最高等级的一个。
类型等级的顺序大致为：byte, short, char -> int -> long -> float -> double。
如果表达式中包含long类型，则整个表达式的类型会提升到long，除非还包含float或double类型。
如果表达式中包含float类型，则整个表达式的类型会提升到float，除非还包含double类型。
如果表达式中包含double类型，则整个表达式的类型会提升到double。
在涉及到浮点类型的运算时（float或double），即使其他操作数是整数类型，结果也会是浮点类型。这是因为浮点类型能够表示更大范围的数值，包括小数和非常大或非常小的数。
强制类型转换：如果需要将一个高精度的类型（如double）赋值给一个低精度的类型（如int），需要进行显式的强制类型转换。但是，这种转换可能会导致数据丢失或精度下降。

package test.com;
public class ArithmeticOperations {
	//整数操作只能得到整数，要想得到小数，必须有浮点数参与运算。
    public static void main(String[] args) {
        // 定义两个变量，分别进行加、减、乘、除、取余运算
        int a = 10;
        int b = 5;

        // 加法
        int sum = a + b;
        System.out.println("Sum: " + sum);

        // 减法
        int difference = a - b;
        System.out.println("Difference: " + difference);

        // 乘法
        int product = a * b;
        System.out.println("Product: " + product);

        // 除法
        int quotient = a / b;
        System.out.println("Quotient: " + quotient);

        // 取余
        int remainder = a % b;
        System.out.println("Remainder: " + remainder);

        // 自增和自减运算
        int c = 5;
        System.out.println("Original c: " + c);
        c++; // 自增运算
        System.out.println("After increment: " + c);
        c--; // 自减运算
        System.out.println("After decrement: " + c);
    }
}

package test.com;
public class TypePromotionExample {  
    public static void main(String[] args) {  
        byte b = 10;  
        short s = 20;  
        char c = 'a'; // 'a' 的 ASCII 值是 97  
        int i = 100;  
        long l = 1000L;  
        float f = 10.5f;  
        double d = 20.0;  
        char char1 = 'A';
        char char2 = 'B';
     
        //字符 'A' 和字符 'B' 被相加得到了一个int类型的结果。字符“+”操作是对ASCII码值进行加法操作，而不是直接拼接字符。
        int result = char1 + char2;

        System.out.println("Result of char1 + char2: " + result);
        // byte, short, char 自动提升到 int  
        int result1 = b + s + c; // 结果是 int 类型  
        System.out.println("Result 1 (int): " + result1); // 输出类似 Result 1 (int): 127  
  
        // 包含 long，整个表达式提升到 long  
        long result2 = i + l; // 结果是 long 类型  
        System.out.println("Result 2 (long): " + result2); // 输出类似 Result 2 (long): 1100  
  
        // 包含 float，整个表达式提升到 float（如果没有double）  
        float result3 = i + f; // 结果是 float 类型  
        System.out.println("Result 3 (float): " + result3); // 输出类似 Result 3 (float): 110.5  
  
        // 包含 double，整个表达式提升到 double  
        double result4 = i + d; // 结果是 double 类型  
        System.out.println("Result 4 (double): " + result4); // 输出类似 Result 4 (double): 120.0  
  
        // 强制类型转换  
        int result5 = (int) (d + f); // 显式地将 double 类型转换为 int 类型  
        System.out.println("Result 5 (int after casting): " + result5); // 输出类似 Result 5 (int after casting): 30  
  
        // 注意：由于float和double的精度问题，实际输出可能略有不同  
    }  
}

2、 赋值运算符：

package test.com;
public class AssignmentExample {
	//扩展的赋值运算符隐含强制类型转换。
    public static void main(String[] args) {
        // 声明并赋值一个整型变量
        int a = 10;
        int b = 5;
        System.out.println("a 的值为：" + a);

        // 声明并赋值一个字符串变量
        String name = "John";
        System.out.println("name 的值为：" + name);

        // 加法赋值运算符（+=）
        a += b; // 相当于 a = a + b
        System.out.println("a += b 的结果为：" + a);

        // 减法赋值运算符（-=）
        a -= b; // 相当于 a = a - b
        System.out.println("a -= b 的结果为：" + a);

        // 乘法赋值运算符（*=）
        a *= b; // 相当于 a = a * b
        System.out.println("a *= b 的结果为：" + a);

        // 除法赋值运算符（/=）
        a /= b; // 相当于 a = a / b
        System.out.println("a /= b 的结果为：" + a);

        // 取余赋值算符（%=）
        a %= b; // 相当于 a = a % b
        System.out.println("a %= b 的结果为：" + a);
    }
}

3、 自增自减运算符：

package test.com;
public class VariableAdd {  
	//自增（++）和自减（--）运算符用于将变量的值分别增加或减少1。
    public static void main(String[] args) {  
        int a = 5;  
        int b = 10;  
      
        // 前缀自增  
        int preIncrement = ++a;
        System.out.println("前缀自增后 a 的值：" + a); 
        System.out.println("前缀自增表达式的值：" + preIncrement); 
       
        // 后缀自增  
        int postIncrement = b++; 
        System.out.println("后缀自增后 b 的值：" + b);
        System.out.println("后缀自增表达式的值：" + postIncrement); 
         
        // 前缀自减  
        int preDecrement = --a; 
        System.out.println("前缀自减后 a 的值：" + a); 
        System.out.println("前缀自减表达式的值：" + preDecrement);
       
        // 后缀自减  
        int postDecrement = b--; 
        System.out.println("后缀自减后 b 的值：" + b); 
        System.out.println("后缀自减表达式的值：" + postDecrement);
        
    }  
}

package test.com;
public class MultipleDecrementExample {
    public static void main(String[] args) {
        // 初始化多个整型变量，并赋初始值
        int a = 10;
        int b = 5;
        int c = 3;
        
        // 对多个变量分别使用自减运算符进行自减操作
        a--;
        b--;
        c--;
        
        // 打印执行自减操作后的变量值
        System.out.println("Decrement a: " + a); // 预期输出为 9
        System.out.println("Decrement b: " + b); // 预期输出为 4
        System.out.println("Decrement c: " + c); // 预期输出为 2
    }
}

4、 字符与字符串"+"运算：

package test.com;
public class StringConcatenation {  
	//字符串（String）类型的+操作符用于连接（拼接）字符串。
	//当+操作符的任一操作数是String类型时，Java会尝试将另一个操作数也转换为String类型（如果它还不是的话），然后将它们连接起来。
	//在”+”操作中，如果出现了字符串，就是连接运算符，否则就是算术运算。当连续进行“+”操作时，从左到右逐个执行。
    public static void main(String[] args) {  
        String firstName = "John";  
        String lastName = "Doe";  
        int age = 30;  
  
        // 字符串与字符串连接  
        String fullName = firstName + " " + lastName;  
        System.out.println(fullName); // 输出: John Doe  
  
        // 字符串与整数连接（整数会自动转换为字符串）  
        String ageString = "Age: " + age;  
        System.out.println(ageString); // 输出: Age: 30  
  
        // 字符串与字符连接（字符会自动转换为字符串）  
        char initial = 'J';  
        String initialString = firstName + " starts with " + initial;  
        System.out.println(initialString); // 输出: John starts with J  
  
        // 字符串与null连接
       
        String riskyString = firstName + " and " + null; 
        System.out.println(riskyString);
        // 安全的字符串与可能为null的值连接  
        String maybeNull = null;  
        String safeString = firstName + " and " + (maybeNull != null ? maybeNull : "unknown");  
        System.out.println(safeString); // 输出: John and unknown  
    }  
}