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.运行结果