【Java基本语法】变量和运算符

个人的一些学习：Java中的变量和六种运算符

• 变量
• • 基本数据类型
  • 字符串类型
• 运算符
• • 运算符一：算数运算符
  • 运算符二：赋值运算符
  • 运算符三：比较运算符
  • 运算符四：逻辑运算符
  • 运算符五：位运算符
  • 运算符六：三元(三目)运算符

变量 基本数据类型

基本数据类型之间的运算规则：
7种基本数据类型变量之间的运算，不包含boolean类型

1. 自动类型提升
   byte/char/short --> int --> long --> float --> double
   当byte/char/short三种类型的变量做运算时，结果为int类型
2. 强制类型转换，自动类型提升运算的逆运算
3. 需要使用强转符：()
4. 强制类型转换可能导致精度损失

public class VariableTest {
    public static void main(String[] args) {
        byte b1 = 2;
        int i1 = 12;
        int res1 = b1 + i1;

        System.out.println(res1);//14

        char a1 = 'a';
        int i2 = a1 + 1;
        System.out.println(i2);//98

        // 精度损失1
        double d1 = 12.3;
        int i3 = (int)d1;//截断 *** 作
        System.out.println(i3);//12

        // 精度损失2
        int i4 = 128;
        byte b = (byte)i4;
        System.out.println(b);//-128
    }
}

字符串类型

1. String属于引用数据类型
2. 声明String类型变量时，使用""
3. String可以和8种基本数据类型变量做运算，且运算只能是连接运算：+
4. 运算的结果仍然是String类型

public class StringTest {
    public static void main(String[] args) {
        int number = 1001;
        String numberStr = "学号:";
        System.out.println(numberStr + number);//学号:1001
    }
}

运算符 运算符一：算数运算符

算数运算符中较为常规的 + - * / %(取模) ++(自增) --(自减)

public class ArithmeticTest {
    public static void main(String[] args) {

        //除号: /
        int num1 = 12;
        int num2 = 5;
        int result1 = num1 / num2;

        System.out.println(result1);//2

        double result2 = num1 / (num2 + 0.0);
        double result3 = (double)num1 / num2;
        double result4 = (double)(num1 / num2);

        System.out.println(result2);//2.4
        System.out.println(result3);//2.4
        System.out.println(result4);//2.0

        // 取模: % 结果的符号与被摸数的符号相同
        int m1 = 12;
        int n1 = 5;
        System.out.println("m1 % n1 = " + m1 % n1);//m1 % n1 = 2

        int m2 = -12;
        int n2 = 5;
        System.out.println("m2 % n2 = " + m2 % n2);//m2 % n2 = -2

        int m3 = 12;
        int n3 = -5;
        System.out.println("m3 % n3 = " + m3 % n3);//m3 % n3 = 2

        int m4 = -12;
        int n4 = -5;
        System.out.println("m4 % n4 = " + m4 % n4);//m4 % n4 = -2

        //(前)++ 先自增1，再运算
        //(后)++ 先运算，再自增1
        int a1 = 10;
        int b1 = ++a1;
        System.out.println("a1:" + a1 + " b1:" + b1);//a1:11 b1:11
        // ++a1 相当于:
//        int a1 = 10;
//        a1 = a1 + 1;
//        int b1 = a1;
//        System.out.println("a1:" + a1 + " b1:" + b1);

        int a2 = 10;
        int b2 = a2++;
        System.out.println("a2:" + a2 + " b2:" + b2);//a2:11 b2:10
        // a2++ 相当于:
//        int a2 = 10;
//        int b2 = a2;
//        a2 = a2 +1;
//        System.out.println("a2:" + a2 + " b2:" + b2);

        int a3 = 10;
        a3++;//++a3 这种写法没有区别，都是独立做了运算的
        int b3 = a3;
        System.out.println("a3:" + a3 + ",b3:" + b3);//a3:11,b3:11

        //注意点：
        short s1 = 10;
        //s1 = s1 + 1;//类型错误
        //s1 = (short)(s1 + 1); //正确
        s1 = ++s1;//自增1不会改变变量本身的数据类型
        System.out.println(s1);//11

        //问题
        byte bt = 127;
        bt++;
        System.out.println(bt);//-128

        //(前)-- 先减1，再运算
        //(后)-- 先运算，后减1
        int a4 = 10;
        int b4 = a4--;
        System.out.println("a4=" + a4 + ",b4=" + b4);//a4=9,b4=10

        int a5 = 10;
        int b5 = --a5;
        System.out.println("a5=" + a5 + ",b5=" + b5);//a5=9,b5=9
    }
}

一个关于算数运算符的小练习
随意给出一个整数，打印显示它的个位数，十位数，百位数的值
格式：365
个位数：5
十位数：6
百位数：3

代码如下

public class ArithmeticExec {
    public static void main(String[] args) {
        int num = 888;
        int gw = num % 10;
        int sw = num / 10 % 10;
        int bw = num / 100;
        System.out.println("个位数：" + gw + '\n' +
                "十位数：" + sw + '\n' +
                "百位数：" + bw);
    }
}

运行结果如下

个位数：8
十位数：8
百位数：8

运算符二：赋值运算符

= += -= *= /= %=
常规的算数运算可能会有自动类型转换
注：赋值运算不会改变变量的数据类型

代码演示

public class SetValueTest {
    public static void main(String[] args) {
        // 连续赋值
        int i1, j1;
        i1 = j1 = 10;

        int i2 = 20, j2 = 20;

        int num1 = 10;
        num1 += 2;
        System.out.println(num1);//12

        int num2 = 20;
        num2 -= 5;
        System.out.println(num2);//15

        int num3 = 30;
        num3 *= 2;
        System.out.println(num3);//60

        int num4 = 40;
        num4 /= 3;
        System.out.println(num4);//13

        int num5 = 50;
        num5 %= 4;
        System.out.println(num5);//2

        //Exec 1
        int i = 1;
        i *= 0.1;
        System.out.println(i);//0
        i++;
        System.out.println(i);//1

        //Exec 2
        int m = 2;
        int n = 3;
        n *= m++;
        System.out.println("m=" + m + ",n=" + n);//m=3,n=6

        //Exec 4
        int n1 = 10;
        n1 += (n1++) + (++n1);
        System.out.println(n1);//32
    }
}

运算符三：比较运算符

== != > < >= <= instanceof
结论：比较运算符的结果是boolean类型

代码演示

public class CompareTest {
    public static void main(String[] args) {
        int i = 10;
        int j = 20;
        System.out.println(i == j);//false
        System.out.println(i = j);//20

        boolean b1 = true;
        boolean b2 = false;
        System.out.println(b2 == b1);//false
        System.out.println(b2 = b1);//true
    }
}

运算符四：逻辑运算符

& && | || ! ^(异或)
逻辑运算符 *** 作的都是boolean类型的变量

其中关于&&(短路与)
当左边为true时，都会执行右边的运算
当左边为false时，&会执行右边的运算，&&不会执行右边的运算

关于||(短路或)
当左边为false时，都会执行右边的运算
当左边为true时，|会执行右边的运算，||不会执行右边的运算

代码演示

public class LogicTest {
    public static void main(String[] args) {
        //当左边为true时，都会执行右边的运算
        //当左边为false时，&会执行右边的运算，&&不会执行右边的运算
        boolean b1 = true;
        b1 = false;
        int num1 = 10;
        if (b1 & (num1++ > 0)) {
            System.out.println("lalala...");
        } else {
            System.out.println("hahaha...");//输出
        }
        System.out.println("num1 = " + num1);//num1 = 11

        boolean b2 = true;
        b2 = false;
        int num2 = 10;
        if (b2 && (num2++ > 0)) {
            System.out.println("lalala...");
        } else {
            System.out.println("hahaha...");//输出
        }
        System.out.println("num2 = " + num2);//num2 = 10

        //当左边为false时，都会执行右边的运算
        //当左边为true时，|会执行右边的运算，||不会执行右边的运算
        boolean b3 = false;
        b3 = true;
        int num3 = 10;
        if (b3 | (num3++ > 0)) {
            System.out.println("lalala...");//输出
        } else {
            System.out.println("hahaha...");
        }
        System.out.println("num3 = " + num3);//num3 = 11

        boolean b4 = false;
        b4 = true;
        int num4 = 10;
        if (b4 || (num4++ > 0)) {
            System.out.println("lalala...");//输出
        } else {
            System.out.println("hahaha...");
        }
        System.out.println("num4 = " + num4);//num4 = 10
    }
}

关于逻辑运算符的一些小练习

public class LogicExec {
    public static void main(String[] args) {
        int x1 = 1;
        int y1 = 1;
        if (x1++ == 2 & ++y1 == 2){
            x1 = 7;
        }
        System.out.println("x1=" + x1 + ",y1=" + y1);//x1=2,y1=2

        int x2 = 1;
        int y2 = 1;
        if (x2++ == 2 && ++y2 == 2){
            x2 = 7;
        }
        System.out.println("x2=" + x2 + ",y2=" + y2);//x2=2,y2=1

        int x3 = 1;
        int y3 = 1;
        if (x3++ == 1 | ++y3 == 1){
            x3 = 7;
        }
        System.out.println("x3=" + x3 + ",y3=" + y3);//x3=7,y3=2

        int x4 = 1;
        int y4 = 1;
        if (x4++ == 1 || ++y4 == 1){
            x4 = 7;
        }
        System.out.println("x4=" + x4 + ",y4=" + y4);//x4=7,y4=1

        boolean x5 = true;
        boolean y5 = false;
        short z = 42;
        if (y5 == true)
        if ((z++==42)&&(y5=true))z++;
        if ((x5==false)||(++z==45))z++;

        System.out.println("z=" + z);//z=43
    }
}

运算符五：位运算符

<< >> >>>(无符号右移) & | ^(异或) ~(取反)

1. 位运算符 *** 作的都是整形的数据
2. << : 在一定范围内，每向左移一位，相当于 *2
   >> : 在一定范围内，每向右移一位，相当于 /2
3. >> : 如果原来的数最高位是0，右移补0，如果原来是1，右移补1
   >>> : 无符号右移，不管原来的数是正数还是负数都那0补
4. 关于取反的 *** 作：
   由于正数的原码、反码、补码都相同，所以可以直接按位取反
   但是负数要先转为原码再取反，(计算机底层是按补码保存的)

Tips：最高效的计算 2 * 8？–> 2 << 3 或 8 << 1

代码演练

public class BitTest {
    public static void main(String[] args) {
        int i = 21;

        System.out.println("i << 2 = " + (i << 2));//i << 2 = 84
        System.out.println("i << 3 = " + (i << 3));//i << 3 = 168
        System.out.println("i << 26 = " + (i << 26));//i << 26 = 1409286144
        System.out.println("i << 27 = " + (i << 27));//i << 27 = -1476395008

        int m = 12;
        int n = 5;

        //计算过程通过将数字转换成对应的二进制，然后按照& | ^ 的逻辑运算来求出新值
        /*
        eg: 0 0 0 0 1 1 0 0  --> 12
            0 0 0 0 0 1 0 1  --> 5
            -------------------- &
            0 0 0 0 0 1 0 0  --> 4

            0 0 0 0 1 1 0 0  --> 12
            0 0 0 0 0 1 0 1  --> 5
            -------------------- |
            0 0 0 0 1 1 0 1  --> 13

            0 0 0 0 1 1 0 0  --> 12
            0 0 0 0 0 1 0 1  --> 5
            -------------------- ^
            0 0 0 0 1 0 0 1  --> 9
         */
        System.out.println("m & n = " + (m & n));//m & n = 4
        System.out.println("m | n = " + (m | n));//m | n = 13
        System.out.println("m ^ n = " + (m ^ n));//m ^ n = 9

        //～ 取反，包括符号位在内所有的数取反 0变1 1变0
        //～ 取反有个万能公式 ～x = - (x + 1)
        /*
        0 0 0 0 0 1 1 0  --> 6 的原码/补码
                         ~
        1 1 1 1 1 0 0 1  --> 取反后得到这个补码
                         -1
        1 1 1 1 1 0 0 0  --> 得到反码
                         除符号位取反
        1 0 0 0 0 1 1 1  --> 此时二进制转十进制得 -7
        由此可知，对6取反，得到-7
        */
        System.out.println("~ 6 = " + (~6));//~ 6 = -7

        /*
        同样对-7进行取反 *** 作
        1 0 0 0 0 1 1 1  --> -7的补码
        1 0 0 0 0 1 1 0  --> -7的反码
        1 1 1 1 1 0 0 1  --> -7的原码
                         ～
        0 0 0 0 0 1 1 0  --> 得到补码 由于整数的原码/反码/补码相同，因此这个数就是6
        其中负数的十进制转二进制得到的是补码，要先转为原码再按位取反
         */
        System.out.println("~ -7 = " + (~-7));//~ -7 = 6
        System.out.println("~ -4 = " + (~-4));//3
        System.out.println("~ -2 = " + (~-2));

        //交换两个变量的值
        int num1 = 10;
        int num2 = 20;
        //方法一：定义临时变量
        //推荐方式
//        int num3 = num1;
//        num1 = num2;
//        num2 = num3;
        //num1=20,num2=10

        //方法二：不用定义临时变量
        //但是数值型数据可能会超出范围，字符串类型的数据无法相减会受限制
//        num1 = num1 + num2;
//        num2 = num1 - num2;
//        num1 = num1 - num2;
        //num1=20,num2=10

        //方法三：使用位运算符
        // 只能适用于数值类型
        num1 = num1 ^ num2;
        num2 = num1 ^ num2;
        num1 = num1 ^ num2;
        System.out.println("num1=" + num1 + ",num2=" + num2);//num1=20,num2=10
    }
}

运算符六：三元(三目)运算符

结构：(条件表达式)? 表达式1 : 表达式2;

1. 条件表达式的结果为boolean类型。

2. 条件表达式为真，执行表达式1，条件表达式为假，执行表达式2。

3. 表达式1和表达式2需要是一致的。

4. 凡是可以使用三元运算符的地方，都可以改写为if-else,相反能用if-else的不一定可以用三元运算。

5. 如果相关代码满足使用两者时，优先选用三元运算，相对于if-else的流程控制语句，三元运算符的执行效率较高，且简洁。

代码演练

public class SanYuanTest {
    public static void main(String[] args) {

        //获取两个整数的较大值
        int m = 98;
        int n = 5;

        int max = (m > n) ? m : n;
        System.out.println(max);//98

        double num = (m > n) ? 2 : 1.0;
        System.out.println(num);//2.0

        n = 98;
        String maxStr = (m > n) ? "m大" : ((m == n) ? "m和n相等" : "n大");
        System.out.println(maxStr);//m和n相等

        //获取三个数的较大值
        int n1 = 21;
        int n2 = 11;
        int n3 = -88;
        //这种写法可读性较差，不建议
        int maxStr1 = (n1 > n2) ? ((n1 > n3) ? n1 : n3) : ((n2 > n3) ? n2 : n3);
        System.out.println(maxStr1);//21

        int max1 = (n1 > n2) ? n1 : n2;
        int max2 = (max1 > n3) ? max1 : n3;
        System.out.println(max2);//21

        //改写成if-else
        if (m > n) {
            System.out.println(m);
        } else {
            System.out.println(n);
        }
    }
}