java基本数据类型

最新推荐文章于 2024-08-26 23:57:38 发布

小刘哈哈哈

最新推荐文章于 2024-08-26 23:57:38 发布

阅读量336

点赞数 5

文章标签：开发语言 java

本文链接：https://blog.csdn.net/weixin_60668256/article/details/135980373

版权

import java.math.BigDecimal;

public class note2 {
    public static void main(String[] args) {
        //System.out.println("hello");
//        long a=100L;//说明当前a是long类型的数据
//        //long 8个字节  64个比特位(1个符号位,63个数值位)
//       //大小范围:-2^63---2^63-1
//        //BigDecimal  更大类型的数据
//        System.out.println(a);
//        System.out.println(Long.MAX_VALUE);//9223372036854775807
//        System.out.println(Long.MIN_VALUE);//-9223372036854775808
//        //注意事项：
//        //1. 长整型变量的初始值后加L或者l，推荐加L
//        //2. 长整型不论在那个系统下都占8个字节
//        //3. 长整型的表示范围为： ~
//        //4. long的包装类型为Long
//
//
//
//        short s=10;
//        //2个字节      -2^15---2^15-1
//        System.out.println(s);
//        System.out.println(Short.MAX_VALUE);//32767
//        System.out.println(Short.MIN_VALUE);//-32768
//
//
//        byte b=100;//字节类型
//        //1个字节  -2^7---2^7-1
//        System.out.println(Byte.MAX_VALUE);//127
//        System.out.println(Byte.MIN_VALUE);//-128



//        double d=12.5;
//        //8个字节
//        System.out.println(d);
//
//
        int a = 1;
        int b = 2;
        System.out.println(a / b);//0
//
//
//        double a = 1.0;
//        double b = 2.0;
//        System.out.println(a / b); // 输出0.5
//
//
//        double num = 1.1;
//        System.out.println(num * num); // 1.2100000000000002
        //任何小数都没有很精确的值(只能到后几位)
        //1. double在任何系统下都占8个字节
        //2. 浮点数与整数在内存中的存储方式不同，不能单纯使用 的形式来计算
        //3. double的包装类型为Double
        //4. double 类型的内存布局遵守 IEEE 754 标准(和C语言一样), 尝试使用有限的内存空间表示可能无限的小数, 势
        //必会存在一定的精度误差，因此浮点数是个近似值，并不是精确值。



        //默认12.5为double类型的数据,要在结尾加F/f
//        float f=12.5F;
//        System.out.println(f);//12.5
//        System.out.printf("%.2f\n",f);//12.50
        //4字节
//        float 类型在 Java 中占四个字节, 同样遵守 IEEE 754 标准. 由于表示的数据精度范围较小, 一般在工程上用到浮点数
//        都优先考虑 double, 不太推荐使用 float. float的包装类型为Float。




//        //unicode字符集->阿拉伯文  汉字....
//        char ch='a';
//        //char ch4='ab';//ab占4个字节
//        char ch1='中';//会生成不认识的字符
//        char ch2=97;//只能是正数
//        //c语言中为1字节,java中以2个字节
//        System.out.println(ch);
//        System.out.println(ch2);
//        System.out.println(ch1);
//        //char的包装类型为Character
//        //2. 计算机中的字符本质上是一个整数. 在 C 语言中使用 ASCII 表示字符, 而 Java 中使用 Unicode 表示字符. 因此
//          //      一个字符占用两个字节, 表示的字符种类更多, 包括中文





//        boolean flag=true;
//        System.out.println(flag);
//        //没有明确的大小
//        //不能和其他类型转化
//        //boolean的包装类型为Boolean。
//        // Java 的 boolean 类型和 int 不能相互转换, 不存在 1 表示 true, 0 表示 false 这样的用法
//        // boolean 类型的变量只有两种取值, true 表示真, false 表示假.
//        // Java虚拟机规范中，并没有明确规定boolean占几个字节，也没有专门用来处理boolean的字节码指令，在
//        //Oracle公司的虚拟机实现中，boolean占1个字节。





//        //类型转换
//        int a = 10;//4个字节
//        long b = 100L;//8个字节
//        b = a; // 可以通过编译
//        //a = b; // 编译失败
//        a=(int)b;//强制类型转化(显式类型转换)
//        //可能会有数据的丢失
//        //大类型数据--->小类型数据
//        //自动类型转换(隐式) 和 强制类型转换(显式)。


//        int a = 100;
//        long b = 10L;
//        b = a; // a和b都是整形，a的范围小，b的范围大，当将a赋值给b时，编译器会自动将a提升为long类型，然后赋值
//       // a = b; // 编译报错，long的范围比int范围大，会有数据丢失，不安全
//        float f = 3.14F;
//        double d = 5.12;
//        d = f; // 编译器会将f转换为double，然后进行赋值
//        //f = d; // double表示数据范围大，直接将float交给double会有数据丢失，不安全
//        byte b1 = 100; // 编译通过，100没有超过byte的范围，编译器隐式将100转换为byte
//        //byte b2 = 257; // 编译失败，257超过了byte的数据范围，有数据丢失
//        byte bb=(byte)128;
//        System.out.println(bb);//-128



//        int a = 10;
//        long b = 100L;
//        b = a; // int-->long，数据范围由小到大，隐式转换
//        a = (int)b; // long-->int, 数据范围由大到小，需要强转，否则编译失败
//        float f = 3.14F;
//        double d = 5.12;
//        d = f; // float-->double，数据范围由小到大，隐式转换
//        f = (float)d; // double-->float, 数据范围由大到小，需要强转，否则编译失败
//        a = d; // 报错，类型不兼容
//        a = (int)d; // int没有double表示的数据范围大，需要强转，小数点之后全部丢弃
//        byte b1 = 100; // 100默认为int，没有超过byte范围，隐式转换
//        byte b2 = (byte)257; // 257默认为int，超过byte范围，需要显示转换，否则报错
//        boolean flag = true;
//        a = flag; // 编译失败：类型不兼容
//        flag = a; // 编译失败：类型不兼容
//1. 不同数字类型的变量之间赋值, 表示范围更小的类型能隐式转换成范围较大的类型
//2. 如果需要把范围大的类型赋值给范围小的, 需要强制类型转换, 但是可能精度丢失
//3. 将一个字面值常量进行赋值的时候, Java 会自动针对数字范围进行检查
//4. 强制类型转换不一定能成功，不相干的类型不能互相转换




        // 类型提升
        //不同类型的数据之间相互运算时，数据类型小的会被提升到数据类型大的。
//        int a = 10;
//        long b = 20;
//        //int c =(int) (a + b); // 编译出错: a + b==》int + long--> long + long 赋值给int时会丢失数据
//        long d = a + b; // 编译成功：a + b==>int + long--->long + long 赋值给long



//        byte a = 10;
//        byte b = 20;
//        byte c = (byte)(a + b);//所有小于4个字节的计算是都要转换成int
//        // 从int转换到byte可能会有损失
//        //由于计算机的 CPU 通常是按照 4 个字节为单位从内存中读写数据. 为了硬件上实现方便, 诸如 byte 和 short
//        //这种低于 4 个字节的类型, 会先提升成 int, 再参与计算
//        System.out.println(c);





        //string类型
//        String str="hello";
//        String str2="world";
//        String str3=str+str2;
//        System.out.println(str3);//helloworld
//        //+号为拼接
//        int a=10;
//        int b=20;
//        System.out.println("a="+a+" b="+b);
//        System.out.println("a+b="+(a+b));//30
//        System.out.println("a+b="+a+b);//1020
//        System.out.println(a+b+"a+b");//30a+b
        //从左到右运行
        //字符串就拼接,没有字符串("")就相加



//int转字符串(string)
//        int num = 10;
 方法1
//        String str1 = num + "";
 方法2
//        String str2 = String.valueOf(num);//"10"
//        System.out.println(str2);//10
//        System.out.println(str1);//10
//
//
//        //String转int
//        String str="123";//str必须是合法的数字
//        int a=Integer.parseInt(str);
//        System.out.println(a);



        //包装类 型 指的是 基本数据类型对应的数据类型
        //






        //运算符

        //算术运算符
        //1. 基本四则运算符：加减乘除模(+ - * / %)
//        System.out.println(5/2);//2
//        System.out.println(5.0/2);//2.5
//        //System.out.println(5/0);//异常
//        System.out.println(5.0/0);//Infinity(无限的)

//        System.out.println(9%2);//1
//        System.out.println(9%-2);//1
//        System.out.println(-9%2);//-1
//        System.out.println(-9%-2);//-1
//        System.out.println(11.5%2);//1.5

//        int a = 20;
//        int b = 10;
//        System.out.println(a + b); // 30
//        System.out.println(a - b); // 10
//        System.out.println(a * b); // 200
//        System.out.println(a / b); // 2
//        System.out.println(a % b); // 0 --->模运算相当于数学中除法的余数


//        //都是二元运算符，使用时必须要有左右两个操作数
//        //int / int 结果还是int类型，而且会向下取整
//        int a = 3;
//        int b = 2;
 在数学中应该是1.5 但是在Java中输出结果为1 会向下取整，即小数点之后全部舍弃掉了
//        System.out.println(a / b);
 如果要得到数学中的结果，可以使用如下方式
//        double d = a*1.0 / b;
//        System.out.println(d);

        //System.out.println(11.5 % 2.0);
         运行结果
        //1.5

        //System.out.println(1+0.2); // +的左侧是int，右侧是double，在加之前int被提升为double,输出为1.2


        //增量运算符 += -= *= %=//会自动类型转换
//        double d=12.5;
//        int b=10;
//        //b=d+b;//报错
//        b+=d;


//        int a = 1;
//        a++; // 后置++ 表示给a的值加1，此时a的值为2
//        System.out.println(a++); // 注意：后置++是先使用变量原来值，表示式结束时给变量+1，因此输出2
//        System.out.println(a); // 输出3
//        ++a; // 前置++ 表示给a的值加1
//        System.out.println(++a); // 注意：前置++是先给变量+1，然后使用变量中的值，因此输出5
//        System.out.println(a); // 输出5
// --操作符给操作-1，与++含义类似
//如果单独使用，【前置++】和【后置++】没有任何区别
//如果混合使用，【前置++】先+1，然后使用变量+1之后的值，【后置++】先使用变量原来的值，表达式
//结束时给变量+1
//只有变量才能使用自增/自减运算符，常量不能使用，因为常量不允许被修改

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



//        //关系运算符主要有六个: == != < > <= >= ，其计算结果是 true 或者 false 。
//        int a = 10;
//        int b = 20;
 注意：在Java中 = 表示赋值，要与数学中的含义区分
 在Java中 == 表示相等
//        System.out.println(a == b); // false
//        System.out.println(a != b); // true
//        System.out.println(a < b); // true
//        System.out.println(a > b); // false
//        System.out.println(a <= b); // true
//        System.out.println(a >= b); // false


//        逻辑运算符主要有三个: && || ! ，运算结果都是 boolean类型。
//        1. 逻辑与 &&
        //语法规则：表达式1 && 表达式2，左右表达式必须是boolean类型的结果。
        //相当于现实生活中的且，比如：如果是学生，并且 带有学生证 才可以享受半票。
        //两个表达式都为真，结果才是真，只要有一个是假，结果就是假。
//        int a = 1;
//        int b = 2;
//        System.out.println(a == 1 && b == 2); // 左为真 且 右为真 则结果为真
//        System.out.println(a == 1 && b > 100); // 左为真 但 右为假 则结果为假
//        System.out.println(a > 100 && b == 2); // 左为假 但 右为真 则结果为假
//        System.out.println(a > 100 && b > 100); // 左为假 且 右为假 则结果为假

//        System.out.println(true&&true);//true
//        System.out.println(true&&false);//false
//        System.out.println(false&&true);
//        System.out.println(false&&false);

//        语法规则：表达式1 || 表达式2，左右表达式必须是boolean类型的结果。
//        相当于现实生活中的或，比如：买房子交钱时，全款 或者 按揭都可以，如果全款或者按揭，房子都是你的，
//        否则站一边去。
//        int a = 1;
//        int b = 2;
//        System.out.println(a == 1 || b == 2); // 左为真 且 右为真 则结果为真
//        System.out.println(a == 1 || b > 100); // 左为真 但 右为假 则结果也为真
//        System.out.println(a > 100 || b == 2); // 左为假 但 右为真 则结果也为真
//        System.out.println(a > 100 || b > 100); // 左为假 且 右为假 则结果为假

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


//        语法规则：! 表达式
//        真变假，假变真。
//        int a = 1;
//        System.out.println(!(a == 1)); // a == 1 为true，取个非就是false
//        System.out.println(!(a != 1)); // a != 1 为false，取个非就是true





        //System.out.println(10 > 20 && 10 / 0 == 0); // 打印 false,不再发生10/0==0
        //System.out.println(10 < 20 || 10 / 0 == 0); // 打印 true.第一个为真就不会执行第二个表达式了
//        对于 && , 如果左侧表达式值为 false, 则表达式结果一定是 false, 无需计算右侧表达式.
//                对于 ||, 如果左侧表达式值为 true, 则表达式结果一定是 true, 无需计算右侧表达式.
//                & 和 | 如果表达式结果为 boolean 时, 也表示逻辑运算. 但与 && || 相比, 它们不支持短路求值


        //&  |和&&   ||的功能一致但不具有短路功能
//        System.out.println(10 > 20 & 10 / 0 == 0); // 程序抛出异常
//        System.out.println(10 < 20 | 10 / 0 == 0); // 程序抛出异常



        //位运算符主要有四个: & | ~ ^ ，除 ~ 是一元运算符外，其余都是二元运算符。
        //1.按位与&(全一才为一)
//        int a = 10;
//        int b = 20;
//        System.out.println(a & b);
        //2.按位或 |:(全为0才是0)
//        int a = 10;
        int b = 20;
        System.out.println(a | b);
        //3.按位异或^(相同为0相异为1)
//        int a = 0x1;
//        int b = 0x2;
//        System.out.printf("%x\n", a ^ b);//3
        //4.按位取反~(如果该位为 0 则转为 1, 如果该位为 1 则转为 0)//和符号位没有关系
//        0x 前缀的数字为 十六进制 数字. 十六进制可以看成是二进制的简化表示方式. 一个十六进制数字对应 4
//        个二进制位.
//        0xf 表示 10 进制的 15, 也就是二进制的 1111
//        printf 能够格式化输出内容, %x 表示按照十六进制输出.
//\n 表示换行符


        //移位运算符有三个: << >> >>> ，都是二元运算符，且都是按照二进制比特位来运算的。
        //1. 左移 <<: 最左侧位不要了, 最右侧补 0.
//        int a = 0x10;
//        System.out.printf("%x\n", a << 1);//20
// 运行结果(注意, 是按十六进制打印的)

        //2.右移 >>: 最右侧位不要了, 最左侧补符号位(正数补0, 负数补1)

        //int a = 0x10;
        //System.out.printf("%x\n", a >> 1);//8


//        //>>>(无符号右移):都补0
//        int a=-1;
//        System.out.println(a>>>1);//214783647
//        System.out.println(a>>1);//-1
//        //位运算比加减乘除更快


//        表达式1 ? 表达式2 : 表达式3
//        当 表达式1 的值为 true 时, 整个表达式的值为 表达式2 的值;
//        当 表达式1 的值为 false 时, 整个表达式的值为 表达式3 的值
//        int a = 10;
//        int b = 20;
//        int max = a > b ? a : b;

       // boolean flg=true==true?true==false?true:false:true;//false


        //运算符优先级:=(赋值):最低

//逻辑控制
        //if语句:
        //1.单分支
//        if(a==b){
//
//
//        }
        //2.双分支
//        if(a==b){
//
//
//        }else{
//
//        }
        //3.多分支
        //if(a=10){
//
//
//        }else if(a=20){
//
//
//        }else{
//
//        }

//        int x = 10;
//        int y = 10;
//        if (x == 10)
//            if (y == 10)
//                System.out.println("aaa");
//            else
//                System.out.println("bbb");//和最近的if匹配

        short a =128;

        byte b =(byte)a;
        System.out.println(a);
        System.out.println(b);


    }
}