1.赋值运算符
赋值运算符:
基本的赋值运算符: =
举例:int a = 10 ; //将10这个数据赋值给int类型的变量a
扩展的赋值运算符: +=,-=,*=,/=,%=
将=号左边的值和右边的值相加,赋值给左边
变量进行+=...计算的时候,隐藏了强制类型转换
//+=举例
int y = 30 ;
y += 10 ; ---->很像(类似于) y = y +10 ;
short s = 1
s += 1; 等价于 s = (short)(s+1) ;
2.比较运算符
比较(关系运算符):
>=,<=,>,<,==,!=(mysql数据库的语法: !=符号)
结论:
当前关系运算符的符号不管连接简单的表达式还是复杂的表达式,结果要么true,要么是false
注意事项:
在进行比较的时候,==千万不能写成=
//注意事项
int m = 20 ;
int n = 10 ;
System.out.println(m==n) ; //false
System.out.println(m=n) ; //直接输出(将n的值赋值m) //10
//不兼容的类型: int无法转换为boolean
//boolean flag = (m = n); //==不能写成= ,此时意思变了,将n的赋值m,但是结果是boolean 要么是true/false
3.逻辑运算符
3.1基本的逻辑运算符
基本的逻辑运算符:
逻辑单与& : 有false,则false (逻辑运算符操作的表达式,最终结果不是true,就是false)
逻辑单或| : 有true,则true
逻辑异或^ : 相同则为false,不同则为true
简单记忆:男女关系
男男 女女 男女 女男
逻辑非! : 非true 则false,非false则true,
偶数个非是它本身
3.2扩展的逻辑运算符（重点理解举例）
扩展的逻辑运算符:
逻辑双与&& :左边表达式如果为false,右边不执行!
逻辑双或|| : 左边表达式如果为true,右边不执行!
逻辑双与&&和逻辑单与&的区别
共同点:
最基本的原则:有false,则false (并列关系)
不同点:
逻辑双与&&特点:
&&符号左边的表达式如果是false,右边不执行了(&&的短路效果!)
逻辑双|特点|:
||如果左边的表达式如果是true,右边不执行了(||的短路效果!)
//定义三个变量
int x = 3 ;
int y = 4 ;
int z = 5 ;
//逻辑双与&&
System.out.println((x>y) && (y>z)) ; //false && false --->false
System.out.println((x>y) && (y<z)) ; //false && true --->false
System.out.println((x<y) && (y>z)) ; //true && false ---->false
System.out.println((x<y) && (y<z)) ;//true && true ---->true
System.out.println("--------------------------");
int m = 3 ;
int n = 4 ;
//输出m,n的值
System.out.println("m:"+m); //3
System.out.println("n:"+n) ;//4
System.out.println("--------------------------");
//做操作
//重点理解******************************
//(4==3) & (3 == 4)--->false & false --->false
//System.out.println((++m == 3) & (--n==4)) ; //逻辑单与:无论左边表单是false,都要执行的!
//(4 == 4) & (4 == 3)---> true & false --->false
//System.out.println((++m == 4) & (n-- == 3)) ;
//true & flase
//逻辑双与&& :&&符号左边的表达式如果是false,右边不执行了(&&的短路效果!)
System.out.println((++m == 3) && (--n == 4)) ; //false
//m=4 false && false n =3 (理想的结果)
//m,n的值
System.out.println("m:"+m); // 4
System.out.println("n:"+n) ;// 4
4 位运算符
4.1概念
位运算符:
位运算符的基本符号 &,|,^,~
位与 & : 有0 则0
位或 | : 有1则1
位异或 ^ :相同则为0,不同则为1
一个数据被另一个数据位异或两次,其值是它本身!
~(按位取反,0边1,1边0):
位运算的移动符号 <<, >>, >>>
<<: 左移,最高符号位丢弃掉,右边补0
>>:右移,如果最高符号位是1,左边补1,如果最高符号位是0,补0
>>>:无符号右移,无论最高符号位是1还是0,左边补齐都是0
4.2举例
4.2.1练习题一（基本位运算符）
System.out.println(3 & 4) ; //0
System.out.println(3 | 4) ; //7
System.out.println(3 ^ 4) ; //7
System.out.println(~3) ; // -4
/*
3,4分别算出十进制---->二进制数据 (以补码进行计算---->先算出原码)
3----->11
4----->100
补全比特位
3 00000000 0000000 00000000 00000011
4 00000000 0000000 00000000 00000100
3 & 4 :有0 则0
00000000 0000000 00000000 00000011
位与& 00000000 0000000 00000000 00000100
-------------------------------------------------------------
00000000 0000000 00000000 00000000
结果:0
3 | 4 : 有1则1
00000000 0000000 00000000 00000011
位或| 00000000 0000000 00000000 00000100
-------------------------------------------------------
00000000 0000000 00000000 00000111
结果:7
3 ^ 4 :相同则为0,不同则为1
00000000 0000000 00000000 00000011
位异或^ 00000000 0000000 00000000 00000100
--------------------------------------------------------
00000000 0000000 00000000 00000111
结果:7
~3 :反码:( 按位取反 0变1,1变0)
00000000 00000000 00000000 00000011
~
-----------------------------------------------
11111111 11111111 11111111 11111100 (补码) ---->原码
最高符号位 数值位
1 1111111 11111111 11111111 11111100 (补码)
-1
------------------------------------------------------------------
1 1111111 11111111 11111111 11111011 (反码)
1 0000000 00000000 00000000 00000100 (原码)
结果: - 4
*/
4.2.2 练习题二（位运算的移动符号）
//请有效的方式写出 2^3 的结果!
1 << 3 (使用符号左边的数据*2的移动次幂 1 *2^3)
//将左移符号左边的数据乘以当前2的移动次幂
System.out.println(2<<3); //16 2*2^3 = 16
//将右移符号右边的数据除以当前2的移动次幂
System.out.println(10>>2); //2 10/(2^2) = 10/4 = 2(取整)
//特点:将左移符号左边的数据乘以当前2的移动次幂
System.out.println(3 << 2) ; //3 * 2 ^2 = 12 ;
//特点:将右移符号左边的数据除以2的移动次幂
System.out.println(24 >> 2) ; //24右移两位 24/2^2 = 24/ 4 = 6
System.out.println(-24 >> 2) ; //-6
System.out.println(-24 >>> 2) ; //1,073,741,818
/*
1) 3 << 2
先算出3十进制---二进制数据 11
原码: 00000000 00000000 00000000 00000011
反码: 00000000 00000000 00000000 00000011
补码: 00000000 00000000 00000000 00000011
//算出补码---->向左边移动两位 (最高符号位丢弃掉,右边补0)
00000000 00000000 00000000 00000011
(00)000000 00000000 00000000 0000001100
0 000000 00000000 00000000 0000001100 (补码) -- 反码-->求原码 (正数的原反补一样):12
2) 24 >> 2
先算出24十进制---->对应的二进制数据 11000
原码: 00000000 00000000 00000000 00011000
反码: 00000000 00000000 00000000 00011000
补码: 00000000 00000000 00000000 00011000
>> 移动两位
00000000 00000000 00000000 00011000
0000000000 00000000 00000000 000110(00) (补码) 正数:原,反,补一样
0000000000 00000000 00000000 000110 反码
0000000000 00000000 00000000 000110 原码
---------------------------------------------
结果: + 6
3) -24 >> 2
-24---->二进制数据
-24 >> 2
最高符号位 数值位
10000000 00000000 00000000 00011000 (原码)
11111111 11111111 11111111 11100111 (反码)
+1
--------------------------------------------- +1
11111111 11111111 11111111 11101000 (补码)
11111111 11111111 11111111 11101000
1111111111 11111111 11111111 111010(00) (补码)---->反码---->原码
1111111111 11111111 11111111 111010 (补码)
-1
---------------------------------------------
1111111111 11111111 11111111 111001 (反码)
1000000000 00000000 00000000 000110 (原码) :
结果: - 6
4) -24 >>> 2
10000000 00000000 00000000 00011000 (原码)
11111111 11111111 11111111 11100111 (反码)
+1
--------------------------------------------- +1
11111111 11111111 11111111 11101000 (补码)
11111111 11111111 11111111 11101000
0011111111 11111111 11111111 111010(00) (补码--->反码---->原码)
0011111111 11111111 11111111 111010
结果:1,073,741,818
*/
4.3 位异或特点
一个数据被另一个数据位异或两次,其值是它本身.
int a = 10 ;
int b = 20 ;
System.out.println(a ^ b ^ b) ; //10
System.out.println(a^ b ^ a) ; //20
4.3.1 位异或举例(数据交换)
面试题:
自定义两个变量(没有告诉具体数据类型,默认都是int)
将这两个变量的值进行交换!
//定义两个int类型的变量
int a = 10 ;
int b = 20 ;
//a,b输出
System.out.println("a:"+a) ;
System.out.println("b:"+b) ;
System.out.println("------------------") ;
//目的:一些操作---a =20 , b =10
//方式1:开发中经常用到的第三方变量
//定义一个临时变量 temp
//int temp = a ; //temp = 10
//a = b ; //a = b = 20 ;
//b = temp ; //b = temp = 10
//方式2:可以使用位运算符:位异或 ^特点 :个数据被另一个数据位异或两次,其值是它本身!
//=号左边:a,b,a
//=号右边:a ^ b
// a = a ^ b ; //a = 10 b =20 10 ^ 20
// b = a ^ b ;//将上面a变量带入进来 int b = a^ b ^ b = 10 ;
// a = a ^ b ;//int a = a ^ b ^a = b = 20
//方式3: 基本的加减运算
a = a + b ; // a = 10 +20 = 30
b = a - b ; //b = 30 - 20 = 10
a = a - b ;//a = 30 - 10 = 20
System.out.println("a:"+a) ;
System.out.println("b:"+b) ;
5 三元运算符
格式:
(表达式)? 表达式1的结果: 表达式2的结果 ;
执行流程:
计算/比较表达式是否成立,如果为true,就执行表达式1的结构,否则,就执行表达式2的结果
6 键盘录入数据
6.1格式
键盘录入数据操作步骤:
1)在Java中,只要不是java.lang包下的类,都需要导包!
Scanner (jdk提供的一个核心类) ---->java.util.Scanenr;
格式:import java.util.Scanner; 固定写法
import位置在 ,在class类的上面
2)导包了,需要在main方法中使用Scanner类,
就需要创建键盘录入对象
固定写法:
Scanner 对象名 = new Scanner(System.in) ;
3)友情提示: "请您输入一个数据:"
4) 接收数据
使用int类型来接收数据
固定写法:
int 变量名 = 对象名.nextInt() ;
float 变量名 = 对象名.nextFloat();
String 变量名 = 对象名.nextLine();
5)输出变量名 :打印在控制台上!
import java.util.Scanner;
6.2 举例代码
class ScannerDemo{
public static void main(String[] args){
//2)创建文本扫描器对象(键盘录入对象)
//固定写法:
//Scanner 对象名 = new Scanner(System.in) ;
Scanner sc = new Scanner(System.in) ;
//3)友情提示
System.out.println("请您输入一个数据:") ;
//4)接收数据:
//固定写法:
//int 变量名 = 对象名.nextInt() ;
int num = sc.nextInt() ; //等待用户输入数据
//nextLine() ; 使用键盘录入对象录入字符串数据
//String s = sc.nextLine() ; //String:后面讲的常用类(特殊的引用类型)
//5)输出键盘录入数据
System.out.println("您输入的数据是:"+num) ;
//System.out.println("您输入的数据是:"+s) ;
/*
Exception in thread "main" java.util.InputMismatchException
*/
}
}
7 流程控制语句
7.1 顺序结构语句
进入main方法中,代码由上而下依次加载!
7.2 选择结构语句
7.2 .1 if语句
if语句格式1的注意事项:
1)如果使用格式1,if(){语句},{}中的语句只有一条语句,那么 {}是省略不写的! (一般不建议!),如果有多条,
最好不要省略{}
2)在if语句定义的变量,只能在当前{} 里面有效!
3)在书写if语句的时候,有花括号的地方不能有分号; 有分号的地方就不能花括号!
int x = 10 ; // 局部变量
if(x > 5 || x <=10){ //建议永远带上括号
int y = 5 ;
System.out.println("x大于5或者x小于10");
}
//System.out.println(y); //y变量随着if语句结束而消失
System.out.println("over") ;
int z = 20 ;
if(z >= 10); //if语句后面直接分号,没有意义,if是一个空语句
//局部代码块 :限定变量的生命周期
//{
// System.out.println("z大于等10");
//}
{
int m = 100;
System.out.println(m) ;
}
7.2 .2 switch语句
switch语句的结构
switch(表达式){
case 值1:
语句1;
break ;
case 值2:
语句2;
break;
...
default:
语句n+1;
break ;
}
执行流程:
表达式中的数据和case语句中的值1 进行比较,如果匹配成功,就执行语句1,遇见break switch语句结束;
如果不匹配,继续和case语句中的值2比较,如果匹配,执行语句2,break结束语句,
如果上面caste中的语句都和表达式中的数据不匹配,最终执行default中的语句n+1,break结束语句!
switch中的表达式可以是什么数据类型?
可以跟的类型,byte,short,int,char,
Jdk5以后可以跟 枚举类型 (enum) ,jdk的新特性去讲
JDK7以后可以跟 String类型 常用类中讲String
import java.util.Scanner;
class Demo06Scanner{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
/* System.out.println("请根据如下选项选择");
System.out.println("65 张三");
System.out.println("66 李四");
System.out.println("67 王五");
int choice = sc.nextInt();
System.out.println("------------------");
//int类型强制转换成char
char choiceNum = (char)choice;
switch (choiceNum){
case 'A':
System.out.println("张三");
break;
case 'B':
System.out.println("李四");
break;
case 'C':
System.out.println("王五");
break;
default:
System.out.println("输入有误");
}
// */
String s = "hello";
System.out.println(s.charAt(1));
System.out.println("--------------------");
char choice01 = sc.next().charAt(0);
System.out.println("--------------------");
switch(choice01){
case 65:
System.out.println("A");
break;
case 66:
System.out.println("B");
break;
default:
System.out.println("输入不合法");
}
//System.out.println("程序结束");
}
}
7.2 .3循环结构语句
for
while
do-while
死循环
222
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
