java基础之运算符与语句

一、运算符

1、算数运算符

运算符	名称	举例
+	加法	a等于10，b等于3 则a+b=13
-	减法	a等于10，b等于3 则a-b=7
*	乘法	a等于10，b等于3 则a*b=30
/	除法	a等于10，b等于3 则a/b=3
%	取余	a等于10，b等于3 则a%b=1
++	自增	b++或++b等于4
--	自减	b--或--b等于2

　　++：意为将变量值+1，如果++出现在变量名的前面，则变量本身先加1，然后在输出；如果++出现在变量名的后面，则先输出变量本身的值，然后加1

1 public static void main(string[] args) {
2     int i=1;
3     system.out.println("i++的值-----"+(i++));
4     system.out.println("i的值-----"+i);
5     int k=1;
6     system.out.println("++k的值"+(++k));
7 }

输出的结果为

i++的值-----1
i的值-----2
++k的值2

　　--：意为将变量值-1，如果--出现在变量名的前面，则变量本身先减1，然后在输出，如果--出现在变量名的后面，则先输出变量本身的值，然后在减1

1 public static void main(string[] args) {
2     int i=1;
3     system.out.println("i--的值-----"+(i--));
4     system.out.println("i的值-----"+i);
5     int k=1;
6     system.out.println("--k的值"+(--k));
7         
8 }

输出的结果为：

i--的值-----1
i的值-----0
--k的值0

2、赋值运算符

　　两个操作数进行操作，把结果再赋值给其中的一个变量

运算符	名称	举例
=	赋值	c=a+b,将a+b的值赋值给c
+=	加等于	c+=a等价于c=c+a
-+	减等于	c-=a等价于c=c-a
*+	乘等于	c*=a等价于c=c*a
/=	除等于	c/=a等价于c=c/a
%=	模等于	c%=a等价于c=c&a

 1 public static void main(string[] args) {
 2     int one=10;
 3     int two=3;
 4     int three=0;
 5     three=one+two;
 6     system.out.println("three=one+two----"+three);
 7     three+=one;
 8     system.out.println("three+=one----"+three);
 9     three-=one;
10     system.out.println("three-=one---"+three);
11     three*=one;
12     system.out.println("three*=one---"+three);
13     three/=one;
14     system.out.println("three/=one---"+three);
15     three%=one;
16     system.out.println("three%=one---"+three);
17         
18 }

输出结果为

three=one+two----13
three+=one----23
three-=one---13
three*=one---130
three/=one---13
three%=one---3

3、关系运算符

　　关系运算符运算得到的结果类型为boolean类型

运算符	描述	例子
==	检查如果两个操作数的值是否相等，如果相等则条件为真。	（a == b）为假(非真)。
!=	检查如果两个操作数的值是否相等，如果值不相等则条件为真。	(a != b) 为真。
>	检查左操作数的值是否大于右操作数的值，如果是那么条件为真。	（a> b）非真。
<	检查左操作数的值是否小于右操作数的值，如果是那么条件为真。	（a <b）为真。
>=	检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。	（a> = b）为假。
<=	检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。	（a <= b）为真。

 1  public static void main(string[] args) {
 2         int a = 10;
 3         int b = 20;
 4         system.out.println("a == b = " + (a == b) );
 5         system.out.println("a != b = " + (a != b) );
 6         system.out.println("a > b = " + (a > b) );
 7         system.out.println("a < b = " + (a < b) );
 8         system.out.println("b >= a = " + (b >= a) );
 9         system.out.println("b <= a = " + (b <= a) );
10         
11     }

输出结果为

a == b = false
a != b = true
a > b = false
a < b = true
b >= a = true
b <= a = false

4、逻辑运算符：

下表列出了逻辑运算符的基本运算，假设布尔变量a为真，b为假，c为真，d为假

运算符	名称	举例
&	与（两个变量同为真结果为真，否则为假）	a&b为假   a&c为真   b&d为假
|	或（两个变量有一个为真结果就是真，否则为假）	a|b为真   a|c为真   b|d为假
^	异或(两个变量相同为假，不同为真）	a^b为真   a^c为假  b^d为假
!	非（条件为真，非后结果为假）	！（a&b）为假   ！（a&c）为真   ！（b&d）为假

&& 短路与：规则与&相同，但是如果使用&&时，第一个条件为false，则不再对第二个条件进行判断，直接输出结果为false。

|| 短路或：规则与|相同，但是如果使用||时，第一个条件为true，则不再对第二个条件进行判断，直接输出结果为为true。

5、字符串连接符

　　string表示字符串类型，如果要申明一个字符串的变量，则变量值需要使用双引号，任何数据类型通过+和字符串类型连接，组成的依然是一个字符串

6、条件运算符

　　也叫三目运算符，三元运算符等，

　　语法：条件表达式？结果1：结果2；

　　注意：1、条件表达式的结果只能是boolean类型

　　　　　2、如果返回的结果为true，则输出结果1，否则输出结果2

1  public static void main(string[] args) {
2     int a,b,c;
3     a=20;
4     b=(a==10)?20:30;
5     c=(a==20)?20:30;
6     system.err.println("b的值"+b);
7     system.err.println("c的值"+c);
8         
9 }

输出结果为

b的值30
c的值20

7、instanceof运算符

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

　　语法：（object  reference  variable） instanceof （class/interface  type）

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

　　例子

string  name="xiaoming";
//由于name是string类型，所以返回true
boolean result =name instanceof  string 

　　如果被比较的对象兼容于右侧类型，改运算符仍然返回true

　　例子：

class vehicle{}


public class car extends vehicle{

    publicstatic void main(string []args){
            vehicle a=new car();
            boolean result = a instanceof  car;
            systen.out.println(result)
    
    }        
}    

　　运行结果为　

true

8、java运算符优先级

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

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

类别	操作符	关联性
后缀	() [] . (点操作符)	左到右
一元	+ + - ！〜	从右到左
乘性	* /％	左到右
加性	+ -	左到右
移位	>> >>>  <<	左到右
关系	>> = << =	左到右
相等	==  !=	左到右
按位与	＆	左到右
按位异或	^	左到右
按位或	|	左到右
逻辑与	&&	左到右
逻辑或	| |	左到右
条件	？：	从右到左
赋值	= + = - = * = / =％= >> = << =＆= ^ = | =	从右到左
逗号	，	左到右

二、java语句

1、条件语句

　　1）、if语句

　　语法：

if（条件语句）{

　　//条件成立，需要运行的代码

}else{

　　　//可选项，当条件不成立，就执行else中的代码

}

 

 

　　如果有多个条件时可以选择else if和if语句匹配使用，语法：

if（条件语句）{
    //调价成立，需要运行的代码

}else  if(){
    //条件成立，需要运行的代码
}
.....

else if(){
   //条件成立，需要运行的代码
}else{
    //可选项，当以上条件都不成立时，就执行else中的代码
}

【一个if语句中可以有多个else if，但只能有一个esle，而且else要位于所有else if  的后面】

　　2）、switch语句

　　　　语法：

switch（表达式）{

       case 取值1：代码块
             break；
      case 取值1：代码块
             break；
      case 取值1：代码块
             break；
      case 取值1：代码块
             break；
        .....
        default  代码块    

　　注意：1、switch中的表达式的类型只能是byte，short，int，char，string和枚举

　　　　　2、每个case语句块后面，都要跟上break，用来条出语句

　　　　　3、default表示当所有条件不成立时们就会被执行。

　if和switch的区别：if和switch都是条件语句，但是switch只能做等值判断，而if条件语句既可以做等值判断，也可以做范围判断

　2、循环语句

　　顺序结构的程序语句只能被执行一次，如果想要同样的操作执行多次，就需要使用循环结构。java中有三种主要的循环结构，while循环，do....while循环，for循环

　　1）、while循环

　　while循环是最基本的循环，结构为：　

while (布尔表达式）{
       循环内容  
}

 

只要布尔表达式为true，循环就会一直执行下去

1 public static void main(string[] args) {
2     int i=20;
3     while(i<30){
4         system.out.println("i的值="+i);
5         i++;
6     }
7 }

输出结果为：

i的值=20
i的值=21
i的值=22
i的值=23
i的值=24
i的值=25
i的值=26
i的值=27
i的值=28
i的值=29

　　2）、do...while循环

　　对于whlie语句而言，如果不满足条件，则不能进入循环，但有时我们需要即使不满足条件，也至少执行一次。do...whlie循环和while循环相似，不同的是，do...while循环至少会执行一次。

do{
    //代码语句
}while(布尔表达式）；   

例子：

 1     public static void main(string[] args) {
 2         int i=20;
 3         do {
 4             system.err.println("i的值为==="+i);
 5         } while (i>20);
 6         
 7         do {
 8             system.err.println("i的值为----"+i);
 9             i++;
10         } while (i<25);
11     }

输出结果为：

i的值为===20
i的值为----20
i的值为----21
i的值为----22
i的值为----23
i的值为----24

注意：布尔表达式在循环体的后面，所以语句块在检测布尔表达式之前已经执行了。如果布尔表达式的值为true，语句块一直执行，知道布尔表达式的值为false。

 

 　　3）、for循环

　　虽然所有循环结构都可以用while或do...while表示，但是java提供了另一种语句——for循环，是一些循环结构更加简单。

　　for循环执行的次数是在执行前就确定的，结构为：

for(初始化；布尔表达式；更新){
      //代码语句  
}

　　for循环需要注意几点：

　　1、最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。

　　2、然后，检测布尔表达式的值，如果为true，循环体被执行，如果为false，循环终止，开始执行循环体后面的语句。

　　3、执行一次循环后，更新循环控制变量。

　　4、再次检测布尔表达式，循环执行上面的过程。

1     public static void main(string[] args) {
2         for(int i=0;i<5;i++){
3             system.err.println("i的值"+i);
4         }
5     }

输出结过为

i的值0
i的值1
i的值2
i的值3
i的值4

　　java增强的for循环　　

　　在java5以后引入了一种用于数组或集合的增强型for循环，结构为：

for(声明语句：表达式）{
      //打码语句
}

声明语句：声明新的局部变量，该变量的类型必须和数组或集合元素的类型匹配。其作用域限定在循环语句块，其值与此时数组或集合元素的值相等。

表达式：表达式是要访问的数组或集合名，或者是返回值为数组或集合的方法

例子：

 1 public static void main(string[] args) {
 2         
 3         string [] strings={"小明","小李","小红","小白"};
 4         for(string s:strings){
 5             system.err.println("数组循环==="+s);
 6         }
 7         list<string> lstrings=new arraylist<>();
 8         lstrings.add("小明");
 9         lstrings.add("小李");
10         lstrings.add("小红");
11         lstrings.add("小白");
12         for(string list:lstrings){
13             system.err.println("集合循环==="+list);
14         }
15 }

输出结果为：

数组循环===小明
数组循环===小李
数组循环===小红
数组循环===小白
集合循环===小明
集合循环===小李
集合循环===小红
集合循环===小白