第一篇Java基础知识复习

云玩java.dog️

已于 2023-03-29 00:01:11 修改

阅读量258

点赞数 1

文章标签： java jvm 开发语言

于 2023-03-28 21:59:09 首次发布

本文链接：https://blog.csdn.net/2301_76548945/article/details/129801709

版权

本文详细介绍了Java的基础知识，包括变量的定义、数据类型、运算符（如算术、赋值、比较、逻辑和位运算）、流程控制（if、for、while、do...while、switch）以及方法的使用。此外，还讲解了数组的定义、遍历和多维数组的概念。文章还提到了注释的种类和变量的作用域，以及如何编写简单的Java程序，如商城库存清单和随机点名器案例。

摘要由CSDN通过智能技术生成

全章节学习目标：

1.掌握Java基本语法、常量、变量、流程控制语句、方法以及数组

2.了解Java代码的基本格式

3.熟悉Java运算符的使用

Java代码的基本格式

学习笔记（p14)：

编写Java时需要注意以下几点：

大小写敏感：Java 是大小写敏感的，这就意味着标识符 Hello 与 hello 是不同的。
类名：对于所有的类来说，类名的首字母应该大写。
方法名：所有的方法名都应该以小写字母开头。如果方法名有若干单词，后面的每个单词首字母大写。
主方法入口：所有的 Java 程序由 public static void main(String[] args) 方法开始执行。
功能执行语句：最后都必须用分号(;)结束。
字符串书写格式：一句连续的字符串不能分开在两行中书写，否则在编译时将会出错，太长的字符串可以要“+”来分开

System.out.println("这是第一个"+
"Java程序!");

学习笔记（p15）：

Java支持以下三种注释方式：

1.单行注释：以双斜杠“//”标识，只能注释一行内容，用在注释信息内容少的地方。

2.多行注释：包含在“/*”和“*/”之间，能注释很多行的内容。为了可读性比较好，一般首行和尾行不写注释信息（这样也比较美观好看）

3.文档注释：包含在“/**”和“*/”之间，也能注释多行内容，一般用在类、方法和变量上面，用来描述其作用。注释后，鼠标放在类和变量上面会自动显示出我们注释的内容

学习笔记（p16)

java中的标识符：为方法、变量或其他用户定义项所定义的名称。标识符可以有一个或多个字符。

标识符用来命名常量、变量、类和类的对象等。

标识符命名规则：

标识符由数字（0~9）和字母（A~Z 和 a~z）、美元符号（$）、下划线（_）以及 Unicode 字符集中符号大于 0xC0 的所有符号组合构成（各符号之间没有空格）
标识符的第一个符号为字母、下划线和美元符号，后面可以是任何字母、数字、美元符号或下划线。
标识符命名时，切记不能以数字开头，也不能使用任何 Java 关键字作为标识符，而且不能赋予标识符任何标准的方法名。
标识符用来命名常量、变量、类和类的对象等。因此，一个良好的编程习惯要求命名标识符时，应赋予它一个有意义或有用途的名字。
包名所有字母一律小写。例如:cn.itcast.test。
类名和接口名每个单词的首字母都要大写。如: ArravList、Iterator。
常量名所有字母都大写，单词之间用下划线连接。例如:DAY_OF_MONTH。

学习笔记（p17)

java中的关键字

关键字具有专门的意义和用途，和自定义的标识符不同，不能当作一般的标识符来使用。
Java 区分大小写，因此 public 是关键字，而 Public 则不是关键字。但是为了程序的可读性，要尽量避免使用关键字的其他形式来命名
Java 的关键字对 Java 编译器有特殊的意义，它们用来表示一种数据类型，或者表示程序的结构等。保留字是为 Java 预留的关键字，它们虽然现在没有作为关键字，但在以后的升级版本中有可能作为关键字。
这些关键字不能作为变量名、类名和方法名来使用：
数据类型：boolean、int、long、short、byte、float、double、char、class、interface。
流程控制：if、else、do、while、for、switch、case、default、break、continue、return、try、catch、finally。
修饰符：public、protected、private、final、void、static、strict、abstract、transient、synchronized、volatile、native。
动作：package、import、throw、throws、extends、implements、this、supper、instanceof、new。
保留字：true、false、null、goto、const。

学习笔记（p18)

Java中的常量：常量值又称为字面常量，它是通过数据直接表示的，因此有很多种数据类型，像整型和字符串型等。

final double PI = 3.1415927;

整型常量值

Java 的整型常量值主要有如下 3 种形式。

十进制数形式：如 54、-67、0。
八进制数形式：Java 中的八进制常数的表示以 0 开头，如 0125 表示十进制数 85，-013 表示十进制数 -11。
十六进制数形式：Java 中的十六进制常数的表示以 0x 或 0X 开头，如 0x100 表示十进制数 256，-0x16 表示十进制数 -22。

实型常量值

Java 的实型常量值主要有如下两种形式。

十进制数形式：由数字和小数点组成，且必须有小数点，如 12.34、-98.0。
科学记数法形式：如 1.75e5 或 32&E3，其中 e 或 E 之前必须有数字，且 e 或 E 之后的数字必须为整数。

布尔型常量值

Java 的布尔型常量只有两个值，即 false（假）和 true（真）。

字符型和字符串常量值

Java 字符串常量值中的单引号和双引号不可混用。双引号用来表示字符串，像 "1"、"a" 等都是表示单个字符的字符串。
Java 还允许使用一种特殊形式的字符常量值来表示一些难以用一般字符表示的字符，这种特殊形式的字符是以开头的字符序列，称为转义字符

学习笔记（p19)

变量的定义及其数据类型

变量名的作用：变量用于在内存中保留可变数据。

变量的使用：1.声明变量

int a; //<数据类型><变量名>

2.变量赋值

a=10; //<变量名>=<值>

变量的类型

整数类型分为4种不同的类型: 字节型 (byte) 、短整型 (short)、整型(int) 和长整型 (long)

浮点类型

在为一个float类型的变量赋值时需要注意一点，所赋值的后面一定要加上字母“F”(或“f”)，而为double类型的变量赋值时，可以在所赋值的后面加上字符“D” (或“d”)

字符类型赋值时，要用英文半角格式的单引号 (") 把字符括起来，如'a'.

布尔类型变量用来存储布尔值，在Java中用boolean表示，该类型的变量只有两个值，即true和false。

学习笔记（p20 )

变量的类型转换

整型、实型（常量）、字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型，然后进行运算。

自动类型转换

自动类型转换需要满足两个条件：一两种数据类型彼此兼容，二目标类型的取值大源类型的取值范围。

byte b = 6;
//byte类型的变量赋值给int类型,无需特殊声明,因为int取值大于byte
int i = b;

强制类型转换

强制类型转换也叫显示类型转换，指的是两种类型彼此不兼容。或者目标类型的取值范围小于源类型时，自动类型转换无法进行，需要进行强制类型转换。
转换格式：目标类型变量 = (目标类型)值

int num = 10;
//如果不进行强制类型转换,编译不通过
byte b = (byte)num;

在进行强制类型转换时，会发生取值较大的数据类型向取值范围较小的数据类型时，会发生数据精度的丢失。

学习笔记（p21 )

变量的作用域

变量是预先定义后才能被使用，但并不是变量定义之后的语句中一定可以使用该变量。变量需要在它的作用范围内才能够使用，这个作用范围就是变量的作用域。按照作用范围可以分为：成员变量和局部变量

在程序中，变量一定会被定义在某一对大括号中，该大括号所包含的代码区域便是这个变量的作用域。

int x=12;//定义变量x
		{
		int y = 96;
		System.out.println("x is " + x);//访问变量x
	    System.out.println("x is " + y);//访问变量y
		}
		System.out.println("x is " + x);//访问变量x
	}
}

学习笔记（p22—p26 )

运算符

用于对数据进行算数运算、赋值、和比较等操作，Java中运算符分为：算数运算符，赋值运算符，比较运算符，逻辑运算符和位运算符。

public static void main(String[] args) {
		
		int x=12;//定义变量x
		{
		int y = 96;
		System.out.println("x is " + x);//访问变量x
	    System.out.println("x is " + y);//访问变量y
		}
		System.out.println("x is " + x);
		int z = 1;
		z++;
		System.out.println("z is" + z);
	}
}

算数运算符
数学中常用加减乘除，被称作为四则运算。Java中的算术运算就是用来处理四则运算的符号

赋值运算符

赋值运算符用" = "表示，其作用是将右边的值赋值给左边的操作
short s = 3;
int i = 5;
a += 1;
System.out.println("s =" s +s);
}
}

自增和自减运算符

进行自增和自减运算时，运算符++和–放在操作数的前面则是先进行自增或自减运算，在进行其他运算。反之，运算符放在操作数的后面则是先进行其他运算再进行自增或自减运算。

int x=12;//定义变量x
		{
		int y = 96;
		System.out.println("x is " + x);//访问变量x
	    System.out.println("x is " + y);//访问变量y
		}
		System.out.println("x is " + x);
		int z = 1;
		int i = z++;
		System.out.println("z is" + z);
		System.out.println("i is" + i);
	}
}

比较运算符

用于比较两个变量或常量的大小，比较运算的结果是一个布尔值(true或false)。Java支持的比较运算符如下：
1.’ >:’ 大于，只支持左右两边的操作数是数值类型。如果前面变量的值大于后面变量的值，则返回true。
2. >= ：大于等于，只支持左右两边的操作数是数值类型。如果前面变量的值大于等于后面变量的值，则返回true。

比较运算符在使用时需要注意一个问题，不能将比较运算符4误写成赋值运算符“=”

逻辑运算符
||（短路或）   都为false，则false。有一个为true便不再继续判断了
|（逻辑或）   都为false，则false。所有的条件都判断
&&（短路与）   都为true，则true。有一个为false便不再继续判断了
&（逻辑与）   都为true，则true。所有的条件都判断
！(非)   变成相反的样子
^（异或）   相同则为false，不相同则为true

运算符的优先级

在对一些比较复杂的表达式进行运算时，要明确表达式中所有运算符参与运算的先后顺序，把这种顺序称作运算符的优先级。

学习笔记（p27)

商城库存清单程序设计案例

任务描述
编写一个模拟商城库存清单的程序，打印出库存中每种商品的详细信息以及所有商品的汇总信息。每种商品的详细信息包括品牌型号、尺寸、价格、配置和库存数，所有商品的汇总信息包括总库存数和库存商品总金额。

package cn.itcast.chapterdemo;
 
/*商品库存清单案例
 * 变量的形式对商品的数据保存
 * 品牌，尺寸大小，价格，配置，库存数量
 * 三个品牌：苹果，联想thinkpad，华硕
 */
public class Test02 {
 public static void main(String[] args) {
  // 定义苹果电脑的属性
  String macBrand = "MacBookAir";// brand:品牌
  double macSize = 13.3;
  double macPrice = 6988.88;
  String macConfig = "i5处理器4GB128GB固态硬盘";// config：配置
  int macCount = 5;
  // 定义联想电脑
  String thinkpadBrand = "ThinkPadT450";
  double tinkpadSize = 14.0;
  double thinkpadPrice = 5999.99;
  String thinkpadConfig = "i5处理器4GB500GB硬盘";
  int thinkpadConut = 10;
  // 定义华硕电脑
  String ASUSBBrand = "ASUS-FL5800";
  double ASUSBSize = 15.6;
  double ASUSBPrice = 4999.90;
  String ASUSBConfig = "i7处理器4GB内存128GB固态硬盘";
  int ASUSBConut = 18;
 
  // 列表的顶部
  System.out.println("------------------------商品库存清单------------------------");
  System.out.println(
    "品牌型号                     尺寸                 价格                  配置                                                        库存数");
  // 列表中部
  System.out.println(
    macBrand + "   " + macSize + "    " + macPrice + "   " + macConfig + "            " + macCount);
  // 快捷键ctrl+alt+上键：复制当前行到上一行
  System.out.println(thinkpadBrand + " " + tinkpadSize + "    " + thinkpadPrice + "   " + thinkpadConfig
    + "                  " + thinkpadConut);
 
  System.out.println(
    ASUSBBrand + "  " + ASUSBSize + "    " + ASUSBPrice + "    " + ASUSBConfig + "   " + ASUSBConut);
  // 设置分界线
  System.out.println("---------------------------------------------------------");
  // 定义库存总数和总金额
  int total = macCount + thinkpadConut + ASUSBConut;
  double moneyTotal = macPrice * macCount + thinkpadPrice * thinkpadConut + ASUSBPrice * ASUSBConut;
  // 列表底部
  System.out.println("库存总数是： " + total);
  System.out.println("库存总金额是： " + moneyTotal);
 }
 
}

学习笔记（p28)

if条件语句分为三种语法格式，具体如下!

if语句

public class Test {
 
   public static void main(String args[]){
      int x = 10;
 
      if( x < 20 ){
         System.out.print("这是 if 语句");
      }
   }
}

if...else语句

if 语句后面可以跟 else 语句，当 if 语句的布尔表达式值为 false 时，else 语句块会被执行。

if(布尔表达式){
//如果布尔表达式的值为true
}else{
//如果布尔表达式的值为false }

public class Test {
 
   public static void main(String args[]){
      int x = 30;
 
      if( x < 20 ){
         System.out.print("这是 if 语句");
      }else{
         System.out.print("这是 else 语句");
      }
   }
}

if...else 语法

if 语句后面可以跟 else if…else 语句，这种语句可以检测到多种可能的情况。

使用 if，else if，else 语句的时候，需要注意下面几点：
if 语句至多有 1 个 else 语句，else 语句在所有的 else if 语句之后。
if 语句可以有若干个 else if 语句，它们必须在 else 语句之前。
一旦其中一个 else if 语句检测为 true，其他的 else if 以及 else 语句都将跳过执行。
实例

public class Test {
   public static void main(String args[]){
      int x = 30;
 
      if( x == 10 ){
         System.out.print("Value of X is 10");
      }else if( x == 20 ){
         System.out.print("Value of X is 20");
      }else if( x == 30 ){
         System.out.print("Value of X is 30");
      }else{
         System.out.print("这是 else 语句");
      }
   }
}

学习笔记（p29)

switch语句也是一种很常见的选择语句。和if条件语句不同，它只能针对某个表达式的值做出判断，从而决定执行哪一段代码。
```
switch(用于判断的参数)(
case 常量表达式1 :语句1;[break;] case.常量表达式2 :语句2;[break;]
..
case 常量表达式n:语句n;[break;1 default :语句n+1; [break;]
```
switch 语句中参数必须是整型、字符型、枚举类型或字符串类型，常量值I~n必须是与参数兼容的数据类型。 switch语句首先计算参数的值,如果参数的值和某个 case 后面的常量表达式相同,则执行该case语句后的若干个语句，直到遇到 break 语句为止。此时如果该cas se 语句中没有 break 语句，将继续执行后面 case 中的若干个语句，直到遇到 break 语句为止。若没有任何一个常量表达式与参数的值相同，则执行default后面的语句。
break的作用是跳出整个 switch语句。
default语句是可以不写的，如果它不存在，而且switch语句中表达式的值不与任何case的常量值相同，switch 则不做任何处理。

如果 switch 语句中没有 break关键字，即使执行完对应的 case的处理语句，switch语句也不会立即停止，而是会继续执行下面所有的case，直至遇见break关键字或者完成执行完所有代码才会停止。这就是 switch的“贯穿”特性。我们可以利用这个“贯穿”的特性，让多个 case 共享同一段处理代码。

学习笔记（p30)

while循环语句

While语句的循环方式为利用一个条件来控制是否要继续反复执行这个语句，语法如下:
while(条件表达式){
执行语句 }
当条件表达式的返回值为真时，则执行“{}”中的语句，当把执行完“{}”中的语句后，重新判断条件表达式的返回值，直到表达式返回的结果为假时，退出循环。while 循环语句的执行流程如图：

do...while 循环语句
do...while 循环语句与 while 循环语句类似，它们之间的区别是 while 语句为先判断条件是否成立再执行循环体，而 do...while 循环语句则先执行一次循环后，再判断条件是否成立。也就是说 do...while 循环语句中“{}”中的程序段至少要被执行一次。语法如下： do{
执行语句 }
while(条件表达式);
do...while 语句与 while 语句的一个明显区别是 do...while语句在结尾处多了一个分号(;)。根据 do...while 循环语句的语法特点总结出的 do...while 循环语句的执行流程。

学习笔记（p31)

for循环语句

for循环是Java设计中最有用的循环语句之一，一个for循环可以用来重复执行某条语句，直到某个条件得到满足。for语句语法如下:
for(表达式1;表达式2;表达式3) {
语句 }
*表达式 1:该表达式通常是一个赋值表达式，负责设置循环的起
始值，也就是给控制循环的变量赋初值。
*表达式 2:该表达式通常是一个关系表达式,用控制循环的变量和循环变量允许的范围值进行比较。
*表达式 3:该表达式通常是一个赋值表达式，对控制循环的变量
进行增大或减小。
*语句:语句仍然是复合语句。

for 循环语句的执行流程如下

(1)先执行表达式1.

(2)判断表达式 2，若其值为真，则执行for 语句中指定的内嵌语句，然后执行

(3)若表达式2值为假，则结束循环，转到(5)。

(3)执行表达式3。

(4)返回(2)继续执行。

(5)循环结束，执行 for 语句下面的一个语句。

学习笔记（p32)

循环嵌套

循环嵌套是指在一个循环语句的中在定义一个循环语句的语法结构。while do...while for循环语句都可以进行嵌套，和并且他们之间可以互相嵌套，如最常见的for循环中嵌套for循环

学习笔记（p33）

跳转语句（break、continue）

跳转语句用于实现循环执行过程中程序流程的跳转，在java中跳转语句有break和continue两个语句

1: break语句用在switch体哦阿健语句和循环语句中，它的作用是终止某个case并跳出switch结构

直接跳出循环

学习笔记（p34）

continue语句：用在循环语句中的作用是中止本次循环执行下一个循环语句

跳出本次循环执行下一个循环

学习笔记（p35）

任务描述：Java猜数字游戏(实现0-9的随机数字)

import java.util.Random;//引入Random
import java.util.Scanner;//引入Scanner
public class GuessNumber {
    public static void main (String[] args) {
        //1.通过Random类中的nextInt（int n）方法，生成一个0~9的随机数
        int randomNumber = new Random().nextInt(10);
        System.out.println("随机数已生成!");
        //2.输入猜的数字
        System.out.println("----请输入您猜的数字：----");
        Scanner sc = new Scanner(System.in);
        int enterNumber = sc.nextInt();
        //3.通过while循环，进行猜数字的对错判断
        //猜对，跳出循环，游戏结束
        while (enterNumber != randomNumber) {
            if (enterNumber > randomNumber) {
                System.out.println("猜大了，继续！");
            } else {
                System.out.println("猜小了，加油！");
            }
            System.out.println("请输入你猜的数字。");
            enterNumber = sc.nextInt();
        }
            System.out.println("恭喜你回答正确");
        }
    }

学习笔记（p36）

什么是方法

>假设有一个游戏程序，程序在运行过程中，要不断地发射炮弹。

发射炮弹的动作需要编写100行的代码，在每次实现发射炮弹的地

方都需要重复地编写这100行代码，这样程序会变得很臃肿，可读性也非常差。

>为了解决代码重复编写的问题，可以将发射炮弹的代码提取出来放在一个{中，并为这段代码起个名字，这样在每次发射炮弹的地方通过这个名字来调用发射炮弹的代码就可以了。

>上述过程中，所提取出来的代码可以被看作是程序中定义的一个方法，程序在需要发射炮弹时调用该方法即可。

在java中，声明一个方法的具体语法格式如下所以

修饰符返回值方法名{[参数类型参数名 1 参数类型参数名2、.....]}{
执行语句

------

return返回值

}

修饰符：是对访问权限的限定，例如public、static都是修饰符

返回值类型：用于限定方法返回值的数据类型

参数类型：用于限定调用方法是传入参数的数据类型

参数名：是一个变量，用于接收调用方法时传入数据

return关键字：用于结束方法以及返回值指定类型的值

返回值i:被return语句返回的值，改制会返回调用者

学习笔记（p37）

方法的重载

下面的方法实现两个整数相加

public static int add01（int x，int y）{
return x+y；

}

下面的方法实现三个整数相加

public static int add02（int x，int y， int z ）{
return x+y+z；

}

下面的方法实现两个小数相加

public static double add03 （double x，double y，）

return x+y ；

int sum1 =add01（1，2）；

int sum2 =add02 （1，2，3）；

double sum3（1，2，3）；//

学习笔记（p38）

数组的定义

数组是之一组数据的集合，数组中的每个元素被称为元素在数组中可以存放任何类型的元素，单同一个数组中存放的元素类型必须一致

在java中可以使用下列格式定义一个数组，具体如下

int[] x=new int [100];

上述语句就相当于内存中定义了100个int类型的变量，第一个变量的名称为x[1],以此类推，第一百个变量名称为x[99]这些变量的初始值都是0

为了更好理解数组的定义方式具体如下

in[]x; //声明一个int[]类型的变量

x=new int[100]//创建一个长度为100的数组

在java中为了方便我们获得数组的长度，提供了一个length属性子啊程序中可以通过数组名.length的方式来获得数组的长度，即元素的个数

当数组被成功创建后，数组中元素会被自动赋予一个默认值，根据元素类型的不同，默认初始化的值也是不一样的

在初始化数组时还有一种方式叫做静态初始化，就是在定义数组的同时就为数组的每个元素赋值。数组的静态初始化有两种方法如下

类型[]数组名 =new类型[]{元素，元素.........};

类型[]数组名 =new类型[]{元素，元素，元素......};

学习笔记（p39）

数组的常见操作

数组遍历

在操作数组时，经常需要依次访问数组中的每个元素，这种操作叫做数组的遍历

例如arr[3]

分别赋值为 5 8 2 3

如果元素比较少的话可以依次定义

如果数组内的元素多的话就使用循环

循环：循环的变量从0开始，每次递增

for循环遍历数组

int[]啊让人= {1，2，3，4，5}；//定义数组

//使用for循环遍历数组元素

for (int i=0,i<arr.length;i++);//通过索引访问元素

数组排序

在操作数组是，经常需要对数组中的元素进行排序，其中排序时比较常见的一种算法。冒泡过程中，不断比骄傲数组中相邻的两个元素，较小的向上浮，较大的往下沉，整个过程和水中的气泡的上升原理相似

数组最大值

在操作数组时，经常需要获取数组中的元素的最大值

定义变量max保存数组中的0索引

max=arr[0]

max和数组中的其他索引上的元素进行比较

如果数组中的元素大雨了变量max

变量max记住住角度的数值

数组中的所有元素都遍历并且比较完成

变量max保存的就是数组中的最大值

学习笔记（p40）

多维数组

多维数组可以简单的理解为在数组中嵌套数组。在程序中比较常见的就是二维数组

二维数组的定义有很多中，具体如下

方法一

int[][]arr=new int [3][4];

上面的代码定义了一个三行四列的二维数组

方法二

int[][]arr=new int[3][]

上述方式与第一种方式类似，只是数组中的每个元素长度不确定，采用第二种方式常见的数组结构

方法三

int[][]arr={{1,2},{3,4,5,6},{7,8,9}};

采用上述方式定义的二维数组有三个元素，这三个元素都是数组分别是{1,2},{3,4,5,6},{7,8,9}

对为数组对元素的访问也是通过角标的方式，例如访问二维数组中第一个元素数组的第二个元素的方式如下所示

arr[0][1]；

学习笔记（p40、42、43、44）
第四十四个视频
案例随机点名器

存储全班同学的姓名，创建一个存储多个同学姓名的容器

键盘上录入的每个同学的名字存储到容器中

创建扫描器

遍历数组，得到每个同学的名字

然后再使用for循环

依次输出

随机点其中一人根据数组产孤独，获得随机数

通过随即所以从数组中获取姓名

返回随机点到的名字

再创建一个可以存储多个同学姓名的容器（数组）

存储全班同学的名字

总揽全班同学的名字

随机点出其中一人

public static void main(String[] args) {
  //创建一个字符串数组存储姓名
  String []arr=new String[3];
  System.out.println("---------随机点名器---------");
  //创建接收数据对象
  Scanner sc=new Scanner(System.in);
  //使用for循环依次接收用户输入的姓名存储到数组中
  for(int i=0;i<arr.length;i++) {
   //因为数组的下标从0开始，所以这里表示第几人时需要将下标+1
   System.out.println("存储第"+(i+1)+"个姓名");
   //使用nextLine方法获取所有字符串存储到数组中
   arr[i]=sc.nextLine();
  }
  //打印数组中的所有姓名
  for(int i=0;i<arr.length;i++) {
   System.out.println("第"+(i+1)+"个姓名:"+arr[i]);
  }
  //创建随机数对象
  Random r=new Random();
  //数组的长度作为抽取随机数的范围
  int a=r.nextInt(arr.length);
  //将随机抽取到的数值作为数组下标时输出的姓名即为抽取的学生姓名
  System.out.println("被点名的同学是"+arr[a]);
}