一、运算符(6个)
运算符是一种特殊的符号,用以表示数据的运算、赋值和比较等。参与运算两边类型相同
Java中有算术运算符、关系运算符、位运算符、逻辑运算符、赋值运算符 和 其他运算符。
1.1算术运算符
a=10,b=20
+ | 加 | a+b=30 |
---|---|---|
- | 减 | a-b=-10 |
* | 乘 | a*b=200 |
/ | 除 | a/b=1/2 |
% | 取余/取模 | b%a=0 |
++ | 自加 | a++=11 ,++a=11 |
– | 自减 | a–=9 , --a=9 |
自运算符
自增(++)自减(–)运算符是一种特殊的算术运算符,在算术运算符中需要两个操作数来进行运算,而自增自减运算符是一个操作数。
前缀自增自减法(++a,–a): 先进行自增或者自减运算,再进行表达式运算。(先加再算)
后缀自增自减法(a++,a–): 先进行表达式运算,再进行自增或者自减运算 实例:(先算再加)
//自加符
int i=10;
int j= i++;//右自增 先赋值在运算 结果:j=10 i=11
int k= ++i; //左自增 先运算再赋值 结果:k=12 i=12
//i=12
i=i++ 当把12赋值给i 时 ,不会两次赋值,运算后则为12
i=++i i为13
// 自减符--
// +=
int i=0;
i+=3; //相当于 i=i+3
1.2关系运算符
所有的关系运算符的运算结果都是布尔类型,不是true就是false,不可能是其他值。
操作符 | 例子 |
---|---|
> | 大于 |
>= | 大于等于 |
< | 小于 |
<= | 小于等于 |
== | 等于 |
!= | 不等于 |
1.3位运算符
Java定义了位运算符,应用于整数类型(int),长整型(long),短整型(short),字符型(char),和字节型(byte)等类型。
位运算符作用在所有的位上,并且按位运算。
下表列出了位运算符的基本运算,假设整数变量A的值为60(二进制:0011 1100)和变量B的值为13(0000 1101):
操作符 | 描述 | 例子 |
---|---|---|
& 与 | 如果相对应位都是1,则结果为1,否则为0 | (A&B),得到12,即0000 1100 |
| 或 | 如果相对应位都是0,则结果为0,否则为1 | (A|B), 得到61,即 0011 1101 |
^ | 如果相对应位相同,则结果为0,否则为1 | (A ^ B)得到49,即 0011 0001 |
〜 | 按位取反运算符翻转操作数的每一位,即0变成1,1变成0。 | (〜A)得到-61,即1100 0011 |
<< | 按位左移运算符。左操作数按位左移左操作数指定的位数。 | A << 2得到240,即 1111 0000 |
>> | 按位右移运算符。右操作数按位右移右操作数指定的位数 | A >> 2得到15, 即 0000 1111 |
1.4逻辑运算符
所有的关系运算符的运算结果都是布尔类型,不是true就是false,不可能是其他值。
操作符 | 描述 | 例子 | |
---|---|---|---|
& | 逻辑与(并且) | 两边都是true,结果才是true | 有假则为假 |
│ | 逻辑或(或者) | 有一边是true,结果就是true | 有真即为真 |
! | 逻辑非(取反) | !true = false , !false = true | |
&& | 短路与 | 两边都是true,结果才是true | 只要左边为flate 右边不运算 |
││ | 短路或 | 有一边是true,结果就是true | 只要左边为true 右边不运算 |
1.41.短路与 &&和 逻辑与 &有什么区别?
首先这两个运算符的运算结果没有任何区别,完全相同。
只不过“短路与&&”会发生短路现象。
//测试逻辑与&
int x = 10;
int y = 11;
System.out.println(x > y & x > y++); //false
//通过这个测试得出:x > y++ 这个表达式执行了。
System.out.println(y); // 12
//测试短路与&&
int m = 10;
int n = 11;
// 使用短路与&&的时候,当左边的表达式为false的时候,右边的表达式不执行
// 这种现象被称为短路。
System.out.println(m > n && m > n++);
System.out.println(n); // 11
1.42什么是短路现象?
右边表达式不执行,这种现象叫做短路现象。
1.43什么时候使用短路与&&,逻辑与& ?
从效率方面来说,&&比&的效率高一些。
因为逻辑与&不管第一个表达式结果是什么,第二个表达式一定会执行。
以后的开发中,短路与&&和逻辑与还是需要同时并存的。
大部分情况下都建议使用短路与&&只有当既需要左边表达式执行,又需要右边表达式执行的时候,才会选择逻辑与&。
1.44 短路或 ||和逻辑或|有什么区别?
首先这两个运算符的运算结果没有任何区别,完全相同。
只不过“短路或 ||”会发生短路现象。
//测试逻辑或|
int x = 10;
int y = 11;
System.out.println(x < y | x > y++); //ture
// 通过这个测试得出:x > y++ 这个表达式执行了。
System.out.println(y); // 12
//测试短路或||
int m = 10;
int n = 11;
// 使用短路或||的时候,当左边的表达式为true的时候,右边的表达式不执行
// 这种现象被称为短路。
System.out.println(m < n || m > n++);
System.out.println(n); // 11
1.45逻辑符运算符例子
//布尔值表达式 逻辑运算符 布尔值表达式
1==1 & 2==2; t
1!=1&2==2; f
1!=1|2==2; true
1!=1&& 2==2; 2==2 不需要判定
1==1 || 2==2; t 右边不需要判定
1.5赋值运算符
运算符 | 含义 | 例子 |
---|---|---|
= | 赋值,右边的赋值给左边的 | 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 |
<< = | 左移位赋值运算符 | C << = 2等价于C = C << 2 |
&= | 按位与赋值运算符 | C&= 2等价于C = C&2 |
^ = | 按位异或赋值操作符 | C ^ = 2等价于C = C ^ 2 |
|= | 按位或赋值操作符 | C|= 2等价于C = C|2 |
除了第一个是赋值运算符,其他都是拓展赋值运算符
使用扩展赋值运算符的时候,永远都不会改变运算结果类型。
1.6条件运算符
1.61三目运算符/三目运算符
语法格式:布尔表达式 ? 表达式1 : 表达式2
只能写值的赋予
赋值表达式,最终一定会返回一个值,可以嵌套使用
1.62执行原理是什么?
布尔表达式的结果为true时,表达式1的执行结果作为整个表达式的结果。
布尔表达式的结果为false时,表达式2的执行结果作为整个表达式的结果。
1.63代码表示
char a = true ? '男' : "女";
string a1 = true ? '男' : "女";
以上两个都报错。
//下面可以
String s = "";
s += true ? '男' : "女";
int i=100;
char c =i>=100? 'A':'B'
char c =i> 100? 'A': i>=90?'B' : 'C';
//对mark判定,大于90则为A,80-90为B,70-80为C,60-70为D,否则为E
int mark=100;
char level=mark>=90? 'A': mark>=80? 'B': mark>=70? 'C': mark>=60? 'D': 'E';
//局部变量在同一个作用域内不能同名
int mark=100;
char c;
if( mark>=90){
c= 'A';
}else if( mark>=80){
c='B';
}else if( mark>=70 ){
c= 'C';
}else if(mark>=60){
c= 'D';
}else{
c= 'E';
}
//如果if的花括号内只有一行语句 可以忽略{}
if(true) int i=100;
if (true){
int i =100;
}
1.7运算符题目
int i=10;
int k=10;
i++>10 && i++>k 10>10 false 左边为false,右边不运算 f i=11 k不变
++i >k || --k>8 11>10 true 左边为真,右边不运算. t i=11 k=10
i-->k-- || i++>=k 10>10 false 9>= 9 true t i=10 k=9
i++>--k && i-->k 10>9 true 11>9 true t i=10 k=9
i++>--k || i-->--k 10>9 true t i=11 k=9
//按照 参与运算的最大的数据类型输出
10/3 3
10/3.0 3.3333
jshell> char c ='a'+'b'
c ==> '?'
jshell> char d=1+1
d ==> '\002'
1.8类型转换
运算时,byte short char 不会相互转换,直接视为 int
隐式转换 byte short char int long float double
int i='a' 合法 //i=97
short s=100 合法 //s=100
byte b=i 不合法 //变量 ,从int转换到byte可能会有损失
byte b2=100 合法 //b2=100
short s2=b2+b2 不合法 //从int转换到short可能会有损失,大类型转小类型
char c =b2 +b2 不合法 //从int转换到char可能会有损失,大类型转小类型
short s3=100+100 合法 //s3=200
float f =1.0F +(1+1.0)+ (float)1.0 不合法 // 从double转换到float可能会有损失
float f =1.0F +(float)(1+1.0)+ (float)1.0 合法//f=4.0
double d=i+i+1.0 合法
float f2=1.0F 合法 //fa2=1.0
float f2=1.0 不合法 // 从double转换到float可能会有损失
f2-0.1 ==0.9 true //都是double
f-0.1F==0.9 false //float转为double
byte b=99999999999 //过大,超出byte范围
1.9字符串连接运算符(+)
-
+运算符在java语言中有两个作用。
作用1:求和
作用2:字符串拼接 -
什么时候求和?什么时候进行字符串的拼接呢?
当 + 运算符两边都是数字类型的时候,求和。
当 + 运算符两边的“任意一边”是字符串类型,那么这个+会进行字符串拼接操作。 -
一定要记住:字符串拼接完之后的结果还是一个字符串。
int a = 100; int b = 200; // 这里的 + 两边都是数字,所以加法运算 int c = a + b; System.out.println(a + "+" + b + " = " + a + b);//100+200=100200 字符拼接 System.out.println(a + "+" + b + " = " + (a + b));//100+200=300 数字计算
遵循“自左向右”的顺序依次执行(除非额外添加了小括号,小括号的优先级高)
二、流程控制
2.1顺序结构
int i=10;
int j=10;
int k=i+j;
2.2分支结构
2.21 if else
//从上到下挨个匹配,直到有个符合条件
if (布尔值表达式) {
//todo
}else if(布尔表达式){
//todo
}else{
//以上情况都不符合
}
//{}变量的作用域
int k=100;
if(true){
int k=10;
}else{
int y=k+100;
}
// 对mark判定
int mark=100;
char level= mark>=90? 'A': mark>=80? 'B': mark>=70? 'C': mark>=60? 'D' : 'E';
//局部变量在同一个作用域内不能同名
int mark=100;
char c;
if( mark>=90){
c= 'A';
}else if( mark>=80){
c='B';
}else if( mark>=70 ){
c= 'C';
}else if(mark>=60){
c= 'D';
}else{
c= 'E';
}
//如果if的花括号内只有一行语句 可以忽略{}
if(true) int i=100;
if (true){
int i =100;
}
2.22 switch …case
对变量进行判定,进行精确判定,不会从上到下匹配,直接进入符合条件的分支,如果没有,进入default分支
break的作用 跳出花括号,防止break 向下执行.
只能针对变量,效率比if高
//变量只能是基本数据类型中的 byte char short int 和引用数据类型String
switch (变量){
case 值:
break;
case 值:
break;
...
default :
break;
}
//例子
int i=100;
switch(i){
case 100:
System.out.println("i的值是100");
break;
case 90:
System.out.println("i的值是90");
break;
default:
System.out.println("i的值是100");
}
println 打印并换行
print 打印
System.out.printf()
2.23字符串String
引用数据类型 ,所有引用类型首字母大写
//在java中单引号表示字符,双引号表示字符串
String s1="a";
String s='a'+'b'; 错误 //右边返回int数据类型, int无法转换为java.lang.String
//什么地方出现字符串,什么时候就是字符串的拼接
//字符串的拼接
System.out.println(1+2+3+"我"+"我们"+12); //6我我们12
System.out.println("我"+"我们"+"1"+"2222"); //我我们12222
//switch case用法
String aut="春天";
switch (aut){
case"春天" :
System.out.println("春天345");
break;
case"夏天" :
System.out.println("夏天567");
break;
case"秋天" :
System.out.println("秋天8910");
break;
case "冬天":
System.out.println("冬天1112");
break;
default :
System.out.println("非法");
break;
}
//去掉break 尝试 看输出结果
2.3循环结构
2.31 for循环
for(初始值表达式;布尔值表达式;值改变表达式){
//todo 循环体
}
//1 常规写法
for(int i=1;i<=10;i++){
System.out.println(i);
}
//2 在外面声明变量
int i=1;
for(;i<=10;i++){
System.out.println(i);
}
//3 布尔值表达式放里面
int i=1;
for(;;i++){
if(i>10)break;
System.out.println(i);
}
//4 值改变表达式放里面
int i=1;
for(;;){
if(i>10)break;
System.out.println(i);
i++;
}
for循环例子
//输出1-50的所有偶数 ,用两种方法
//能被2整除的就输出,加判断条件
for(int i=1;i<=50;i++){
if(i%2==0)
System.out.println(i);
}
//改变初始值表达式和值改变表达式
for(int i=2;i<=50;i+=2){
System.out.println(i);
}
//continue用法
//continue 跳出本次循环
//break 跳出本层循环
for(int i=1;i<=50;i++){
if(i%2!=0)continue;
System.out.println(i);
}
//九九乘法表 %d占位符
for(int i=1;i<10;i++){
for(int j=1;j<=i;j++){
System.out.printf("%d*%d=%d ",j,i,i*j);
}
System.out.println();
}
//
for(int i=1;i<10;i++){
for(int j=1;j<10;j++){
System.out.print(j+"x"+i+"="+j*i+"\t");
};
System.out.println();
}
//左下角直角三角
*
**
***
****
for(int i=1;i<10;i++){ //i控制行数
for(int j=1;j<=i;j++){ //j控制列数
System.out.printf("* ");
}
System.out.println();
}
//菱形
int hight=9;
int top=hight%2 ==0? hight/2: hight/2+1;
int left=top;
int right=top;
for (int i=1;i<=hight;i++ ){
String line="";
for(int j=1;j<=hight;j++){
line+= j>=left && j<= right? "* ": " ";
}
if(i<top){
left--;
right++;
}else{
left++;
right--;
}
System.out.println(line);
}
2.32 while do
while(布尔值表达式){
}
//输出1-10
int i=1;
while(i<=10){
System.out.println(i);
i++;
}
2.33 do while
至少执行一次循环
do{
}while(布尔值表达式);
//1-10
int i=1;
do{
System.out.println(i);
i++;
} while(i<=10);