java基础（二）

发表于 | 分类于 | | 本文总阅读量 次
字数统计: 3.5k 字 | 阅读时长 ≈ 15 分钟

本次主要记录的是基本控制语句、数组两块内容

基本控制语句

在java中，控制语句有顺序结构、选择结构、循环结构三类。而顺序结构我们写一般的代码，一行一行的写下去，就像看书一样，有顺序，一行一页。

本次主要记录的是选择结构和循环结构。

选择结构

选择也称为判断，如果…就…，只有满足条件才执行响应的语句块。

if语句

如果第一个if执行，输出大数，如果第二个if执行，输出小数。有多少个if，就进行几次判断。

1
2
3
4
5
6
7
8
9
10
11
int a = (int)(Math.random()*10+1);	
//random()是Math类的静态方法，产生[0,1)之间的随机数，为浮点型
//random()*10，就是产生[0,10)之间的随机数，再加1,产生[1,11)之间的浮点型随机数，最后转为int型

System.out.println(a);
if(a>=5) {	//()里填的条件语句是布尔表达式，为真执行语句
	System.out.println("大数");
}
if(a<5) {
	System.out.println("小数");
}

if-else语句

我们把上面的代码改改，变成if-else语句，变量a只需要判断一次，如果if不执行，那么else执行

1
2
3
4
5
6
7
8
int a = (int)(Math.random()*10+1);	

System.out.println(a);
if(a>=5) {	//()里填的条件语句是布尔表达式，为真才执行语句
	System.out.println("大数");
}else {		//if里不执行，那表达式为假，就跳到else执行
	System.out.println("小数");
}

if-elseif-else语句

如果我们要输出成绩怎么办，优、良、中、及格、不及格，我们用if和if-elseif-else进行对比。

以下为了方便直观，把判断句的语句块都去掉了，但很容易出现问题。所以请记住，一定要打{}。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
int a = (int)(Math.random()*100+1);	
System.out.println(a);
//先用if来操作
if(a < 60) System.out.println("不及格");
if(a>=60 && a < 70) System.out.println("及格");
if(a>=70 && a < 80) System.out.println("中等");
if(a>=80 && a < 90) System.out.println("良好");
if(a >= 90) System.out.println("优秀");
System.out.println("--------------------");


//现在用if-else if-else操作
if(a>=90) System.out.println("优秀");		//如果大于等于90执行这条语句
else if(a>=80) System.out.println("良好");	//否则，大于等于80执行这条语句
else if(a>=70) System.out.println("中等");	//再否则， 大于等于70执行这条语句
else if(a>=60) System.out.println("及格");	//再再否则， 大于等于60执行这条语句
else System.out.println("不及格");		//再再再再否则，终于输出最后一条语句

嵌套的if

我们可以在if里再加判断句。

1
2
3
4
5
6
7
8
if(布尔表达式){
	if(){
		if(){}
		else if(){}
		else {}
	}
	else {}
}

我们用嵌套的if-else来输出成绩

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
if(a>=90) {
	System.out.println("优秀");
}
else {
	if(a>=80) {
	System.out.println("良好");
	}
	else {
		if(a>=70) {
			System.out.println("中等");
		}
		else {
			if(a>=60) {
				System.out.println("及格");
			}
			else {
				System.out.println("不及格");
			}
		}
	}
}

如果把{}都拿掉，是不是很像if-elseif-else类型。

总结一下if条件语句，如果只满足一个条件才执行，那就用if单条语句，如果判断对立面，那就用if-else语句，如果有多判断多选择，就用if-elseif-else。好像说的废话一样。。。怎么方便怎么用就行。

switch语句

此switch非彼switch，不是游戏机，没有任天堂，就是用来判断的，是多选择语句，和if-else if-else类似。但是switch可以很简单用字符串来判断。你也可以在case里嵌套switch，实现嵌套判断。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
String[] game = {"ps4", "xbox", "switch"};	//这是字符串数组，马上讲数组了，而字符串会专门讲，很重要
int i = (int)(Math.random()*3);			//数组从0开始，所以这里随机[0,3)就行

System.out.println(i);

switch(game[i]) {
	case "ps4":
		System.out.println("大家好，我是索尼游戏机");
		break;		//break是停止语句，接下来语句块内的内容不执行，一般在循环语句块用
	case "xbox":
		System.out.println("大家好，我是微软游戏机");
		break;		//如果没有break,当i=0时，会输出全部内容
	case "switch":
		System.out.println("大家好，我是任天堂游戏机");
		break;
	default:		//相当于else,可以把case "switch"去掉，把输出任天堂放到这里
		break;
}

循环语句

只要满足相应的条件，就一直执行下去。

for循环

1
2
3
4
5
6
for(初始值; 循环条件; 循环走向){

}
初始值:循环从开始的地方
循环条件:循环在什么情况下满足条件
循环走向:循环是递增还是递减,等比数列还是等差数列进行取值
1
2
3
4
5
6
7
8
9
10
11
12
for(int i=0; i<=10; i++) {
	//System.out.print(i+' '); 这里把char自动转型为int，空格为32，和i加在一起(i+32),输出3233343536373839404142
	System.out.print(i+" "); 	//这样才打印[0,10] 输出0 1 2 3 4 5 6 7 8 9 10 
}
//原因:char是一个字符，能与int相加转型为int型，而" "是字符串(String)
//" "里有两个值，' '和'\0'组成，int不会与String相加

//但String放到+前，会把之后的内容拼接在一起,下面把循环输出改一改
for(int i=0; i<=10; i++) {
	System.out.print(i+2+" "+i+2+',');	//输出2 02,3 12,4 22,5 32,6 42,7 52,8 62,9 72,10 82,11 92,12 102,
}
//" "前i和2相加，之后把i和2还有','拼接在一起,所以用String类型，要注意放的位置

增强for循环

增强for循环一般只是输出变量的数值。下面打印0~9的数。

1
2
3
4
5
6
int [] a = {0,1,2,3,4,5,6,7,8,9};
//for(Object 临时变量名:要打印的变量名)
//增强for循环不仅可以用于基本的数据类型，还能用于类，类都继承了Object对象
for(int temp:a) {
	System.out.print(temp+" ");
}

while循环

while循环只有循环条件，初始值只能在循环体外定义。

下面输出0到10的数

1
2
3
4
5
int i=0;
while(i<=10) {
	System.out.print(i+" ");
	i++;
}

for和while都是比较常用的循环。

do-while循环

1
2
3
4
5
int i=5;
do {
	System.out.print(i+" ");
	i++;
}while(i<0);

do-while和while有啥区别呢，那就是do-while第一次无论 有没有满足条件，都先执行一次，而while、乃至for都是先要满足条件才执行。而上面的这段代码，5本来就小于0，而do-while会打印了5，才来判断是否满足条件。

嵌套循环

我们用for和while分别打印乘法表。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
for(int i=1; i<=9; i++) {
	for(int j=1; j<=i; j++) {
		System.out.print(j+"*"+i+'='+(i*j)+' ');	//之前说过""之后是字符串拼接，所以(i*j)打了括号，当然不打括号也行，*优先级大于+
	}
	System.out.println();
}
System.out.println("------------------------");

int i=1;
while(i<=9) {
	int j=1;
	while(j<=i) {
		System.out.print(j+"*"+i+'='+(i*j)+' ');
		j++;
	}
	System.out.println();
	i++;
}

当然，如果想输出格式化对齐，最简单的办法就是用C语言的格式输出。

System.out.printf(“%d*%d = %2d “,j,i,i*j);

!、&&、||

当然，它们也是参与布尔表达式的运算，常常在条件语句和循环语句出现，前面也提及过，if()里进行的是布尔表达式，循环里的循环条件也是布尔表达式。我们来一起用用吧。

符号 名称 说明
! 非 肯变否，否变肯
&& 与 全真才真
|| 或 全假才假

条件语句经常和循环语句一起使用，我们来看看下面的例子。

1
2
3
4
5
6
7
//输出1000年到2999年之间有多少闰年
for(int i=1000; i<= 2999; i++) {
	if((i%4==0 && i%100!=0) || i%400==0) {	//里面可以不用加()，!的优先级>&&>>||
		System.out.println(i+"\t");
	}
//闰年一定可以被4整除，而千年是闰年，还能被400整除，可是百年大部分都不是闰年，但它能被100整除
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
int a = 2, b = 3, c = 0;
if(!(c!=0) && a>1) {
	System.out.println("c不是不是0，并且a的值大于1"); //有点拗，c!=0，是false,又加个否定，等价于c==0
}

if(a>2 && (c++)>=0) {	
	System.out.println("有输出吗?");
}
System.out.println("c:"+c);
//看的出来， a>2不成立，没有执行if里的内容，&&后面也没有执行

if((c++)>=0 && a>2) {	
	System.out.println("有输出吗?");
}
//更改一下位置，c++,c变为1，条件成立，但a>2不成立，没有执行if里的内容
System.out.println("c:"+c);

if(a>2 || (c++)>=0) {
	System.out.println("c:"+c);
}
// ||有一个成立就行，所以if里打印了c的值

break和continue

break是强制退出循环，不执行剩余的内容；而continue是跳过本次循环的内容。

下面是嵌套循环，在j==3进行了处理，break每次到j==3时，跳出内循环，进行下一次外循环。而continue是跳过本次内循环，进行下一次内循环。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
for(int i=1; i<5; i++) {
	for(int j=1; j<5; j++) {
		if(j==3) break;
		System.out.print(i+":"+j+'\t');
	}
	System.out.println();
}
System.out.println("------------------------------------------------------");

for(int i=1; i<5; i++) {
	for(int j=1; j<5; j++) {
		if(j==3) continue;
		System.out.print(i+":"+j+'\t');
	}
	System.out.println();
}

在C语言中，有一个语句叫goto，很少用，因为太调皮了。能够从一个语句跳转到另一个语句，用起来很爽，但太乱了，所以java中就只成为保留字，没有任何意义。但是，break和continue却有点像goto，不执行接下来的语句，执行另外的语句，只是限制在了循环里。而它只是不执行内循环接下来的语句，如果我们也不想执行外循环接下来的语句呢？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
a:for(int i=1; i<5; i++) {
	for(int j=1; j<5; j++) {
		if(j==3) break a;
		System.out.print(i+":"+j+'\t');
	}
	System.out.println();
}
System.out.println();
System.out.println("------------------------------------------------------");

a:for(int i=1; i<5; i++) {
	for(int j=1; j<5; j++) {
		if(j==3) continue a;
		System.out.print(i+":"+j+'\t');
	}
	System.out.println();	//这条语句就成了摆设，可以放在第一个循环下面
}

也差不多实现和goto一样的意思，想跳哪就去哪，只是限制在循环里的操作。如果里面的判断再多点，估计也就像goto一样看不懂了，所以我感觉自己玩玩挺好的，真正拿来写代码，那有点得罪人的意思了。

数组

当存在多个相同数据类型的变量，我们用x1,x2,x3,x4…进行数据操作时效率太低，因此才有了数组。数组分为一维数组在，和多维数组，我们最常用的应该就是一维数组在和二维数组。而这个维度，指的只是空间的增多而已。一维只是一行元素，二维在一维的每个元素又拉出来一列，构成一个矩阵。三维也是只在每行每列的每个元素又来出来一纵，构成一个像魔方一样的立体。四维也就只是再在每个元素又拉出一行元素，以此类推。

数组的声明和赋值

好像有三种吧。但好像我一般只用两种。

一维数组

第一种是声明数组类型和长度，然后赋值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//数组声明
int []a = new int [10];		//[0,10)
//int a[] = new int [10]; //这种也可以，C/C++的规范
//数组赋值，数字下标从0开始计算
a[0] = 0;
a[1] = 1;
a[2] = 2;
//也可以循环赋值
for(int i=3; i<10; i++) {
	a[i] = i;
}
System.out.println(Arrays.toString(a));		//一定要引入 import java.util.Arrays;

//打印出[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

第二种是声明数组类型写内容

1
2
3
int []a = new int[] {0,1,2,3,4,5,6,7,8,9};
System.out.println(Arrays.toString(a));		//一定要引入 import java.util.Arrays;
//打印内容和上面一样

第三种是直接写内容

1
2
3
4
5
int []a ={0,1,2,3,4,5,6,7,8,9};
for(int i=0; i<a.length; i++) {	//也可以用循环打印结果，length是获取数组的长度
	System.out.print(a[i]+" ");
}
//输出 0 1 2 3 4 5 6 7 8 9

二维数组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
int [][]a = new int [3][]; //告诉编译器二维数组有三行，每行多少个就看你自己写的
//int [][]a = new int [3][4]; //也可以直接写死，有三行，有四列
a[0] = new int[3];
a[0][0] = 0;
a[0][1] = 1;
a[0][2] = 2;
a[1] = new int[] {0,1,2,3,4};
//a[2] = {0,1}是不行的，否则就是一维数组，但我们声明的是二维
a[2] = new int[] {0,1};
for(int i=0; i<a.length; i++) {
	for(int j=0; j<a[i].length; j++) {
		System.out.print(a[i][j]+" ");
	}
	System.out.println();
}

1
int [][]a = new int[][] {{0,1,2},{0,1,2,3,4},{0,1}};

二维数组也可以像一维数组一样声明和使用，但它列可以是不固定的，有多长看自己的喜爱。但我一般喜欢用固定，方便两层for循环输入数据。

1
2
3
4
5
6
7
8
int [][]a = new int[3][4];
for(int i=0; i<a.length; i++) {
	for(int j=0; j<a[i].length; j++) {
		a[i][j] = i*j+i+j;
	}	
}
System.out.println(Arrays.deepToString(a));	//声明 import java.util.Arrays;
//输出 [[0, 1, 2, 3], [1, 3, 5, 7], [2, 5, 8, 11]]

数组还有多维数组，当然，可不要搞迷糊了。这次就到这里啦。

谢谢您对我的支持
0%