Java编程基础
作者：互联网
选择结构语句
1.if语句
if语句也称为条件语句，也就是说它需要对一些条件进行判断，从而决定执行哪一段语 句。
（1）单分支if语句
单分支 if语句就是对某种条件进行判断，通常表现为: “如果满足某一条件，就执行相 应的语句，不满足条件则不执行”。
if(表达式){
语句序列
}
（2）双分支if...else语句
if...else语句是条件语句的一种最通用形式，通常表现为: “如果满足某一条件，就执行 相应的语句，不满足条件则执行另一条语句”。
if(表达式){
语句序列 １
}else{
语句序列 ２
}
（3）多分支if...else if...else语句
if...else if...else语句用于对多个条件进行判断，进而进行多种不同的处理，通常表现 为: “如果满足某一条件，就执行相应的语句，否则满足另一条件才执行另一种处理，如果 前面的条件都不满足，则执行 else后面的语句”。
if(表达式 １){
语句序列1
}else if(表达式 ２){
语句序列2
}
......
}else if(表达式 ｎ){
语句序列n
}else{
语句序列n+1
}
2.switch多分支语句
switch语句是多分支的开关语句，和if语句不同它只能根据表达式的值来确定执行哪 一条语句。
switch(表达式){
case常量表达式1:语句序列1
[break;]
case常量表达式2:语句序列2
[break;]
........
case常量表达式n:语句序列n
[break;]
default:语句序列n+1
[break;]
}
其中,表达式的值必须是整数型或字符型,switch 语句将表达式的值与 case中的常量值 进行匹配,如果匹配则执行其后面的语句,如果不匹配则不执行其后面的语句,如果所有case 后的常量值都不匹配,则执行default后面的语句,break语句用于跳转语句,一旦执 行,则不再判断后续的case, 直接跳出switch 结构。
循环结构语句
1.while语句
while 循环语句是根据条件来判断是否反复执行某段代码。
while(表达式){
语句序列
}
其中的表达式就是需要进行判断的条件，它的 值必须是布尔值，即true 或false。 如果表达式的值 为真，则执行语句序列，语句序列执行完毕后，程 序会接着继续判断表达式的值是否为true如果为true 则继续执行语句序列，直到表达式的结果为false， 则结束while 循环。
2.do...while语句
do...while循环语句与while 循环语句的区别在于: do...while 循环语句是先无条件地执 行一次语句，再根据条件来判断是否反复执行刚才已经执行过一次的语句。
do{
语句序列
}while表达式);
其中的表达式就是需要进行判断的条件，它的值必须是布尔值， 即true 或false,如果表 达式的值为真, 则执行语句序列,语句序列执行完毕后,程序会接着继续判断表达式的值是 否为 true, 如果为true 则继续执行语句序列,直到表达式的结果为false ,则结束do...while 循环。
3.for循环语句
for 循环语句是最常用的循环语句，一般用在循环次数已知的情况下。
for(①初始化表达式;②循环条件;③操作表达式){
④语句序列
}
①初始化表达式: 初始化循环体变量。
②循环条件: 用于判断是否继续执行循环体，其值只能是布尔型。
③操作表达式: 用于改变循环条件的语句。
④语句序列: 该语句也叫作循环体语句，当循环条件为 true时，反复执行。
for循环语句的执行过程如下：
第一步，执行①初始化表达式。
第二步，执行②循环条件，当其结果为true时，执行第三步，当结果为false 时，执行 第五步。
第三步，执行④语句序列。
第四步，执行③操作表达式，然后重复执行第二步。
第五步，退出循环。
循环的嵌套
循环的嵌套就是在一个循环语句的循环体中再包含其他循环结构，在 while、do...while、for语句中都可以进行嵌套，并且它们之间也可以互相嵌套，虽然循环嵌套较为复杂，但是 在实际程序开发中，最常用的就是for循环的嵌套。
for(;;){
for(;;){
语句序列
}
}
跳转语句
跳转语句用于实现程序流程的跳转，Java语言支持break跳转语句和continue跳转语句。
1.break跳转语句
break跳转语句用在switch条件语句和循环语句中，当它出现在switch 条件语句中时，它的作用是终止某个case 并跳出整个switch结构，当它出现在循环语句中时，它的作用是 跳出整个循环结构，终止循环。
public class Example12{
public static void main(String[] args){
int x=1;
while(x<=5){
System.out.println("x="+x);
if(x==３){
break; //当 x的值为3时,循环结束
}
x++;
}
}
}
2.continue跳转语句
pubic class Example13 {
pubic static void main(String[] args) {
int sum=0; //定义变量 sum,用于存储累加和的结果
for(int ｉ=1;ｉ<=50;ｉ++) {
if(ｉ%2!=0) { //如果 i是一个奇数,不累加
continue; //结束本次循环
}
sum+=i; // 实现sum和i的累加
}
System.out.println("sum＝"+sum);
}
}
什么是数组
1.数组的定义
数组是指一组数据的集合，数组中的每个数据被称为元素，通过数组可以保存一组相同 数据类型的数据，数组的类型可以是基本数据类型，也可以是引用数据类型(暂不讨论)。可 以是一维数组，也可以是多维数组。
（1）声明数组
数组类型[] 数组标识符; 数组类型 数组标识符[];
例如，声明一个int 型一维数组变量x, 具体代码如下:
int[ ] x; int x[ ];
（2）创建数组
int[ ] x; //声明一个int[ ]类型的变量 x=new int[10]; // 创建一个长度为10的数组,并将数组的地址赋给 x
同时，也可以将数组的声明和创建用一行代码代替：
int[ ] x=new int[10];
上述语句就相当于在内存中定义了 10 个整型变量, 第 １ 个变量的名称为 x[０]、 第 ２ 个 变量的名称为 ｘ[１]......第 １０ 个变量的名称为 ｘ[９], 此时,这些变量的初始值由系统自动 提供,都是 ０。
（3）初始化数组
数组的初始化分为动态初始化和静态初始化，在定义数组时，只声明创建数组， 数组中 的元素值由系统提供初值的方式称为动态初始化，而在定义数组的同时为数组的每个元素赋 值的方式叫作静态初始化。
数组类型[] 数组标识符=new 类型[ ]{元素,元素,......};
数组类型[] 数组标识符＝ {元素,元素,......};
数组的常见操作
1.遍历数组
所谓数组的遍历就是指依次访问数组中的每个元素。一般使用for循环来遍历数组。
public class Example15{
public statics void main(String[] args){
int[] x＝{2,4,6,8,10}; // 定义数组
//for使用循环遍历数组的元素
for(int i=0;i<x.length;i++) {
System.out.println(x[i]); // 通过索引访问元素
}
}
}
2.最值获取
在操作数组时，经常会遇到获取数组中的最值，接下来通过一个案例来演示如何获取数 组中元素的最大值及最小值。
public class Example16{
public static void main (String[] args){
int[]x ＝ {8,16,3,32,99,28}; //定义一个数组
int max = x[0]; //定义变量max用于记住最大数,假设第一个元素为最大值
int min= x[0]; //定义变量min用于记住最小数,假设第一个元素为最小值 //下面通过一个for循环遍历数组中的元素
for (int i = 1; i < x. length; i++){
if (x[i] > max){ //比较x[i]的值是否大于max
max = x[i]; //条件成立,将x[i]的值赋给max
}
}
//下面再次通过一个for循环遍历数组中的元素
for (int i = 1; i < x. length; i++){
if (x[i] < min){ //比较x[i]的值是否小于min
min = x[i]; //条件成立,将x[i]的值赋给min
}
}
System. out. println(" max=" + max); // 打印最大值 System.
out. println (" min=" + min); // 打印最小值
}
}
3.数组排序
在操作数组时，还经常需要对数组中的元素进行排序，而对数组进行排序的方法很多，以下介绍一种比较常见的排序方法———冒泡排序法。冒泡排序的原理如下：
第一步: 从第一个元素开始，依次将相邻的两个元素进行比较，将较大值(或较小值) 存放到后一个元素中，整个过程完成后，数组中的最后一个元素就是最大值(或最小值)。
第二步: 除了最后一个元素外，将剩余的元素继续进行两两比较，过程同第一步，这样 就可以保证数组中倒数第二个元素是最大值(或最小值)。
第三步: 以此类推， 继续对越来越少的元素重复上面的步骤，直到没有任何一对元素需 要比较为止。
按照上述原理， 通过一个案例来实现冒泡法对数组的排序。
public class Example17{
public static void main (String[ ] args) {
int[ ] x = { 8, 16, 3, 32, 99, 28 } ;
System. out. print("冒泡排序前: \n");
for (int i = 0; i< x.length; i++) {
System. out. print(x[i]+"\t"); //通过索引访问元素
}
//通过for循环的嵌套来实现冒泡排序
//定义外层循环
for (int i = 0; i < x.length - 1; i++){
//定义内层循环
for (int j = 0; j < x. length - i - 1; j++){
if (x[j] > x[j + 1]){ //比较相邻元素
//下面的三行代码用于交换两个元素
int temp = x[j];
x[j] = x[j + 1];
x[j + 1] = temp;
}
}
}
System. out. print(" In I2排序: In" ) ;
for (int i = 0; i < x. length; i++) |
System. out. print(x[i]+"\t"); //通过索引访问元素
}
}
}
程序运行结果
二维数组的使用
二维数组的定义方式有多种，第一种方式：
int[ ][ ] ａ=new int[２][３];
第二种方式：
int[ ][ ] ａ = {{1,2},{3,4,5}};
实现学生成绩管理系统
１.任务描述
录入班级学生的各科成绩，计算每名学生的总分、平均分，并按总分降序排序。
２. 任务目标
(１)学会分析“学生成绩管理系统”子任务实现的逻辑思路。
(２)能够独立完成“学生成绩管理系统”程序的源代码编写、 编译及运行。
(３)能够在程序中使用循环进行相关操作ꎮ。
(４)掌握数组的使用。
３. 实现思路
(１)需定义存储学生姓名的数组、 存储课程名称的数组、 各科成绩的二维数组、 存储总 分的数组、 存储平均分的数组、 存储学生信息的数组。(拼接学生姓名、 各科成绩、 总分、 平均分)
(２)键盘输入学生的信息，将输入的值赋值给数组各个元素，需要使用Scanner 类,以 下代码能够从键盘输入中读取相关数据。
Scanner sc＝new Scanner(System.in); 某变量=sc.nextInt(); // 该变量可以接受键盘输入的整型数据 某变量=sc.next(); //该变量可以接收键盘输入的字符串类型的数据
(３)对学生信息排序(根据总分排序)。
(４)循环打印排序后的学生信息。
4.实现代码
import java. util. Scanner;
public class Student{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System. out. println("输入学生人数");
int stuNum = sc. nextInt(); //接收键盘输入的整型数据
System. out. println("请输入课程数");
int couNum=sc. nextInt(); //接收键盘输入的整型数据
String[] name = new String[stuNum]; //存储学生姓名
String[] course =new String[couNum]; //存储课程名称
int[][] score = new int[ stuNum][couNum]; //存储各科成绩
int[] sum=new int[ stuNum]; //存储总分
int[] avg=new int[stuNum]; //存储平均分
String[] content = new String[ stuNum]; //存储生信息
//录入课程名称
for(int i=0; i<couNum;i++){
System. out. println("请输入第"+(i+1)+"个课程名称");
course[i] = sc. next();
}
//录入学生各科成绩,同时计算总分、平均分
for(int i=0; i<stuNum;i++){
System. out. println("请输入第"+(i+1) +"个学生的名字");
name[i] =sc. next(); //接收键盘输入的字符串
content[i] =name[i]+"\t\t"; //拼接姓名
for(int j=0;j<couNum;j++){
System. out. println("请输入" +name[i] +course [j]+"的成绩");
score[i][j] =sc. nextInt(); //接收键盘输入的整型数据
sum[i]+=score[i][j]; //计算总分
content[i]+=score[i][j]+"\t\t"; //拼接各科成绩
}
avg[i] =sum[i]/stuNum; //计算平均分
content[i]+=sum[i]+" \t\t" +avg[i]+"\t\t"; //拼接总分、平均分
}
//根据总分对学生成绩排序
for(int i=0; i<stuNum-1;i++){ //冒泡排序
for( int j= 0;j<stuNum-1;j++){
if(sum[j]<sum[j+1]){ //比较总分
int t=sum[j]; //交换总分
sum[j] =sum[j+1];
sum[j+1] =t;
String temp = content[j]; //交换字符
content[j] =content[j+1];
content [j+1] = temp;
}
}
}
//打印学生成绩
System. out. print("姓名\t\t");
for(int i=0; i<couNum; i++){
System. out. print(course[i]+"\t\t");
}
System.out.println("总分\t\t 平均分\t\t 排名\t\t"); //表头
for(int i=0;i<stuNum;i++){
System.ou.println(content[i]+"第"+(i+1)+"名\t\t");
}
}
}
5.运行结果
标签：语句,元素,Java,int,编程,基础,循环,数组,表达式 来源： https://www.cnblogs.com/ShiFang0406/p/16674064.html