Java学习笔记——运算符与控制语句

最新推荐文章于 2024-06-12 11:59:04 发布

小眼睛_i

最新推荐文章于 2024-06-12 11:59:04 发布

阅读量378

点赞数

文章标签： java 学习 java-ee

本文链接：https://blog.csdn.net/weixin_45875493/article/details/123285594

版权

运算符与控制语句

一、运算符
1.1.1、运算符概述
1.1.2、算术运算符
1.1.3、关系运算符
1.1.4、逻辑运算符
1.1.5、赋值运算符
1.1.6、关于优先级
1.1.7、条件运算符
1.1.8、字符串拼接
二、控制语句
2.2.1、选择语句if
2.2.2、选择语句switch
2.2.3、循环语句for
2.2.4、循环语句while
2.2.5、循环语句do.....while
2.2.6、转向语句break
2.2.7、转向语句continue
2.2.8、Scanner类的使用

一、运算符

1.1.1、运算符概述

运算符是指操作数的运算方式。

1.1.2、算术运算符

在这里插入图片描述

public class Test02 {
public static void main(String[] args) {
        //算术运算符
        //加减乘除运算
        int a = 10;
        int b = 3;
        System.out.println(a + b);
        System.out.println(a - b);
        System.out.println(a * b);
        //3.3333舍弃小数的部分
        System.out.println(a / b);
        
        //取模运算 求余数
        //10除以3，余1
        System.out.println(a % b);
    }
}

运行结果
在这里插入图片描述

//++ --
        //表示：自增1/自减1的运算

        int i = 10;
        i++;
        System.out.println("i= "+i);

        int j = 10;
        ++j;
        System.out.println("j= "+j);
        
        
        /*
            ++如果是出现在变量的右侧，那么是先执行++所在的表达式，再执行++
            表达式int m - k++;
            先执行int m = k;(先执行表达式)
            再执行K= k +1(后进行自增操作)


            ++如果是出现现在变量的左侧，name是先执行++，后执行++所在的表达式
            表达式 int p = ++o;
            先执行o = o+1(先进行自增操作)
            再执行int p = o (后执行表达式)

            int i = 10;
            ++i:是i自身的值，自增了1
            i+1：i自身的值，不会发生改变

         */
        int k = 10;
        int m = k++;
        System.out.println("k="+ k);//11
        System.out.println("m="+ m);//10
        
        int o = 10;
        int p = ++o;
        System.out.println("o=" + o);//10
        System.out.println("p=" + p);//11
    }

运行结果
在这里插入图片描述

1.1.3、关系运算符

关系运算符主要是完成数据和数据之间的比较，比如：5>3，结果是 true（真），5>10，结果是 false（假）。
在这里插入图片描述

public class Test03 {
    public static void main(String[] args) {
        //关系运算符
        int a = 10;
        int b = 20;
        System.out.println(a > b);
        System.out.println(a >= b);
        System.out.println(a < b);
        System.out.println(a <= b);
        System.out.println(a == b);
        System.out.println(a != b);

         /*
            如果==，不是比较数字，而是比较字符串
            通过我们现在案例，得到的结论是没有问题的
            但是==不是用来比较字符串，将来会出现严重的问题

            结论：
                虽然我们看到了以下案例使用==比较字符串是好使的
                但是也不要这么用

                我们将来是使用equals方法对于字符串进行比较
         */
        System.out.println("----------------------");

        String str1 = "abc";
        String str2 = "abc";
        System.out.println(str1==str2);
        System.out.println(str1.equals(str2));

    }
}

运行结果
在这里插入图片描述

1.1.4、逻辑运算符

逻辑运算符主要包括逻辑与（&），逻辑或（|），逻辑异或（^），短路与（&&），短路或（||）。所有逻辑运算符的特点是操作数都是布尔类型，并且最终的运算结果也是布尔类型。
在这里插入图片描述

public class Test05 {
public static void main(String[] args) {
        /*
            &表示与
                两侧必须都是true，最终结果才是true
            |表示或
                两侧，其中有一侧为ture，最终结果就是true

            !表示取反
                !ture结果为false
                !false结果为true
         */
        System.out.println((5 > 3) & (5 < 4));
        System.out.println((5 > 3) & (5 > 4));
        System.out.println((5 > 100) & (5 > 4));

        System.out.println(true & true);//true
        System.out.println(true & false);//false
        System.out.println(true | false);//true
        System.out.println(false & false);//false
        System.out.println(!true);//false
        System.out.println(!false);//true

        /*
            ^表示异或
                两侧都是true，最终的结果就是false
                两侧都是false，最终的结果就是false

                两侧是不一样的取值，最终的结果就是true

                使用的比较少，了解
         */
        System.out.println("---------------------------");
        System.out.println(true ^ false);
        System.out.println(false ^ true);
        System.out.println(true ^ true);
        System.out.println(false ^ false);


        /*
            逻辑与(&),和 短路与(&&)的区别

            逻辑与(&)
                &符号两侧表达式都会完整的执行
            短路与(&&)
                &&符号左侧表达式如果为false，那么最终的结果一定为false
                &&符号右侧的部分就没有比较继续执行了

            短路或(//)
                //符号左侧表达式如果true，那么最终的结果一定为true
                //符号右侧的部分就没有必要继续执行了

            前提:
            m > n && m >n++语句的可读性很差
            未来实际项目开发，我们会将上面的语句进行有效的拆解
            更重要的是 ++是一种运算，运算参与到了比较当中
            所以先运算后比较，还是先比较后运算，读起来很麻烦，需要认为的判断


         */
        System.out.println("==========================");
        int m = 99;
        int n = 100;
        System.out.println(m > n & m >n++);
        System.out.println(n);//我们看到了101，表示上面的n++执行了


        System.out.println("==========================>>>>");
        int a = 99;
        int b = 100;
        System.out.println(a > b && a >b++);
        System.out.println(b);//我们看到了100，表示上面的n++没有执行

        System.out.println("------------------------->短路");
        //短路
        int q = 99;
        int w = 100;
        boolean flag1 = q > w;
        w++;
        boolean flag2 = q > w;
        System.out.println(flag1 & flag2);//false
        System.out.println(q > w & q>w++ | 10 >100 && !(q >= n));//false


    }
}

运行结果
在这里插入图片描述

1.1.5、赋值运算符

赋值运算符目前也是只需要掌握=、+=、-=、=、/=、%=，其它和二进制相关的内容也是到后面遇到的时候再详细学习。赋值类的运算符包括基本赋值运算符（=）和扩展的赋值运算符（+=、-=、=、/=、%=）。
在这里插入图片描述

public class Test05 {
    public static void main(String[] args) {
        //赋值运算符
        int i;
        i = 10;
        System.out.println("i=" + i);

       /* int x = 10;
        x += 1;//效果 x = x + 1;
        x -= 1;//x = x + 1;
        x *= 2;
        x /= 2;
        x %= 3;
        System.out.println("x="+ x);*/


        //笔试题：小坑
        // x += 1;和 x = x + 1;的区别

        int x = 10;
        x += 1;
        x = x + 1;
        System.out.println("x=" + x);//12

        byte b = 10;
        //b = b + 1 ;编译报错，右侧有变量参与byte不再特殊
        //需要进行强转
        b =(byte)(b+1);
        System.out.println(b);//11

        byte a = 10;
        a += 1;//编译通过
        System.out.println(a);//11

        /*
            从以上案列效果来看
            如果我们造作的是int 类型
            x += 1;和 x = x + 1;
            的效果似是一样的，没有任何区别

            但是如果我们操作的是比int小的类型的整数
            x += 1;和 x = x + 1;就不一样了
            x = x + 1;编译报错，需要强转
            x += 1;编译通过

            凭什么 x += 1;就不需要强转？
            因为使用这种复制运算 +=
            如果遇到了需要强转的操作，系统会自动为我们进行转换

            对于byte b= 10;
            b += 1;
            就是相当于 b =(byte)(b+1);系统会帮我们进行强转
         */



    }
}

运行结果
在这里插入图片描述

1.1.6、关于优先级

在这里插入图片描述

1.1.7、条件运算符

条件运算符我们经常称之为三目运算符（三元运算符），它的语法结构是：布尔表达式?表达式1：表达式2。

public class Test06 {
    public static void main(String[] args) {
        //三目运算符

        /*
            语法：
                布尔表达式？表达式1：表达式2
                如果布尔表达式的取值为true，则执行表达式1
                如果布尔表达式的取值为false，则执行表达式2

         */
        boolean flag1 = true;
        int k = flag1 ? 1 : 0;
        System.out.println(k);

        boolean flag2 = false;
        int q = flag2 ? 1 : 0;
        System.out.println(q);

        int x = 100;
        int y = 200;
        System.out.println(x==y? "x和y的值相等":"x和y的值不相等");

        int x1 = 100;
        int y1 = 100;
        System.out.println(x1==y1? "x和y的值相等":"x和y的值不相等");



    }
}

运行结果

在这里插入图片描述

1.1.8、字符串拼接

字符串拼接符的符号就是加号“+”,实际上“+”运算符在java 语言中有两个作用，作用一是对数字进行求和运算，作用二就是字符串连接运算。

public class Test07 {
    public static void main(String[] args) {
        //字符串拼接运算符 +
        int i = 10;
        int j = 20;
        String s = "abc";
        boolean flag = true;
        //System.out.println(i+flag+"");//编译报错了
        System.out.println(""+i+ flag);
    }
}

运行结果
在这里插入图片描述

二、控制语句

顺序结构的程序语句只能被执行一次。

如果您想要同样的操作执行多次，就需要使用循环结构。

Java中有三种主要的循环结构：

while循环
do…while循环
for循环

2.2.1、选择语句if

选择语句又称为分支语句，它通过对给定的条件进行判断，从而决定执行两个或多个分支中的哪一支。因此，在编写选择语句之前，应该首先明确判断条件是什么，并确定当判断结果为“真”或“假”时应分别执行什么样的操作/算法。

我们先看看if语句，if语句的编写方式归纳为以下四种：
如图所示：

在这里插入图片描述

public class Test01 {
    public static void main(String[] args) {
        /*
            流程控制
            if
         */

        /*
            案例1：
                如果外面下雨了，出门就带一把伞，反之（没下雨），则不带雨伞

                如果boolean值为true,则执行if语句体{}中的内容
                如果boolean值为false,则不会执行if语句体{}中的内容

                if(boolean){

                }


                如果boolean值为true,则执行if语句体{}中的内容
                如果boolean值为false,则执行else语句题{}中的内容

                if(boolean){

                }else{

                }

         */
        boolean raining = true;
        //如果
        if(raining){
            System.out.println("外面下雨了，需要带伞");
        //否则
        }else{
            System.out.println("外面没有下雨，不需要要带伞");
        }

        System.out.println("-------------------------------");

        //如果你吃饱了就出门逛街，反之则继续吃东西

        boolean eatFull = true;
        if(eatFull){
            System.out.println("吃饱了，出门逛街");
        }else
            System.out.println("没吃饱，继续吃饭");

        System.out.println("----------------------------------");

        /*
            案例2：
                多重判断
                提供一个变量值 int a = 1;
                如果变量值a的值为1，则打印这个值为一
                如果变量值a的值为2，则打印这个值为二
                如果变量值a的值为3，则打印这个值为三
                如果变量值a的值不是1,2，3中任何一个数字，则打印：不是想要的数字

         */
        /*int a = 3;
        if(a == 1){
            System.out.println("这个值为1");
        }else if(a == 2){
            System.out.println("这个值为2");
        }else if(a == 3){
            System.out.println("这个值为3");
        }else{
            System.out.println("不是我想要的数字");
        }
*/
        /*
            案例3：
                if的嵌套使用
                根据以上的案例2，进行后续的判断
                如果a的值为1，判断b的值，输入相应的信息
         */

        int a = 1;
        int b = 1;
        if(a == 1){
            System.out.println("a的值为1");

            if(b ==1){
                System.out.println("b的值也是1");
            }else{
                System.out.println("b的值不是想要的数字");
            }


        }else if(a == 2){
            System.out.println("这个值为2");
        }else if(a == 3){
            System.out.println("这个值为3");
        }else{
            System.out.println("不是我想要的数字");
        }

        System.out.println("--------------------------");

        /*
            补充：
                if语句不加花括号{}，这样的语法也是可以使用的

                不加大括号只对下一行产生作用

                实际项目开发中对于if语句，要统一的加上{}，可读性强
         */

        /*int a1 = 1;
        if(a1==1)
            System.out.println("a1的值为1");
            System.out.println("是我想要的结果");*/
        //以上代码等价于
        int a1 = 1;
        if(a1==1){
            System.out.println("a1的值为1");
        }
        System.out.println("是我想要的结果");


    }
}

运行结果
在这里插入图片描述

2.2.2、选择语句switch

看下图片switch语句运行原理
在这里插入图片描述 switch运行原理文字性描述是这样的，比方说：拿着c和表达式1进行比较，如果相等，则执行语句1，如果不相等，继续拿着c和表达式2进行比较，如果相等，则执行语句2，如果不相等，继续继续…等等（废话文字。。。。）

public class Test02 {
    public static void main(String[] args) {
        /*
            流程控制
            switch
                需要case语句的后面，加上break;
                否则会产生穿透


            案例1：判断的值为整数
         */
        int a = 2;
        switch (a){
            case 1:
                System.out.println("a的值为1");
                break;
            case 2:
                System.out.println("a的值为2");
                break;
            case 3:
                System.out.println("a的值为3");
                break;
            default:
                System.out.println("失效的数字");
        }

        /*
            案例2：判断的值为字符型

         */

        char gender = '男';
        switch (gender){
            case '男':
                System.out.println("男性");
                break;
            case '女':
                System.out.println("女性");
                break;
            default:
                System.out.println("无效的性别");
        }

        /*
            案例3：判断的值为字符串

         */
        String gender1 = "1-男";
        switch (gender1){
            case "1-男":
                System.out.println("男性");
                break;
            case "1-女":
                System.out.println("女性");
                break;
            default:
                System.out.println("无效的性别");
        }

        /*
            案例4：switch语句中的case是可以进行合并的
            利用的是在没有加break关键词的基础上，case的穿透现象


            成绩 100 90 80 70 过关了
            成绩60不及格
         */
        int score = 80;
        switch (score){
            case 100:case 90: case 80:
                System.out.println("优秀");
                break;
            case 70:
                System.out.println("中等");
                break;
            case 60:
                System.out.println("不及格，继续努力");
                break;
            default:
                System.out.println("你输入无效的成绩");
        }

    }
}

运行结果
在这里插入图片描述

2.2.3、循环语句for

在不少实际问题中有许多具有规律性的重复操作，因此在程序中就需要重复执行某些语句。一组被重复执行的语句称之为循环体，能否继续重复，取决于循环的终止条件。循环结构是在一定条件下反复执行某段程序的流程结构，被反复执行的程序被称为循环体。循环语句是由循环体及循环的终止条件两部分组成的。

语法格式如下图所示：
在这里插入图片描述

public class test01 {
    public static void main(String[] args) {
        //案例1：for循环语法

        //输入10行Hello World
        //在for循环（）中声明的变量，只能在for循环中
        //不能被外部访问到
        for(int i = 0; i < 10; i++){
            System.out.println("i="+i);
            System.out.println("Hello World");
        }
        //System.out.println("i="+i);

        System.out.println("--------------------1");

        //想要让for循环中使用的i变量，在for循环的外部也能够访问到
        //将i的声明放在for循环的上面
        //这种形式虽然可以，但是在实际项目开放中，这样的写法，是不常用的
        //for循环体中使用的i变量，一般情况下，需求只能安排i使用在for循环里面，外面几乎不会使用到
        //所以我们以后的写法依然是要将i变量的声明写在for（）里面for(int i=0；i<5；i++)
        int j = 0;
        for( j = 0; j < 10; j++){
            System.out.println(j);
            System.out.println("Hello World");
        }
        System.out.println("j="+j);

        System.out.println("-------------------2");

        //除以以上的做法，我们来看看下面的for循环声明，判断，和改变条件的方式
        //这些改变型你换条件的方式可读性差，并且很难预测最终打印出来的信息
        for(int k = 10;k > 0;k--){
            System.out.println(k);
            System.out.println("Hello world");
        }


        for(int i=10;i>0;i-=2){
            System.out.println("h w");
        }

        for(int i=100;i>0;i/=3){
            System.out.println("q w");
        }

        //补充：关于变量的作用范围
        /*
            注意观察代码块{}
            {}里面声明的变量，外面是访问不到的
            外面声明的变量，{}里面是能够访问到的
         */

        //{}里面声明的变量，外面是访问不到的
        if(true){
            int  i = 10;
        }
        //System.out.println(i);外面是访问不到

        int i = 10;
        if(true){
            System.out.println(i);//10
        }

        System.out.println("----------------------3");

        //案例2：for循环的嵌套使用
        /*
            //外层循环
            for(){

                //内层循环
                for(){

                }
            }

            在内层循环的里面，也可以继续无限的继续嵌套循环
            在我们实际项目开发中，对于嵌套的循环，两层是使用最多的
            3层for循环，以后的需求非常少，3+层的for循环的需求，如果没有遇到特殊行业的特殊需求，几乎使用不到的

         */

        /*
            外层循环，循环一次
            相当于内层循环完整的执行一次
         */
        for(int f=0;f<5;f++){

            for(int g=0;g<5;g++){

                System.out.println("g="+g);
            }
            System.out.println("---------------------- f="+f);

        }

        /*
            关于for循环的注意事项：
         */
        //（1）for循环中的三个表达式都可以省略不写
        //但是分好; 不能省略
        //这种情况，会出现无限循环，在IT界管无限循环，也叫做死循环
      /*  for(;;){
            System.out.println(123);
        }*/

        //(2)当省略表达式1，则会出现编译错误
        //解决办法，就是将表达式1，写在for循环的外面
        //虽然能解决，但是不要这么写
        int y = 0;
        for(;y <10; y++){
            System.out.println(y);
        }

        //(3)当省略表达式2
        //出现死循环，当省略表达式2的时候，表达式2的位置会默认为我们提供true这个值
        /*for(int l=0;;l++){
            System.out.println(123);//死循环
        }*/

        System.out.println("---------------------------4");

        //(4)当省略表达式3，同样是死循环
        //解决办法：可以将变量的变更直接写在循环体的内部
        for(int p=0;p<10;){
            System.out.println(123);
            p++;
        }




    }
}

运行结果

运行结果
i=0
Hello World
i=1
Hello World
i=2
Hello World
i=3
Hello World
i=4
Hello World
i=5
Hello World
i=6
Hello World
i=7
Hello World
i=8
Hello World
i=9
Hello World
--------------------1
0
Hello World
1
Hello World
2
Hello World
3
Hello World
4
Hello World
5
Hello World
6
Hello World
7
Hello World
8
Hello World
9
Hello World
j=10
-------------------2
10
Hello world
9
Hello world
8
Hello world
7
Hello world
6
Hello world
5
Hello world
4
Hello world
3
Hello world
2
Hello world
1
Hello world
h w
h w
h w
h w
h w
q w
q w
q w
q w
q w
10
----------------------3
g=0
g=1
g=2
g=3
g=4
---------------------- f=0
g=0
g=1
g=2
g=3
g=4
---------------------- f=1
g=0
g=1
g=2
g=3
g=4
---------------------- f=2
g=0
g=1
g=2
g=3
g=4
---------------------- f=3
g=0
g=1
g=2
g=3
g=4
---------------------- f=4
0
1
2
3
4
5
6
7
8
9
---------------------------4
123
123
123
123
123
123
123
123
123
123
Process finished with exit code 0

2.2.4、循环语句while

循环语句除了for 循环之外还有while 和do…while，接下来我们先来看一下while 循环~，首先学习while 循环的语法结构
如图所示：
在这里插入图片描述
执行原理如图：

public class test02 {
    public static void main(String[] args) {
        /*
            while循环

            只要()中的boolean的值为true
            则会执行循环体中的内容

            当()中的loolean的值false
            则退出循环体
         */

        //需求：打印数字 1,2,3，4,5
        int t = 1;
        while(t<=5){
            System.out.println(t);
            t++;
        }

        //使用while循环，做一个死循环
        while(true){
            System.out.println(123);
        }
    }
}

运行结果
在这里插入图片描述

2.2.5、循环语句do…while

do…while 循环是while 循环的变形，它们的区别在于do…while 循环可以==保证循环体执行次数至少为1 次，==也就是说 do…while 循环的循环体执行次数是1~N 次，它有点儿先斩后奏的意思，而while 循环的循环体执行次数为0~N 次。

如图所示：
在这里插入图片描述

public class test03 {
    public static void main(String[] args) {
        /*
            do....while循环
            至少执行一次
            先执行do语句块中的信息，再进行while()中的判断

            这种循环使用的很少
         */

        //需求：打印数字1,2,3,4,5,
        int i=1;
        do{
            System.out.println(i);
            i++;
        }while (i<=5);
    }
}

运行结果
在这里插入图片描述

2.2.6、转向语句break

转向语句用于实现循环执行过程中程序流程的跳转，在Java 中转向语句有break 和continue语句。

public class test04 {
    public static void main(String[] args) {
        /*
            break;语句
            使用在switch中，是为了防止case的穿透现象

            使用在循环体中，是为了终止循环
         */
        //案例1：for循环10次，当i的值为5是(如果i的值为5)，终止循环
        for(int i=0; i <10; i++){
            if(i==5) {
                break;
            }
            System.out.println(i);
        }

        System.out.println("=========================>1");

        //案例2：break使用在嵌套循环中
        /*
            通过以下测试的结果，可以得到这样的结论
            break语句在默认情况下只能终止离它最近的一层循环
            不会影响到外层循环完整的执行
         */
        for(int q=0;q<10;q++){
            for(int w=0;w<10;w++){
                if(w==5){
                    break;
                }
                System.out.println("w="+w);
            }
            System.out.println("-----------------q="+q);
        }

        System.out.println("========================>2");

        //如果想要通过break，将外层循环也一并终止
        //解决方案：在相应的for关键字的前面加上具体的标识
        //break要通过标识来选择退出循环




       /* 外层循环，循环一次
          相当于内层循环完整的执行一次*/
        one:for (int i = 0; i < 10; i++) {
            two:for (int j = 0; j < 10; j++) {
                if(j==5){
                    break one;
                }
                System.out.println("j="+j);//01234
            }
            System.out.println("---------------- i="+i);//  break two循环十次

        }


    }
}

结果运行
0
1
2
3
4
=========================>1
w=0
w=1
w=2
w=3
w=4
-----------------q=0
w=0
w=1
w=2
w=3
w=4
-----------------q=1
w=0
w=1
w=2
w=3
w=4
-----------------q=2
w=0
w=1
w=2
w=3
w=4
-----------------q=3
w=0
w=1
w=2
w=3
w=4
-----------------q=4
w=0
w=1
w=2
w=3
w=4
-----------------q=5
w=0
w=1
w=2
w=3
w=4
-----------------q=6
w=0
w=1
w=2
w=3
w=4
-----------------q=7
w=0
w=1
w=2
w=3
w=4
-----------------q=8
w=0
w=1
w=2
w=3
w=4
-----------------q=9
========================>2
j=0
j=1
j=2
j=3
j=4

Process finished with exit code 0

2.2.7、转向语句continue

continue 语句也是单个单词自成一条java 语句，例如“continue;”，它和break 语句都是用来控制循环的，break 语句是用来终止循环的执行，而 continue 语句则是用来终止当前本次循环，直接进入下一次循环继续执行。

public class test05 {
    public static void main(String[] args) {
        /*
             continue;语句
                终止本次循环，自动跳到下一次循环
         */
        //案例：打印整数1~10 ，不打印5
        for(int i = 0; i < 10; i++){
            if(i==5){
                continue;
            }
            System.out.println(i);
        }


    }
}

结果运行
在这里插入图片描述

2.2.8、Scanner类的使用

Scanner是控制台做运行结果的输出操作。

public class Test01 {
    public static void main(String[] args) {
        //Scanner类：操作控制台输入的 （以前的System.out是做控制台输出的）

        //创建一个控制台输入的对象 s
        Scanner s = new Scanner(System.in);
        System.out.println("请你输入一个整数");

        //System.out.println("=========================>1");

        //通过s，调用指定的next方法，来接收指定类型的数据
        //将输入的数据，进行接收，赋值给int类型的变量num
        int num = s.nextInt();
        System.out.println("控制台输入的数据是："+num);
        System.out.println("继续输入一个字符串：");
        String str = s.next();
        System.out.println("你输入的字符串是："+str);

    }
}

运行结果

在这里插入图片描述

以上内容到这里了，后续。。。

小眼睛_i

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java学习笔记——运算符与控制语句

运算符与控制语句一、运算符1.1.1、运算符概述1.1.2、算术运算符1.1.3、关系运算符1.1.4、逻辑运算符1.1.5、赋值运算符1.1.6、关于优先级1.1.7、条件运算符1.1.8、字符串拼接二、控制语句2.2.1、选择语句if2.2.2、选择语句switch2.2.3、循环语句for2.2.4、循环语句while2.2.5、循环语句do.....while2.2.6、转向语句break2.2.7、转向语句continue2.2.8、Scanner类的使用一、运算符1.1.1、运算符概述运算
复制链接

扫一扫