java 运算符，流程控制语句，键盘录入

1.比较运算符

public static void main(String args[])
{
    int x = 3;
    int y = 4;
    int z = 5;
    System.out.println(x > y);
    System.out.println(x < y);
    System.out.println(x == y);
    System.out.println(x + y > x + z);
    System.out.println(x >= y);
    }
    基本的比较运算符便是  大于，小于，等于，大于等于，小于等于， 输出结果也是看是否符合比较，符合便输出true，不符合编书处flase；

2.赋值运算符

public static void main(String args[])
{
    int a = 20;
    System.out.println(a);
    int b = 10;
    System.out.println(b);
    System.out.println("----------------");
    int n;
    int m = n = 10;
    System.out.println((newStringBuilder("m:")).append(m).append(",n:").append(n).toString());
    System.out.println("-----------------");
    int y = 10;
    y += 20;
    System.out.println((new StringBuilder("y:")).append(y).toString());
}   

赋值运算符“=”
注意赋值时和其他运算符之间的优先级；
+++++++
上述代码中的
(1).  new StringBuilder("内容 ")为匿名创建对象，而对象的内容便是双引号中的内容;
(2). append（" "）是附加的意思，append方法中如果是自定义变量，则不需要加双引号，如果是字符串，则加双引号;

(3). toString()这个方法它是一种对象类型，字符串，不可变的，StringBuilder带有缓冲区，通过它，可改变字符串的这个不足的地方，如是我们用“+”来拼字符串，这个过程中，会创建很多个字符串对象，用StringBuilder,它就利用缓冲作用来完成这种工作，它与stringbuffer很类似，只是，它是线程非安全的，效率要比stringbuffer高些 ，在用append()附加字符串，最后最好使用toString()方法将其变成一个完整的字符串；

内容扩充：此时可以注意String类型，StringBuffer类型和StringBuilder类型的区别？
https://zhidao.baidu.com/question/1386767228469012700.html&gt;<br/<https://zhidao.baidu.com/question/2058150115619791027.html&gt;

3.键盘录入

public static void main(String args[])
{

    Scanner sc = new Scanner(System.in);
    System.out.println("请您输入第一个数据:");
    int num1 = sc.nextInt();
    System.out.println("请您输入第二个数据:");
    int num2 = sc.nextInt();
    int max = num1 <= num2 ? num2 : num1;
    System.out.println((new StringBuilder("您输入的最大值是:")).append(max).toString());
    }

    如上述代码，先创建Scanner对象,创建对象时记得导入Java.util.Scanner包,因为只有导入这个包才可以创建Scanner对象,进而调用方法nextInt()获取键盘录入的内容;
    nextInt()代表获取输入的Int型对象;
    而代码中int max = num1 <= num2 ? num2 : num1;
    ?:其实是一个三目运算符;
    代表的意思是如果符合num1 <= num2,则输出num2,否则输出num1;输出的顺序看num2 : num1;如果想输出最小数,为 int min = num1<=num2?num1:num2;

4.三目运算符
?:三目运算符,比较大小,类似于if(){}else{},如三所示
三目运算符比较两数是否相等时
boolean flag = num1==num2?true:false;
改进后
boolean flag = num1==num2;即可

5.逻辑运算符

&和 | 既是逻辑运算符也是位运算符，而&&和||只是逻辑运算符。

同为逻辑运算符,他们的区别在哪里??
（1）当&与&&同为逻辑运算符时，它们都用于连接两个Boolean类型的表达式，当&和&&的两端表达式同时为真时，表达式的结果为真，只要有一端为假，那么表达式结果为假。从用法上来看，&和&&并没有什么区别，比如我们可以写两个表达式：

          3>5&3>2;       3>5&&3>2;

          两个运算符都可以这么用，但是不同的是，当在判断这个表达式的真或假的时候，两者的判断次数不同；

         当使用&运算符： 计算机在判断表达式的值的时候，先判断3>5 的值为假，然后再判断3>2的结果为真，于是最后的结果是 假&真 为假；

         但是当我们使用&&运算符的时候：计算机先判断3>5 的值为假，此时表达式的结果一定为假，所以计算机就不再往下判断了，判定表达式结果为假。

         逻辑运算符&与&&的区别是：

         & 无论左边结果是什么，右边还是继续运算；

         &&当左边为假，右边不再进行运算。

         但是两者的结果是一样的。

        （2）当|和||的两端表达式同时为假时，表达式的结果为假，只要有一端为真，那么表达式结果为真。

         所以同理，我们可以知道|与||的区别：

         | 无论左边结果是什么，右边还是继续运算；

         ||当左边为真，右边不再进行运算。

         但是两者的结果是一样的。

         所以&&和||是比较高效一些;

                     如代码所示:
                    public static void main(String args[])
{
    int a = 3;
    int b = 4;
    int c = 5;
    System.out.println(a > b & a > c);
    System.out.println(a > b && a > c);
    System.out.println(a < b && a > c);
    System.out.println(a < b && a < c);
    System.out.println("---------------------");
    int x = 3;
    int y = 4;
    boolean b1 = ++x == 3 && y++ == 4;
    System.out.println((new StringBuilder("x:")).append(x).toString());
    System.out.println((new StringBuilder("y:")).append(y).toString());
    System.out.println(b1);
}
输出的前两个虽然结果一样,但是运行绝对不同;

!!!补充++x和x++的含义
++x会在本次运行中使x+1,进行改变;而x++则在本次运行中不改变;
如上述代码;++x==3,则x=4;  y++==4,则y还是4;

代码迷茫症状易错点:boolean b1 = 4&&4;应该为true,可为什么运行结果为false?

其实是x=3,++x与3进行比较为false,所以结果为false;在这里boolean b1 = ++x == 3 && y++ == 4;是个三目运算符,连接的是两个boolean关系的表达式,虽然有&&,但是只能代表&&左边右边分别为一个boolean的表达式;

6.算术运算符

• 加 -减 *乘 /除 %除 ++ --

  /和%的区别?
  比如 int a = 3 ; int b = 4;
  a/b=0; /代表取整数;
  a%b=3; /代表取余数;

  如果要求出a/b的确切答案,最好定义int(整型)为double(双精度型);如果定义的为int型,如上面运算,则进行强制转换;
  强制转换为double:   ((double)a*1.0d)/(double)b=0.75;
  1.0d代表的对double的生命,不加也不会出错,最好加上,而前面的(double)代表强制转换为double类型;
  
  如代码所示:
  
  public static void main(String args[])

  {

  int x = 3;
  int y = 4;
  int m = x++;
  int n = y--;
  System.out.println((new StringBuilder("x:")).append(x).toString());
  System.out.println((new StringBuilder("y:")).append(y).toString());
  System.out.println((new StringBuilder("m:")).append(m).toString());
  System.out.println((new StringBuilder("n:")).append(n).toString());

  }

  ++x会在本次运行中使x+1,进行改变;而x++则在本次运行中不改变;

  如上述代码;++x==3,则x=4; y++==4,则y还是4;

  则上述代码输出结果为 x:4 y:3 m:3 n:4
  原因是x++ 中x并没有先+,而是先给m赋值,所以m为3,之后x自行加1,则x为4,y同理.

  7.流程控制语句

  (1)顺序结构 从上往下，依次执行
  (2)选择结构 按照不同的选择，执行不同的代码
  (3)循环结构 做一些重复的代码

  if语句

  **格式:
  if(条件){满足条件后的运行语句};(1)
  else if(条件){满足条件后的运行语句};(2)
  else{不满足上述条件的其他所有情况的运行语句};(3)
  上述三行第一行单独是一种格式,第一行和第三行合起来是一种格式,三行一起是一种格式;
  注意点:
  A:比较表达式无论简单还是复杂，结果是boolean类型
  B:if语句控制的语句体如果是一条语句，是可以省略大括号的；如果是多条，不能省略。
  建议：永远不要省略。
  C:一般来说，有左大括号，就没有分号，有分号，就没有左大括号。
  D:else后面如果没有if，是不会出现比较表达式的。
  E:三种if语句其实都是一个语句，只要有一个执行，其他的就不再执行。

**如果运行语句只有一句,可以不加{};
如代码:
public static void main(String args[])
{
int x = 10;
if(x!=10)
System.out.println("x等于10");
if (x == 20)
System.out.println("x等于20");
System.out.println("over");
}
运行结果:over

**易错点,小心;的添加,上述代码,如果给if(x!=10)后面加;  ,会出现如下情况

    public static void main(String args[])
{
    int x = 10;
    if (x != 10);
    System.out.println("x等于10");
    if (x == 20)
        System.out.println("x等于20");
    System.out.println("over");
}
    运算结果:x等于10    over
    *为什么?
    此时的分号可以让此次if语句无效,则会直接输出,然后进入下次的if语句;

    switch语句

    **格式：
    switch(表达式) {
        case 值1:
            语句体1;
            break;
        case 值2:
            语句体2;
            break;
        ...
        default:
            语句体n+1;
            break;
    }

    **格式解释说明：
        switch:说明这是switch语句。
        表达式:可以是byte,short,int,char
            JDK5以后可以是枚举
            JDK7以后可以是字符串
        case:后面的值就是要和表达式进行比较的值
        break:表示程序到这里中断，跳出switch语句
        default:如果所有的情况都不匹配,就执行这里,相当于if语句中的else

                **小问题: switch语句的表达式可以是byte吗?可以是long吗?可以是String吗?
        可以,不可以,JDK7以后可以

**执行流程:
A:首先计算表达式的值
B:和每一个case进行匹配，如果有就执行对应的语句体，看到break就结束。
C:如果没有匹配，就执行default的语句体n+1。

            **注意事项:
    A:case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的
    B:default可以省略吗?
        可以省略，但是不建议，因为它的作用是对不正确的情况给出提示。
        特殊情况：
            case就可以把值固定。
            A,B,C,D
    C:break可以省略吗?
        可以省略，但是结果可能不是我们想要的。
        会出现一个现象：case穿透。
        最终我们建议不要省略
    D:default一定要在最后吗?
        不是，可以在任意位置。但是建议在最后。
    E:switch语句的结束条件
        a:遇到break就结束了
        b:执行到末尾就结束了

            ****if语句和switch语句各自的场景
    A:if
        针对boolean类型的判断
        针对一个范围的判断
        针对几个常量的判断
    B:switch
        针对几个常量的判断

    **下面对循环语句做出解释:
    for,while,do...while

    **for循环语句
    A:格式
        for(初始化语句;判断条件语句;控制条件语句){
            循环体语句;
        }

     **执行流程：
            a:执行初始化语句
            b:执行判断条件语句
                如果这里是true，就继续
                如果这里是false，循环就结束
            c:执行循环体语句
            d:执行控制条件语句
            e:回到b
     **B:注意事项
        a:判断条件语句无论简单还是复杂，结果是boolean类型
        b:循环体语句如果是一条，可以省略大括号，但是不建议
        c:有分号就没有左大括号，有左大括号就没有分号

                    **while循环
    **A:基本格式
        while(判断条件语句) {
            循环体语句;
        }

     **扩展格式：
        初始化语句;
        while(判断条件语句){
            循环体语句;
            控制条件语句;
        }

        通过查看这个格式，我们就知道while循环可以和for循环等价转换。

            **for和while的区别
        **a:使用上的区别
            for语句的那个控制条件变量,在循环结束后不能在使用了。
            而while的可以继续使用。
        b:理解上的区别
            for适合于一个范围的判断
            while适合次数不明确的

                **do...while循环
   ** A:基本格式
        do {
            循环体语句;
        }while(判断条件语句);

        **扩展格式：
        初始化语句;
        do {
            循环体语句;
            控制条件语句;
        }while(判断条件语句);

        通过查看格式，我们就可以看出其实三种循环的格式可以是统一的。
   ** B:三种循环的区别
        a:do...while循环至少执行一次循环体
        b:for和while必须先判断条件是否是true，然后后才能决定是否执行循环体

         **循环使用的注意事项(死循环)
    A:一定要注意修改控制条件,否则容易出现死循环。
    B:最简单的死循环格式
        a:while(true){...}

        b:for(;;){}

原文地址：http://blog.51cto.com/13678296/2312504