Java实验01 Java编程基础（猜数字游戏、随机点名器）

小咪咪 2022-12-23 01:53 196阅读 0赞

实验一 Java编程基础  
实验1-1 随机点名器  
一、实验描述  
1、 任务描述  
编写一个随机点名的程序，使其能够在全班同学中随机点中某一名同学的名字。随机点名器具备3个功能，包括存储全班同学姓名、总览全班同学姓名和随机点取其中一人姓名。比如随机点名器首先分别向班级存入张飞、刘备和关羽这3位同学的名字，然后总览全班同学的姓名，打印出这3位同学的名字，最后在这3位同学中随机选择一位，并打印出他的名字，至此随机点名成功。  
2、 任务目标  
学会分析“随机点名器”任务实现的逻辑思路。  
能够独立完成“随机点名器”的源代码编写、编译及运行。  
能够根据“随机点名器”程序功能的不同，将功能封装到不同的方法中。  
能够使用数组解决多个同学姓名的存储问题。  
掌握方法和数组的使用。

3、 设计思路（实现原理）  
（1）在存储同学姓名时，如果对每一个同学都定义一个变量进行姓名存储，则会出现过多孤立的变量，很难一次性将全部数据持有。此时，可以使用数组解决多个数据的存储问题。创建一个可以存储多个同学姓名的数组，打算存几个同学姓名就创建相应长度的数组。  
（2）键盘输入同学姓名，将输入的姓名依次赋值给数组各元素，此时便存储了全班同学姓名。键盘输入需要使用Scanner 类，以下代码能够从键盘输入中读取一个字符串：  
Scanner sc = new Scanner(System.in);  
String sc= sc.next();  
（3）对数组进行遍历，打印出数组中每个元素的值，即实现了对全班每一位同学姓名的总览；  
（4）根据数组长度，获取随机索引，例如数组长度为3，则获取的随机索引只能在0~2之间，通过随机索引获取数组中的姓名，该姓名也就是随机的姓名。获取随机索引可以使用Random类中的nextInt(int n)方法。  
（5）“随机点名器”明确地分为了三个功能，如果将多个独立功能的代码写到一起，则代码相对冗长，可以针对不同的功能将其封装到不同的方法中，将完整独立的功能分离出来，然后只需要在程序的main()方法中调用这3个方法即可。  
二、实验实现  
随机点名器程序的实现代码

package experiment;
    
    import java.util.Random;
    import java.util.Scanner;
    
    public class  Example01 {
        
        public static void main(String[] args) {
        
            // 1.初始化学生数组
            String[] student = new String[3];
            initialStudentArray(student);//输入学生
            printStudentArry(student);//输出学生
    
            Scanner sc=new Scanner(System.in);
            while(true){
        
                System.out.println("请输入1进行随机点名，输入0结束");
                int cnt = sc.nextInt();
                //2.产生一个随机数（0~学生数-1）
                int randNum=new Random().nextInt(student.length);
                //3.输出随机数对应的学生姓名
                if(cnt == 1)
                    System.out.println("被点到名的同学是："+student[randNum]);
                else
                    break;
            }
        }
    
        private static void printStudentArry(String[] student) {
        
            for (int i = 0; i < student.length; i++) {
        
                System.out.print(student[i]+" ");
            }
            System.out.println();
        }
    
        private static void initialStudentArray(String[] student) {
        
            Scanner sc=new Scanner(System.in);
            for (int i = 0; i < student.length; i++) {
        
                System.out.println("请输入第"+(i+1)+"个学生的姓名：");
                student[i]=sc.next();
            }
        }
    
    }

三、实验总结  
在文件2-1中，第3542行代码定义了一个initialStudentArray()方法，用于实现存储全班同学姓名的功能，其中通过创建一个String类型的数组student来存储多个同学的姓名，借助Scanner类通过键盘输入的方式输入同学的姓名，并将这些姓名依次存储到数组元素中；第2733行代码定义一个printStudentArry()方法，用于实现总览全班同学姓名的功能，通过遍历数组students的方式打印全班每一位同学的姓名；第21行代码一个random ()方法，用于实现随机点名其中一人的功能，通过Random类的nextInt(intn)方法获取随机索引，然后根据随机索引从数组中获取姓名，这个姓名就是随机点名到的同学姓名。  
实验1-2 变量的强制类型转换  
一、实验描述  
1、 考核知识点  
名 称：变量的类型转换  
2、 练习目标  
 掌握不同数据类型间的强制类型转换  
3、 需求分析  
强制类型转换也叫显式类型转换，指的是两种数据类型之间的转换需要进行显式地声明。例如，两种类型彼此不兼容，或者目标类型取值范围小于源类型，都需要进行强制类型转换。  
4、 设计思路（实现原理）  
1） 编写一个类Example02  
2） 在Example02中的main()方法中定义一个int类型的变量i和byte类型的变量b，并将变量i的值赋给变量b  
3） 使用println语句打印出变量b的值  
二、实验实现  
定义Example02类：

package experiment;
    
    public class Example02 {
        
        public static void main(String[] args) {
        
            int i=2;
            byte b=(byte)i;
            System.out.println(b);
        }
    }

三、实验总结  
1、强制类型转换，具体格式如下：  
目标类型 变量 = （目标类型）值  
2、在对变量进行强制类型转换时，会发生取值范围较大的数据类型向取值范围较小的数据类型的转换，如将一个int类型的数转为byte类型，这样做极容易造成数据精度的丢失。int在内存中占用4个字节。byte类型的数据在内存中占用1个字节，当将变量i的数据在内存中占的内存大于1个字节时，前面3个高位字节的数据会丢失，数值也会发生改变。

实验1-3 运算符的优先级  
一、实验描述  
1、 考核知识点  
名称：运算符的优先级  
2、 练习目标  
 掌握运算符之间的优先级  
3、 需求分析  
当使用不同的运算符进行运算时，应该按照一定的顺序进行运算，即根据运算符的优先级进行运算。  
4、 设计思路（实现原理）  
1） 编写一个类Example03  
2） 在main方法中定义两个int型变量x和y  
3） 将表达式3>2\*x?x++:–x赋值给y  
4） 用输出语句分别输出变量x和y的值  
二、实验实现  
定义Example03类：

package experiment;
    
    public class Example03 {
        
        public static void main(String[] arg“”s) {
        
            int x=1,y;
            y=3>2*x?x++:--x;
            System.out.println(x+","+y);
        }
    }

三、实验总结  
1、本实验中表达式的运算过程如下所示：  
1） 在表达式y=3>2\*x?x++:–x；中赋值运算符=的优先级最低，所以要先运算=右侧的表达式；  
2） ？：为三元运算符，该运算符的优先级较低，要先运算？前面的表达式。  
3） *的优先级比>的高，所以3>2*1为true。按照三元运算符的运算规则表达式等价于y=x++  
4） x++的++在后面，所以要先进行其它运算再自增，最后结果为x=2,y=1

2、下表列举了Java中运算符的优先级，数字越小优先级越高。  
优先级 运算符  
1 . \[\] ()  
2 ++ – ~ ! (数据类型)  
3 \* / %  
4 + -  
5 << >> >>>  
6 < > <= >=  
7 == !=  
8 &  
9 ^  
10 |  
11 &&  
12 ||  
13 ?:  
14 = \*= /= %= += -= <<= >>= >>>= &= ^= |=  
3、其实没有必要去刻意记忆运算符的优先级。由于运算符“()”的优先级最高，编写程序时，尽量使用括号“()”来实现想要的运算顺序，以免产生歧义。

实验1-4 if条件语句  
一、实验描述  
1、 考核知识点  
名称：if条件语句  
2、 练习目标  
 掌握if条件语句的语法格式  
 了解if条件语句的执行流程  
3、 需求分析  
if…else if…else语句用于对多个条件进行判断，进行多种不同的处理。本实验使用if…else if…else语句实现判断某月是哪个季节的功能。  
设计思路（实现原理）  
1）编写一个类Example04  
2）定义一个变量month用于存储月份。  
3）用if条件语句，判断这个月份在哪一个季节并输出结果，如：春季是3、4、5月，夏季是6、7、8月，秋季是9、10、11月，冬季是12、1、2月  
4）由于一年只有12个月，所以要过滤除1-12以外的月份值  
二、实验实现  
定义Example04类：

package experiment;
    
    import java.util.Scanner;
    
    public class Example04 {
        
        public static void main(String[] args) {
        
            int month;
            while (true) {
        
                Scanner sc = new Scanner(System.in);
                System.out.println("请输入月份");
                month = sc.nextInt();
                switch (month){
        
                    case 12:
                    case 1:
                    case 2: System.out.println("这个月在冬季");break;
                    case 3:
                    case 4:
                    case 5: System.out.println("这个月在春季");break;
                    case 6:
                    case 7:
                    case 8: System.out.println("这个月在夏季");break;
                    case 9:
                    case 10:
                    case 11: System.out.println("这个月在秋季");break;
                    default : System.out.println("没有这个月份");break;
                }
            }
        }
    }

三、实验总结  
1、f…else if…else语句用于对多个条件进行判断，进行多种不同的处理。if…else if…else语句具体语法格式如下：  
if (判断条件1) \{  
执行语句1  
\} else if (判断条件2) \{  
执行语句2  
\}  
…  
else if (判断条件n) \{  
执行语句n  
\} else \{  
执行语句n+1  
\}  
if…else if…else语句的执行流程如图1-5所示。

图1-5 流程图  
2、因为一年只有12个月，所以当month>12时是不符合逻辑的数据，这时会打印“没有这个月份”。在编程过程中，经常要考虑程序在实际环境下是否符合逻辑需求。  
3、“||”表示或操作，当运算符两边的操作数任何一边的值为true时，其结果为true，当两边的值都为false时，其结果才为false。所以只要符合三个条件中的一个就会被判断为这个季节。  
实验1-5 switch条件语句  
一、实验描述  
1、 考核知识点  
名称：switch条件语句  
2、 练习目标  
 熟悉switch条件语句的语法格式  
 了解switch条件语句的特点  
3、 需求分析  
switch 条件语句也是一种很常用的选择语句，和if条件语句不同，它只能针对某个表达式的值作出判断，从而决定程序执行哪一段代码。本实验使用switch 条件语句实现判断选择题对错的功能。  
4、 设计思路（实现原理）  
1）编写一个类Example05  
2）定义一个变量answer用于存储答案选项  
3）用switch条件语句判断如果变量answer为B则正确，其它则错误  
4）如果变量answer不等于ABCD四个选择则打印“不存在此选项”  
二、实验实现  
定义Example05类：

package experiment;
    
    import java.util.Scanner;
    
    public class Example05 {
        
        public static void main(String[] args) {
        
            char answer;
            while (true) {
        
                System.out.println("请输入选项");
                Scanner in = new Scanner(System.in);
                answer = in.next().charAt(0);
                switch (answer) {
        
                    case 'A':
                        System.out.println("错误");
                        break;
                    case 'B':
                        System.out.println("正确");
                        break;
                    case 'C':
                        System.out.println("错误");
                        break;
                    case 'D':
                        System.out.println("错误");
                        break;
                    default:
                        System.out.println("不存在此选项");
                }
            }
        }
    }

三、实验总结  
1、switch语句的执行流程是：根据表达式的值查找与其匹配的项,如果有匹配项,则执行该匹配项下面的语句。如果没有匹配项，就会执行default后面的语句。  
2、switch关键字后括号内的表达式可以是byte,short,int,char四种类型；在JDK5以后表达式可以是枚举；在.JDK7以后表达式可以是字符串。  
3、switch语句只适合判断若干值的情况，不适合判断范围。  
4、if和switch都可以判断值的情况，这时应该使用switch语句，因为switch的效率比if语句高。  
实验1-6 while循环语句  
一、实验描述  
1、 考核知识点  
名称：while循环语句  
2、 练习目标  
 掌握while循环语句的语法格式和使用  
 了解while循环语句的特点  
3、 需求分析  
while语句会反复地进行条件判断，只要条件成立，\{\}内的执行语句就会执行，直到条件不成立，while循环才会结束。本实验使用while语句实现统计1-10以内奇数的功能。  
4、 设计思路（实现原理）  
1）编写一个类Example06  
2）定义一个变量x为1，用while语句循环条件为x<=10  
3）在while循环中，使用表达式x%2判断是否为奇数，如果为奇数，则变量count的值加1。

二、实验实现  
定义Example06类：

package experiment;
    
    public class Example06 {
        
        public static void main(String[] args) {
        
            int x=1;
            int count=0;
            while(x<=10)
            {
        
                if(x%2==1)
                    count++;
                x++;
            }
            System.out.println(count);
        }
    }

三、实验总结  
1、while循环语句和条件判断语句有些相似，都是根据条件判断来决定是否执行大括号内的执行语句。区别在于，while语句会反复地进行条件判断，只要条件成立，\{\}内的执行语句就会执行，直到条件不成立，while循环结束。  
2、while循环的执行流程如图1-8所示。

图1-8 流程图

实验1-7 for循环语句  
一、实验描述  
1、 考核知识点  
名称：for循环语句  
2、 练习目标

*  掌握for循环语句的语法格式和使用
 *  了解for循环语句的特点

3、 需求分析  
for循环语句是最常用的循环语句，一般用在循环次数已知的情况下。本实验使用for循环语句计算1+2+3+4+5…+100表达式的结果  
4、 设计思路（实现原理）  
1）编写一个类Example07  
2）在该类中定义一个变量sum来存储每次循环整数相加的和。  
3）在for循环语句中定义变量x,循环条件为x<=100  
二、实验实现  
定义Example07类：

package experiment;
    
    public class Example07 {
        
    
        public static void main(String[] args) {
        
            // TODO Auto-generated method stub
            int count = 0;
            for (int x = 1; x <= 100; x++) {
        
                count += x;
            }
            System.out.println(count);
        }
    }

三、实验总结  
1、在for循环中，for关键字后面()中包括了三部分内容：初始化表达式、循环条件和操作表达式，它们之间用“;”分隔，\{\}中的执行语句为循环体。  
2、通过序号来具体分析for循环的执行流程。具体如下：  
for（① ; ② ; ③）\{  
④  
\}  
第一步，执行①  
第二步，执行②，如果判断结果为true，执行第三步，如果判断结果为false，执行第五步  
第三步，执行④  
第四步，执行③，然后重复执行第二步  
第五步，退出循环

实验1-8 for循环嵌套  
一、实验描述  
1、 考核知识点  
名称：循环嵌套  
2、 练习目标

*  掌握循环嵌套的使用和执行顺序

3、 需求分析  
在编程过程中，经常需要双重循环或多重循环，这就需要循环语句的嵌套。最常见的循环嵌套就是在for循环中嵌套for循环。为了让初学者熟悉for循环嵌套的使用，本实验将演示如何用for循环嵌套打印由“*”组成的直角三角形。具体要求如下：  
 第一个三角形为倒直角三角形，共5行，第一行5个 “*”，一行减少一个，第5行一个“*”  
 将倒直角三角形上下翻转为正直角三角形，第一行1一个“*”，第5行5个“*”  
4、 设计思路（实现原理）  
1） 分析第一个三角形的打印，外层for循环控制行数，初始化表达式从0开始，循环条件为小于5；第一行是5个“*”所以应该内层循环打印5次，初始化表达式从0开始，循环条件为小于5。同理，内层的循环初始化和条件如下所示：  
0 1 2 3 4  
1 2 3 4  
2 3 4  
3 4  
4  
由此可见内层循环的初始化表达式y 与外层的x是相等的，循环条件都是小于5。  
2） 分析第二个三角形的打印，第一行1个“*”，第二行2个“*”…由此可见，内层循环的循环次数与行数是相等的，所以内层循环的y小于或等于外层的x。

二、实验实现  
定义Example08类:

package experiment;
    
    public class Example08 {
        
    
        public static void main(String[] args) {
        
            // TODO Auto-generated method stub
            for (int i = 0; i < 5; i++) {
        
                for (int j = 5 - i; j >= 1; j--)
                    System.out.print("*");
                System.out.println();
            }
        }
    }

三、实验总结  
由于嵌套循环程序比较复杂，下面分步骤进行讲解，具体如下：  
第一个三角形：  
1、 当x=0时，y=0且y<5，循环5次，完成后返回到外层循环进行换行。  
2、 当x=1时，y=1且y<5，循环4次，完成后返回到外层循环换行。  
3、 当x=2时，y=2，循环3次，完成后返回到外层循环换行。  
4、 当x=3时，y=3，循环2次，完成后返回到外层循环换行。  
5、 当x=4时，y=4，循环1次，完成后返回到外层循环换行。由于x<5所以循环终止，打印结束。  
第二个三角形：  
1、 当x=0时，y=0且y<=0，循环1次，完成后返回到外层循环进行换行。  
2、 当x=1时，y=0且y<=1，循环2次，完成后返回到外层循环进行换行。  
3、 当x=2时，y=0且y<=2，循环3次，完成后返回到外层循环进行换行。  
4、 当x=3时，y=0且y<=3，循环4次，完成后返回到外层循环进行换行。  
5、 当x=4时，y=0且y<=4，循环5次，完成后返回到外层循环进行换行。由于x<5所以循环终止，打印结束。

实验1-9 方法的定义  
一、实验描述  
1、 考核知识点  
名称：方法的定义  
2、 练习目标

*  掌握方法的定义

3、 需求分析  
为了减少重复代码编写的问题，Java中可以将具有相同功能的重复代码提取出来，封装成方法。本实验定义一个方法，该方法能够实现四则运算的功能。  
4、 设计思路（实现原理）  
1） 编写一个类Example09  
2） 定义一个方法siZe，设置三个参数，两个数字为int型，一个符号为char型  
3） 在方法中，用if选择语句根据传入的符号参数进行不同的运算  
4） 如果传入的符号不包含在加减乘除四个符号中则输出“符号错误”  
5） 在main方法中调用方法计算3\*0的结果，测试方法是否成功运算出正确结果  
二、实验实现  
定义Example09类：

package experiment;
    
    import java.util.Scanner;
    
    public class Example09 {
        
        public static int siZe(int a, int b, char c) {
        
            if (c == '+')
                return a + b;
            else if (c == '-')
                return a - b;
            else if (c == '*')
                return a * b;
            else if (c == '/')
                return a / b;
            else
                System.out.println("符号错误");
            return 0;
        }
    
        public static void main(String[] args) {
        
            // TODO Auto-generated method stub
            int a, b;
            char c;
            while (true) {
        
                Scanner in = new Scanner(System.in);
                System.out.println("请输入2个整数及运算符号");
                a = in.nextInt();
                b = in.nextInt();
                c = in.next().charAt(0);
                int p = siZe(a, b, c);
                System.out.println(p);
            }
        }
    }

三、实验总结  
1、在Java中，声明一个方法的具体语法格式如下：  
修饰符 返回值类型 方法名(\[参数类型 参数名1,参数类型 参数名2,．．．．．．\])\{  
// 执行语句  
return 返回值;  
\}  
2、需要特别注意的是，方法中的“参数类型 参数名1，参数类型 参数名2”被称作参数列表，它用于描述方法在被调用时需要接收的参数，如果方法不需要接收任何参数，则参数列表为空，即()内不写任何内容。方法的返回值必须为方法声明的返回值类型，如果方法中没有返回值，返回值类型要声明为void，此时，方法中return语句可以省略。  
实验1-10 方法的重载  
一、实验描述  
1、 考核知识点  
名称：方法的重载  
2、 练习目标

*  了解重载的定义
 *  掌握方法重载的用法

3、 需求分析  
方法重载指的是方法名相同，参数类型或个数不同。本实验通过方法重载的方式实现九九乘法表的打印  
4、 设计思路（实现原理）  
1） 编写一个类Example10  
2） 在Example10中定义一个带参数的方法print99，该参数用于指定乘法表打印的行数  
3） 在Example10中定义一个方法print99，此方法没有参数。  
4） 在main方法中分别调用无参方法print99()和有参方法print99(6)，测试两个重载的方法print99能否成功打印出符合要求的乘法表。

二、实验实现  
定义Example10类，代码如下所示:

package experiment;
    
    public class Example10 {
        
        public static void print99(int n)
        {
        
            for(int i=1;i<=n;i++)
            {
        
                for(int j=1;j<=i;j++)
                {
        
                    System.out.print(j+" * "+i+" = "+j*i+" ");
                }
                System.out.println();
            }
        }
        public static void print99()
        {
        
            System.out.println("该选择下不打印");
        }
        public static void main(String[] args) {
        
            // TODO Auto-generated method stub
            print99(6);
            print99();
    
        }
    }

三、实验总结  
1、方法的重载是在一个程序中定义多个名称相同的方法，但是参数的类型或个数必须不同。  
2、值得注意的是，方法的重载与返回值类型无关，它只有两个条件，一是方法名相同，二是参数个数或参数类型不相同。  
实验1-11 一维数组的定义  
一、实验描述  
1、 考核知识点  
名称：数组的定义  
2、 练习目标

*  掌握一维数组的定义

3、 需求分析  
数组是指一组数据的集合，数组中的每个数据被称作元素。在数组中可以存放任意类型的元素，但同一个数组里存放的元素类型必须一致。请定义一个数组，将序列\{0,1,2,3,4\}赋值给数组，并写一个方法用来访问数据的每一个元素。  
4、 设计思路（实现原理）  
1） 定义一个数组，在初始化数组时有一种方式叫做静态初始化，就是在定义数组的同时就为数组的每个元素赋值。可以在定义数组时将序列\{0,1,2,3,4\}赋值给数组。  
2） 定义一个方法输出数组的元素，可以用for循环语句依次输出数组的元素，各元素用“，”间隔可以更清楚的输出元素。  
3） 在最后一个元素输出时，后面就不需要加“，”了，所以循环到length-1时不打印“，”。

二、实验实现  
定义Example11类:

package experiment;
    
    public class Example11 {
        
        public static void main(String[] args) {
        
            int []a= {
        0,1,2,3,4};
            for(int i=0;i<a.length-1;i++)
                System.out.print(a[i]+",");
            System.out.println(a[a.length-1]);
        }
    }

运行结果截图为图1-13：

图1-13 运行结果  
三、实验总结  
1、每个数组的索引都有一个范围，即0~length-1。在访问数组的元素时，索引不能超出这个范围，否则程序会报数组越界异常ArrayIndexOutOfBoundsException。所谓异常指程序中出现的错误，它会报告出错的异常类型、出错的行号以及出错的原因。  
2、在使用变量引用一个数组时，变量必须指向一个有效的数组对象，如果该变量的值为null，则意味着没有指向任何数组，此时通过该变量访问数组的元素会出现空指针异常NullPointerException。  
实验1-12 数组最值  
一、实验描述  
1、 考核知识点  
名称：数组的常见操作-数组的最值  
2、 练习目标

*  掌握如何获取一维数组的最值

3、 需求分析  
在操作数组时，经常需要获取数组中元素的最值。定义一个数组，并获取该数组中值最小的元素。  
4、 设计思路（实现原理）  
1） 定义一个数组。  
2） 定义一个方法，用来获取最小值。该方法应返回一个int型的数值，参数为数组类型。在方法中，定义一个临时变量min，用于记住数组的最小值。首先假设数组中第一个元素arr\[0\]为最小值，然后使用for循环对数组进行遍历，在遍历的过程中只要遇到比min值还小的元素，就将该元素赋值给min。这样一来，变量min就能够在循环结束时记住数组中的最小值。  
3） 在main方法中调用该方法，将定义的数组作为参数传给方法，获取该数组的最小值。

二、实验实现  
定义Example12类:

package experiment;
    
    public class Example12 {
        
        public static int FindMin(int[] a) {
        
            int min = a[0];
            for (int i = 0; i < a.length; i++) {
        
                if (a[i] < min)
                    min = a[i];
            }
            return min;
        }
    
        public static void main(String[] args) {
        
            int[] a = {
         7, 8, 4, 89, 4, 64, 7, 6, 75, 14, 9 };
            int min = FindMin(a);
            System.out.println(min);
    
        }
    }

三、实验总结  
getMin()方法用于求数组中的最小值，该方法中定义了一个临时变量min，用于记住数组的最小值。需要注意的是，在for循环中的变量i是从1开始的，这样写的原因是程序已经假设第一个元素为最小值，for循环中只需要从第二个元素开始比较，从而提高程序的运行效率。  
实验1-13 数组排序  
一、实验描述  
1、 考核知识点  
名称：数组的常见操作-数组的排序  
2、 练习目标

*  掌握一维数组中元素的排序

3、 需求分析  
在操作数组时，经常需要对数组中元素进行排序。常用的排序算法有选择排序，冒泡排序等。请定义一个数组，用冒泡排序算法将数组中的元素进行从小到大的排序。  
4、 设计思路（实现原理）  
对数组元素进行冒泡排序的原理是：

1.  第一个元素开始，将相邻的两个元素依次进行比较，直到最后两个元素完成比较。如果前一个元素比后一个元素大，则交换它们的位置。整个过程完成后，数组中最后一个元素自然就是最大值，这样也就完成了第一轮比较。
2.  除了最后一个元素，将剩余的元素继续进行两两比较，过程与第一步相似，这样就可以将数组中第二大的数放在了倒数第二个位置。
3.  以此类推，持续对越来越少的元素重复上面的步骤，直到没有任何一对元素需要比较为止。  
    二、实验实现  
    定义Example13类:

package experiment;
    
    public class Example13 {
        
        public static void main(String[] args) {
        
            int[] a = {
         7, 8, 1, 5, 4, 3, 98, 52, 10, 25, 4, 1, 5, 7, 19, 20 };
            int l = a.length;
            for(int i =0; i < l; i++){
        
                System.out.print(a[i] + " ");
            }
            System.out.println();
            for (int i = 0; i < l - 1; i++) {
        
                for (int j = 0; j < l - 1 - i; j++) {
        
                    if (a[j + 1] < a[j]) {
        
                        int temp = a[j + 1];
                        a[j + 1] = a[j];
                        a[j] = temp;
                    }
                }
            }
            for(int i =0; i < l; i++){
        
                System.out.print(a[i] + " ");
            }
        }
    }

三、实验总结  
常用的排序算法除了选择排序外，还有冒泡排序。在冒泡排序的过程中，不断地比较数组中相邻的两个元素，较小者向上浮，较大者往下沉，整个过程和水中气泡上升的原理相似。  
接下来介绍下选择排序的思路与原理，具体如下：  
定义排序方法，在方法中，用for循环嵌套实现排序。第一层循环是从数组的第一个元素开始循环。第二层循环用于与第一层循环中的元素比较找出最值，并将最小值的下标跟第一个元素的下标进行互换。  
选择排序法的原理是：首先找到数组中的最值，将最小值（最大值）的下标与第一个元素  
的下标交换，再在剩下的元素中找最小值（最大值）的下标与第二个元素的下标交换，以此类推，完成所有元素的排序。