JAVA学习笔记(二) - 运算符

变量与常量

变量的声明和赋值

/*
 * 变量的声明和赋值
 */
public class Test
{
    public static void main(String[] args)
    {
        // 1-可以声明的同时，对变量赋值:int x = 10;
        //局部变量，变量名符合命名规则。
        //推荐使用此种方式。
        int x = 10;

        // 2-可以先声明，再赋值：int x; x = 10;
        int y;//变量的声明
        y = 20;//将20赋值给y指向的内存空间

        // 3-可以一行声明多个变量: int x, y, z;由,分隔
//      int a, b, c, d, e;

        // 4-一行声明多个变量，且为所有变量或部分变量赋值:由,分隔
        int a, b = 10, c, d = 20, e = 100;

        // 5-建议：一行只声明一个变量，且在声明的同时，为其初始化。
        int z = 5;

        //6-如果变量在声明的时候，不初始化，则编译通不过
        //报The local variable xx may not have been initialized
        int xx;
        xx = 100;
        System.out.println(xx);//编译错误。
    }
}

常量

/*
 * 常量
 */
public class Test
{
    public static final int MAX_AGE = 25;

    public static void main(String[] args)
    {
        //1-使用final来定义Java中的常量。
        //在声明的同时为常量名赋值。一旦赋值后，该常量名的值则不能修改。
        final int BLOOD = 10;
//      BLOOD = 100;//此时报错The final local variable BLOOD cannot be assigned. 

        //2-定义常量，可以先声明常量，再为常量赋值，注意，此种情况下，只能为常量名赋值一次。
        final int AGE;
        AGE = 20;
//      AGE = 100;//第二次赋值，会报错。The final local variable AGE may already have been assigned

        //关于常量名的命名-全部大写，如果多个单词，中间用_分割
        final int MY_AGE = 20;
    }
}

交换变量

/*
 * 交换两个变量的值的方法
 */
public class Test
{
    public static void main(String[] args)
    {
        int a = 10;
        int b = 5;

        //1-方法一
//      int temp = 0;
//      temp = a;
//      a = b;
//      b = temp;
//      System.out.println("a = " + a + ", b = " + b);

        //2-方法2
//      a = a + b;//a = 15, b = 5;//注意，有可能出现数据溢出
//      b = a - b;//a = 15, b = 10;
//      a = a - b;//a = 5, b = 10;
//      System.out.println("a = " + a + ", b = " + b);

        //3-方法3
        a = a ^ b;//a=10^5  b=5
        b = a ^ b;//b=10 a=10^5
        a = a ^ b;//a=5, b = 10
        System.out.println("a = " + a + ", b = " + b);
    }
}

字符串拼接

字符串拼接

/*
 * 字符串拼接:区分哪些是可变的，哪些是不可变的，不可变的放入""内，可变的通过+连接
 */
public class Test
{
    public static void main(String[] args)
    {
        System.out.println(10 + "aaa");//"10" + "aaa"="10aaa"
        int a = 10;
        int b = 5;
        System.out.println("a + b = " + a + b);//"a + b = 105"
        System.out.println(a + b + " = a + b");//"15 = a + b"
        System.out.println("a + b = " + (a + b));//"a + b = 15"
        System.out.println(a + " + " + b + " = " + (a + b));//10 + 5 = 15

        //(10) + (5) = [15]
        //"(" + a + ") + (" + b + ") = [" + (a + b) + "]"
        System.out.println("(" + a + ") + (" + b + ") = [" + (a + b) + "]");

        //[10 + 5] + (10 - 5) = [result]
        //"[" + a + " + " + b + "] + (" +  + a + " - " + b + ") = [" + ((a + b) + (a - b)) + "]"

        //作业
        //[a] + [b] / [a - b] = [result]
    }
}

运算符

运算符-算术运算符

/*
 * 运算符-算术运算符
 */
public class Test
{
    public static void main(String[] args)
    {
        byte b1 = 10;
        byte b2 = 20;
        byte b3 = (byte)(b1 + b2);

        int x = 100;
        int y = 10;
        System.out.println(x + y);//110
        System.out.println(x - y);//90
        System.out.println(x * y);//1000
        System.out.println(x / y);//10
        //%，以后经常使用再判断条件中，判断一个数能否被另一个数整除。
        //如果整除则余数为0,否则，不为0
        System.out.println(x % y);//0 求模或求余

        int a = 12;
        int b = 5;
//      float b = 5.0f;
        //两个数相除时，如果两个数都是整数，则结果一定是整数。
        System.out.println(a / b);//2

        int w = 10;
        int q = 0;
        //编译时，发现不了分母为0的错误。
        //运行时错误，java.lang.ArithmeticException: / by zero
        System.out.println(w / q);
    }
}

自增：++与自减：–

/*
 * 自增：++    ++a或a++  相当于 a = a + 1;
 * 自减：--    --a或a--    相当于a = a - 1;
 * 
 * ++/-- 位于操作数之前，该操作数参与运算时，会先自增/自减，再参与运算。
 * ++/--位于操作数之后，该操作数先用当前值参与运算，再自增/自减
 */
public class Test
{
    public static void main(String[] args)
    {
        int a = 10;
        a++;//a = a + 1;
        System.out.println(a);

        int b = 10;
        b--;//b = b - 1;
        System.out.println(b);

        //++/--位于操作数的前后
        int aa = 10;
        System.out.println(aa++);//10
        System.out.println(aa);//11
        int bb = 10;
        System.out.println(++bb);//11
    }
}

案例

/*
 * ++或--案例
 */
public class Test
{
    public static void main(String[] args)
    {
        int a = 10;
        int b = 10;
        int c = 10;
//              a=11  b=11  c=9   b=10  a=10
        //      10    11    10      10  11
        int d = a++ + ++b + c-- + --b + a--;
        System.out.println(d);
        System.out.println(a++ + 1);//11  a=11
        System.out.println(--b + --c + a++);//28  a=12,b=9,c=8


        a += b;//a = a + b;
        a -= b;//a = a - b;
        a *= b;
        a /= b;
        a %= b;

        byte b1 = 10;
        byte b2 = 10;
//      b1 = b1 + b2;//编译错误
//      b1 = (byte)(b1 + b2);
        b1 += b2;// b1 = (byte)(b1 + b2);
    }
}

关系运算符

/*
 * 关系运算符->,>=,<,<=,==,!=,instanceof
 *  使用关系运算符，如果成立，返回true，否则，返回false
 *  比较运算符，条件判断中比较常用。
 */
public class Test
{
    public static void main(String[] args)
    {
        int a = 10;
        int b = 20;

        System.out.println(a > b);//false
        System.out.println(a < b);//true
        System.out.println(a >= b);//false
        System.out.println(a <= b);//true
        System.out.println(a == b);//false
        System.out.println(a != b);//true

        boolean flag = true;
        System.out.println(flag = false);//false
//      flag = false;
//      System.out.println(flag);

        System.out.println(flag == true);//false
    }
}

逻辑运算符

/*
 * 逻辑运算符
 */
public class Test
{
    public static void main(String[] args)
    {
        int a = 5;
        int b = 6;
        int c = 7;
        //&&  || 有短路的逻辑运算符，此种形式非常常用。
        //&&逻辑与---全部条件都为true，结果才为true
        //条件1 && 条件2 && 条件3...
        //表示条件1，2，3同时为true，结果才为true。
        System.out.println(a < b && b < c);//true
        System.out.println(a < b && b > c);//false
        System.out.println(a < b && b < c && a < c);//true
        //||逻辑或---全部条件，都为false，结果才为false
        //条件1 || 条件2 || 条件3...
        //表示条件1，2，3任何一个为true，结果为true。
        System.out.println(a < b || b < c);//true
        System.out.println(a < b || b > c);//true
        System.out.println(a < b || b < c || a < c);//true
        System.out.println(a > b || b > c);//false

        //& | 无短路的逻辑运算符
        //&逻辑与---全部条件都为true，结果为true
        System.out.println(a > b & b < c);//false
        System.out.println(a < b & b < c);//true
        //|逻辑或---全部条件，都为false，结果才为false
        System.out.println(a < b | b < c | a < c);//true
        System.out.println(a > b | b > c);//false
    }
}

位运算符

/*
 * 位运算符
 *  ~, ^, &, |
 */
public class Test
{
    public static void main(String[] args)
    {
        int a = 5;
        int b = 7;

//      ~  按位取反
//  5   00000000000000000000000000000101
//  ~5 11111111111111111111111111111010--补码
//      11111111111111111111111111111001--反码
//      10000000000000000000000000000110--原码
        System.out.println(~a);

//      &   按位与 对应的位全部为1，结果为1.
//      特点：一个数与全1相与，得到其本身。全0相与，得到0
//  5   00000000000000000000000000000101
//  7   00000000000000000000000000000111
//  &
//      00000000000000000000000000000101
        System.out.println(a & b);

//      |   按位或 对应位，全部为0，结果为0
//      5   00000000000000000000000000000101
//      7   00000000000000000000000000000111
//      |
//          00000000000000000000000000000111
        System.out.println(a | b);

//      ^   按位异或    对应的位，相同为0，不同为1
//      5   00000000000000000000000000000101
//      7   00000000000000000000000000000111
//      ^   
//          00000000000000000000000000000010
        int c = a ^ b;
//      System.out.println(c ^ a);//c^a=b
//      System.out.println(c ^ b);//c^b=a
        System.out.println(a ^ b);
//      文件 ^ 12341234---加密
//      加密后文件 ^ 12341234---解密
    }
}

/*
 * 移位运算符
 *  << 左移   10 << 2 表示10表示的二进制向左移动2位    10*2的2次方
 *  >> 右移   10 >> 2表示10的二进制向右移动2位，10/2的2次方
 * >>> 无符号右移    10 >>> 2表示10的二进制向右移动2位， 10/2的2次方。
 */
public class Test
{
    public static void main(String[] args)
    {
        int a = 5;
        int b = -5;
//      << 有符号左移
//      5 << n  高位去掉n位，低位以0补n位，相当于x乘以n个2； 
//  5   00000000000000000000000000000101--补码
//  <<2 00000000000000000000000000010100
        System.out.println(a << 2);

//  -5  10000000000000000000000000000101--原码
//  -5  11111111111111111111111111111010--反码
//      11111111111111111111111111111011--补码
//  <<2 11111111111111111111111111101100--移位后补码
//      11111111111111111111111111101011--移位后反码
//      10000000000000000000000000010100--移位后原码
        System.out.println(b << 2);

        int x = 16;
        int y = -16;
//      >> 有符号右移 
//      5 >> n  低位去掉n位，高位以符号位补n位，相当于x除以n个2；
//16    00000000000000000000000000010000
//  >>2 00000000000000000000000000000100
        System.out.println(x >> 2);

//  -16  10000000000000000000000000010000
//       11111111111111111111111111101111--反码
//       11111111111111111111111111110000--补码
//-16>>2 11111111111111111111111111111100--移位后的补码
//       11111111111111111111111111111011--移位后反码
//       10000000000000000000000000000100--移位后原码
        System.out.println(-16 >> 2);

//      >>> 无符号右移
//      16 >>> 2    低位去掉n位，高位以0补n位，相当于x除以n个2；
        System.out.println(x >>> 2);

//  -16     10000000000000000000000000010000
//          11111111111111111111111111101111--反码
//          11111111111111111111111111110000--补码
//-16>>>2   00111111111111111111111111111100    
        System.out.println(y >>> 2);

//      2 << 5;
//      62-63=1;
    }
}

条件运算符

/*
 * 条件运算符：
 *  条件表达式?返回值1:返回值2
 */
public class Test
{
    public static void main(String[] args)
    {
        //条件运算符一定会返回一个值。
        int a = 10;
        int b = 5;

        int c = a > b? a : b;
        System.out.println(c);

        boolean flag = false;
        int x = flag?10:20;
        System.out.println(x);

        String str = 10 < 20 ? "10 < 20" : "10 > 20";
        System.out.println(str);
    }
}