chapter-3运算符

算术运算符
关系运算符 [比较运算符]
逻辑运算符
赋值运算符
三元运算符
键盘输入语句
进制介绍
进制之间的转换
原码、反码、补码(重点难点)
位运算符 [需要二进制基础]

算术运算符

/**
 * 演示算术运算符的使用 
 */
public class ArithmeticOperator { 
    //编写一个main方法
    public static void main(String[] args) {
        // /使用
        System.out.println(10 / 4); //从数学来看是2.5, java中 2 因为整数默认是int 不带小数
        System.out.println(10.0 / 4); //java是2.5  10.0 double  带小数的
        double d = 10 / 4; //java中10 / 4 = 2, 2=>2.0  除法不带小数
        System.out.println(d);// 是2.0
        // % 取模 ,取余
        // 在 % 的本质 看一个公式!!!!  a % b = a - a / b * b
        // -10 % 3 => -10 - (-10) / 3 * 3 = -10 + 9 = -1
        // 10 % -3 = 10 - 10 / (-3) * (-3) = 10 - 9 = 1
        // -10 % -3 =  (-10) - (-10) / (-3) * (-3) = -10 + 9 = -1
        System.out.println(10 % 3); //1
        System.out.println(-10 % 3); // -1
        System.out.println(10 % -3); //1
        System.out.println(-10 % -3);//-1
        //++的使用
        //
        int i = 10;
        i++;//自增 等价于 i = i + 1; =>  i = 11
        ++i;//自增 等价于 i = i + 1; => i = 12
        System.out.println("i=" + i);//12
        /*
        作为表达式使用
        前++：++i先自增后赋值
        后++：i++先赋值后自增
         */
        int j = 8;
        int l = 10;
        //int k = ++j; //等价先执行 j=j+1; 在执行k=j;  把新值给了k
        int k = j++; // 等价先执行 k =j; 在执行 j=j+1; 把旧值给了k
        int z = ++l; //得到的是新值
        System.out.println("k=" + k + "z=" + z);//8 9
    }
}


public class ArithmeticOperatorExercise01 { 
    //编写一个main方法
    public static void main(String[] args) {
        // int i = 1;//i->1
        // i = i++; //规则使用临时变量: (1) temp=i;(2) i=i+1;(3)i=temp;
        // System.out.println(i); // 1
        // int i=1;
        // i=++i; //规则使用临时变量: (1) i=i+1;(2) temp=i;(3)i=temp;
        // System.out.println(i); //2
        // 
        // 测试输出
        int i1 = 10;
        int i2 = 20;
        int i = i1++;
        System.out.print("i="+i);//10
        System.out.println("i2="+i2);//20
        i = --i2; 
        System.out.print("i="+i);//19
        System.out.println("i2="+i2);//19
    }
}

public class ArithmeticOperatorExercise02 { 
    //编写一个main方法
    public static void main(String[] args) {
        //1.需求:
        //假如还有59天放假，问：合xx个星期零xx天
        //2.思路分析
        //(1) 使用int 变量 days 保存 天数
        //(2) 一个星期是7天 星期数weeks： days / 7 零xx天leftDays days % 7
        //(3) 输出
        //3.走代码
        int days = 25911;
        int weeks = days / 7;
        int leftDays = days % 7;
        System.out.println(days + "天 合" + weeks + "星期零" 
            + leftDays + "天");
        //1.需求
        //定义一个变量保存华氏温度，华氏温度转换摄氏温度的公式为
        //：5/9*(华氏温度-100),请求出华氏温度对应的摄氏温度
        //
        //2思路分析
        //(1) 先定义一个double huaShi 变量保存 华氏温度
        //(2) 根据给出的公式，进行计算即可5/9*(华氏温度-100)
        //    考虑数学公式和java语言的特性
        //(3) 将得到的结果保存到double sheShi
        //3走代码
        double huaShi = 1234.6;
        double sheShi = 5.0 / 9 * (huaShi - 100); 
        //5/9是零点几 直接返回 0 所以 改成5.0/9  会保留小数
        System.out.println("华氏温度" + huaShi 
            + " 对应的摄氏温度=" + sheShi);
    }
}

关系运算符 [比较运算符]

关系运算符的结果都是 boolean 型，也就是要么是 true，要么是 false
关系表达式经常用在 if 结构的条件中或循环结构的条件中

//演示关系运算符的使用
//
public class RelationalOperator { 
    //编写一个main方法
    public static void main(String[] args) {
        int a = 9;  //老韩提示:  开发中，不可以使用  a, b 
        int b = 8;
        System.out.println(a > b); //T 
        System.out.println(a >= b);  //T
        System.out.println(a <= b); //F
        System.out.println(a < b);//F
        System.out.println(a == b); //F
        System.out.println(a != b); //T
        boolean flag = a > b; //T
        System.out.println("flag=" + flag);
    }
}

逻辑运算符

用于连接多个条件（多个关系表达式），最终的结果也是一个 boolean 值。
短路与 && ，短路或 ||，取反 !
逻辑与 &，逻辑或 |，^ 逻辑异或

说明逻辑运算规则：
1) a&b : & 叫逻辑与：规则：当a 和 b 同时为 true ,则结果为 true, 否则为 false
2) a&&b : && 叫短路与：规则：当 a 和 b 同时为 true ,则结果为 true,否则为 false
3) a|b : | 叫逻辑或，规则：当 a 和b ，有一个为 true ,则结果为 true,否则为 false

4) a||b : || 叫短路或，规则：当a 和 b ，有一个为 true ,则结果为 true,否则为 false
5) !a : 叫取反，或者非运算。当 a 为 true, 则结果为 false, 当 a 为 false 是，结果为 true
6) a^b: 叫逻辑异或，当 a 和b 不同时，则结果为 true, 否则为 false

&& 和 & 基本规则

名称语法特点
短路与&& 条件 1&&条件 2 两个条件都为 true，结果为 true,否则 false
逻辑与& 条件 1&条件 2 两个条件都为 true，结果为 true,否则 false

&& 和 & 运算符的使用

/**
 * 演示逻辑运算符的使用
 */
public class LogicOperator01 { 
    //编写一个main方法
    public static void main(String[] args) {
        //&&短路与  和 & 案例演示
        int age = 50;
        if(age > 20 && age < 90) {
            System.out.println("ok100");
        }
        //&逻辑与使用
        if(age > 20 & age < 90) {
            System.out.println("ok200");
        }
        //区别
        int a = 4;
        int b = 9;
        //对于&&短路与而言，如果第一个条件为false ,后面的条件不再判断
        //对于&逻辑与而言，如果第一个条件为false ,后面的条件仍然会判断
        if(a < 1 & ++b < 50) {
            System.out.println("ok300");
        }
        System.out.println("a=" + a + " b=" + b);// 4 10 a<1为假 后面 b++还会执行    
        if(a < 1 && ++b < 50) {
            System.out.println("ok300");
        }
        System.out.println("a=" + a + " b=" + b);// 4 9 a<1为假 后面 b++不会执行
    }
}

1) &&短路与：如果第一个条件为 false，则第二个条件不会判断，最终结果为 false，效率高
2) & 逻辑与：不管第一个条件是否为 false，第二个条件都要判断，效率低

|| 和 | 基本规则

短路或|| 条件 1||条件 2 两个条件中只要有一个成立，结果为 true,否则为 false
逻辑或条件 1|条件 2 只要有一个条件成立，结果为 true,否则为 false

|| 和| 的使用

//演示| || 使用
public class LogicOperator02 { 
    //编写一个main方法
    public static void main(String[] args) {
        //||短路或  和 |逻辑或 案例演示
        //|| 规则: 两个条件中只要有一个成立，结果为true,否则为false
        //| 规则: 两个条件中只要有一个成立，结果为true,否则为false
        int age = 50;
        if(age > 20 || age < 30) {
            System.out.println("ok100");
        }
        //&逻辑与使用
        if(age > 20 | age < 30) {
            System.out.println("ok200");
        }
        //看看区别
        //(1)||短路或：如果第一个条件为true，
        //则第二个条件不会判断，最终结果为true，效率高
        //(2)| 逻辑或：不管第一个条件是否为true，第二个条件都要判断，效率低
        int a = 4;
        int b = 9;
        if( a > 1 || ++b > 4) { // 可以换成 | 测试
            System.out.println("ok300");
        }
        System.out.println("a=" + a + " b=" + b); //4 9
        if( a > 1 | ++b > 4) { // 可以换成 | 测试
            System.out.println("ok300");
        }
        System.out.println("a=" + a + " b=" + b); //4 10
    }
}

! 取反基本规则

! 非（取反） !条件如果条件本身成立，结果为 false，否则为 true
^ 相同为假不同为真

//!和^案例演示
public class InverseOperator { 
    //编写一个main方法
    public static void main(String[] args) {
        //! 操作是取反 T->F  , F -> T
        System.out.println(60 > 20); //T
        System.out.println(!(60 > 20)); //F
        //a^b: 叫逻辑异或，当 a 和 b 不同时，则结果为true, 否则为false
        boolean b = (10 > 1) ^ ( 3 > 5);
        System.out.println("b=" + b);//T
    }
}

//验证
public class Test { 
    //编写一个main方法
    public static void main(String[] args) {
        // int x = 5;
        // int y=5;
        // if(x++==6 & ++y==6){ //逻辑与
        //     x = 11;
        // }
        // System.out.println("x="+x+",y="+y);
        // //6, 6
        // int x = 5,y = 5;
        // if(x++==6 && ++y==6){
        //     x = 11;
        // }
        // System.out.println("x="+x+",y="+y);
        // //6, 5
        // 
        // int x = 5,y = 5;
        // if(x++==5 | ++y==5){
        //     x =11;
        // }
        // System.out.println("x="+x+",y="+y);
        //11, 6
        //
        // int x = 5,y = 5;
        // if(x++==5 || ++y==5){
        //     x =11;
        // }
        // System.out.println("x="+x+",y="+y);
        //11, 5
        //
        //
        boolean x=true;
        boolean y=false;
        short z=46;
        if( (z++==46)&& (y=true) )   z++;  
        //z++后++ 46 ==46 真 同时z=47 后面是赋值True给Y 也是真 z++=48
        if((x=false) || (++z==49))  z++; 
        //把x赋值False ||操作一个为真就为真 所以去判断 ++z=49  上面是48 这个是后++ 为真
        //  执行后面的z++ z=50
        System. out.println("z="+z); //50 
    }
}

赋值运算符

基本赋值运算符 = int a = 10;
复合赋值运算符
+= ，-= ，*= ， /= ，%= 等 , 重点讲解一个 += ，其它的使用是一个道理
a += b; [等价 a = a + b; ]
a -= b; [等价 a = a - b; ]

//演示赋值运算符的使用
public class AssignOperator { 
    //编写一个main方法
    public static void main(String[] args) {
        int n1 = 10;
        n1 += 4;// n1 = n1 + 4;
        System.out.println(n1); // 14
        n1 /= 3;// n1 = n1 / 3;//4
        System.out.println(n1); // 4
        //复合赋值运算符会进行类型转换
        byte b = 3;
        b += 2; // 正常b=b+2会报错 因为+2就成为int类型 无法赋值给byte
        //所以内部有一个强制类型转换 b += 2 就等于 b = (byte)(b + 2); b=b+2会报错
        b++; // b = (byte)(b+1);
        //b++ 也是内部有强制类型转换   但是写b = b+1   会报错
    }
}

1) 运算顺序从右往左 int num = a + b + c;
2) 赋值运算符的左边只能是变量,右边可以是变量、表达式、常量值
int num = 20; int num2= 78 * 34 - 10; int num3 = a;
3) 复合赋值运算符等价于下面的效果
比如：a+=3;等价于 a=a+3; 其他类推
4) 复合赋值运算符会进行类型转换。
byte b = 2; b+=3; b++;

三元运算符

条件表达式 ? 表达式1: 表达式 2;
运算规则：

如果条件表达式为 true，运算后的结果是表达式 1
如果条件表达式为 false，运算后的结果是表达式 2 ```java //三元运算符使用

public class TernaryOperator {

//编写一个main方法
public static void main(String[] args) {
    int a = 10;
    int b = 99;
    // 解读
    // 1. a > b 为 false
    // 2. 返回 b--, 先返回 b的值,然后在 b-1
    // 3. 返回的结果是99 
    int result = a > b ? a++ : b--;
    System.out.println("result=" + result);//a后++所以result=10
    //判断条件为真 a是后++ 所以result=10  后面a=11了
    System.out.println("a=" + a);// 所以 a=11
    System.out.println("b=" + b);// b++ 不执行所以 99
}

}

<a name="j9xKW"></a>
### 三元运算符使用细节
1)  表达式 1 和表达式 2 要为可以赋给接收变量的类型(或可以自动转换)<br />2)   三元运算符可以转成 if--else 语句<br />int res = a >b ?      a++ :    --b;  等于下面这个if-else语句<br /> if ( a > b) res = a++;<br />else res = --b;
```java
//三元运算符细节
public class TernaryOperatorDetail { 
    //编写一个main方法
    public static void main(String[] args) {
        //表达式1和表达式2要为可以赋给接收变量的类型
        //(或可以自动转换/或者强制转换)
        int a = 3;
        int b = 8;
        int c = a > b ? a : b;//正确 因为ab都是int类型 返回给也是int
        int c = a > b ? (int)1.1 : (int)3.4;//可以的
        //1.1 3.4是double类型,后面通过强转int  可以运行
        double d = a > b ? a : b + 3;//可以的，满足 int -> double
        //int 个字节 double 8个字节 默认就可以直接转
    }
}

求三个数的最大值


public class TernaryOperatorExercise { 
    //编写一个main方法
    public static void main(String[] args) {
        //案例：实现三个数的最大值
        int n1 = 553;
        int n2 = 33;
        int n3 = 123;
        //思路
        //1. 先得到 n1 和 n2 中最大数 , 保存到 max1
        //2. 然后再 求出 max1 和  n3中的最大数，保存到 max2
        int max1 = n1 > n2 ? n1 : n2;
        int max2 = max1 > n3 ? max1 : n3;
        System.out.println("最大数=" + max2);
        //使用一条语句实现, 推荐使用上面方法
        //老师提示: 后面我们可以使用更好方法,比如排序
        //也就是把上面的max2的表达式搬过来 把max1 换成表达式（）括起来
        // int max = (n1 > n2 ? n1 : n2) > n3 ? 
        //                 (n1 > n2 ? n1 : n2) : n3;
        // System.out.println("最大数=" + max);    
        // 
        int abcclass = 10;
        int n = 40;
        int N = 50;
        System.out.println("n=" + n);//40
        System.out.println("N=" + N);//50
        //? abc 和 aBc 是两个不同变量
        int abc = 100;
        int aBc = 200;
        //int a b = 300;
        //int a-b=10;
        int goto1 = 10;
    }
}

运算符优先级

1) 运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序。如右表，上一行运算符总优先于下一行。
2) 只有单目运算符、赋值运算符是从右向左运算的。
单目运算就是针对一个数区运算 ++ — ~ 取反
3) 一览表, 不要背，使用多了，就熟悉了.

运算符优先级分类从上至下

标识符的命名规则和规范

标识符的规则

必须遵守

public class TernaryOperatorExercise { 
    //编写一个main方法
    public static void main(String[] args) {
        int abcclass = 10;
        int n = 40;//区分大小写
        int N = 50;
        System.out.println("n=" + n);//40
        System.out.println("N=" + N);//50
        //? abc 和 aBc 是两个不同变量
        int abc = 100;
        int aBc = 200;
        //int a b = 300;
        //int a-b=10;//a-b不能是变量名
        int goto1 = 10; //goto是保留字不可以  gotol可以。
    }
}

标识符的规范

更专业

1) 包名：多单词组成时所有字母都小写：aaa.bbb.ccc //比如 com.hsp.crm
2) 类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz [大驼峰]
比如： TankShotGame
3) 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz
[小驼峰，简称驼峰法]
比如： tankShotGame
4) 常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ比如：定义一个所得税率 TAX_RATE
5) 后面我们学习到类，包，接口，等时，我们的命名规范要这样遵守,更加详细的看文档.

关键字

定义：被 Java 语言赋予了特殊含义，用做专门用途的字符串（单词）
特点：关键字中所有字母都为小写

保留字

Java 保留字：现有 Java 版本尚未使用，但以后版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留字 byValue、cast、future、 generic、 inner、 operator、 outer、 rest、 var 、 goto 、const

键盘输入语句

用户输入的语句

在编程中，需要接收用户输入的数据，就可以使用键盘输入语句来获取。Input.java , 需要一个扫描器(对象), 就是
Scanner
步骤：
1) 导入该类的所在包, java.util.*
2) 创建该类对象（声明变量）
3) 调用里面的功能

import java.util.Scanner;//表示把java.util下的Scanner类导入 
public class Input { 
    //编写一个main方法
    public static void main(String[] args) {
        //演示接受用户的输入
        //步骤
        //Scanner类 表示 简单文本扫描器，在java.util 包
        //1. 引入/导入 Scanner类所在的包
        //2. 创建 Scanner 对象 , new 创建一个对象,体会
        //   myScanner 就是 Scanner类的对象
        Scanner myScanner = new Scanner(System.in);
        //3. 接收用户输入了， 使用 相关的方法
        System.out.println("请输入名字");
        //当程序执行到 next 方法时，会等待用户输入~~~
        String name = myScanner.next(); //接收用户输入字符串
        System.out.println("请输入年龄");
        int age = myScanner.nextInt(); //接收用户输入int
        System.out.println("请输入薪水");
        double sal = myScanner.nextDouble(); //接收用户输入double
        System.out.println("人的信息如下:");
        System.out.println("名字=" + name 
            + " 年龄=" + age + " 薪水=" + sal);
    }
}

进制介绍

对于整数，有四种表示方式：
二进制：0,1，满 2 进 1.以 0b 或 0B 开头。
十进制：0-9，满 10进 1。
八进制：0-7 ，满 8 进1. 以数字 0 开头表示。
十六进制：0-9 及 A(10)-F(15)，满 16 进 1. 以。此处的 A-F 不区分大小写。

//演示四种进制
//
public class BinaryTest { 
    //编写一个main方法
    public static void main(String[] args) {
        //n1 0b开头二进制
        int n1 = 0b1010;
        //n2 10进制
        int n2 = 1010;
        //n3 0开头 8进制
        int n3 = 01010;
        //n4  0x开头 16进制
        int n4 = 0X10101;
        //输出的结果都是十进制的数
        System.out.println("n1=" + n1);
        System.out.println("n2=" + n2);
        System.out.println("n3=" + n3);
        System.out.println("n4=" + n4);
        System.out.println(0x23A);
    }
}

进制之间的转换

其它进制转十进制

1.1 二进制转十进制

1.2 八进制转十进制

1.3 十六进制转十进制

十进制转其它进制

2.1 十进制转二进制
规则：将该数不断除以 2，直到商为 0 为止，然后将每步得到的余数倒过来，就是对应的二进制。
案例：请将 34 转成二进制 = 0B00100010 一个字节是8位所有结果前面+两个0

2.2 十进制转8进制
规则：将该数不断除以 8，直到商为 0 为止，然后将每步得到的余数倒过来，就是对应的八进制。
案例：请将 131 转成八进制 => 0203

2.3 十进制转16进制
规则：将该数不断除以 16，直到商为 0 为止，然后将每步得到的余数倒过来，就是对应的十六进制。
案例：请将 237 转成十六进制 => 0xED

二进制转其它进制

3.1 二进制转八进制
规则：从低位开始,将二进制数每三位一组，转成对应的八进制数即可。
案例：请将 ob11010101 转成八进制
ob11(3)010(2)101(5) => 0325
3 2 5
011 010 101

3.2 二进制转16进制
规则：从低位开始，将二进制数每四位一组，转成对应的十六进制数即可。
案例：请将 ob11010101 转成十六进制
ob1101(D)0101(5) = 0xD5

其他进制转二进制

4.1 八进制转二进制

规则：将八进制数每 1 位，转成对应的一个 3 位的二进制数即可。
案例：请将 0237 转成二进制
02(010)3(011)7(111) = 0b10011111

4.2 十六进制转二进制
规则：将十六进制数每 1 位，转成对应的 4 位的一个二进制数即可。
案例：请将 0x23B 转成二进制
0x2(0010)3(0011)B(1011) = 0b001000111011

原码、反码、补码(重点难点)

位运算符 [需要二进制基础]

java中有 7 个位运算(&、|、^、~、>>、<<和 >>>)

//位运算
public class BitOperator { 
    //编写一个main方法
    public static void main(String[] args) {
        //推导过程
        //int 4个字节  每个字节8比特 转换为二进制  00000000 00000000 00000000 00000010
        //1. 先得到 2的补码 => 2的原码 00000000 00000000 00000000 00000010
        //   2的补码 00000000 00000000 00000000 00000010
        //2. 3的补码 3的原码 00000000 00000000 00000000 00000011
        //   3的补码 00000000 00000000 00000000 00000011
        //正数的原码补码反码一样 
        //3. 按位与&  相同为1 不同为0
        //   00000000 00000000 00000000 00000010
        //   00000000 00000000 00000000 00000011 
        //   00000000 00000000 00000000 00000010 & 运算后的补码
        //   结果要看原码  运算后的原码 也是  00000000 00000000 00000000 00000010
        //   结果就是  2
        System.out.println(2&3);//2
        //推导 ~ 取反运算
        //1. 先得到 -2的原码 10000000 00000000 00000000 00000010      符号位改成1 
        // 运算是以补码形式运算的   负数的补码是在反码的基础上+1  所以先得到反码
        //负数的反码 原码的符号位不变  其它取反
        //2. -2的 反码         11111111 11111111 11111111 11111101
        //3. -2的 补码         11111111 11111111 11111111 11111110
        //4. ~-2操作        00000000 00000000 00000000 00000001运算后的补码  补码符号位是0 所以是正数
        //5. 运算后的原码 就是 00000000 00000000 00000000 00000001 => 1 正数的原 补 反是一样的
        System.out.println(~-2);//1
        //推导
        //1. 得到2的补码 00000000 00000000 00000000 00000010
        //2. ~2操作     11111111 11111111 11111111 11111101  运算后的补码   是一个负数 符号位是1
        //3. 运算后的反码  11111111 11111111 11111111 11111100  补码-1 得到反码
        //4. 运算后的原码  10000000 00000000 00000000 00000011=>-3 负数 反码到原码 符号位不变 其它取反
        System.out.println(~2); //-3
    }
}


public class Book {
    public static void main(String[] args) {
        // 演示2|3
        //  2的补码 00000000 00000000 00000000 00000010
        //  3的补码 00000000 00000000 00000000 00000011
        //  | 有一个为1就为1 否则为0 
        //  运算后的补码 00000000 00000000 00000000 00000011
        //  正数的原 反补一样 所以运算后的原码
        //  00000000 00000000 00000000 00000011=>3
        System.out.println(2|3); 
        //  |相同为0  不同为1
        //  2的补码  00000000 00000000 00000000 00000010
        //  3的补码  00000000 00000000 00000000 00000011
        // ^运算结果 00000000 00000000 00000000 00000001 结果是正数=原码
        //  结果原码 00000000 00000000 00000000 00000010>=1
        System.out.println(2^3);
    }
}

3 个位运算符 >>、<< 和 >>> , 运算规则:
1) 算术右移 >>：低位溢出,符号位不变,并用符号位补溢出的高位
2) 算术左移 <<: 符号位不变,低位补 0
3) >>> 逻辑右移也叫无符号右移,运算规则是: 低位溢出，高位补 0
4) 特别说明：没有 <<< 符号
溢出就是扔掉不要了

1) int a=1>>2; //1 => 00000001 => 00000000 本质 1 / 2 / 2 =0 左边补零2位把最右边两位去掉
2) int c=1<<2; //1 => 00000001 => 00000100 本质 1 2 2 = 4 右边补零两位把左边的两位去掉


public class BitOperator02 { 
    //编写一个main方法
    public static void main(String[] args) {
        System.out.println(1 >> 2); //0
        System.out.println(1 << 2); //4
        System.out.println(4 << 3); // 4 * 2 * 2 * 2 = 32
        System.out.println(15 >> 2); // 15 / 2 / 2 = 3
        System.out.println(-10.4%3); // -1.4近似值
        // 当a%b a是小数的时候 等于a -(int)a/b*b  -10.4-(-10)/3*3=-10.4 + 9=-1.4
        // 有小数参与的运算  得到的都是近似值
        int i=66;
        System.out.println(++i+i); //134 先自增  i=67  然后+i  这时候i是67  所以是67+67=134
    }
}