java三：数据类型之间的计算

一.基本数据类型之间的运算规则：

前提：7种基本数据类型之间的计算，整型（整数类型：byte、short、int、long）、浮点型（float、double）、字符型char，不包含布尔型。

1.自动类型提升的计算

2.强制类型转换的计算

class VariableTest {
    public static void main(String[] args) {
        /* 1.自动提升数据类型
        结论：当容量小的数据类型，和容量大的数据类型的变量做运算时，结果要使用容量大的数据类型变量来接收，
        即自动提升为容量大的数据类型。这里说的容量是指表示数值的范围的大小，不是占用内存容量的大小。
        依次：byte、char、short --> int --> long --> float --> double
        例外 ----> 当byte、char、short三种类型的变量做运算时，结果为int型或更大 **/

        // ************byte和int
        byte b1 = 2;
        int i1 = 12;
        int i2 = b1 + i1; // byte和int之间运算，使用什么类型的变量接收?
        // 当容量小的数据类型，和容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。
        // 因此使用int来接收。当然使用更大容量的long型、float型、double型接收，也是可以的。
        System.out.println(i2);  // 14
        long l1 = b1 + i1;
        float f1 = b1 + i1;
        double d1 = b1 + i1;
        System.out.println(l1); // 14
        System.out.println(f1);  // 14.0
        System.out.println(d1);  // 14.0

        // ********char和int
        char c1 = 'a';  // 97
        int i3 = 10;
        int i4 = c1 + i3;
        System.out.println(i4);  // 107

        // ********short
        short s1 = 123;
        double d2 = s1;
        System.out.println(d2);  // 123.0

        // *******特殊情况：char、short、byte之间运算：
        // char + short >= int
//        char c2 = c1 + s1; //编译不通过，char和short之间做运算是，数据类型要提升为int或int以上的容量的数据类型。
        int i5 = c1 + s1;
        System.out.println(i5);  // 220
        // char + byte >= int
//        char c3 = c1 + b2;  // 编译不通过，char和byte之间做运算是，数据类型要提升为int或int以上的容量的数据类型。
        // char + char >= int
        char c2 = 'b';
        int i6 = c1 + c2;
        System.out.println(i6);  // 195
    }
}

 

class VariableTest1 {
    public static void main(String[] args) {
        /*
         2.强制数据类型转换：自动提升数据类型的逆运算
            1.使用强转符: (指定要强制的类型)
            2.强制类型转换，可能导致精度损失(截断操作)
        */
        double d1 = 12.3;
//        int i1 = d1; //编译不通过，因为double类型的数据，比int型的容量(数值范围)大
        int i1 = (int)d1; // (类型)：表示强制转换，并强制转换为指定的类型。截断操作
        System.out.println(i1);  // 12，精度损失，截断了小数部分.3 。

        long l1 = 123;
        short s2 = (short)l1;
        System.out.println(s2);  // 123,没有损失精度

        int i2 = 128;
        byte b1 = (byte)i2;
        System.out.println(b1);  // -128,精度损失
    }
}

 

几种特殊情况：

class VariableTest2 {
    public static void main(String[] args) {
        // 1.规定：long类型变量定义时，要使用l或者L结尾。
        // 有时定义long型变量时，没有使用l或者L结尾，有时可以编译通过，有时不能编译通过，是什么情况?
        long l1 = 123123; // 定义long型变量时，并没有使用l或者L结尾，但编译通过。
        // 是因为此时将123123认为是int型，int型定义为long型时，自动提升了数据类型。
//        long l2 = 12345678912;  //编译不通过，虽然认为12345678912是int型数据自动提升为long型变量，但是12345678912超出了int的范围。

        // 2.float型任何时候，都要以l或者L结尾。
//        float f1 = 12.3;

        // 3.整型常量，默认类型为int，浮点型常量默认为double型
        byte b1 = 12;
//        byte b2 = b1 + 1; // 编译不通过，因为1是整型常量，默认为int型
//        float f2 = b1 + 12.3; // 编译不通过，因为12.3是浮点型常量，默认为double型
    }
}

 

二.字符串类型String

String不是基本数据类型，属于引用数据类型。

定义：String s1 = "abcd";

字符串必须使用双引号声明，字符必须使用单引号声明。

一个字符串，可以串接另外一个字符串，也可以直接串接其他类型的数据。如： s2 = s1 + "abc";  s2 = s1 + 100;

String可以和8中基本数据类型做运算，只能是连接运算，包括Boolean；运算使用+，结果为String（即只能使用String接收）

class StringTest {
    public static void main(String[] args)  {
        String s1 = "Hello World";
        System.out.println(s1);
//        String s2 = 'Hello World'; // 编译不通过, 字符串声明必须使用双引号
        String ss2 = "";  // 编译通过, 声明字符串可以为空
        String ss3 = " "; // 编译通过
//        char c= ""; // 编译不通过，声明字符必须使用单引号
//        char c = ''; // 编译不通过，声明字符不能为空

        //************
        int number = 10000;
        String info = number + s1; // +: 连接运算符
        boolean b1 = true;
        String info1 = info + b1;
        System.out.println(info);  // 10000Hello World
        System.out.println(info1);  // 10000Hello Worldtrue
        System.out.println("HaHa HaHa" + true);  // HaHa HaHatrue
        //*******：+号练习: 1.作为加运算, 2.作为连接运算
        char c = 'a'; // a:97 A:65
        int num = 10;
        String str = "hello";
        System.out.println(c + num + str); //结果: 107hello,第一个+为加法运算，第二个+为字符串连接
        System.out.println(c + str + num); //结果: ahello10，第一个和第二个+，都是字符串连接
        System.out.println(c + (num + str)); //结果: a10hello，第一个和第二个+，都是字符串连接
        System.out.println((c + num) + str); //结果: 107hello，第一个+为加法运算，第二个+为字符串连接
        System.out.println(str + num + c); //结果: hello10a，第一个和第二个+，都是字符串连接
        
        //*******: *号练习，输出*   *：1. char相加，是加法运算；2. 字符串相加是连接运算，包括特殊字符* \t等等
        System.out.println("*     *"); //结果: *   *
        System.out.println('*' + '\t' + '*'); //结果：93，这里的'\t'是字符，第一个和第二个+，都是加法运算
        System.out.println('*' + "\t" + '*'); //结果：*   *，这里的"\t"是字符串，第一个和第二个+，都是字符串连接
        System.out.println('*' + '\t' + "*"); //结果：51*，这里的'\t'是字符，第一个+，是加法运算，第二个+是字符串连接
        System.out.println('*' + ('\t' + "*")); //结果：*  *，这里的'\t'是字符，第一个和第二个+，都是连接字符串

        //*****: 语法对错练习
//        String str5 = 4; // 错
        String str6 = 3.5f + ""; // 对
        System.out.println(str6);  //结果: 3.5

        int num1 = 123;
        String s9 = num1 + "";
//        int num2 = (int)s9; // 编译不通过, string不能直接转换为int
        int num2 = Integer.parseInt(s9);
        System.out.println(num2);  // 123
    }
}

  三.进制

1.二进制转换为十进制：

二进制表示整数：

• java整数常量默认是int型
• 当使用二进制定义byte型时，有8位二进制数值，其第8位是符号位
• 当使用二进制定义short型时，有16位二进制数值，其第16位是符号位
• 当使用二进制定义int型时，有32位二进制数值，其第32位是符号位
• 当使用二进制定义long型时，有64位二进制数值，其第64位是符号位

二进制表示整数有三种形式：

• 原码：直接将一个数值换成二进制，最高位是符号位。正数的符号位为0，负数的符号位为1
• 反码：正数的反码与原码相同；负数的反码：对原码按位取反，最高位（符号位）不变
• 补码：正数的补码与原码相同；负数的补码：其反码加1

计算机以二进制补码的形式，保存所有的整数：

• 正数的原码、反码、补码，都相同
• 负数的反码，对原码按位取反，最高位（符号位）不变。
• 负数的补码，是其反码+1

 

 2.十进制转换为二进制

 除2取余的逆，如：13

• 13除2，商6，余1
• 6除2，商3，余0
• 3除2，商1，余1
• 1除2，商0，余1
• 0除2，商0，余0
• 0除2，商0，余0.........0一直补够