2021-04-01

saprk 运算符和选择语句

1、ascii码表：

• 字符0~9：对应（48-57），A-Z对应（65-90），a-z对应（97-122）

int和char类型数据转换

• char转换成int,字符型和数值型进行转换的时候都会直 询编码表,由于int4个字节,char2个字节,所以属于自动的 类型转换
• int转换成char,需要强制类型转换
• 如果char是汉字,转换成整数查询的就是Unicode编码表
• char类型的最大整数是65535,因为char设有负数
• char可以直接赋值为Unicode编码,格式为luxox,十六 进制

运算符

* 逻辑运算符:

语法格式:
boolean r = 布尔表达式1 逻辑运算符(&;|;!..) 布尔表达式2
1)逻辑运算符运算结果是布尔典型
2)布尔表达式:是指运算结果是布尔值的式子

• ==&==与和(and) false&true false
  只有&两边的表达式的值都是true 整体结果才是true,其他都是false
  全真才真,一假就假
• ==| == 或
  只有| 两边的表达式的值都是false,整体结果才是false,其他都是true
  全假才假,一真就真
• ! 非/取反
  非错即对
• && 短路与
  因为&是一错就错,所以当&&前已经是false时,那么就可以确定整体表达式的结果是false
  后续的表达式就不再执行了
• ==|| ==短路或
  与上类似

运算符

算数运算符

运算符	运算规则	范例	结果
+	正号	+3	3
+	加法	1+3	4
+	字符串连接	“中”+“国”	“中国”
-	负号	int a=3;-a	-3
-	减	3-1	2
*	乘	2*3	6
/	除	5/2	2

• 加法运算符在连接字符串时要注意,只有直接与字符串相加才会转成字符串
  -除法"/"当两边为整数时,取整数部分,舍余数,当其中一遍为浮点型时,按正常规则相除

基本数据类型转换

• 自动转换 范围小的可以向范围大的进行转换byte < short < int <long <float <double
• 强制转换 范围大的向范围小的进行转换,需要强制类型转换 小范围数据类型 标识符 = (小范围数据类型) 变量名称;

赋值运算符

运算符	运算规则	范例	结果
=	赋值	int a=2	2
+=	加后赋值	int a=2,a+=2	4
-=	减后赋值	int a=2,a-=2	0
*=	乘后赋值	int a=2;a*=2	4
/=	整除后赋值	int a=2,a/=2	1
%=	取模后赋值	int a=2,a%=2	0

比较运算符

运算符	运算规则	范例	结果
==	相等于	4==3	False
!=	不等于	4!=3	True
<	小于	4<3	False
>	大于	4>3	True
<=	小于等于	4<=3	False
>=	大于等于	4>=3	True

逻辑运算符

运算符	运算规则	范例	结果
!	非	!true	Flase
&&	短路与	false&&true	Flase
II	短路或	false II true	True

• 逻辑运算符运算结果是布尔类型
• 布尔表达式:是指运算结果是布尔值的式子
• &与/和(and) 全真才真,一假就假
• |或,全假才假,一真就真
• ! 非/取反,非错即对
• && 短路与,因为&是一错就错,所以当&&前已经是false时,那么就可以确定整体表达式的结果false,后续的表达式不再执行
• ||短路或,与上类似,只要一个表达式的结果能确定整体表达式的结果,反面表达式就短路不执行
• boolean r1 = 1>0 && 2<0; //
• boolean r1 = 2>0 || 1>0;
  -boolean r1 = 1>0 & 2<0;
  -boolean r1 = 2<0 | 1>0;

System.out.println((1 < 0 || 1 / 1 == 1)&&(1 >0 || 1 / 0 == 1));

1. 先判断两个小括号里true/fales
2. 第一个小括号:1< 0为假 1 / 1 == 1为真 == > 第一个小括号结果为true
3. 第二个小括号:1>0为true 因为短路或一真就真, 后面的就不做判断被短路 ==> true
4. 小括号1:true 小括号2:true == > true

位运算符

运算符	运算规则	范例	结果
!&与	1&0,0&0,1&!	0,0,1
I	或	1I0,0I0,1I1	1,0,1
^	异或	1 ^ 0,0 ^ 0,1^1	1,0,0

• ^运算规律
• 1^0=1,00=0,任何数和0相异或得到的是这个数本身
• 0^1=1,11=0,任何数和1相异或得到的是这个数的相反
• 一个数自己和自己异或得到的是0

三目运算符

• 必须有结果,?后必须跟有东西
• 三目/三元运算
  数据类型 变量= 布尔表达式 ? 当前面结果是true是执行此处;当前面结果是false时执行此处;
  数据类型 变量 = A ? B : C;
  1.先执行A处的布尔运算,得到一个布尔值
  2.当布尔值是true时,执行B处代码
  3.当布尔值是false时,执行C处代码
  4.整体结果的数据类型根据执行B处或者C处代码的结果方式
  5.B处和C处的结果数据类型一致

System.out.println( 1<5 ? “success” : “fa il” );

选择控制语句

• if控制语句
• 当括号内的内容是true的时候,执行{}中的内容

//并列if判断,无论上面的条件成立与否,下面的i f都会进行判断 
if(a < b){ System.out.println("a小于b"); 
}if(a > b){ System.out.println("a大于b");
 }
if(a == b){
 System.out.println("a等于b");
  }

分支语句-if语句

语法
if(布尔表达式){
语句1;
语句2;
…
}
执行流程:
1.先判断布尔表达式
2.如果结果是true,就执行if后的{ }内的语句,然后继续执行后续的
3.如果结果是false,就跳过if后的{ },而是执行后续的代码
双分支 - if…else…
if (布尔表达式){
当布尔表达式值是true,执行if后的语句:
且不执行else中的语句 布尔结果:true 执行if中语句 跳过else
}else{
当布尔表达式值是false是,不执行if后的
而是执行else后的语句,布尔结果是false 执行else语句,不执行if

if(布尔表达式2){
else if(布尔表达式2){
	语句2;
}else if(布尔表达式3){
	语句3;
}...{
	语句n
}else{
	语句n+1;
}
}


一旦有某个语句了,后续的
switch(值){
case 值1:
	语句1;
	break;
case 值2;
	语句2;
	break;
...
	case 值n:
	语句n;
}


执行流程:
1.switch后的值,与case后的值比较
2.如果相等,就执行改case下的语句
3.如果遇到break,跳出switch结构,执行后续
4.如果没有break,会造成case击穿
5.如果不相等,比对下一个case



package com.ligong.basic;
//算术运算符
public class CountOperator {
    public static void main(String[]args){
        //正号
        System.out.println(+3);
        //加法
        System.out.println(1+3);
        //字符串连接
        String a="今天周五";
        String b="今天放假";
        System.out.println(a+b);
        //负号
        int k =3;
        System.out.println(-k);
        //减法
        System.out.println(3-1);
//        String c="晚上吃什么饭";
//        int d=4;
//        System.out.println(c+d);
        //乘法
        int h=2;
        int j=3;
        System.out.println(h*j);
        //除法
        int c=5;
        int d=2;
        System.out.println(c/d);
        double x=c/d;
        System.out.println(x);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
运行结果

3
4
今天周五今天放假

循环四要素

-循环初始值
-循环控制条件
-循环体
-循环迭代

int i = 1;
while (i<6){
System.out.println("你好");
i++;
}

while循环

• 语法：
  while （布尔表达式）{
  循环体；
  循环迭代；（++ / --）–>控制循环次数
  }
• 执行流程：
  1）先判断while后的表达式
  2）如果是true，就行{}内的语句
  3）执行完{}内语句，再次判断while后的表达式
  4）当while后的结果是false就不再执行{}内的内容
  5）继续执行后续

do-while:先判断后执行

do while循环 --> 直到型

• 语法：先执行后判断
  -do{
  循环体；
  迭代
  }while(布尔表达式)；
• 先执行do中的循环内容
• 判断while后的表达式
• 表达式为true，在执行do中的内容
• 在判断。。
• 直到判断为false时，跳过循环，执行后续
• do while至少循环一次

//输出1-10
int i = 1；
do{
	System.out.println（i）；
	i++；
}while（i <= 10);

do while 1-100的求和

  public static void main(String[] args) {
        //求1-100的和
        int i=1;
        int a=0;
        do{
            a +=i;
            i++;

        }while(i<=100);
        System.out.println(a);

    }

for循环

• for（初始值；控制条件；迭代）{
  循环体；
  }
• 变量名：在同一作用域内不能重复
• 变量在这一范围内有效
• 同一作用域：在同一个最近的{}内
  1）限制性初始值1处，且只执行一次
  2）开始2处判断，如果为true，就向下执行循环体
  3）执行完后，执行迭代
  4）继续判断，如果判断为false，就跳出for结构，执行后续