Day03:运算符和表达式 / 分支结构

朱雀 2021-11-02 15:02 391阅读 0赞

Java 运算符

计算机的最基本用途之一就是执行数学运算，作为一门计算机语言，Java也提供了一套丰富的运算符来操纵变量。我们可以把运算符分成以下几组：

*  算术运算符
 *  关系运算符
 *  位运算符
 *  逻辑运算符
 *  赋值运算符
 *  其他运算符

## 算术运算符 ##

算术运算符用在数学表达式中，它们的作用和在数学中的作用一样。下表列出了所有的算术运算符。

表格中的实例假设整数变量A的值为1，变量B的值为2：

<table> 
 <tbody> 
  <tr> 
   <th>操作符</th> 
   <th>描述</th> 
   <th>例子</th> 
  </tr> 
  <tr> 
   <td>+</td> 
   <td>加法 - 相加运算符两侧的值</td> 
   <td>A + B 等于 3</td> 
  </tr> 
  <tr> 
   <td>-</td> 
   <td>减法 - 左操作数减去右操作数</td> 
   <td>A – B 等于 -1</td> 
  </tr> 
  <tr> 
   <td>*</td> 
   <td>乘法 - 相乘操作符两侧的值</td> 
   <td>A * B等于2</td> 
  </tr> 
  <tr> 
   <td>/</td> 
   <td>除法 - 左操作数除以右操作数</td> 
   <td>B / A等于2</td> 
  </tr> 
  <tr> 
   <td>％</td> 
   <td>取余 - 左操作数除以右操作数的余数</td> 
   <td>B%A等于0</td> 
  </tr> 
  <tr> 
   <td>++</td> 
   <td>自增: 操作数的值增加1</td> 
   <td>B++ 或 ++B 等于 3</td> 
  </tr> 
  <tr> 
   <td>--</td> 
   <td>自减: 操作数的值减少1</td> 
   <td>B-- 或 --B 等于 1</td> 
  </tr> 
 </tbody> 
</table>

### 自增自减运算符 ###

待补充！！！

## 关系运算符 ##

<table> 
 <tbody> 
  <tr> 
   <th>运算符</th> 
   <th>描述</th> 
   <th>&nbsp;</th> 
  </tr> 
  <tr> 
   <td>==</td> 
   <td>检查如果两个操作数的值是否相等，如果相等则条件为真。</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td>!=</td> 
   <td>检查如果两个操作数的值是否相等，如果值不相等则条件为真。</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td>&gt;&nbsp;</td> 
   <td>检查左操作数的值是否大于右操作数的值，如果是那么条件为真。</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td>&lt;&nbsp;</td> 
   <td>检查左操作数的值是否小于右操作数的值，如果是那么条件为真。</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td>&gt;=</td> 
   <td>检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td>&lt;=</td> 
   <td>检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。</td> 
   <td>&nbsp;</td> 
  </tr> 
 </tbody> 
</table>

## 位运算符 ##

Java定义了位运算符，应用于整数类型(int)，长整型(long)，短整型(short)，字符型(char)，和字节型(byte)等类型。

<table> 
 <tbody> 
  <tr> 
   <th>操作符</th> 
   <th>描述</th> 
   <th>例子</th> 
  </tr> 
  <tr> 
   <td>＆</td> 
   <td>如果相对应位都是1，则结果为1，否则为0</td> 
   <td>（A＆B），得到12，即0000 1100</td> 
  </tr> 
  <tr> 
   <td>|</td> 
   <td>如果相对应位都是0，则结果为0，否则为1</td> 
   <td>（A | B）得到61，即 0011 1101</td> 
  </tr> 
  <tr> 
   <td>^</td> 
   <td>如果相对应位值相同，则结果为0，否则为1</td> 
   <td>（A ^ B）得到49，即 0011 0001</td> 
  </tr> 
  <tr> 
   <td>〜</td> 
   <td>按位取反运算符翻转操作数的每一位，即0变成1，1变成0。</td> 
   <td>（〜A）得到-61，即1100 0011</td> 
  </tr> 
  <tr> 
   <td>&lt;&lt;&nbsp;</td> 
   <td>按位左移运算符。左操作数按位左移右操作数指定的位数。</td> 
   <td>A &lt;&lt; 2得到240，即 1111 0000</td> 
  </tr> 
  <tr> 
   <td>&gt;&gt;&nbsp;</td> 
   <td>按位右移运算符。左操作数按位右移右操作数指定的位数。</td> 
   <td>A &gt;&gt; 2得到15即 1111</td> 
  </tr> 
  <tr> 
   <td>&gt;&gt;&gt;&nbsp;</td> 
   <td>按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。</td> 
   <td>A&gt;&gt;&gt;2得到15即0000 1111</td> 
  </tr> 
 </tbody> 
</table>

## 逻辑运算符 ##

下表列出了逻辑运算符的基本运算，假设布尔变量A为真，变量B为假

<table> 
 <tbody> 
  <tr> 
   <th>操作符</th> 
   <th>描述</th> 
   <th>例子</th> 
  </tr> 
  <tr> 
   <td>&amp;&amp;</td> 
   <td>称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。</td> 
   <td>（A &amp;&amp; B）为假。</td> 
  </tr> 
  <tr> 
   <td>| |</td> 
   <td>称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。</td> 
   <td>（A | | B）为真。</td> 
  </tr> 
  <tr> 
   <td>！</td> 
   <td>称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。</td> 
   <td>！（A &amp;&amp; B）为真。</td> 
  </tr> 
 </tbody> 
</table>

### 短路逻辑运算符 ###

当使用与逻辑运算符时，在两个操作数都为true时，结果才为true，但是当得到第一个操作为false时，其结果就必定是false，这时候就不会再判断第二个操作了。

1  public static void main(String[] args){
    2         int a = 5;//定义一个变量；
    3         boolean b = (a<4)&&(a++<10);
    4         System.out.println("使用短路逻辑运算符的结果为"+b);
    5         System.out.println("a的结果为"+a);
    6     }

**解析： **该程序使用到了短路逻辑运算符(&&)，首先判断 a<4 的结果为 false，则 b 的结果必定是 false，所以不再执行第二个操作 a++<10 的判断，所以 a 的值为 5。

## 赋值运算符 ##

下面是Java语言支持的赋值运算符：

<table> 
 <tbody> 
  <tr> 
   <th>操作符</th> 
   <th>描述</th> 
   <th>例子</th> 
  </tr> 
  <tr> 
   <td>=</td> 
   <td>简单的赋值运算符，将右操作数的值赋给左侧操作数</td> 
   <td>C = A + B将把A + B得到的值赋给C</td> 
  </tr> 
  <tr> 
   <td>+ =</td> 
   <td>加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数</td> 
   <td>C + = A等价于C = C + A</td> 
  </tr> 
  <tr> 
   <td>- =</td> 
   <td>减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数</td> 
   <td>C - = A等价于C = C -<br>&nbsp;A</td> 
  </tr> 
  <tr> 
   <td>* =</td> 
   <td>乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数</td> 
   <td>C * = A等价于C = C * A</td> 
  </tr> 
  <tr> 
   <td>/ =</td> 
   <td>除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数</td> 
   <td>C / = A等价于C = C / A</td> 
  </tr> 
  <tr> 
   <td>（％）=</td> 
   <td>取模和赋值操作符，它把左操作数和右操作数取模后赋值给左操作数</td> 
   <td>C％= A等价于C = C％A</td> 
  </tr> 
  <tr> 
   <td>&lt;&lt; =</td> 
   <td>左移位赋值运算符</td> 
   <td>C &lt;&lt; = 2等价于C = C &lt;&lt; 2</td> 
  </tr> 
  <tr> 
   <td>&gt;&gt; =</td> 
   <td>右移位赋值运算符</td> 
   <td>C &gt;&gt; = 2等价于C = C &gt;&gt; 2</td> 
  </tr> 
  <tr> 
   <td>＆=</td> 
   <td>按位与赋值运算符</td> 
   <td>C＆= 2等价于C = C＆2</td> 
  </tr> 
  <tr> 
   <td>^ =</td> 
   <td>按位异或赋值操作符</td> 
   <td>C ^ = 2等价于C = C ^ 2</td> 
  </tr> 
  <tr> 
   <td>| =</td> 
   <td>按位或赋值操作符</td> 
   <td>C | = 2等价于C = C | 2</td> 
  </tr> 
 </tbody> 
</table>

## 条件运算符（?:） ##

条件运算符也被称为三元运算符。该运算符有3个操作数，并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。

variable x = (expression) ? value if true : value if false

## instanceof 运算符 ##

该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）。

instanceof运算符使用格式如下：

( Object reference variable ) instanceof  (class/interface type)

如果运算符左侧变量所指的对象，是操作符右侧类或接口(class/interface)的一个对象，那么结果为真。

## Java运算符优先级 ##

当多个运算符出现在一个表达式中，谁先谁后呢？这就涉及到运算符的优先级别的问题。在一个多运算符的表达式中，运算符优先级不同会导致最后得出的结果差别甚大。

例如，（1+3）＋（3+2）\*2，这个表达式如果按加号最优先计算，答案就是 18，如果按照乘号最优先，答案则是 14。

再如，x = 7 + 3 \* 2;这里x得到13，而不是20，因为乘法运算符比加法运算符有较高的优先级，所以先计算3 \* 2得到6，然后再加7。

下表中具有最高优先级的运算符在的表的最上面，最低优先级的在表的底部。

# Java表达式: #

数据和符号的组合。  
表达式就是数学中的算式。

# Java (分支结构)条件语句 - if...else #

java程序的运行结构分类  
（1)顺序结构  
 编写的代码一定会执行一次  
（2)分支结构  
 编写的代码可能会执行一次  
（3)循环结构  
 编写的代码可能会执行多次

一个 if 语句包含一个布尔表达式和一条或多条语句。

### 语法 ###

if 语句的语法如下：

if(布尔表达式)
    {
       //如果布尔表达式为true将执行的语句
    }

如果布尔表达式的值为 true，则执行 if 语句中的代码块，否则执行 if 语句块后面的代码。

## if...else语句 ##

if 语句后面可以跟 else 语句，当 if 语句的布尔表达式值为 false 时，else 语句块会被执行。

### 语法 ###

if…else 的用法如下：

if(布尔表达式){
       //如果布尔表达式的值为true
    }else{
       //如果布尔表达式的值为false
    }

## if...else if...else 语句 ##

if 语句后面可以跟 else if…else 语句，这种语句可以检测到多种可能的情况。

使用 if，else if，else 语句的时候，需要注意下面几点：

*  if 语句至多有 1 个 else 语句，else 语句在所有的 else if 语句之后。
 *  if 语句可以有若干个 else if 语句，它们必须在 else 语句之前。
 *  一旦其中一个 else if 语句检测为 true，其他的 else if 以及 else 语句都将跳过执行。

### 语法 ###

if...else 语法格式如下:

if(布尔表达式 1){
       //如果布尔表达式 1的值为true执行代码
    }else if(布尔表达式 2){
       //如果布尔表达式 2的值为true执行代码
    }else if(布尔表达式 3){
       //如果布尔表达式 3的值为true执行代码
    }else {
       //如果以上布尔表达式都不为true执行代码
    }

注意实现：1.else-if数量不限，else可以省略。  
 2.更换条件顺序可能引发错误。  
 3.多重if结构,程序运行一次，只可能运行其中一个代码块。

逻辑运算符的短路特性：  
&&和||  
 false && ????   
 当&&左侧是false时,右侧表达式不会运行。  
 true || ????  
 当||左侧是true时，右侧表达式不会执行

## 嵌套的 if…else 语句 ##

使用嵌套的 if…else 语句是合法的。也就是说你可以在另一个 if 或者 else if 语句中使用 if 或者 else if 语句。

### 语法 ###

嵌套的 if…else 语法格式如下：

if(布尔表达式 1){
       如果布尔表达式 1的值为true执行代码
       if(布尔表达式 2){
          如果布尔表达式 2的值为true执行代码
       }
    }

你可以像 if 语句一样嵌套 else if...else。

# Java switch case 语句 #

switch case 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。

### 语法 ###

switch case 语句语法格式如下：

switch(expression){
        case value :
           //语句
           break; //可选
        case value :
           //语句
           break; //可选
        //你可以有任意数量的case语句
        default : //可选
           //语句
    }

switch case 语句有如下规则：

*  switch 语句中的变量类型可以是： byte、short、int 或者 char。从 Java SE 7 开始，switch 支持字符串 String 类型了，同时 case 标签必须为字符串常量或字面量。
 *  switch 语句可以拥有多个 case 语句。每个 case 后面跟一个要比较的值和冒号。
 *  case 语句中的值的数据类型必须与变量的数据类型相同，而且只能是常量或者字面常量。
 *  当变量的值与 case 语句的值相等时，那么 case 语句之后的语句开始执行，直到 break 语句出现才会跳出 switch 语句。
 *  当遇到 break 语句时，switch 语句终止。程序跳转到 switch 语句后面的语句执行。case 语句不必须要包含 break 语句。如果没有 break 语句出现，程序会继续执行下一条 case 语句，直到出现 break 语句。
 *  switch 语句可以包含一个 default 分支，该分支一般是 switch 语句的最后一个分支（可以在任何位置，但建议在最后一个）。default 在没有 case 语句的值和变量值相等的时候执行。default 分支不需要 break 语句。

**switch case 执行时，一定会先进行匹配，匹配成功返回当前 case 的值，再根据是否有 break，判断是否继续输出，或是跳出判断。**

###### 实例： ######

单分支结构：

1 package JSD02;
     2 import java.util.*;
     3 public class Two {
     4     public static void main(String[] args) {
     5         //需求：用户输入一个年份，如果是闰年输出是闰年
     6         //思路：（年份能被4整除，且不能被100整除，或者能被400整除的年份）
     7         Scanner sr=new Scanner(System.in);
     8         System.out.println("请输入年份：");
     9         int nf=sr.nextInt();
    10         if(nf%4==0&&nf%100!=0||nf%400==0) {
    11             System.out.println("你输入的年份是闰年!");
    12         }else {
    13             System.out.println("你输入的不是闰年！");
    14         }
    15     }
    16 }

多分支结构：

1 package JSD03;
     2 public class One {
     3     public static void main(String[] args) {
     4         //需求：商场根据会员积分打折，
     5         //         2000分以内打9折，
     6         //         4000分以内打8折
     7         //         8000分以内打7.5折，
     8         //         8000分以上打7折，
     9         //         计算出应缴金额：
    10         int gwje=8000;
    11         double dzh;
    12         if(gwje<=2000) {
    13             dzh=gwje*0.9;
    14             System.out.println(dzh);
    15         }else if(gwje<=4000){
    16             dzh=gwje*0.8;
    17             System.out.println(dzh);
    18         }else if(gwje<=6000) {
    19             dzh=gwje*0.75;
    20             System.out.println(dzh);
    21         }else {
    22             dzh=gwje*0.7;
    23             System.out.println(dzh);
    24         }
    25     }
    26 }

* *

######  switch结构： ######

1 package JSD03;
     2 import java.util.*;
     3 public class Three {
     4     public static void main(String[] args) {
     5         //        需求：选择一个形状（1长方形、2正方形、3三角形、4圆形）
     6         //        根据不同的选择让用户输入不同的信息，
     7         //        长方形有长和宽、
     8         //        正方形有边长、
     9         //        三角形有底和高、
    10         //        圆形有半径，
    11         //        计算输出指定形状的面积
    12         Scanner sr=new Scanner(System.in);
    13         System.out.println("请输入你选择的图形(1.长方形 2.正方形 3.三角形 4.圆形)：");
    14         int xz=sr.nextInt();
    15         switch(xz) {
    16         case 1:
    17             System.out.println("请输入长方形的长：");
    18             double cfxc=sr.nextDouble();
    19             System.out.println("请输入长方形的宽：");
    20             double cfxk=sr.nextDouble();
    21             double mj=cfxc*cfxk;
    22             System.out.println("长方形的面积为："+mj);
    23         case 2:
    24             System.out.println("请输入正方形的长：");
    25             double zfxc=sr.nextDouble();
    26             System.out.println("请输入正方形的宽：");
    27             double zfxk=sr.nextDouble();
    28             mj=zfxc*zfxk;
    29             System.out.println("正方形的面积为："+mj);
    30         case 3:
    31             System.out.println("请输入三角形的底：");
    32             double sjxd=sr.nextDouble();
    33             System.out.println("请输入三角形的高：");
    34             double sjxg=sr.nextDouble();
    35             mj=sjxd*sjxg/2;
    36             System.out.println("三角形的面积为："+mj);
    37         case 4:    
    38             System.out.println("请输入圆形的半径：");
    39             double yxbj=sr.nextDouble();
    40             mj=yxbj*yxbj*3.1415926;
    41             System.out.println("圆形的面积为："+mj);
    42         }
    43     }
    44 }

##  分支结构集合： ##

1 package JSD03;
     2 import java.util.*;
     3 public class Two {
     4     public static void main(String[] args) {
     5         //        需求：机票价格按照淡季旺季、头等舱和经济舱收费、
     6         //        输入机票原价、月份和头等舱或经济舱，
     7         //        其中旺季（5-10月）头等舱9折，经济舱85折，
     8         //        淡季（11月到来年4月）头等舱7折，经济舱65折，
     9         //        最终输出机票价格：
    10         Scanner sr=new Scanner(System.in);
    11         System.out.println("请输入机票原价：");
    12         int yj=sr.nextInt();
    13         System.out.println("请输入月份：");
    14         int yf=sr.nextInt();
    15         System.out.println("请输入是头等舱还是经济舱(1.头等舱 2.经济舱):");
    16         int cs=sr.nextInt();
    17         if(yf>=5&&yf<=10) {
    18             System.out.println("你输入的月份是旺季！");
    19             switch(cs) {
    20             case 1:
    21                 double tdc01=yj*0.9;
    22                 System.out.println("头等舱的价格为："+tdc01);
    23                 break;
    24             case 2:
    25                 double jjc01=yj*0.85;
    26                 System.out.println("经济舱的价格为："+jjc01);
    27                 break;
    28             }
    29         }else if(yf<5||yf<=12&&yf>10){
    30             System.out.println("你输入的月份是淡季！");
    31             switch(cs) {
    32             case 1:
    33                 double tdc02=yj*0.7;
    34                 System.out.println("头等舱的价格为："+tdc02);
    35                 break;
    36             case 2:
    37                 double jjc02=yj*0.65;
    38                 System.out.println("经济舱的价格为："+jjc02);
    39                 break;
    40             }
    41         }else{
    42             System.out.println("你输入的月份有误！");
    43         }
    44     }
    45 
    46 }

转载于:https://www.cnblogs.com/wsnb8/p/11306544.html