java的常用语法

java中的常用语法

一.选择结构(1)

1.if 选择结构

为什么要使用选择结构1:

在生活中我们经常需要做判断,然后才能够决定是否做某件事,而if选择结构是根据条件判断在做处理的一种语法结构.

语法:

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

示例代码:

public class Sl1 {
	public static void main (String [] args) {
		Scanner in = new Scanner (System.in);
		System.out.println("请输入java成绩");
		int a =in.nextInt();
		if (a>80) {
			System.out.println("奖励一个MP4");
		}
	}
} 

可以根据条件判断而输出条件成立后的输出语句,满足于具有选择性要求的代码块
流程图:

2.if—else结构

语法：

if（条件）{
	//代码块1
}else {
	//代码块2
}

示例代码:

public class Sl2 {
	public static void main (String [] args) {
		Scanner in = new Scanner (System.in);
		System.out.println("请输入java成绩");
		int a =in.nextInt();
		if (a>80) {
			System.out.println("奖励一个MP4");
		}else {
			System.out.println("写代码");
		}
		
	}

}

if–else选择结构:可以处理简单的条件分支,这种形式简单,但在实际中使用非常频繁
流程图:

3.多重if选择结构

语法:

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

示例:

public class Sj3 {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		System.out.println("请输入消费金额：");
		int money = in.nextInt();
		System.out.println("是否参加优惠换购活动？（0~5）");
		if(money<50) {
			System.out.println("抱歉，您的消费金额不满足活动要求");
		} else if(money>=50 && money<100){
			int choose = in.nextInt();
			System.out.println("谢谢合作");
		} else if(money>=100 && money<200) {
			int choose = in.nextInt();
			System.out.println("抱歉，您的消费金额不满足活动要求");
		} else {
			int choose = in.nextInt();
			System.out.println("欢迎使用");
		}
	}
}

多重if选择结构:可以处理复杂的条件分支情况.多重if选择结构在解决需要判断的条件是连续的区间时有很大的优势
流程图:

4.嵌套if选择结构

语法:

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

嵌套if选择结构:在if选择结构中又包含了一个或多个if选择结构的情况,这种结构一般较为复杂的流程控制中.

嵌套if的形式有很多种,上面的语法是最常见的一种

5.随机数公式

语法

int random=(int ) (Math.random()*10);

6.符号汇总

7.常用逻辑运算符

运算符	汉语名称	表达式	说明	举例
&&	与,并且	条件1&&条件2	两个条件同时为真,则结果为真,两个条件有一个为假,则为假	具有选举的条件
||	或,或者	条件1||条件2	两个条件有一个为真,则结果为假,两个同时为假则,则结果为假	从中国去美国的方式:乘飞机与乘船,满足一个即可
!	非	!条件	条件为真时,结果为假,条件为假时,结果为真	成为优秀软件工程师的条件为

一.选择结构(2)

switch选择结构

.1为什么使用switch选择结构

问题1:

韩阳参加计算机编程比赛:

如获得第一名,将参加麻省理工大学组织的一个月夏令营;

如获得第二名,将奖励惠普笔记本电脑一个;

如获得第三名,将奖励移动硬盘一个;

否则,没有奖励;

如果使用多重if选择结构来解决,可以但会很麻烦,如以下代码:

public class D5 {
	public static void main (String []args) {
		Scanner in = new Scanner(System.in);
		System.out.println("请输入三个数字");
		double a = in.nextDouble();
		double b = in.nextDouble();
		double c = in.nextDouble();
		double s ;
		if (a>b) {
		s=a;
		a=b;
		b=s;
		}
		if (a>c) {
		s=c;
		c=a;
		a=s;
		}
		if (b>c) {
		s=b;
		b=c;
		c=s;
		}
		System.out.println(+a+""+b+""+c);
		//System.out.println(a);
		//System.out.println(b);
		//System.out.println(c);
	}
	
}

可以而如果使用switch选择结构就可以简化代码格式,

.2使用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：表示“停止”，即跳出当前结构。

.3switch选择结构的执行过程：

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

.4如何使用switch选择结构

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

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

.5三目运算符:

$$(条件)?(true):(false)$$

二、循环结构(1)

1、循环结构的特点

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

2、while循环结构

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

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

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）检查循环能否退出。
流程图:

二,循环结构(2)

.1for循环

for循环的语法：

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

循环结构的四部分：

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

.2每个表达式的含义：

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

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

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

（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；）；

.4二重循环

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

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.数组概述

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

1.1数组的四要素:

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

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

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

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

1.2语法

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

2.如何使用数组

2.1声明数组

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

语法:

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

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

int[] scores;					//存储学员的成绩,类型为int
double height[];				//存储学员的身高,类型为double
String[] names;					//存储学员的姓名,类型为String

2.2分配空间

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

一个存储单元.

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

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

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

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

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

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

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

2.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();	//从控制台接受键盘输入进行循环赋值
}

2.4运用

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

简便语法:
$$数据类型[]数组名=值1,值2,值3,.....值n;$$

3.数组应用

3.1数组排序

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

$$importjava.util.Scanner;$$

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

public class Yx2 {
	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()方法的括号中,该方法执行后,利用循环输出数组中的成绩,可以看出数组中的成绩已经按升序排序.

3.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.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后,成绩依然按降序排列.

在数组中,数组经常与选择结构,循环结构搭配来使用