java运算加减乘除混合

一、运算符

不论什么编程语言来说，都会涉及到有关计算、拼接字符串等操作，那么“运算符”，就是必不可少的了。

运算符：以一个或多个自变量为基础，可以生成一个新值。

常见运算符包括：加号（+）、减号（-）、乘号（*）、除号（/）、等号（=）

1、优先级
运算符优先级决定了存在多个运算符时一个表达式各个部分的计算顺序。

其中我们最熟悉也是最简单的规则就是：乘法和出发需要在加法和减法之前完成。
当我们不清楚其他的规则时，最简单办法就是用括号表明计算顺序。
例如：
R = X-2+Y/X+8与R = X-(2+Y)/(X+8)有着截然不同的意义与结果。

2、赋值
赋值是使用运算符（=）来进行，意思为“取得等号右边的值，将其复制到左边”。右边可以使任何值，常量、变量、表达式、方法，只要可以产生一个值就行。单左边必须是一个明确的、已知名称的变量。

例子：
可以常量赋值给变量：a =4
不行变量赋值给常量：4 =a

给大家看一段有趣的代码：

class Num {
    int i;
}
public class Operator {
    public static void main(String[] args) {
        operatorAssignment();
        System.out.println("======================================");
        operatorAssignment2();
    }
    /**
     * 运算符赋值
     */
    public static void operatorAssignment2() {
        Num n1 = new Num();
        Num n2 = new Num();
        n1.i = 9;
        n2.i = 47;
        System.out.println("1: n1.i: " + n1.i +
                ", n2.i: " + n2.i);
        n1 = n2;
        System.out.println("2: n1.i: " + n1.i +
                ", n2.i: " + n2.i);
        n1.i = 27;
        System.out.println("3: n1.i: " + n1.i +
                ", n2.i: " + n2.i);
    }
    /**
     * 运算符赋值
     */
    public static void operatorAssignment() {
        Num n1 = new Num();
        Num n2 = new Num();
        n1.i = 9;
        n2.i = 47;
        System.out.println("1: n1.i: " + n1.i +
                ", n2.i: " + n2.i);
        n1.i = n2.i;
        System.out.println("2: n1.i: " + n1.i +
                ", n2.i: " + n2.i);
        n1.i = 27;
        System.out.println("3: n1.i: " + n1.i +
                ", n2.i: " + n2.i);
    }
}

运算结果：

对主数据类型的赋值是十分直接的，A=B，那么B的值就复制给了A，修改A的值对B不会有影响。因为主数据类型容纳的是实际的值，并非指向一个对象的句柄。

对于对象赋值的时候，情况却是大不相同。A=B，意味着A和B都会指向B才指向的那个对象。因为对一个对象进行操作的时候，我们真正操作的是它的句柄。也就是说，将右侧的句柄复制到了左侧。

3、算数运算符
算数运算符包括：加号（+）、减号（-）、乘号（*）、除号（/）、取余（%）

public class ArithmeticOperator {
    /**
     * 算术运算符主要包括：加号（+）、减号（-）、乘号（*）、除号（/）、取余（%）
     * 扩展：自动递增、递减
     * @param args
     */
    public static void main(String[] args) {
        int a = 3;
        int b = 7;
        double s ;
        s = a+b;
        System.out.println("加法运算符："+s);
        s = a-b;
        System.out.println("减法运算符："+s);
        s = a*b;
        System.out.println("乘法运算符："+s);
        s = b/a;
        System.out.println("除法运算符："+s);
        s = b%a;
        System.out.println("取余运算符："+s);
        System.out.println("=============自动递增、递减==============");
        System.out.println("自动递增（前缀）："+ ++a);
        System.out.println("自动递增（前缀）后a的值："+a);
        System.out.println("自动递减（前缀）："+ --a);
        System.out.println("自动递减（前缀）后a的值："+a);
        System.out.println("自动递增（后缀）："+ b++);
        System.out.println("自动递增（后缀）后b的值："+b);
        System.out.println("自动递减（后缀）："+ b--);
        System.out.println("自动递减（后缀）后b的值："+b);
    }
}

运算结果：

自动递增、递减的前缀后缀涉及到使用时数据的具体值，对应上图仔细查看不同的地方。

4、关系运算符
关系运算符生成的是一个布尔（boolean）结果。他们评价的是运算对象之间的关系，若关系是真实的，关系表达式会生成True，否者为false。

关系运算符包括：小于（<）、大于（>）、小于或等于（<=）、大于或等于（>=）、等于（==）、不等于（!=）。

有一段有趣的代码：

public class RelationalOperators {
    public static void main(String[] args) {
        Integer n1 = new Integer(22);
        Integer n2 = new Integer(22);
        System.out.println(n1 == n2);
        System.out.println(n1 != n2);
    }
}

程序运行结果：

是不是与预期的结果不一样呢？这里涉及到了另一个知识–对象相等检查。

由之前的内容（对象赋值部分）我们可以知道，这里比较的是两个对象n1和n2的句柄，虽然二者的数值是相等的，但是其句柄是不等的。这里比价的是二者的句柄。

public class RelationalOperators {
    public static void main(String[] args) {
        Integer n1 = new Integer(22);
        Integer n2 = new Integer(22);
        System.out.println(n1 == n2);
        System.out.println(n1 != n2);
        System.out.println(n1.equals(n2));
    }
}

我们新增加一行代码System.out.println(n1.equals(n2)); 结果会有什么不同呢，可以看到，这次打印结果为：true

关于==与equals的区别于比较我们会在之后进行详细的讲解，其实通过上面的代码我们也可以发现其中的规律：
== 比较的是两个对象的地址是否相同，即指针地址是否指向同一物理地址，若是则为相等，否者不等。
equals比较的是两个对象的数值是否相等，若相等返回true，否者为false。

注：后续部分会详细讲解二者区别，这里的说明并非绝对。

5、逻辑运算符

逻辑运算符包括：AND（&&）、OR（||）、NOT（！） 。

public class LogicalOperator {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println((a>11)&&(b<30));
        System.out.println((a>11)||(b<30));
        System.out.println(a != 20);
    }
}

程序运行结果：

只可将逻辑运算符应用于布尔值！

6、按位运算符与移位运算符

常用按位运算符包括：按位与（&）、按位或（|）、异或运（^）、取反（~）、左移（<<）、右移（>>）
按位运算符允许我们操作一个整数数据类中的单个“比特”，即二进制。
在计算机中二进制最高位为符号为“0”为假，“1”为真。

/**
 * 按位运算符与移位运算符演示
 * Integer.toBinaryString(int i)方法为：十进制转二进制
 */
public static void bitwise(){
    int a = 5;
    int b = 3;
    System.out.println(Integer.toBinaryString(a));
    System.out.println(Integer.toBinaryString(b));
    //a与b的与
    System.out.println("a与b的与:"+ (a&b));
    //a与b的或
    System.out.println("a与b的或:"+(a|b));
    //a与b的异或
    System.out.println("a与b的异或:"+(a^b));
    //a的非
    System.out.println("a的非:"+(~a));
    //a左移两位
    System.out.println("a左移两位:"+(a<<2));
    //b右移两位
    System.out.println("b右移两位:"+(b>>2));
}

运算结果为：

解析：
5的二进制为：0101
3的二进制为：0011
与运算，一真一假则为假，两真则为真。所以二者运算后为：0001转换十进制为1；
或运算，一真则为真，两假则为假。所以二者运算后为：0111转换十进制为7；
异或运算，相同为假，不同为真。所以二者运算后为：0110转换十进制为6；
非运算，反码：11111111 11111111 11111111 11111010
补码：11111111 11111111 11111111 11111001
按位取反：10000000 00000000 00000000 00000110 转十进制 -6
左移：0000 0101 --左移2位后–>0001 0100 转十进制 20
右移：0000 0011 --右移2位后–>0000 0000 转十进制 0

7、三元（也叫三目）运算符
三元运算符包含三个运算对象，最终会生成一个值，其表达式为：
布尔表达式?值0:值1

如果布尔表达式为true，则计算值0，否者计算值1
简单例子：

public class TernaryOperator {
    public static void main(String[] args) {
        int a = 3;
        int b = 7;
        int s = (a<b) ? 9 : 11;
        System.out.println("三元运算符判断后的结果为："+s);
    }
}

运算结果为：

8，逗号运算符
java中使用到逗号运算符的场景就是for循环：

public class CommaOperator {
    public static void main(String[] args) {
        for (int i = 0,j = 0; i < 3; i++,j=i*2) {
            System.out.println("当前i的值："+i+"，当前j的值为："+j);
        }
    }
}

运算结果为：

最后还有一个字符串运算符，可以做字符串拼接使用，前面很多代码都有使用到这一特点。

二、执行控制

在java中的流程控制 包括关键字：if-else、while、do-while、for、switch，接下来，让我们一一介绍。

1、if-else
if-else是流程控制的最基本形式。其实else是可选的。其基本结构如下
if (布尔表达式){
语句
}else {
语句
}

简单例子：

public static void ifElse(){
    int a = 8;
    if (a>3){
        System.out.println("执行到此，说明a大于3");
    }else {
        System.out.println("执行到此，说明a不大于3");
    }
}

运算结果为：

2、while
其基本结构如下，除非用于控制while的布尔表达式为false，否者语句会一直执行下去。
while (布尔表达式){
语句
}

简单例子：

public static void whileControl(){
    int a = 5;
    while(a>0){
        System.out.println("当前a的值为："+a);
        a--;
    }
}

运算结果为：

3、do-while
do-while与while极其相似，二者唯一区别是do-while至少会执行一次，即便表达式第一次计算就为false。其基本结构如下：
do {
语句
}
while (布尔表达式)

简单例子（举一个第一次就为false的例子）：

public static void doWhile(){
    int a = 5;
    do {
        System.out.println("当前的a值为："+a);
    }
    while (a>10);
}

运算结果为：

4、for
for循环在第一次反复之前要进行初始化，随后它会进行条件测试，并且每次反复的时候会进行着某种形式的“进步”，其基本结构如下：
for (初始表达式;布尔表达式;进步){
语句
}

简单例子：

public static void forControl(){
    for (int i = 0 ; i <5 ; i++){
        System.out.println("当前i的值为："+i);
    }
}

运算结果为：

5、switch
switch更像是一种语言选择，根据一段表达式的值，switch可以选择一段代码执行，其基本结构为：
switch (选择因子){
case 因子1:
语句
break;
case 因子2:
语句
break;
//…
default:
语句
}

简单例子：

public static void switchControl(){
    String language = "Java";
    switch (language){
        case "Java":
            System.out.println("我爱Java");
            break;
        case "Python":
            System.out.println("我爱Python");
            break;
        case "Go":
            System.out.println("我爱Go");
            break;
        default:
            System.out.println("啥也不爱，老子最帅！");
    }
}

运算结果为：

---

代码部分可以复制到自己的编译器中修改数值，查看不同的生成结果。

博客中的代码已经上传至码云，会同步实时更新，若有需要可自行下载。

也可以添加我的博客，获取海量Java资源。