我的第二周知识总结

JavaSE基础知识:

一 运算符(重点掌握)

1.1什么是运算符

运算符是指对操作数的运算方式.

1.2运算符的分类:

1.2.1算术运算符:
+、-、*、/、%（取模）、++（自加 1【单目】）、--（自减 1【单目】）

1.2.2关系运算符:
 |>、>=、<、<=、==、!=

1.2.3逻辑运算符:
&（逻辑与）、|（逻辑或）、!（逻辑非）、&&（逻辑双与）、||（逻辑双或）

1.2.4赋值运算符:
=、+=、-=、*=、/=、%=、

1.2.5位运算符:
&（位与）、|（位或）、^（位异或）、~（按位取反【单目】）、
<<（左移）、>>（带符号右移）、>>>（无符号右移）

1.2.6字符串连接运算符: 
+

2.算术运算符:

算术运算符包括：+（两个数字求和）、-（两个数字相减）、*（两个数字乘积）、/（两个数字相除）、%（两个数字取模或者求余）、++（单目运算符，对数字自加 1）、–（单目运算符，对数字自减 1）

public class Test01 {
public static void main(String[] args) {
int a = 10;
int b = 3;
System.out.println(a + b); //13
System.out.println(a - b); //7
System.out.println(a * b); //30
/*
在 java 语言中 10 除以 3 结果不是 3.3333..
因为 java 中有一个语法规则：int 类型和 int 类型
做运算，最终的结果还是 int 类型，所以 10 除以 3
的结果就是 3，这个过程会取整数位。
*/
System.out.println(a / b); //3
/*
10 对 3 求余数，3 乘 3 得 9，余 1。
*/
System.out.println(a % b); //1
/*
++和--都是单目运算符，++负责自加 1，--负责自减 1
*/
int i = 10;
i++;
System.out.println("i = " + i); //11
int j = 10;
++j;
System.out.println("j = " + j); //11
/*
++可以出现在变量前，也可以出现在变量后，无论是变量前还是变量后，
只要执行完++，最终的结果都会让变量自加 1。
出现在变量前和变量后的区别:
*/
int k = 10;
int m = k++;
/*
++无论是出现在变量前还是变量后，只要++执行
变量一定会自加 1，那么 k 变量一定会自加 1，所以以下输出 k=11
*/
System.out.println("k = " + k); //11
/*
以int m = k++;代码中++和=两个运算符同时存在，
当++运算符出现在变量后，会先做赋值运算，再自
加 1,所以最后 m = 10
*/
System.out.println("m = " + m); //10
int x = 10;
int y = ++x;
// x 变量自加 1 了，所以 x=11
System.out.println("x = " + x); //11
/*
++出现在变量前，会先进行自加 1的操作，然后再做赋值运算，所以 y = 11
*/
System.out.println("y = " + y); //11
	} 
}

3.关系运算符:

关系运算符主要是完成数据和数据之间的比较,有>、>=、<、<=、==、!=

class Test02 {
public static void main(String[] args) {
int a = 10;
int b = 10;
System.out.println(a > b);//false
//a的值等于b的值,所以为false
System.out.println(a >= b);//true
//a不大于b,但是a=b.所以为true
System.out.println(a < b);//false
//a不小于b.所以为false
System.out.println(a <= b);//true
//a不小于但是等于b,true
System.out.println(a == b);//true
//a等于b.所以为true
System.out.println(a != b);//false
//a等于b,所以false

//如何比较两个字符?
//比较两个字符串是否相等，不能使用“==”，必须调用 equals 方法，
System.out.println("abc".equals("abc"));//true

4.逻辑运算符:

逻辑运算符主要包括逻辑与（&），逻辑非(!),逻辑或（|），逻辑异或（^），逻辑双与（&&），逻辑双或（||）。所有逻辑运算符的特点是操作数都是布尔类型，并且最终的运算结果也是布尔类型。

public class Test03 {
public static void main(String[] args) {
System.out.println(5 > 3 & 5 > 4); //true
//逻辑与的规则:有false则false,
System.out.println(5 > 100 | 5 > 4); //true
//逻辑或的规则:有true这true
System.out.println(!(5 > 3)); //false
//逻辑非为求反,!true为false.!false=true
System.out.println(!(5 < 3)); //true
System.out.println(true & true); //true
System.out.println(true & false); //false
System.out.println(true | false); //true
System.out.println(!false); //true
System.out.println(!true); //false
System.out.println(true ^ false); //true
//逻辑异或:相同则为true,不同则为false
System.out.println(true ^ true); //false
System.out.println(false ^ false); //false

//重点研究逻辑与（&）和短路与（&&）的区别
int x = 100;
int y = 98;
int z = 99;
System.out.println(x > y & x > z); //true
System.out.println(x > y && x > z); //true
//作用都一样,有false则false
int m = 99;
int n = 100;
System.out.println(m > n & m > n++); //false
System.out.println("n = " + n); //101
/*运行结果是 101，足以说明 n++已经执行了。
也说明了逻辑与运算符无论左边表达式结果是true 还
是 false，右边表达式一定会执行。
*/
//逻辑双与&&
int k = 99;
int f = 100;
System.out.println(k > f && k > f++); //false
System.out.println("f = " + f); //100
/* f++并没有执行，因为左边表达式(k > f)为 false，右边的表达式就
不再执行了，这种现象被称为短路现象。也就是说对于短路与来说，
左边的表达式只要为 false，就会发生短路，右边表达式不再执行了。
*/

//逻辑双或||与逻辑双与&&作用效果相同,逻辑与|的特点是有true则true,所以逻辑双与||的效果是:只要符号前边是true,则不判断符号后面是true还是false,直接跳过.如果符号前面是false,才去去看符号后面是否成立!

5.赋值运算符:

赋值运算符目前也是只需要掌握=、+=、-=、*=、/=、%=

public classTest04 {
public static void main(String[] args) {
//基本的赋值运算符
int i;//定义一个变量
i = 10;//给变量初始化,将10赋值给i
System.out.println("i = " + i);
i = 100;
System.out.println("i = " + i);
//扩展的赋值运算符
int x = 10;
x += 1; //等同于 x = x + 1
System.out.println("x = " + x); //11
int y = 10;
y -= 1; //等同于 y = y - 1
System.out.println("y = " + y); //9
int z = 10;
z *= 2; //等同于 z = z * 2
System.out.println("z = " + z); //20
int m = 10;
m /= 3; //等同于 m = m / 3
System.out.println("m = " + m); //3
int n = 10;
n %= 3; //等同于 n = n % 3
System.out.println("n = " + n); //1
}

面试题:看程序,分析代码

		short s = 1 ;
		
		1)s = s + 1 ;
		2)s += 1 ; 

问:哪一句会编译错误?

解:1).Java中的隐式数据提升(隐式转换):byte,short,char三者之间不进行转换,
但是在参与运算时,都会提升为int(优先),long,float,double类型.
所以(s=s+1)中右边的部分计算结果的数据类型为int类型,而左边的s的数据类型为
short类型,两个数据能存储的数据的大小不同,这里需要用到"强制类型转换"

强制类型转换的格式:
目标数据类型 变量名 = (目标数据类型)(字面值/表达式);
解答:
s = short(s+1);
2).s+=1;拓展赋值运算符的特点,隐藏了强制类型转换.
结果等价与
s = short(s+1);
+=,-=,*=,/=,%=隐藏了强转类型转换

6.字符串连接运算符

“+”运算符在 java 语言中有两个作用作用一是对数字进行求和运算，作用二就是字符串连接运算.

class Test05 {
public static void main(String[] args) {
int a = 10;
int b = 20;
//加号两边都是 int 类型，执行求和运算
int c = a + b;
System.out.println("a + b = " + c); //a + b = 30;
/*
代码中虽然有两个加号，第一个加号在双引号当中，不起任何作用，只是一个普
通字符串，第二个加号由于左边操作数是一个字符串，所以这个加号一定会进行
字符串连接，连接之后的结果还是一个字符串。
*/

二 控制语句(重点掌握)

1.1程序执行的结构:

三种:
顺序结构:自上而下执行;
选择结构:选择对应的分支;
循环结构:重复某一段语句,直到不符合要求为止;

1.2控制语句的类型:

Java 语言中共有 8 种控制语句，可以分为“选择语句”，’’‘循环语句’，“跳转语句”。那么，这 8 种控制语句分别是什么呢？if 语句、switch 语句、for 循环、while 循环、do…while 循环、break 语句、continue 语句、return 语句。其中 if 和switch 语句属于选择语句，for、while、do…while 语句属于循环语句，break 和 continue 语句属于跳转控制语句.

2.选择结构

选择语句又称为分支语句，它通过对给定的条件进行判断，从而决定执行两个或多个分支中的哪一支。在 Java 语言中选择语句主要提供了两个，一个是 if 语句，另一个则是 switch 语句.

2.1 If语句

//if语句的三种基本格式:
//第一种:
if(条件表达式){
	Java语句;
	}
//第二种
if(条件表达式){
	Java语句;
	}else{
	Java语句;	
	}
//第三种
if(表达式1){
	Java语句;
}else if(表达式2){
	Java语句;
}else if(表达式3){
	Java语句;
}else{
	语句n+1;
}

if语句的执行流程:

第一种:

执行流程:
1)当if表达式为true,则执行语句1;

在这里插入代码片
int a = 1;
	if(a>0){
	System.out.println("明天是大晴天,出门要注意防晒哦!");
	}
}

第二种:

执行流程:
1)先判断表达式是否成立,如果成立,执行执行语句1;
2)如果不成立,则执行语句2;

boolean eatFull = true;
if(eatFull){
System.out.println("吃的好饱啊！");
}else{
System.out.println("还没有吃饱，再来份米饭！");
}

第三种:

执行流程:
1)首先判断表达式1是否成立,如果成立,则执行语句1;
2)如果上面表达式1不成立,继续判断表达式2是否成立,如果成立,执行语句2
3)如果表达式2也不成立,继续判断表达式3是否成立,如果成立,执行语句3
...
...
4)如果上面的条件表达式都不成立,则执行最终语句n+1 ;

//判断学生的成绩:
if(socre>100 || socre<0){
			System.out.println("您输入的数据不合法...") ;
		}else if(socre>=90 && socre <=100){
			System.out.println("该学生成绩优秀...") ;
		}else if(socre >=80 && socre< 90){
			System.out.println("该学生成绩良好...") ;
		}else if(socre>=70 && socre<80){
			System.out.println("该学生成绩较好...") ;
		}else if(socre>=60 && socre<70){
			System.out.println("该学生成绩及格...") ;
		}else{
			System.out.println("不及格") ;
		}

2.2 三目运算符

格式:(条件判断语句)?语句一:语句二;

执行流程：与if语句执行流程相似，先进行条件判断，如果为true，则执行语句一；
如果为false，则执行语句二

//比较两个数中较大的数字
int a = 10;
int b = 20;
int max = 0;
max = (a>b)?a:b;
System.out.println("两个数中最大的数字是"+max);
//比较完之后,得出较大的数字,赋值给max,最后输出得出最大的数字.

3.循环语句(重点掌握)

在问题中有许多具有规律性的重复操作，在程序中就需要重复执行某些语句。一组被重复执行的语句称之为循环体，能否继续重复，取决于循环的终止条件。循环结构是在一定条件下反复执行某段程序的流程结构，被反复执行的程序被称为循环体。

java 中的循环语句共包括三个，分别是：for 循环、while 循环、
do..while 循环

3.1 for循环

for循环的基础结构:
for(初始化表达式;布尔表达式;步进表达式){
		Java语句;(循环体)
}

for循环的执行流程:
初始化表达式最先执行，在整个循环当中初始化表达式只执行一次，布尔表达式
结果是 true 或者 false，true 表示循环可以继续执行，循环体当中的代码就是
需要反复执行的代码，直到布尔表达式的值为false,停止循环.

//最常见的for循环:
for(int i = 1; i <= 10; i++){
System.out.println("i = " + i);
}
//这段代码可以走1~10全部输出

对程序的解释:首先执行 int i = 1，并且只执行一次，定义初始化变量 i，值1，
然后判断 i <= 10 结果为 true，则执行循环体打印 i = 1，循环体结束之后，
执行 i++，然后 i 变成了 2，继续判断 i <= 10 结果为 true，则执行循环体
打印 i = 2，如此循环执行，直到打印 i = 10之后，再执行 i++让i变成了 11，
然后判断 i <= 10 结果为 false，循环结束.

执行结果:

循环结构的练习题:
1)在控制台输出1~10;
2)在控制台输出1~100的和;
3)在控制台输出1~100的偶数和

3.2 while循环

循环语句除了 for 循环之外还有 while 和 do…while

while循环结构的语法结构：
while（布尔表达式）{
	Java语句；（循环体）
}

while语句的执行流程：
判断布尔表达式的结果，如果是 true，则执行循环体，循环体结束之后，再次判断
布尔表达式的结果，如果是 true，再执行循环体，循环体结束之后，再判断布尔表
达式的结果，直到结果为 false 的时候，while 循环结束，如果第一次判断布尔表
达式的值就为false，那么while循环一次都不执行，

//while结构也可以执行n次,
while(true){
System.out.println("死循环");
}
/*如果布尔表达式一直为false,并且布尔表达式的值不会改变,就会一直循环,无法
跳出循环,一直进行循环,就变成了了死循环.
*/

如果进入了死循环,可以使用Ctrl＋c键结束死循环

//while循环的结构很简单;
int i = 0;
while(i < 10){
i++;
System.out.println("i = " + i);
}
//这是一段能够输出1~10的代码

//对1~100的偶数求和
int sum = 0;
int i = 0;
while(i <= 100){
if(i % 2 == 0){
//用来判断进入循环的数字是否为偶数,如果取余为0则可以被2整除,则为偶数,
//反之则不是
sum += i;
}
i++;
}
System.out.println("sum = " + sum);

3.3 do while循环

do…while 循环是 while 循环的变形，它们的区别在于 do…while 循环可以保证循环体执行次数至少为 1 次，也就是说 do…while 循环的循环体执行次数是 1~N 次.

do while的语法结构:
 先执行一次循环体,再判断布尔表达式的值,如果为true,再执行循环体,直到布尔表
 达式的值为false时,跳出循环.

do while 与 while循环的区别:
while循环中,先判断布尔表达式的值,然后再执行,循环语句,所以执行次数是0~n次;
而 do..while 循环最先执行的不是条件判断，它会先执行循环体，然后再进行
条件判断，这样就可以保证循环体至少执行一次

/*
业务背景：在使用的一个系统的时候需要登录，而这个循环当中首先要做的第一件事
儿不是判断用户名和密码是否正确，它的起点是先让用户输入用户名和密码，所以
这个时候我们就需要使用 do..while 循环来完成
*/
java.util.Scanner scanner = new java.util.Scanner(System.in);
String username;
String password;
do{
System.out.print("用户名：");
username = scanner.next();
System.out.print("密码：");
password = scanner.next();
}while(!username.equals("admin") || !password.equals("123"));
System.out.println("登录成功，欢迎" + username + "回来！");

先提示用户输入用户名和密码，然后判断用户名和密码，当用户名不是admin 或者
密码不是 123 的时候继续提示用户输入用户名和密码，直到用户输入的用户名是
admin 并且密码是 123 的时候循环结束，循环结束之后输出登录成功的信息，
只要循环没有结束就表示用户名和密码还是不对.

3.4 控制跳转语句

3.4.1 break

它可以使用在 switch 语句当中，用来终止 switch语句的执行，break 语句重点
是使用在循环语句当中，用来终止/跳出循环

for(int i = 1;i <=10;i++){
	if(i%3==0){
	break;
	}
System.out.println(i);
}

执行结果:

解释:for循环原来的执行结果是输出1~10;加入了if语句和break之后;
首先初始化,i=1;进入if语句,结果为false不执行,输出i;i++;
i++之后,i的结果变为2;进入if语句,结果为为false,不执行,输出i;i++;
i=3的时候,进入if语句,结果为true,执行break;跳出循环
所以输出结果为
1
2

3.4.2 continue

continue 语句则是用来终止当前本次循环，直接进入下一次循环继续执行

for(int i = 1;i <=10;i++){
	if(i%3==0){
	continue;
	}
System.out.println(i);
}

运行结果:

解释:continue的作用是终止本次循环,进入下一次循环,在i能被3整除的时候,
会执行continue,结束本次循环,就不会对i进行输出,所以输出的结果就没有3 6 9