java_数据类型转换、运算符

数据类型转换

Java程序中要求参与计算的数据，必须要保证数据类型一致，如果数据类型不一致将发生类型的转换。

1.1 自动转换

一个 int 类型变量和一个 byte 类型变量进行加法运算,运算结果，变量的类型将是 int 类型

public static void main(String[] args) {
    int i = 1;
    byte b = 2;
    // byte x = b + i; // 报错
    //int类型和byte类型运算，结果是int类型
    int j = b + i;
    System.out.println(j);
}

byte 类型内存占有1个字节，在和 int 类型运算时会提升为 int 类型 ，自动补充3个字节，因此计算后的结果还是 int 类型。

同样道理，当一个 int 类型变量和一个 double 变量运算时， int 类型将会自动提升为 double 类型进行运算。

public static void main(String[] args) {
    int i = 1;
    double d = 2.5;
    //int类型和double类型运算，结果是double类型
    //int类型会提升为double类型
    double e = d+i;
    System.out.println(e);
 }

转换规则

范围小的类型向范围大的类型提升， byte、short、char 运算时直接提升为 int 。

byte、short、char‐‐>int‐‐>long‐‐>float‐‐>double

1.2 强制转换

强制转换格式：
数据类型 变量名 = （数据类型）被转数据值；

当一个 short 类型与 int 类型相加，我们知道会类型提升，但是还想给结果赋值给 short 类型变量，
就需要强制转换。

public static void main(String[] args) {
     //short类型变量，内存中2个字节
     short s = 1;
     int i = 1;
     /*
       出现编译失败
       s和i做运算的时候，i是int类型，s会被提升为int类型
       s+i后的结果是int类型，将结果在赋值会short类型时发生错误
       short内存2个字节，int类型4个字节
       必须将int强制转成short才能完成赋值
     */
     s = s + i；//编译失败
     s = (short)(s+1);//编译成功
}

注意

浮点转成整数，直接取消小数点，可能造成数据损失精度。
int 强制转成 short 砍掉2个字节，可能造成数据丢失。

1.3 ASCII编码表

public static void main(String[] args) {
  //字符类型变量
  char c = 'a';
  int i = 1;
  //字符类型和int类型计算
  System.out.println(c+i);//输出结果是98
}

在char类型和int类型计算的过程中，char类型的字符先查询编码表，得到97，再和1求和，结果为98。char类型提升为了int类型。char类型内存2个字节，int类型内存4个字节。

运算符

运算符: 对变量进行操作的符号
运算符的分类: 算数运算符 , 赋值运算符 , 比较运算符 , 逻辑运算符 , 三元运算符

2.1 算数运算符

算数运算符包括：
+ 加法运算，字符串连接运算
- 减法运算
*乘法运算
/ 除法运算
% 取模运算，两个数字相除取余数
++ 、 - - 自增自减运算

public class Demo{
    public static void main(String[] args) {
        // 定义变量
        int a = 5;
        int b = 3;
        
        System.out.println(a + b); // 8
        System.out.println(a ‐ b); // 2
        System.out.println(a * b); // 15
        System.out.println(a / b); // 1.66666?
        System.out.println(a % b); // 2
        
        System.out.println("‐‐‐‐‐‐‐‐‐");
        // 整数相除,结果是整数,要得到小数,必须有小数参与运算
        System.out.println(5.0 / 3); // 1.6666666666666667
        System.out.println(5 / 3.0); // 1.6666666666666667
    }
}

%取余面试题:

System.out.println(5 % 3);  // 2
System.out.println(‐5 % 3); // -2
System.out.println(5 % ‐3); // 2
System.out.println(‐5 % ‐3); // -2

注意:取余结果符号与左边符号相同

++ 运算，变量自己增长1。反之， - - 运算，变量自己减少1，用法与 ++ 一致。
独立运算：
变量在独立运算时， 前++ 和 后++ 没有区别 。
变量 前++ ：例如 ++i 。
变量 后++ ：例如 i++ 。
混合运算：
和其他变量放在一起， 前++ 和 后++ 就产生了不同。
变量 前++ ：变量a自己加1，将加1后的结果赋值给b，也就是说a先计算。a和b的结果都是2。

public static void main(String[] args) {
    int a = 1;
    int b = ++a; // 先++,后=赋值
    System.out.println(a);//计算结果是2
    System.out.println(b);//计算结果是2
}

变量 后++ ：变量a先把自己的值1，赋值给变量b，此时变量b的值就是1，变量a自己再加1。a的
结果是2，b的结果是1。

public static void main(String[] args) {
    int a = 1;
    int b = a++; // 先=赋值,后++
    System.out.println(a);//计算结果是2
    System.out.println(b);//计算结果是1
}

自增自减面试题

// 面试题：
int a = 10;
int b = 10;
int c = 10;
a = b++;
// a = 10, b = 11
c = ‐‐a;
// a = 9, c = 9
b = ++a;
// a = 10, b = 10
a = c‐‐;
// a = 9, c = 8
// 请分别计算出a,b,c的值

+ 符号在字符串中的操作：
+ 符号在遇到字符串的时候，表示连接、拼接的含义。
“a”+"b"的结果是“ab”，连接含义

public static void main(String[] args) {
    // + 遇到字符串表示连接
    System.out.println("abc" + "def");
    System.out.println("abc" + 5);
    System.out.println("abc" + 5 + 5); // 1. "abc" + 5 = "abc5"; 2. "abc5" + 5 = "abc55"
    System.out.println("abc" + (5 + 5)); // 1. 5 + 5 = 10; 2. "abc" + 10 = "abc10"
    System.out.println(5 + 5 + "abc"); // 1. 5 + 5 = 10; 2. 10 + "abc" = "10abc"
}

面试题:

System.out.println("5+5="+5+5);//输出5+5=55

2.2 赋值运算符

赋值运算符包括：
= 赋值
+= 加后赋值
-= 减后赋值
*= 乘后赋值
/= 除后赋值
%= 取模后赋值
赋值运算符，就是将符号右边的值，赋给左边的变量。

public static void main(String[] args) {
    // 定义变量
    int i = 3; // 将3赋值给变量i
    i = i + 2; // 将变量i和2相加,再赋值给变量i
    System.out.println(i);
    // +=: 赋值运算符, 将=左边的变量和=右边的值进行操作,再赋值给变量
    int j = 10;
    j += 5; // j = j + 5
    System.out.println(j);
    
    int m = 10;
    m ‐= 5; // m = m ‐ 5;
    System.out.println(m);
    System.out.println("‐‐‐‐‐‐‐‐‐‐");
    byte b = 1;
    // b = b + 2; // 错误: 不兼容的类型: 从int转换到byte可能会有损失
    // b += 2; // 可以
     b = (byte)(b + 2);
    System.out.println(b);
}

2.3 比较运算符

比较运算符又叫关系运算符，是两个数据之间进行比较的运算，运算结果都是布尔值 true 或者 false 。

比较运算符包括：
== 比较符号两边数据是否相等，相等结果是true。
< 比较符号左边的数据是否小于右边的数据，如果小于结果是true。
> 比较符号左边的数据是否大于右边的数据，如果大于结果是true。
<= 比较符号左边的数据是否小于或者等于右边的数据，如果小于或等于结果是true。
>= 比较符号左边的数据是否大于或者等于右边的数据，如果小于或等于结果是true。
!= 不等于符号 ，如果符号两边的数据不相等，结果是true。

public static void main(String[] args) {
    System.out.println(3==3); // true
    System.out.println(3==4); // false
    System.out.println(3!=4); // true
    System.out.println(3>4); // false
    System.out.println(3<4); // true
    System.out.println(5<=4); // false
    System.out.println(4>=4); // true
    // 注意
    int i = 3;
    int j = 4;
    System.out.println(i=j); // 将j赋值给i,输出i
    System.out.println(i==j); // true
}

2.4 逻辑运算符

逻辑运算符，是用来对两个布尔类型进行运算的，运算结果都是布尔值 true 或者 false

逻辑运算符包括

2.5 三元运算符

三元运算符格式：
数据类型 变量名 = 布尔类型表达式？结果1：结果2;

三元运算符计算方式：
布尔类型表达式结果是true，三元运算符整体结果为结果1，赋值给变量。
布尔类型表达式结果是false，三元运算符整体结果为结果2，赋值给变量。

public static void main(String[] args) {
    int a = 30;
    int b = 20;
    int c = a > b ? 100 : 20;
    System.out.println(c);
}