Java中的常用语法

Java中的常用语法

一、选择结构

1、if选择结构:

​ if选择结构是根据条件判断之后再做处理的一种语法结构。基本的if选择结构的语法如下：

if(条件){
     代码块	//条件成立后要执行的代码，可以是一条语句，也						可以是一组语句
}

​ 注意：关键字if后小括号里的条件是一个表达式，而且表达式的值必须为true或false。
​ 流程图：逐步解决指定问题的步骤和方法的一种图形化表示方法。

​ 流程图直观、清晰地帮助我们分析问题或设计解决法案，是程序开发人员的好帮手。流程图使用一组预定义的符号来说明如何执行特定的任务。

图形	意义	图形	意义
[外链图片转存失败(img-tqjHBQJM-1567222700793)(file:///C:\Users\ASUS\AppData\Local\Temp\ksohtml10204\wps1.png)]	程序开始或结束	[外链图片转存失败(img-4mdnvVIf-1567222700803)(file:///C:\Users\ASUS\AppData\Local\Temp\ksohtml10204\wps2.png)]	判断和分支
[外链图片转存失败(img-KA9vlZsh-1567222700807)(file:///C:\Users\ASUS\AppData\Local\Temp\ksohtml10204\wps3.png)]	计算步骤/处理符号	[外链图片转存失败(img-L1I7X0Xj-1567222700809)(file:///C:\Users\ASUS\AppData\Local\Temp\ksohtml10204\wps4.png)][外链图片转存失败(img-0q0aOPSU-1567222700812)(file:///C:\Users\ASUS\AppData\Local\Temp\ksohtml10204\wps5.png)][外链图片转存失败(img-CZ0kosjJ-1567222700814)(file:///C:\Users\ASUS\AppData\Local\Temp\ksohtml10204\wps6.png)][外链图片转存失败(img-Czfj5o60-1567222700816)(file:///C:\Users\ASUS\AppData\Local\Temp\ksohtml10204\wps7.png)]	连接符
[外链图片转存失败(img-r4qxFgBr-1567222700819)(file:///C:\Users\ASUS\AppData\Local\Temp\ksohtml10204\wps8.png)]	输入/输出指令	[外链图片转存失败(img-NUMnJAkh-1567222700820)(file:///C:\Users\ASUS\AppData\Local\Temp\ksohtml10204\wps9.png)][外链图片转存失败(img-Hev2954N-1567222700822)(file:///C:\Users\ASUS\AppData\Local\Temp\ksohtml10204\wps10.png)]	流程线

​ Java中可以使用逻辑运算符连接多个条件。常用的逻辑运算符如下：

运算符	汉语名称	表达式	说明
&&	与、并且	条件1&&条件2	两个条件同时为真，则结果为真；两个条件有一个假，则结果为假
||	或、或者	条件1||条件2	两个条件有一个为真，则结果为真；两个条件同时为假，则结果为假
！	非	！条件	条件为真时，结果为假；条件为假时，结果为真

三目运算符：

(条件) ? (true 输出语句) : (false 输出语句)

2、if—else选择结构

​ if—else结构，表示“如果···，就···；否则，就···”。语法结构如下：

if(条件){
	//代码块1
}else{
	//代码块2
}

​ 需要掌握的if选择如下：基本的if选择结构，只有一个if块；if—else选择结构，有if块和else块。

3、多重if选择结构

​ 在java中还有一种if选择结构的形式：多重if结构。多重if选择结构在解决需要判断的条件是连续的区间时有很大的优势。

​ 多重if结构不是多个基本if结构简单的排列在一起的，语法如下：

if(条件1){
	//代码块1
}else if{
	//代码块2
}else{
	//代码块3
}

​ 注意事项：else块最多有一个或没有，else块必须要放在else if块之后。如果多重if选择结构中的所有条件之间只是简单的互斥，不存在连续的关系，则条件没有顺序要求。

4、嵌套if选择结构

​ 嵌套if选择结构就是在if选择结构里面在嵌入if选择结构，语法如下：

if(条件1){
	if(条件2){
		//代码块1
	}else{
		//代码块2
	}
}else{
		//代码块3
}

if结构书写规范如下：

（1）为了使if结构更加清晰，应该把每个if或else包含的代码块用大括号括起来。

（2）相匹配的一对if和else应该左对齐。

（3）内层的if结构相对于外层的if结构要有一定的缩进。

5、switch选择结构

1、什么是switch选择结构

​ switch选择结构可以更好地解决等值判断问题。

​ switch的语法如下：

switch(表达式){
	case 常量1:
		//代码块1;
		break;
	case 常量2:
		//代码块2;
		break;
	default:
		//代码块n;
		break;
}

​ switch选择结构用到了四个关键字：

​ （1）switch：表示“开关”，这个开关就是switch关键字后面小括号里表达式的

​ 值，JDK1.7后，switch语句小括号里可以是int、short、byte、char、枚举 类型、String类型表达式。

​ （2）case：表示“情况、情形”，case后可以是int、short、byte、char、枚举 、String类型，通常是一个固定的值。case块可以有多个，顺序可以改变，但是每个case后常量的值必须各不相同。

​ （3）default：表示“默认”，即其他情况都不满足。default后要紧跟冒号。default块和case块的先后顺序可以变动，不会影响程序执行的结果。通常，default块放在末尾，也可以省略。

​ （4）break：表示“停止”，即跳出当前结构。

switch选择结构的执行过程：

​ 先计算并获得switch后面小括号里的表达式或变量的值，然后将计算结果顺序与每个case后的常量比较，当二者相等时，执行这个case块中的代码；当遇到break时，就跳出switch选择结构，执行switch选择结构之后的代码。如果没有任何一个case后的常量与switch后的小括号中的值相等，则执行switch末尾部分的default块中的代码。

（2）如何使用switch选择结构

switch选择结构的条件只能是等值的判断，而且只能是整型或字符型的等值判断。也就是说，switch选择结构只能用于判断一个整型变量或表达式是否等于某个整数值的情况，或者一个字符型变量或表达式是否等于某个字符的情况，并且每一个case后面的常量值都不同。而多重if选择结构既可以用于判断条件是等值的情况，也可以用于判断条件是区间的情况。

在case后面的代码块中，break语句是可以省略的，还可以让多个执行同一语句。

Java中的switch选择结构：

​ 当需要多重分支并且条件判断是等值判断的情况下，使用switch选择结构代替多重if选择结构会更简单，代码结构更清晰易读。

二、循环结构

1、循环结构的特点

​ 循环结构不是无休止进行的，满足一定条件的时候循环才会继续，称为“循环条件”，循环条件不满足的时候，循环退出；其次，循环结构是反复进行相同的或类似的一系列操作，称为“循环操作”。

2、while循环结构

1、while循环结构的语法、流程图如下：

while(循环条件){
	//循环操作
}

​ whlie后小括号中的内容是循环条件。循环条件是一个表达式，它的值为boolean类型，即true或false，如i<=100。{ }中的语句统称为循环操作，又称为循环体。

2、while循环的执行顺序：

（1）声明并初始化循环变量。

（2）判断循环条件是否满足，如果满足则执行循环操作；否则退出循环。

（3）执行完循环操作后，再次判断循环条件，决定继续执行循环或退出循环。

3、用while循环结构解决问题的步骤如下：

（1）分析循环条件和循环操作。

（2）套用while语法写出代码。

（3）检查循环能否退出。

4、常见的错误

（1）没有为循环变量赋初值

（2）缺少{ }

3、do-while循环结构

1、do-while循环的语法：

do{
	//循环操作
}while(循环条件);

2、do-while循环的执行顺序：

（1）声明并初始化循环变量。

（2）执行一遍循环操作。

（3）判断循环条件，如果循环条件满足，则循环继续执行，否则退出循环。

3、do-while循环解决问题的步骤：

（1）分析循环条件和循环操作；

（2）套用do-while语法写出代码；

（3）检查循环能否退出。

4、for循环

1、for循环的语法：

for(表达式1;表达式2;表达式3){
	//循环体
}

循环结构的四部分：

（1）初始部分；（2）循环体；（3）迭代部分；（4）循环部分

2、每个表达式的含义：

表达式	形式	功能	举例
表达式1	赋值语句	循环结构的初始部分，为循环变量赋初值	int i=0
表达式2	条件语句	循环结构的循环条件	I<100
表达式3	赋值语句，通常使用++或–运算符	循环结构的迭代部分，通常用来修改循环变量的值	i++

for关键字后面括号中的三个表达式必须用“ ; ”隔开。for循环中的这三个部分及{ }中的循环体使循环结构必需的四个组成部分完美地结合在了一起，非常简明。

3、for循环结构的执行顺序：

（1）执行初始部分（int i=0;）

（2）进行循环条件判断（i<100;）

（3）根据循环条件判断结果。如果为true，则执行循环体；如果为false，则退出循环，步骤（4）和步骤（5）均不执行

（4）执行迭代部分，改变循环变量值（i++）

（5）依次重复步骤（2）~步骤（4），直到退出for循环结构

for循环结构中有三个表达式，在语法上，这三个表达式都可以省略，但表达式后面的分号不能省略：

省略“表达式1”，即不判断循环条件，循环将无终止运行，也就形成了“死循环”，如下面的for语句：

for(int i = 0; ; i++);

省略“表达式3”，即不改变循环变量的值，也会出现“死循环”，如下面的语句：

for（int i = 0; i < 10；）；

5、二重循环

二重循环就是一个循环体内又包含另一个完整的循环结构。

while循环、do-while循环和for循环。这三种循环之间是可以互相嵌套的一个循环要完整地包含在另一个循环中，下面四种形式是合法的：

//while与while的嵌套：
while(循环条件1){
	//循环操作1
	while(循环条件2){
		//循环操作2;
	}
}

//do-while与do-while循环嵌套
do{
	//循环操作1
	do{
		//循环操作2
	}while(循环条件2);
}while(循环条件1);

//for与for循环嵌套
for(循环条件1){
	//循环操作1
	for(循环条件2){
		//循环操作2
	}
}

//while与for循环嵌套
while(循环条件1){
	//循环操作1
	for(循环条件2){
		//循环操作2
	}
}

四种形式中，循环条件1和循环操作1对应的循环称为外层循环，循环条件2和循环操作2对应的循环称为内层循环，内层循环结束后才执行外层循环的语句。在二重循环中，外层循环变量变化一次，内层循环变量要从初始值到结束值变量一遍。

二重循环中continue和break语句的对比

当continue和break语句用在内层循环时，只会影响内层循环的执行，对外层循环没有影响，它们的不同点在于执行该语句后，程序跳转的位置不同。

三、数组

1.数组概述

数组就是一个变量,用于将相同数据类型的数据存储在内存中,数组的每一个数据元素都属于同一数据类型.

2、数组的四要素:

(一)标识符:首先,和变量一样,在计算机中,数组也有一个名称,称为标识符,用于区分不同的数组

(二)数组元素:当给出了数组名称,即数组标识符后,要向数组中存放数据,这些数据就称为数组元素

(三)数组下标:在数组中,为了正确地得到数组的元素,需要对它们进行编号,这样计算机才能根据编号去存取,这个编号就称为数组下标

(四)元素类型:存储在数组中的数组元素应该是同一数据类型,如可以把学员的成绩存储在同一数据中,而每一个学员的成绩可以用整形变量来存储,因此称它的元素数据类型为整型

1.语法

$$数据类型[]数组名=new数据类型[数组长度];$$

3、如何使用数组

1.声明数组

在java中,声明一维数组的语法如下.

语法:

​
$$数据类型[]数组名;或数据类型数组名[];$$
以上两种方式都可以声明一个数组,数组可以是任意合法的变量名.

声明数组就是告诉计算机该数组中的数据类型是什么.例如:

int[] scores;					//存储类型为int
double height[];				//存储类型为double
String[] names;					//存储类型为String

2.分配空间

为了给数组元素分配内存空间,此时还不能使用数组.因此要为数组分配内存空间,这样数组的每一个元素才能对应

一个存储单元.

简单地说,分配空间就是要告诉计算机在内存中分配一些连续的空间来存储数据.在java中可以使用new关键字来给

数组分配空间.
$$数据名=new数据类型[数组长度];$$
其中,数组长度就是能存放的元素个数,显然要大于0的整数.例如:

scores =new int[30];			//长度为30的int类型数组
height =new double[30];			//长度为30的double类型数组
names=new String				//长度为30的String类型数组

也可以将上面两个步骤合并,即在声明数组的同时给它分配空间,语法如下.

语法:
$$数据类型[]数组名=new数据类型[数组长度];$$
例如:

int scores[]=new 数据类型[30];		//存储30个学员的成绩

一旦声明了数组的大小就不能再修改,即数组的长度是固定的.如,上面名称为scores的数组长度是30,假如发现有31个学员成绩需要存储,想把数组长度改为31,则不可以,只能重新声明.

3.赋值

分配空间后就可以向数组里放数据了.数组中的每一个元素都是通过下标来访问的,

语法:

数组名[下标值];
scores[0] =89;
scores[1] =60;
scores[2] =70;
...........

数组的下标是规律变化的,即从0开始的顺序递增,所以考虑用循环变量表示数组下标,从而利用循环给数组赋值.

Scanner input=new Scanner(System.in);
for (int=0; i<30 ;i++){
	score[i]=input.nextInt();	//从控制台接受键盘输入进行循环赋值
}

4.运用

最后我们就可以使用这个数组了,运用循环大大简化了代码

简便语法:
$$数据类型[]数组名=值1,值2,值3,.....值n;$$
在循环中，循环变量i从0开始递增直到数组的最大长度score.length。因此每次循环i加1实现数组的每个元素和的累加

元素的初始值，如下：

数据类型	初始值
int	0
double	0.0
char	‘\u0000’
boolean	false

注意：数组下标从0开始，而不是从1开始。如果访问数组元素时指定的下标小于0，或者大于等于数组的长度，都将出现数组下标越界异常。

4、数组应用

1.数组排序

语法:
$$Arrays.sort(数组名);$$
Arrays是java提供的一个类,而sort()是该类的一个方法.套用这个sort()方法在java排序中可以自动排序起来而不再需要用if选择结构去比较大小了,但使用Arrays.sort(数组名);方法时需要导报:
$$importjava.util.Scanner;$$

import java.util.Arrays;
import java.util.Scanner;

public class Y2 {
	public static void main(String[] args) {
		int [] scores=new int[5];
		Scanner input=new Scanner(System.in);
		System.out.println("请输入五位学员的成绩");
		for (int i = 0; i < scores.length; i++) {
			scores [i]=input.nextInt();
			
		}
		Arrays.sort(scores);
		System.out.println("学员成绩升序排列");
		for (int i = 0; i < scores.length; i++) {
			System.out.print(scores[i]+" ");
			
		}
	}

}

在这种数据代码中,成绩数组scores排序,只需要把数组名scores放在sort()方法的括号中,该方法执行后,利用循环输出数组中的成绩,可以看出数组中的成绩已经按升序排序.

2.求数值的最大值及最小值

在解决这个问题之前,我们首先来设想一场“比武打擂”的场景，首先假定第一个上擂台的是擂住，然后下一个竞争选手与他比武。如果他胜利了，他仍然是擂主，继续跟后面的竞争对手比武。如果他失败了，则他的竞争对手便在擂台上。作为目前的擂主，他会继续与后面的选手比武。以此类推，最后胜利的那个便是本次比武的冠军。那么，类似于比武，求最高分就是找出这次考试的擂主。根据上面的描述，可以用代码表示如下：

......
max =scores [0];
if(a[1] > max)
    max = scores [2];
if(a[2] > max)
    max = scores [2];
if(a[3] > max)
    max = scores [3];
......

最终变量max中存储的就是本次考试的最高分.这样写代码就很繁琐了,我们观察可知,这是一个循环的过程,max变量依次与数组中的元素进行比较.如果,max小于比较的元素,则执行置换操作.如果max较大,则不执行操作.因此,采用循环的方式来写代码就会大大简化代码量,提高程序效率, 如以下示例:

public class Sili {
	public static void main(String[] args) {
		int scores[]=new int[5];
		Scanner input=new Scanner(System.in);
		System.out.println("请输入学习成绩");
		for (int  i= 0;  i< scores.length; i++) {
			scores[i]=input.nextInt();
		}
		int max=0;
		max=scores[0];
		for (int i = 1; i < scores.length; i++) {
			if(scores[i]>max) {
				max=scores[i];
			}
		}
	System.out.println("考试成绩最高分为:"+max);
	}
}

其中添加的主要语法为:

max=scores[0];
		for (int i = 1; i < scores.length; i++) {
			if(scores[i]>max) {
				max=scores[i];
			}
		}

3.如何向数组中插入元素

问题:

假设:有一组学员的成绩是{99,85,82,63,60},将它们按降序排列,保存在一个数组中.现需要增加一个学员的成绩,将它插入数组,并保持成成绩降序排列.

分析:

我们可以先将五个学员的成绩保持在长度为6的整型数组中.然后,要找到新增的插入位置.为了保持数组中的成绩有序,需要从数组的第一个元素开始与新增的成绩进行比较,直到找到要插入的位置,可以使用循环进行比较.找到插入位置后,将该位置后的元素后移一个位置,最后将新增的成绩信息插入该位置即可.

解决方案,如下代码:

public class Fangan{ 
	public static void main(String[] args) {
		int [] list =new int[6] ;
		list[0]=99;
		list[1]=85;
		list[2]=82;
		list[3]=63;
		list[4]=60  ;
		int index =list.length;//插入的位置
		System.out.println("请输入新增成绩:");
		Scanner input =new Scanner(System.in);
		int num=input.nextInt();
		for (int i = 0; i < list.length; i++) {
			if(num>list[i]) {
				index=i;
				break;
			}
		}
		for (int j =list.length-1;j>index; j--) {
			list[j]=list[j-1];
		}
		list[index]=num;
		System.out.println("插入成绩的下标是:"+index);
		System.out.println("插入后的成绩信息是");
		for (int k = 0; k < list.length; k++) {
			System.out.print(list[k]+"\t");
		}
	}

}

从运行结果可以看出,插入成绩80后,成绩依然按降序排列.

在数组中,数组经常与选择结构,循环结构搭配来使用，利用Array类提供的sort（）方法可以方便地对数组中的元素进行排序。