学习打卡-02、类型转换、常用运算符

知识点

(1) 记住Ascll码表中的三个特殊的数:

Ascll码表中	48	65	97
十进制中	0	A	a

(2) 计算机中的数据转换

最基础的是 bit 字节(B)
1b = 8B

1KB = 1024B

1MB = 1024KB

1GB = 1024MB

1TB = 1024GB

(3) 基本数据类型 (java是强类型语言

四类八种 long类型后面加 L —–> 19999999L (告诉计算机这是long类型)
float类型后面加 F —–> 199.99F (告诉计算机这是float类型,因为默认是double)

整型: byte short int( 默认) long

浮点型: float double(默认)

字符型: char

布尔型: boolean

两个int运算结果还是int 实例如下: 以及下面的推广

        int q = 3;
        int w = 2;
        int e = q/w;
        System.out.println(e);   // 结果: 1    因为int和int类型的结果默认还是int

//      如果想要得到一个正确的答案
//        (1) 方法一  : 前面的乘以1.0   这样q就会自动类型转换为double
//        然后在运算,在和后面的运算,后面的也会转换为double类型,然后再做运算
        double shang = 1.0 * q / w;
        System.out.println(shang);
//        在后面不行,因为运算等级的问题  ,前面的算完了是1,在乘以1.0 答案不对
        double shang1 = q / w * 1.0;
        System.out.println(shang1);

//        (2) 方法二  :  将其中的一个转换为double
        double shang2 = (double) q / w;
        System.out.println(shang2);

(4) 隐式转换和显示转换 小范围类型 —-> 大范围类型 🔺

隐式转换是计算机自己执行的,是将类型小的变量赋值给类型大的变量

自动转换的类型的形式 🌳 注意这里:long 可以直接转换为 float类型

byte—>short —> int —–> long —-> float —–>double

​ char—–>

当byte char 和 short 同时出现的时候,会首先将数据类型直接转换为int ,然后在计算得到一个int的结果

(5) 强制类型转换 大范围类型 —-> 小范围类型 🔺

强制类型转换可能会造成数据的(丢失)溢出

(6) 算术运算符 + - * / %

(7) 自增自减

🚩 重点:++ 和 - - 只能操作变量,不能操作字面量 —–> 因为常量,不能改变

b = ++a 是先将a+1 然后在赋值给b

c = a++ 是先将a原本的值赋值给c,然后在加一

减减同理

例题:

    public static void main(String[] args) {
        int a = 100;
        int c = a++;
        System.out.println(a); // 101
        System.out.println(c); // 100

        int d = 100;
        int e = ++d;
        System.out.println(d); // 101
        System.out.println(e); // 101
    }

同一个表达式,后面使用到++ 之后变量的值的时候, 在赋值之后就会,先运算然后赋值给后面,供后面使用

public static void main(String[] args) {
    int a = 1;
    int b = a++ + ++a;
    System.out.println(a); // 3
    System.out.println(b); // 4
}

加加减减的练习 (🚩 中间有两个关于常量的面试题 , 即加加和减减不能操作字面量)

//  (0) 试着分析下题
        int a = 1;
        int b = a++ + ++a;
        System.out.println(a); // 3
        System.out.println(b); // 4

//  (1)   先完成赋值然后再自增1
        int c = 1;
        System.out.println(c++); //  1
        System.out.println(c);   //  2

//  (2) 加加和减减只能操作变量不能操作常量
//      常量不能加加和减减只有常量可以加加和减减
//      System.out.println(1++);   // 错误

//  (3)  例题分析
        int a1 = 10;
        int b1 = 5;
        int res = a1++ + ++a1 - --b1 - ++b1 + 1 + a1++;
        System.out.println(a1);
        System.out.println(res);
        System.out.println(b1);

//  (4)+= 是赋值运算符, 因为常量是不能用赋值运算符的
//      System.out.println("1"+=1);

(8) 基本赋值运算符 和 扩展赋值运算符 🔺

=(基本) += -= *= /= %=

扩展运算符,运算之后的类型还是之前的不作‘以为’的隐式转换, 而是隐含了强制类型转换

⛳ 例如: a += b 底层实现如下: a = (a的类型)(a+b)

public static void main(String[] args) {
        int a = 100;
        char b = 12;
        b += a;
        System.out.println(b);  //  p   --->   自动强制转换为字符
}

(9) 逻辑运算符

& 逻辑与	&& 短路与
| 逻辑或	|| 短路或
! 取反	上面两个只执行如果左面符合条件,只执行一半
^ 逻辑异或	只有当两个不同的时候才为真,同为true ,或者同为false的时候为假 可以类比着 性别记忆 —-> 同为男男不可以, 女女不可以 男女可以

(10) 三元运算符 条件表达式 ? 值1 : 值2 返回值为后面范围较大的类型

这里也有一个注意点,就是如果两个不同数据类型的数据进行计算的时候, 是先将两者转换为范围较大的数据

满足一下:

byte —> short —> int —> long —> float —> double

​ char —>

代码测试:

// 		  这个时候是int  因为当byte , short  char 在一起运算的时候转换为int之后在进行计算
        int num1 = 2 > 3 ? (byte)1 : '1';
        System.out.println(num1);  // 49

//        当long类型和float类型相遇的时候,会转换为float类型在进行操作
        float num2 = 2 > 3 ? 1111L : 11.11F;
        System.out.println(num2);   //  11.11

//        这个时候后面没有加 F , 说明是double ,因为浮点型默认是double类型,
//        又因为double类型的范围大于float,所以返回值的类型为double
        double num3 = 2 > 3 ? 11.11 : 11.11F;
        System.out.println(num3);   // 11.109999656677246

*(11) 得到一个多位数的每个位的数字

公式: 任意位置的数字 = 原数据 / 位权 % 10

位权: 个位位权是 1; 十位位权是 10 ; 百位 位权是100;

小练习: 超纲使用for循环 , 用Scanner类输入,并且循环输出每位的值

public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入一个正整数:");
        int num = scanner.nextInt();
        String str = num + "";

        int flag = 1;
        int temp = 0;
//        循环输出每个位的数值
        for (int i = 0; i < str.length(); i++) {
            temp = num / flag % 10;
            System.out.println("倒数第" + (i + 1) + "位是:" + temp);
            flag *= 10;
        }
}