类型转换和运算符

最新推荐文章于 2024-05-16 20:42:16 发布

Vae如约而至

最新推荐文章于 2024-05-16 20:42:16 发布

阅读量494

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/Szz2461050668/article/details/125744947

版权

1 类型转换

1.1 隐式类型转换

规则：是用小范围的数据类型直接转到大范围的数据类型

范围的排序： byte < short = char < int < long < float < double

作用-用途：比如两个软件进行交互，对方发给你一个整数，你并不知道这个数据有多大。我就需要用long类型去接收。不管他发的有多大的整数，我long都能接收。

细节：-- 不同的数据类型是无法进行运算的，必须把他们统一为同一种类型才可以运算。

1：比int 小的数据类型进行运算的时候，都提升为 int类型去运算。

class Demo {
public static void main(String[] args){
byte a = 10;
short s = 20;
//byte b = a + s; //编译报错 因为 a+s的结果是 int类型
byte b = (byte) (a + s) ;
System.out.println(b);
}
}

2：比 int 大的数据类型进行运算的时候，小范围数据类型会自动转到大范围数据类型去。

public class Demo9 {
public static void main(String[] args) {
long lo = 100L;
double d = 3.14;
//int a = lo +d; // 编译报错 long和double运算 long会自动转double
double dou = lo +d;
System.out.println(dou);
long lon = (long) (lo + d);
System.out.println(lon);
}
}

1.2 强制类型转换

规则：从大范围的数据类型只能强制转到小范围的数据类型

情况1：转过去数据就发生改变。意义不大

int a = 200;
byte b = (byte)a; // 强制类型转换
System.out.println(b); // -56

情况2：转过去之后数据不发生改变

int c = 100;
byte d = (byte)c; // 意义所在
System.out.println(d); //100

情况3：小数转整数

double dou = 3.14;
int i = (int)dou; //意义所在
System.out.println(i);//3

1.3 注意事项

boolean类型不参与任何的类型转换

boolean b = true;
int c = b; //编译报错
int a = (int)b; //编译报错
System.out.println(a);

常量优化机制。基本类型中只有比int小的数据类型才有常量优化机制

public class Demo11 {
    public static void main(String[] args) {
        System.out.println(100); // 默认是 int 类型 4个字节。
        byte b = 100; // 正确的。 100虽然是int的 但是他是一个常量数据。 常量优化机制
            //底层 其实是这样的 byte b = (byte)100;

        int a = 100;
        //byte c = a; //因为a是变量 只有常量才有 常量优化机制。

        byte d = 80 + 20; //正确的 常量优化
            // 常量的运算 在编译成class文件的时候， 就已经把 80+20 变成了100
            // 也就是说 等这句话 编译到了class文件的时候 就变成了 byte d = 100; 就又符合常量        
             优化机制了。

        byte e = 80;
        //byte f = e+20; // 编译报错 e是变量
        // 以上的特点 ---演示的都是 比int小的 基本类型常量。
        // 在基本类型里面 只有 比int小的数据 才遵循常量优化机制。 比int大的没有。

        System.out.println(3.14); // 默认是double类型
        //float flo = 3.14; // 编译报错 double转float 报错。 比int大的没有常量优化机制。
        // 所以我们为了在一个小数常量的时候告诉jvm 我这个小数常量不再是默认是 double类型了，所以我们就在小数后面加一个 F

        System.out.println(3.14F); // 是float类型

        float flo = 3.14F;
    
        System.out.println(b);
    }

}

long类型数据后面为什么要加L

public class Demo12 {
    public static void main(String[] args) {
        //int a = 100;
        //long lo = a;
        //System.out.println(lo);

        long lo = 100;
        System.out.println(lo);
        System.out.println(10000); 
        //默认是int类型 int类型的范围 21亿
        //System.out.println(10000000000); //100亿
        // 所以 我们此时 就想 写一个 比21亿大的数据
        // 你需要告诉jvm 我现在写的这个数 不再是 int类型的 而是long类型 你怎么告诉jvm 你只需
        要在后面加一个 L 就告诉他了。

        System.out.println(10000000000L);
    }
}

2 运算符

2.1 算术运算符： + - * / %

public class Demo13 {
    public static void main(String[] args) {
        System.out.println(10+10); // 加法
        System.out.println(+10); // 正号
        System.out.println(10-10); // 0
        System.out.println(-10); // -10
        System.out.println(10*10); //100
        System.out.println(100/5); // 20
        //除法的注意事项

        System.out.println(10/4); // 2
        System.out.println(10 / 3); // 3
        System.out.println(10 / 3.0); // 3.33333333
        System.out.println(10.0 / 3); // 3.33333333
        System.out.println(10.0 / 3.0);// 3.33333333
            // 为什么这样啊？？
   // 用类型转换来解释 不同的数据类型是无法进行运算的，必须把他们统一为同一种类型才可以运算。

    // 取余数
    // 10 / 3 = 3 ----- 1

    System.out.println(10 % 3); // 1
    System.out.println(-10 % 3); // -1
        // -10 / 3 = -3 --- -1

    System.out.println(10 % -3); // 1
        // 10 / -3 = -3 --- 1

    System.out.println(-10 % -3); // -1
        // 结论： 取余数 最终结果的符号 取决于 % 左侧的数据的符号。
        // 为什么？？
    }
}

题目练习

1：键盘录入一个数值（只能是3位数）进行拆分并打印出每一位数 int a = 键盘录入; //345 控制台打印如下： 3 4 5

Scanner sc = new Scanner(System.in);
int a = sc.nextInt(); // 345
// 345 % 10 ---- 5
// 345 /10 --- 34 %10 ---4
// 345 /10 /10 3%10 ---3
System.out.println(a/10/10%10);
System.out.println(a/10%10);
System.out.println(a%10);

字符的加法

System.out.println('a' + 0); // ？？
// char + int
// |
// int + int --- 结果int

码表：记录了数字和字母的一一对应关系，因为计算机只能存储数字。

'0' -- 48 'A' -- 65 'a' -- 97

System.out.println(true + 0); //编译报错
// boolean + int
// |
// int + int 因为boolean不参与任何的类型转换 所以boolean是无法转为 int的

字符串连接符

System.out.println("a" + 0 ); //a0
            // String + int
            // 任何的其他类型 和 String 进行+ ， 其他类型 全部 转为 String 再+。
            // 0 -> "0" true ->"true"
            // String + String
            // "a" + "0"
            // 字符串的+ 是连接符 链接在一起。
            // "a0"

System.out.println(10+20+"a"); //30a
            // 30 + "a"
            // 30a

System.out.println("a"+10+20); //a1020
            // "a10" + 20
            // "a1020"

int a = 10;
System.out.println(a); //10
System.out.println("a" + a); //a10

题目练习2：

键盘录入两个数分别用a和b接收 int a = 键盘录入1; // 4 int b = 键盘录入2; //2 打印 a和b加的过程和结果和窗口打印的结果是如下： 4 + 2 = 6

import java.util.Scanner;
public class Demo16 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        int a = sc.nextInt(); //4
        int b = sc.nextInt(); //2

        //System.out.println("4 + 2 = "+ (a+b) );
        //System.out.println("a + b = "+ (a+b) );

        System.out.println(a + " + b = "+ (a+b) );

        System.out.println(a + " + " + b + " = "+ (a+b) );
                        // 4 + " + " + 2 + " = "+ 6
                        // "4+" + 2 + " = "+ 6
                        // "4+2"+ " = "+ 6
                        // "4+2=" + 6
                        // "4+2=6"
    }
}

表达式概念

把数据通过运算符连接起来的式子就叫做表达式。

public class Demo18 {
    public static void main(String[] args) {
        //表达式概念： 把数据通过运算符连接起来的式子就叫做 表达式。
        // 表达式 肯定都会有一个结果。
        // 表达式 一般情况下 都是不能单独成一条语句

        int a = 10;
        int b = 20;
        //a+b; //编译报错

        System.out.println(a+b);
        int c = a+b;
        System.out.println(c);

        int d = a+b*b+a;
        System.out.println(d); //420

        int e = 10;
        int f = e+=1 ;
        System.out.println(e); //11
        System.out.println(f); //11
    }
}

自增自减运算符 ++ --

//自增自减运算符 ++ --
// 用在变量自身的。 ++就是自身加1 --就是自身减1

int a = 10;
a++;
System.out.println(a); // 11

int b = 10;
++b;
System.out.println(b); //11

// 结论1 不管++ 放在变量的前面 还是放在变量的后面 这个变量经过++之后 自身就会+1

int c = 10;
int d = c++;
//int d = (c+=1) -1;
System.out.println(c); // 11
System.out.println(d); // 10

// 结论2 当++放在变量后面的时候 c++ 这个整体表达式的结果 取的是 c还没有加1的那个值。

int e = 10;
int f = ++e;
//int f = e+=1;
System.out.println(e); // 11
System.out.println(f); // 11

// 结论3 当++放在变量前面的时候 ++e 这个整体表达式的结果 取的是 e加1之后的值。

2.2 赋值运算符

基本赋值运算符 =

int a = 10;

复合赋值运算符 += -= *= /= %=

int a = 10;
a+=5; // a 先和右边的 5进行相加 结果 赋值给 左边的a
System.out.println(a); // 15

注意事项：复合赋值运算符有强制类型转换的动作。

public class Demo17 {
    public static void main(String[] args) {
        /*
        byte b = 10;
        b = b + 10; // 编译报错 比int小的运算的时候 会 都提升为 int在运算把。
        System.out.println(b);
        */

        byte b = 10;
        b += 10; // 正确 因为有强制类型转换 在里面
        System.out.println(b); //20
    }
}

2.3 比较运算符 > < >= <= == !=

// 比较运算符的结果 都是boolean类型 true false
System.out.println(5 > 4); //true
System.out.println(5 < 4); //false

System.out.println(5 >= 4); //true
System.out.println(5 >= 5); //true

System.out.println(5==5); // true
System.out.println(5==4); //false

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

2.4 逻辑运算符

// 逻辑运算符 只用来计算 boolean类型

// & 并且 两瓶酒 一瓶是真的 一瓶是假的
System.out.println(true & false );
System.out.println(false & true );
System.out.println(false & false );
System.out.println(true & true ); //true
//应用
//int a = sc.nextInt();
//System.out.println(a>0 & a<100); //只有a是0-100范围内的时候才是true 其他都是false

System.out.println("-----------------------");

// | 或者 两者选一 一瓶是真的 一瓶是假的
System.out.println(true | true );
System.out.println(true | false );
System.out.println(false | false ); //false
//应用
//int a = sc.nextInt();
//System.out.println(a<0 | a>100); //a是负数 和 大于100的数 都是 true 0-100之间的都是false

System.out.println("-----------------------");

// ! 取反 不是真 那就是假
System.out.println( ! true); //false

System.out.println("-------------------");

// ^ 异或 异 不同 惑 疑惑
System.out.println(true ^ true); //false
System.out.println(true ^ false); //true
System.out.println(false ^ false); //false

//System.out.println("a" ^ "b"); //编译报错
System.out.println("a" != "b"); //true
System.out.println(3 != 4); //true
System.out.println(true != false); //true

短路逻辑运算符： && || && 并且只不过只要看到第一个是false 后面再有多少个也不执行了。 || 或者只不过只要看到第一个是 true 后面在也不看了。

int a = 10;
System.out.println(4>5 & a++>0 );
System.out.println(a); //11

int b = 10;
System.out.println(4>5 && b++>0 );
System.out.println(b); //10

int c = 10
System.out.println(6 >5 || c++>0 ); //true
System.out.println(c); //10

2.5 三元运算符 boolean类型数据 ? 值1 : 值2;

public class Demo25 {
    public static void main(String[] args) {
        //boolean类型数据 ? 值1 : 值2;

        int a = true ? 10 : 20;
        System.out.println(a);

        //请用户键盘录入 1或者0 如果用户录入1 代表 确认 如果用户 录入2 代表 取消。
        //int a = 键盘录入;
        System.out.println( a == 1 ? "确认" : "取消" );

        //int c = 键盘录入;
        //int d = 键盘录入;
        int c = 10;
        int d = 20;

        int e = c > d ? c : d;
        System.out.println(e); //20

        //int f = c > d ? c+d : c-d;
        //System.out.println(f); //

        int m = 10;
        int n = 20;
        int p = 30;

        //求三个数的最大值。
        int temp = m>n ? m :n;
        int max = temp >p ? temp : p;
        System.out.println(max); //30

        // 合起来
        int max1 = m > n ? (m>p?m:p) : (n>p?n:p);
        System.out.println(max1);
    }
}