JAVA自学---运算符的分类和控制语句（语句涉及一个if语句）

- 日理万妓 2021-11-17 06:08 364阅读 0赞

**一、运算符**

1、算数运算符

**1.1预算符和表达式**

运算符：对常量或者变量进行操作的符号

表达式：用运算符把常量或者变量连接起来符合java语法的式子就可以成为表达式。不同运算符连接的表达式体现的是不同类型的表达式。

举例：

int i=10；

int b=15；

int a = i+b；

\+：是运算符号，是算数运算符。

i+b：是表达式；由于+是算术运算符，所以这个表达式叫算术表达式。

算术运算符

<table> 
 <thead> 
  <tr> 
   <th>符号</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>+</td> 
   <td>做加法运算</td> 
  </tr> 
  <tr> 
   <td>-</td> 
   <td>做减法运算</td> 
  </tr> 
  <tr> 
   <td>*</td> 
   <td>做乘法运算</td> 
  </tr> 
  <tr> 
   <td>/</td> 
   <td>做除法运算</td> 
  </tr> 
  <tr> 
   <td>%</td> 
   <td>取余数</td> 
  </tr> 
 </tbody> 
</table>

整数操作只能得到整数，要想得到小数，必须有浮点数参与运算。

**1.2、字符的"+"操作**

字符在计算机底层对应的数值计算（根据Ascll码表）

‘A’ 对应数字65 A-Z按顺序依次往后

‘a’ 对应数字97 a-z按顺序依次往后

‘0’ 对应数字48 0-9按顺序依次往后

算术表达式中包含多个基本数据类型的值时,整个算术表达式的类型会自动进行提升。

提升规则：

byte类型，short类型和char类型自动提升到int类型

整个表达式的类型自动提升到表达式中最高等级操作数同样的等级

等级顺序：byte,short,char>int>long>float>double

**1.3、字符串的"+"操作**

当“+”操作中出现字符串时，这个“+”是字符串连接符，不是算术运算符

“加油”+66

在“+”操作中，如果出现了字符串，就是连接运算符，否则就是算术运算符。当出现连续“+”操作时，从左到右逐个执行。

6+8+“加油”

**二、赋值运算符**

赋值运算符的作用是将一个表达式的值赋给左边，左边必须是可修改的，不能是常量。

<table> 
 <thead> 
  <tr> 
   <th>符号</th> 
   <th>作用</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>=</td> 
   <td>赋值</td> 
   <td>a=10,将10赋值给变量a</td> 
  </tr> 
  <tr> 
   <td>+=</td> 
   <td>加后赋值</td> 
   <td>a+=b,将a+b的值给a</td> 
  </tr> 
  <tr> 
   <td>-=</td> 
   <td>减后赋值</td> 
   <td>a-=b,将a-b的值给a</td> 
  </tr> 
  <tr> 
   <td>*=</td> 
   <td>乘后赋值</td> 
   <td>a*=b,将a * b的值给a</td> 
  </tr> 
  <tr> 
   <td>/=</td> 
   <td>除后赋值</td> 
   <td>a/=b,将a÷b的值给a</td> 
  </tr> 
  <tr> 
   <td>%=</td> 
   <td>取余后赋值</td> 
   <td>a%=b,将a÷b的值取余数给a</td> 
  </tr> 
 </tbody> 
</table>

注意:

扩展的赋值运算符隐含了强制类型转换。

public class Test{
        
    	public static void main(String[] args){
        
    		//给一个变量赋值
    		short i=10;
    		//i=i+10;  // short转为int精度会丢失
    		i+=10;    //赋值运算符隐含了强制类型转换。相当于   short i=(short)(i+10)
    		System.out.println(i);
    	}
    }

三、自增自减运算符

注意事项：

\++和-- 既可以放在变量的后边，也可以放在变量的前边。

单独使用的时候， ++和-- 无论是放在变量的前边还是后边，结果是一样的。

参与操作的时候，如果放在变量的后边，先拿变量参与操作，后拿变量做++或者–。

参与操作的时候，如果放在变量的前边，先拿变量做++或者–，后拿变量参与操作。

/*
      自增自减运算符
      ++和-- 既可以放在变量的后边，也可以放在变量的前边。
    
    ?	单独使用的时候， ++和-- 无论是放在变量的前边还是后边，结果是一样的。
    
    ?	参与操作的时候，如果放在变量的后边，先拿变量参与操作，后拿变量做++或者--。
    
    ?	参与操作的时候，如果放在变量的前边，先拿变量做++或者--，后拿变量参与操作。
      
    */
    public class Test{
        
    	public static void main(String[] args){
        
    		//对变量进行赋值
    		int i=10;
    		i++;  //a=11
    		System.out.println(i);
    		int a=10;
    		++a; //a=11
    		System.out.println(a);
    		int o=10;
    		int p=o++;   //p=10,o=11
    		System.out.println("p:"+p+",o:"+o);
    		int d=15;
    		int n=++d;  //n=16,d=16
    		System.out.println("n:"+n+",d:"+d);
    		int j=16;
    		int l=j--;//l=16,j=15
    		System.out.println("l:"+l+",j:"+j);
    		
    	}
    }

四、关系运算符

关系运算符有6种关系，分别为小于、小于等于、大于、等于、大于等于、不等于。

<table> 
 <thead> 
  <tr> 
   <th>符号</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>==</td> 
   <td>a==b,判断a和b的值是否相等,成立为ture,不成立为false</td> 
  </tr> 
  <tr> 
   <td>！=</td> 
   <td>a!=b,判断a和b的值是否不相等,成立为ture,不成立为false</td> 
  </tr> 
  <tr> 
   <td>&gt;</td> 
   <td>a&gt;b,判断a是否大于b,成立为ture,不成立为false</td> 
  </tr> 
  <tr> 
   <td>&gt;=</td> 
   <td>a&gt;=b,判断a是否大于等于b,成立为ture,不成立为false</td> 
  </tr> 
  <tr> 
   <td>&lt;</td> 
   <td>a&lt;b,判断a是否小于b,成立为ture,不成立为false</td> 
  </tr> 
  <tr> 
   <td>&lt;=</td> 
   <td>a&lt;=b,判断a是否小于等于b,成立为ture,不成立为false</td> 
  </tr> 
 </tbody> 
</table>

注意事项：

关系运算符的结果都是boolean类型，要么是true，要么是false。

千万不要把\*\*“ == ”误写成“ = ” ， " == “是判断是否相等的关系，”="是赋值。\*\*

**五、逻辑运算符**

逻辑运算符把各个运算的关系表达式连接起来组成一个复杂的逻辑表达式，以判断程序中的表达式是否成立，判断的结果是 true 或 false。

<table> 
 <thead> 
  <tr> 
   <th>符号</th> 
   <th>作用</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>&amp;</td> 
   <td>逻辑与</td> 
   <td>a&amp;b,a和b都是ture,结果为ture,否则为false</td> 
  </tr> 
  <tr> 
   <td>|</td> 
   <td>逻辑或</td> 
   <td>a|b,a和b都是false,结果为false,否则为ture</td> 
  </tr> 
  <tr> 
   <td>^</td> 
   <td>逻辑异或</td> 
   <td>a^b,a和b结果不同为ture,相反为false</td> 
  </tr> 
  <tr> 
   <td>！</td> 
   <td>逻辑非</td> 
   <td>!a,结果和a正好相反</td> 
  </tr> 
 </tbody> 
</table>

/*
       逻辑运算符
       
       &（与）、|（或）、^（异或）、！（非）
    
    
    */
    
    public class Text2{
        
    	public static void main(String[] args){
        
    		//定义两个变量
    		int i=15;
    		int c=10;
    		int o=18;
    		
    		//&运算
    		
    		System.out.println((i>c)&(c>o)); //false
    		
    		//|运算
    		System.out.println((i>c)|(c>o)); //ture
    		
    		//^运算
    		System.out.println((i>c)^(c>o)); //ture
    		
    		// !运算
    		System.out.println(!(i>c));  // false
    		
    		
    	}
    }

**短路逻辑运算符**

<table> 
 <thead> 
  <tr> 
   <th>符号</th> 
   <th>作用</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>&amp;&amp;</td> 
   <td>短路与</td> 
   <td>作用和&amp;相同,但有短路效果</td> 
  </tr> 
  <tr> 
   <td>||</td> 
   <td>短路或</td> 
   <td>作用和|相同,但有短路效果</td> 
  </tr> 
 </tbody> 
</table>

在逻辑与运算中，只要有一个表达式的值为false，那么结果就可以判定为false了，没有必要将所有表达式的值都计算出来，短路与操作就有这样的效果，可以提高效率。同理在逻辑或运算中，一旦发现值为true，右边的表达式将不再参与运算。

*  逻辑与&，无论左边真假，右边都要执行。
 *  短路与&&，如果左边为真，右边执行；如果左边为假，右边不执行。
 *  逻辑或|，无论左边真假，右边都要执行。
 *  短路或||，如果左边为假，右边执行；如果左边为真，右边不执行。

/*
    
      短路逻辑运算
       短路与   &&  左边为真,右边执行    左边为假,右边不执行
       短路或   ||  左边为假,右边执行    左边为真,右边不执行
    
    */
    public class Text2{
        
    	public static void main(String[] args){
        
    		int  i=15;
    		int  a=20;
    		int  b=16;
    		System.out.println((i>b)&&(a>b));    //false     //假的&&真的  
    		System.out.println((i>b)||(a>b));    //ture       //假的||真的
    		System.out.println((a>b)&&(i>b));    // false     //真的&&假的   
    		System.out.println((a>b)||(i>b));    //ture       //真的||假的
    		
     }
    }

**六、三元运算符**

三元运算符语法格式：

关系表达式？ 表达式1 ：表达式2；

解释：问号前面的位置是判断的条件，判断结果为boolean型，为true时调用表达式1，为false时调用表达式2。其逻辑为：如果条件表达式成立或者满足则执行表达式1，否则执行第二个。

/*
    
      需求：动物园里有两只老虎，已知两只老虎的体重分别为180kg、200kg，请用程序实现判断两只老虎的体重是否相同。
    
    */
    public class sanyun{
        
    	public static void main(String[] args){
        
    		int w1=180;
    		int w2=200;
    		//用三元运算实现体重的判断,相同为ture不同为false
    		boolean c=w1==w2 ? true:false;
    		System.out.println("c:"+ c);
    	}
    }

七、数据输入

1、数据输入

概述：把输入录入到指定的位置，获取到数据后对其进行操作（需要借助Scanner）

2、Scanner使用的基本步骤

1.1导包

import java.until.Scanner;

导包的动作必须出现在类定义的上边

1.2创建对象

Scanner sc = new Scanner(System in);

这个格式只有sc是变量名 ,可以改变

1.3接受数据

int i =sc.nextInt();

这个格式只有i是变量名,可以改变

import java.util.Scanner;
    public class shujusr{
        
    	public static void main(String[] args){
        
    		Scanner sc=new Scanner(System.in);//导包输入对象
    	     System.out.print("请输入圆的半径:");
    		int i= sc.nextInt();
    	    double s=3.14*i*i;
    		System.out.println("圆的面积:"+s);
    	}
    }

**八、流程控制语句**

在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。所以，我们必须清楚每条语句的执行流程。而且，很多时候要通过控制语句的执行顺序来实现我们想要的功能。

**流程空制语句分类**

顺序结构

分支结构（if，switch）

循环结构（for、while、do…while）

**顺序结构**

顺序结构是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的。

顺序结构执行流程图：

开始>语句A>语句B>语句C>结束

**分支结构之if语句**

if语句格式1

格式:
    if(关系表达式){
        
        语句体;  
    }

执行流程：

①首先计算关系表达式的值

②如果关系表达式的值为true就执行语句体

③如果关系表达式的值为false就不执行语句体

④继续执行后面的语句内容

开始>关系表达式>ture>语句体>其他语句

^flase>其他语句

public class ifdeom{
        
    	public static void main(String[] args){
        
    		System.out.println("开始");
    		int a=10;
    		int b=15;
    		//需求：判断a和b的值是否相等，如果相等，就在控制台输出：a等于b
    		if (a==b){
        
    		System.out.println("a等于b");	
    		//需求：判断a和c的值是否相等，如果相等，就在控制台输出：a等于c
    		}
    		int c=10;		
    		if (c==a){
        
    		System.out.println("c等于a");
    		}
    		System.out.println("结束");
    	}
    }

**if语句格式2**

if(关系表达式){
        
       语句体1; 
    } else {
        
        语句体2;
    }

执行流程：

①首先计算关系表达式的值

②如果关系表达式的值为true就执行语句体1

③如果关系表达式的值为false就执行语句体2

④继续执行后面的语句内容

开始>关系表达式>ture>语句体1>其他语句

^flase>语句体2>其他语句

public class ifdeom1{
        
    	public static void main(String[] args){
        
    		System.out.println("开始");
    		int a=10;
    		int b=15;
    		需求：判断a和b的值是否相等，如果相等，就在控制台输出：a等于b
    		if (a>=b){
        
    		System.out.println("大于等于b");	
    		//需求：判断a和c的值是否相等，如果相等，就在控制台输出：a等于c
    		}else {
        
    	
    		System.out.println("a小于等于b");
    		}
    		System.out.println("结束");
    	}
    }