第4天Java基础语法
今日内容介绍
◆随机点名器案例
◆库存管理案例封装
◆其他知识点
今日内容学习目标
◆能独立完成“随机点名器”案例源代码编写、编译及运行操作
◆能独立完成“库存管理”案例源代码编写、编译及运行操作
◆能够完成在源代码中使用方法进行运算操作
◆能够完成在源代码中使用数组进行运算操作
第1章随机点名器案例1.1案例介绍
随机点名器，即在全班同学中随机的打印出一名同学名字。
要做的随机点名器，它具备以下3个内容：
●存储所有同学姓名
●总览全班同学姓名
●随机点名其中一人，打印到控制台
在编写案例前，我们先来学习下本案例中所涉及到的知识点：
●方法
●数组
1.2案例学习目标
●能独立完成“随机点名器”案例源代码编写、编译及运行操作
●能够完成在源代码中使用方法进行运算操作
●能够完成在源代码中使用数组进行运算操作
1.3方法
今天我们来详细聊聊Java中的方法，那么，方法是什么呢？
假设有一个游戏程序，程序在运行过程中，要不断地发射炮弹。发射炮弹的动作需要编写100行的代码，在每次实现发射炮弹的地方都需要重复地编写这100行代码，这样会导致程序变得很臃肿，可读性也非常差。那么，为了解决代码重复编写的问题，我们可以将发射炮弹的代码提取出来放在一个{}中，并为这段代码起个名字，这样在每次发射炮弹的地方通过这个名字来调用发射炮弹的代码就可以了。上述过程中，所提取出来的代码可以被看作是程序中定义的一个方法，程序在需要发射炮弹时调用该方法即可。
接下来通过一些案例来介绍方法在程序中起到的作用，先来看一下在不使用方法时如何实现打印三个长宽不同的矩形，如下所示。MethodDemo01.java
public class MethodDemo01 {
public static void main(String[] args) {
// 下面的循环是使用*打印一个宽为5、高为3的矩形
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 5; j++) {
System.out.print("*");
}
System.out.println("");
}
System.out.println("");
// 下面的循环是使用*打印一个宽为4、高为2的矩形
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 4; j++) {
System.out.print("*");
}
System.out.println();
}
System.out.println();
// 下面的循环是使用*打印一个宽为10、高为6的矩形
for (int i = 0; i < 6; i++) {
for (int j = 0; j < 10; j++) {
System.out.print("*");
}
System.out.println();
}
System.out.println();
}
}
运行结果如下图所示。
图1-1运行结果
例程2-1在上述代码中，分别使用3个嵌套for循环完成了三个矩形的打印，仔细观察会发现，这3个嵌套for循环的代码是重复的，都在做一样的事情。此时，就可以将使用“*”打印
矩形的功能定义为方法，在程序中调用三次即可，修改后的代码如下所示。
MethodDemo02.java
1public class MethodDemo02 {
2public static void main(String[] args) {
3printRectangle(3, 5); // 调用 printRectangle()方法实现打印矩形
4printRectangle(2, 4);
5printRectangle(6, 10);
6}
7// 下面定义了一个打印矩形的方法，接收两个参数，其中height为高，width为宽
8public static void printRectangle(int height, int width) {
9// 下面是使用嵌套for循环实现*打印矩形
10for (int i = 0; i < height; i++) {
11for (int j = 0; j < width; j++) {
12System.out.print("*");
13}
14System.out.print("\n");
15}
16System.out.print("\n");
17}
18}
运行结果同MethodDemo01.java的运行结果相同，如下图所示。
图1-2运行结果
在上述代码中的第8行~第17行代码就定义了一个方法。其中，{}内实现打印矩形的代码是方法体，printRectangle()是方法名，第8行()中的height和width是方法的参数，方法名前面的void是方法的返回值类型。
在Java中，声明一个方法的具体语法格式如下：
修饰符返回值类型方法名(参数类型参数名1,参数类型参数名2,．．．．．．){
执行语句
………
return 返回值;
}
对于上面的语法格式中具体说明如下：
●修饰符：方法的修饰符比较多，有对访问权限进行限定的，有静态修饰符static，还有最终
修饰符final等，这些修饰符在后面的学习过程中会逐步介绍
●返回值类型：用于限定方法返回值的数据类型
●参数类型：用于限定调用方法时传入参数的数据类型
●参数名：是一个变量，用于接收调用方法时传入的数据
●return关键字：用于结束方法以及返回方法指定类型的值
●返回值：被return语句返回的值，该值会返回给调用者
需要特别注意的是，方法中的“参数类型参数名1，参数类型参数名2”被称作参数列表，它用于描述方法在被调用时需要接收的参数，如果方法不需要接收任何参数，则参数列表为空，即()内不写任何内容。方法的返回值必须为方法声明的返回值类型，如果方法中没有返回值，返回值类型要声明为void，此时，方法中return语句可以省略。
例程2-2由于MethodDemo02.java中的printRectangle()方法没有返回值，接下来通过一个案例来演示方法中有返回值的情况，如下图所示。MethodDemo03.java public class MethodDemo03 {
public static void main(String[] args) {
int area = getArea(3, 5); // 调用 getArea方法
System.out.println(" The area is " + area);
}
// 下面定义了一个求矩形面积的方法，接收两个参数，其中x为高，y为宽
public static int getArea(int x, int y) {
int temp = x * y; // 使用变量temp记住运算结果
return temp; // 将变量temp的值返回
}
}
运行结果如下图所示。
图1-3运行结果
在上述代码中，定义了一个getArea()方法用于求矩形的面积，参数x和y分别用于接收调用方法时传入的高和宽，return语句用于返回计算所得的面积。在main()方法中通过调用getArea()方法，获得矩形的面积，并将结果打印。
接下来通过一个图例演示getArea()方法的整个调用过程，如下图所示。
图1-4getArea()方法的调用过程
从上图中可以看出，在程序运行期间，参数x和y相当于在内存中定义的两个变量。当调用getArea()方法时，传入的参数3和5分别赋值给变量x和y，并将x*y的结果通过return语句返回，整个方法的调用过程结束，变量x和y被释放。
1.4数组
假设，现在需要统计某公司员工的工资情况，例如计算平均工资、最高工资等。假设该公司有50名员工，用前面所学的知识，程序首先需要声明50个变量来分别记住每位员工的工资，这样做会显得很麻烦。其实在Java中，我们可以使用一个数组来记住这50名员工的工资。数组是指一组数据的集合，数组中的每个数据被称作元素。在数组中可以存放任意类型的元素，但同一个数组里存放的元素类型必须一致。
1.4.1数组的定义
在Java中，可以使用以下格式来定义一个数组。如下
数据类型[] 数组名= new 数据类型[元素个数或数组长度];
int[] x = new int[100];
上述语句就相当于在内存中定义了100个int类型的变量，第一个变量的名称为x[0]，第二个变
量的名称为x[1]，以此类推，第100个变量的名称为x[99]，这些变量的初始值都是0。为了更好地
理解数组的这种定义方式，可以将上面的一句代码分成两句来写，具体如下：
int[] x; // 声明一个int[]类型的变量
x = new int[100]; // 创建一个长度为100的数组
接下来，通过两张内存图来详细地说明数组在创建过程中内存的分配情况。
第一行代码int[] x; 声明了一个变量x，该变量的类型为int[]，即一个int类型的数组。变量x 会占用一块内存单元，它没有被分配初始值。内存中的状态如下图所示。
图1-5内存状态图
第二行代码x = new int[100]; 创建了一个数组，将数组的地址赋值给变量x。在程序运行期间可以使用变量x来引用数组，这时内存中的状态会发生变化，如下图所示。
0x3000
……
……
new int[100]
int[] x
（数组的首地址）
0x3000
X[0]
X[1]
X[98]
X[99]
内存
图1-6内存状态图
在上图中描述了变量x引用数组的情况。该数组中有100个元素，初始值都为0。数组中的每个元素都有一个索引(也可称为角标)，要想访问数组中的元素可以通过“x[0]、x[1]、……、x[98]、x[99]”的形式。需要注意的是，数组中最小的索引是0，最大的索引是“数组的长度-1”。在Java中，为了方便我们获得数组的长度，提供了一个length属性，在程序中可以通过“数组名.length”的方式来获得数组的长度，即元素的个数。
接下来，通过一个案例来演示如何定义数组以及访问数组中的元素，如下所示。ArrayDemo01.java 1public class ArrayDemo01 {
2public static void main(String[] args) {
3int[] arr; // 声明变量
4arr = new int[3]; // 创建数组对象
5System.out.println("arr[0]=" + arr[0]); // 访问数组中的第一个元素
6System.out.println("arr[1]=" + arr[1]); // 访问数组中的第二个元素
7System.out.println("arr[2]=" + arr[2]); // 访问数组中的第三个元素
8System.out.println("数组的长度是：" + arr.length); // 打印数组长度
9}
10}
运行结果如下图所示。
图1-7运行结果
在上述代码中声明了一个int[]类型变量arr，并将数组在内存中的地址赋值给它。在5~7行代码中通过角标来访问数组中的元素，在第8行代码中通过length属性访问数组中元素的个数。从打印结果可以看出，数组中的三个元素初始值都为0，这是因为当数组被成功创建后，数组中元素会被自动赋予一个默认值，根据元素类型的不同，默认初始化的值也是不一样的。具体如下表所示。
数据类型默认初始化值
byte、short、int、long 0
float、double 0.0
char 一个空字符（空格），即’\u0000’
boolean false
引用数据类型null，表示变量不引用任何对象如果在使用数组时，不想使用这些默认初始值，也可以显式地为这些元素赋值。接下来通过一个程序来学习如何为数组的元素赋值，如下所示。ArrayDemo02.java
1public class ArrayDemo02 {
2public static void main(String[] args) {
3int[] arr = new int[4]; // 定义可以存储4个整数的数组
4arr[0] = 1; // 为第1个元素赋值1
5arr[1] = 2; // 为第2个元素赋值2
6// 下面的代码是打印数组中每个元素的值
7System.out.println("arr[0]=" + arr[0]);
8System.out.println("arr[1]=" + arr[1]);
9System.out.println("arr[2]=" + arr[2]);
10System.out.println("arr[3]=" + arr[3]);
11}
12}
运行结果如下图所示。
图1-8运行结果
在上述代码中，第3行代码定义了一个数组，此时数组中每个元素都为默认初始值0。第2、3行代码通过赋值语句将数组中的元素arr[0]和arr[1]分别赋值为1和2，而元素arr[2]和arr[3]没有赋值，其值仍为0，因此打印结果中四个元素的值依次为1、2、0、0。在定义数组时只指定数组的长度，由系统自动为元素赋初值的方式称作动态初始化。在初始化数组时还有一种方式叫做静态初始化，就是在定义数组的同时就为数组的每个元素赋值。数组的静态初始化有两种方式，具体格式如
下：
1、类型[] 数组名 = new 类型[]{元素，元素，……};
2、类型[] 数组名 = {元素，元素，元素，……};
上面的两种方式都可以实现数组的静态初始化，但是为了简便，建议采用第二种方式。接下来通过一段代码来演示数组静态初始化的效果，如下所示。ArrayDemo03.java
public class ArrayDemo03 {
public static void main(String[] args) {
int[] arr = { 1, 2, 3, 4 }; // 静态初始化
// 下面的代码是依次访问数组中的元素
System.out.println("arr[0] = " + arr[0]);
System.out.println("arr[1] = " + arr[1]);
System.out.println("arr[2] = " + arr[2]);
System.out.println("arr[3] = " + arr[3]);
}
}
运行结果如下图所示。
图1-9运行结果
上述代码中采用静态初始化的方式为数组每个元素赋予初值，分别是1、2、3、4。需要注意的是，第3行代码千万不可写成int[] x = new int[4]{1,2,3,4};，这样写编译器会报错。原因在于编译器会认为数组限定的元素个数[4]与实际存储的元素{1,2,3,4}个数有可能不一致，存在一定的安全隐患。
1.4.2数组遍历
在操作数组时，经常需要依次访问数组中的每个元素，这种操作称作数组的遍历。接下来通过一个案例来学习如何使用for循环来遍历数组，如下所示。ArrayDemo04.java
public class ArrayDemo04 {
public static void main(String[] args) {
int[] arr = { 1, 2, 3, 4, 5 }; // 定义数组
// 使用for循环遍历数组的元素
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]); // 通过索引访问元素
}
}
}
运行结果如下图所示。
图1-10运行结果
上述代码中，定义一个长度为5的数组arr，数组的角标为0~4。由于for循环中定义的变量i 的值在循环过程中为0~4，因此可以作为索引，依次去访问数组中的元素，并将元素的值打印出来。
1.4.3参数传递
参数传递，可以理解当我们要调用一个方法时，我们会把指定的数值，传递给方法中的参数，这样方法中的参数就拥有了这个指定的值，可以使用该值，在方法中运算了。这种传递方式，我们称为参数传递。
●在这里，定义方法时，参数列表中的变量，我们称为形式参数
●调用方法时，传入给方法的数值，我们称为实际参数
我们看下面的两段代码，来明确下参数传递的过程：
public class ArgumentsDemo01 {
public static void main(String[] args) {
int a=5;
int b=3;
change(a, b);//调用方法时，传入的数值称为实际参数
System.out.println("a=" + a);
System.out.println("b=" + b);
}
public static void change(int a, int b){//方法中指定的多个参数称为形式参数a=100;
b=200;
}
}
程序的运行结果如下：
再看另一段代码
public class ArgumentsDemo02 {
public static void main(String[] args) {
int[] arr = { 1, 2 };
change(arr);// 调用方法时，传入的数值称为实际参数
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
public static void change(int[] arr) {// 方法中指定的多个参数称为形式参数for (int i = 0; i < arr.length; i++) {
arr[i] *= 2;
}
}
}
程序的运行结果如下：
通过上面的两段程序可以得出如下结论：
●当调用方法时，如果传入的数值为基本数据类型（包含String类型），形式参数的改变对
实际参数不影响
●当调用方法时，如果传入的数值为引用数据类型（String类型除外），形式参数的改变对
实际参数有影响
1.5案例需求分析
在全班同学中随机的打印出一名同学名字。
我们对本案例进行分析，得出如下分析结果：
1.存储全班同学名字
2.打印全班同学每一个人的名字
3.在班级总人数范围内，随机产生一个随机数，查找该随机数所对应的同学名字
该案例须有以下3个内容：
●存储所有同学姓名
●总览全班同学姓名
●随机点名其中一人，打印到控制台
随机点名器明确地分为了三个功能。如果将多个独立功能的代码写到一起，则代码相对冗长，我们可以针对不同的功能可以将其封装到一个方法中，将完整独立的功能分离出来。
而在存储同学姓名时，如果对每一个同学都定义一个变量进行姓名存储，则会出现过多孤立的变量，很难一次性将全部数据持有。此时，我们可以使用数组解决多个数据的存储问题。
1.6实现代码步骤
编写CallName.java文件，完成程序的编写。
●存储所有同学姓名
/**
* 1.存储全班同学名字
* 创建一个存储多个同学名字的容器（数组）
* 键盘输入每个同学的名字，存储到容器中（数组）
*/
public static void addStudentName(String[] students) {
//键盘输入多个同学名字存储到容器中
Scanner sc = new Scanner(System.in);
for (int i = 0; i < students.length; i++) {
System.out.println("存储第"+i+"个名称：");
students[i] = sc.next();
}
}
上述方法中，通过键盘录入，完成为指定数组元素赋值。方法定义时，将参数定义为字符串数组，用于接收存放的同学姓名。
●总览全班同学姓名
/**
* 2打印全班同学每一个人的名字
*/
public static void printStudentName(String[] students) {
//遍历数组，得到每个同学名字
for (int i = 0; i < students.length; i++) {
String name = students[i];
//打印同学名字
System.out.println("第"+i+"个学生名称：" + name);
}
}
上述方法中，方法参数students数组中存储了所有学生的姓名。通过遍历将数组中的每一个元素访问一遍，得到每一个同学名称。
●随机点名
/**
* 3.在班级总人数范围内，随机产生一个随机数
*/
public static String randomStudentName(String[] students) {
//根据数组长度，获取随机索引
int index = new Random().nextInt(students.length);
//通过随机索引从数组中获取名称
String name = students[index];
//返回随机点到的名称
return name;
}
上述方法中，通过随机数类Random产生一个从0到数组长度的随机索引。使用该索引获取students数组中对应的值，便得到了全班同学的随机姓名。
●main方法中调用三个独立方法
public static void main(String[] args) {
System.out.println("--------随机点名器--------");
// 创建一个存储多个同学名字的容器（数组）
String[] students = new String[3];
/*
* 1.存储全班同学名字
*/
addStudentName(students);
/*
* 2.打印全班同学每一个人的名字
*/
printStudentName(students);
/*
* 3.获取随机点名到的学生姓名，并打印
*/
String randomName = randomStudentName(students);
System.out.println("被点到名的同学是 :" + randomName);
}
第2章库存管理案例
2.1案例介绍
现在，我们将原有的库存管理案例，进行业务逻辑的封装。
将对下列功能进行方法封装：
●打印库存清单功能
●库存商品数量修改功能
●退出程序功能
2.2案例学习目标
●能独立完成“库存管理”案例源代码编写、编译及运行操作
2.3案例需求分析
管理员能够进行的操作有3项（查看、修改、退出），我们可以采用（switch）菜单的方式来完成。
-------------库存管理------------
1.查看库存清单
2.修改商品库存数量
3.退出
请输入要执行的操作序号：
每一项功能操作，我们采用方法进行封装，这样，可使程序的可读性增强。
选择“1.查看库存清单”功能，则控制台打印库存清单
选择“2.修改商品库存数量”功能，则对每种商品库存数进行更新
选择“3.退出”功能，则退出库存管理，程序结束
2.4实现代码步骤
编写代码Demo库存管理.java，完成如下功能：
●功能菜单
/**
* 库存管理功能菜单
* @return管理员键盘输入的功能操作序号
*/
public static int chooseFunction() {
System.out.println("-------------库存管理------------");
System.out.println("1.查看库存清单");
System.out.println("2.修改商品库存数量");
System.out.println("3.退出");
System.out.println("请输入要执行的操作序号：");
//接收键盘输入的功能选项序号
Scanner sc = new Scanner(System.in);
int choose = sc.nextInt();
return choose;
}
上述方法用来完成库存管理功能菜单的显示、接收管理员选择的功能操作序号。这是完成了案例的第一步。接下来完成“查看、修改、退出”这三项功能。
●编写main主方法，调用库存管理功能菜单方法，与“查看、修改、退出”这三个方法。
public static void main(String[] args) {
//记录库存商品信息
//品牌型号
String[] brands = new String[]{"MacBookAir", "ThinkpadT450"};
//尺寸大小
double[] sizes = new double[]{13.3, 14.0};
//价格
double[] prices = new double[]{6988.88, 5999.99};
//配置
String[] configs = new String[]{"i5处理器4GB内存128G固态硬盘", "i5处理器4GB 内存500G硬盘"};
//库存个数
int[] counts = new int[]{0, 0};
//通过while循环模拟管理员进行功能重复选择操作
while (true) {
//打印功能菜单操作,接收键盘输入的功能选项序号
int choose = chooseFunction();
//执行序号对应的功能
switch (choose) {
case 1://查看库存清单
printStore(brands, sizes, prices, configs, counts);
break;
case 2://修改商品库存数量
update(brands, counts);
break;
case 3://退出
exit();
break;
default:
System.out.println("----------------------------------");
System.out.println("功能选择有误，请输入正确的功能序号!");
break;
}
}
}
在主方法中，创建了5个数组，分别用来存储商品的品牌型号、尺寸大小、价格、配置、库存个数，通过接收到的功能选项序号，进行switch语句判断后，调用对应的功能方法。
查看库存清单功能
/**
* 查看库存清单
* @param brands 商品品牌型号
* @param sizes 商品尺寸大小
* @param prices 商品价格
* @param configs 商品配置信息
* @param counts 商品库存个数
*/
public static void printStore(String[] brands, double[] sizes, double[] prices, String[] configs, int[] counts) {
//统计总库存个数、统计库存总金额
int totalCount = 0;
double totalMoney = 0.0;
for (int i = 0; i < brands.length; i++) {
totalCount += counts[i];
totalMoney += counts[i] * prices[i];
}
//列表顶部
System.out.println("---------------------------查看库存清单--------------------------");
System.out.println("品牌型号尺寸价格配置库存数");
//列表中部
for (int i = 0; i < brands.length; i++) {
System.out.println(brands[i]+" "+sizes[i]+" "+prices[i]+"
"+configs[i]+" "+counts[i]);
}
//列表底部
System.out.println("-------------------------------------------------------------");
System.out.println("总库存数："+totalCount);
System.out.println("库存商品总金额："+totalMoney);
}
上述方法用来完成打印库存清单功能，5个方法参数用来打印的库存商品相关信息
●修改商品库存数量功能
/**
* 修改商品库存数量
* @param brands 商品品牌型号
* @param counts 商品库存个数
*/
public static void update(String[] brands, int[] counts){
System.out.println("------------修改商品库存数量-----------");
for (int i = 0; i < brands.length; i++) {
System.out.println("请输入"+ brands[i] +"商品库存数");
counts[i] = new Scanner(System.in).nextInt();
}
}
上述方法用来完成修改商品库存数量功能，2个方法参数用来指定所要修改的商品与库存数
●退出功能
/**
* 退出
*/
public static void exit(){
System.out.println("----------------退出---------------");
System.out.println("您已退出系统");
System.exit(0);
}
上述方法用来完成退出程序的功能
第3章其他知识点
3.1方法的重载
我们假设要在程序中实现一个对数字求和的方法，由于参与求和数字的个数和类型都不确定，因此要针对不同的情况去设计不同的方法。接下来通过一个案例来实现对两个整数相加、对三个整数相加以及对两个小数相加的功能，具体实现如下所示。MethodDemo04.java
public class MethodDemo04 {
public static void main(String[] args) {
// 下面是针对求和方法的调用
int sum1 = add01(1, 2);
int sum2 = add02(1, 2, 3);
double sum3 = add03(1.2, 2.3);
// 下面的代码是打印求和的结果
System.out.println("sum1=" + sum1);
System.out.println("sum2=" + sum2);
System.out.println("sum3=" + sum3);
}
// 下面的方法实现了两个整数相加
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;
}
}
运行结果如下图所示。
图1-11运行结果
从上述代码不难看出，程序需要针对每一种求和的情况都定义一个方法，如果每个方法的名称都不相同，在调用时就很难分清哪种情况该调用哪个方法。为了解决这个问题，Java允许在一个类中定义多个名称相同的方法，但是参数的类型或个数必须不同，这就是方法的重载。接下来通过方
法重载的方式进行修改，如下所示。MethodDemo05.java
public class MethodDemo05 {
public static void main(String[] args) {
// 下面是针对求和方法的调用
int sum1 = add(1, 2);
int sum2 = add(1, 2, 3);
double sum3 = add(1.2, 2.3);
// 下面的代码是打印求和的结果
System.out.println("sum1=" + sum1);
System.out.println("sum2=" + sum2);
System.out.println("sum3=" + sum3);
}
// 下面的方法实现了两个整数相加
public static int add(int x, int y) {
return x + y;
}
// 下面的方法实现了三个整数相加
public static int add(int x, int y, int z) {
return x + y + z;
}
// 下面的方法实现了两个小数相加
public static double add(double x, double y) {
return x + y;
}
}
MethodDemo05.java的运行结果和MethodDemo04.java一样，如下图所示。
图1-12运行结果
上述代码中定义了三个同名的add()方法，它们的参数个数或类型不同，从而形成了方法的重载。在main()方法中调用add()方法时，通过传入不同的参数便可以确定调用哪个重载的方法，如add(1,2)调用的是两个整数求和的方法。值得注意的是，方法的重载与返回值类型无关，它只有两个条件，一是方法名相同，二是参数个数或参数类型不相同。
3.2数组的常见问题
数组在编写程序时应用非常广泛，灵活地使用数组对实际开发很重要。接下来，本节将针对数组的常见操作进行详细地讲解，如数组的遍历、最值的获取、数组的排序等。
3.2.1数组最值
在操作数组时，经常需要获取数组中元素的最值。接下来通过一个案例来演示如何获取数组中元素的最大值，如下所示。ArrayDemo05.java
public class ArrayDemo05 {
public static void main(String[] args) {
int[] arr = { 4, 1, 6, 3, 9, 8 }; // 定义一个数组
int max = getMax(arr); // 调用获取元素最大值的方法
System.out.println("max=" + max); // 打印最大值
}
static int getMax(int[] arr) {
int max = arr[0]; // 定义变量max用于记住最大数，首先假设第一个元素为最大值
// 下面通过一个for循环遍历数组中的元素
for (int x = 1; x < arr.length; x++) {
if (arr[x] > max) { // 比较 arr[x]的值是否大于max
max = arr[x]; // 条件成立，将arr[x]的值赋给max
}
}
return max; // 返回最大值max
}
}
运行结果如下图所示。
图1-13运行结果
上述代码中的getMax()方法用于求数组中的最大值，该方法中定义了一个临时变量max，用于记住数组的最大值。首先假设数组中第一个元素arr[0]为最大值，然后使用for循环对数组进行遍历，在遍历的过程中只要遇到比max值还大的元素，就将该元素赋值给max。这样一来，变量max就能够在循环结束时记住数组中的最大值。需要注意的是，在for循环中的变量i是从1开始的，这样写的原因是程序已经假设第一个元素为最大值，for循环中只需要从第二个元素开始比较，从而提高程序的运行效率。
3.2.2数组异常
3.2.2.1数组越界异常
每个数组的索引都有一个范围，即0~length-1。在访问数组的元素时，索引不能超出这个范围，否则程序会报错，如下所示。ArrayDemo06.java
1public class ArrayDemo06 {
2public static void main(String[] args) {
3int[] arr = new int[4]; // 定义一个长度为4的数组
4System.out.println("arr[0]=" + arr[4]); // 通过角标4访问数组元素
5}
6}
运行结果如下图所示。
上图运行结果中所提示的错误信息是数组越界异常ArrayIndexOutOfBoundsException，出现这个异常的原因是数组的长度为4，其索引范围为0~3，而上述代码中的第4行代码使用索引4来访问元素时超出了数组的索引范围。所谓异常指程序中出现的错误，它会报告出错的异常类型、出错的行号以及出错的原因，关于异常在后面的章节会有详细地讲解。
3.2.2.2空指针异常
在使用变量引用一个数组时，变量必须指向一个有效的数组对象，如果该变量的值为null，则意味着没有指向任何数组，此时通过该变量访问数组的元素会出现空指针异常，接下来通过一个案例来演示这种异常，如下所示。ArrayDemo07.java
1public class ArrayDemo07 {
2public static void main(String[] args) {
3int[] arr = new int[3]; // 定义一个长度为3的数组
4arr[0] = 5; // 为数组的第一个元素赋值
5System.out.println("arr[0]=" + arr[0]); // 访问数组的元素
6arr = null; // 将变量arr置为null
7System.out.println("arr[0]=" + arr[0]); // 访问数组的元素
8}
9}
运行结果如下图所示。
图1-14运行结果
通过上图所示的运行结果可以看出，上述代码中第4、5行代码都能通过变量arr正常地操作数组。第6行代码将变量置为null，当第7行代码再次访问数组时就出现了空指针异常NullPointerException。
3.3多维数组
在程序中可以通过一个数组来保存某个班级学生的考试成绩，试想一下，如果要统计一个学校
各个班级学生的考试成绩，又该如何实现呢？这时就需要用到多维数组，多维数组可以简单地理解为在数组中嵌套数组。在程序中比较常见的就是二维数组，接下来针对二维数组进行详细地讲解。
二维数组的定义有很多方式，接下来针对几种常见的方式进行详细地讲解，具体如下：
第一种方式：
int[][] arr = new int[3][4];
上面的代码相当于定义了一个3*4的二维数组，即二维数组的长度为3，二维数组中的每个元素又是一个长度为4的数组，接下来通过一个图来表示这种情况，如下图所示。
图1-15二维数组
第二种方式：
int[][] arr = new int[3][];
第二种方式和第一种类似，只是数组中每个元素的长度不确定，接下来通过一个图来表示这种情况，如下图所示。
图1-16二维数组
第三种方式：
int[][] arr = {{1,2},{3,4,5,6},{7,8,9}};
上面的二维数组中定义了三个元素，这三个元素都是数组，分别为{1,2}、{3,4,5,6}、{7,8,9}，接下来通过一个图来表示这种情况，如图2-54所示。
图1-17二维数组
对二维数组中元素的访问也是通过角标的方式，如需访问二维数组中第一个元素数组的第二个元素，具体代码如下：
arr[0][1];
接下来通过一个案例来熟悉二维数组的使用，例如要统计一个公司三个销售小组中每个小组的总销售额以及整个公司的销售额，如下所示。ArrayDemo08.java
1public class ArrayDemo08 {
2public static void main(String[] args) {
3int[][] arr = new int[3][]; // 定义一个长度为3的二维数组
4arr[0] = new int[] { 11, 12 }; // 为数组的元素赋值
5arr[1] = new int[] { 21, 22, 23 };
6arr[2] = new int[] { 31, 32, 33, 34 };
7
8int sum = 0; // 定义变量记录总销售额
9for (int i = 0; i < arr.length; i++) { // 遍历数组元素
西安邮电大学 （计算机学院） 课内实验报告 实验名称：数组与Java基础类 专业名称：计算机科学与技术 班级：计科1405班 学生姓名：高宏伟 学号：04141152 指导教师：刘霞林 实验日期：2016.10.27
一、实验目的 掌握Java中的数组定义、引用，掌握String类和StringBuffer类的使用。 二、实验要求 1．编写一个使用Java 数组的的程序。 2．编写一个使用String类的程序。 3．编写一个使用StringBuffer类的程序。 三、实验内容 (一) 使用数组求Fibonacci数列前10项之和 1.编写程序。 public class Fibonacci { public static void main(String args[]){ int i=0,j=1,s=0; for(int n=1;n<=5;n++){ s+=(i+j); i = (int)(i+j); j = (int)(i+j); } System.out.print("前10项之和是："+s); } } 2.编译并运行程序。 （二）练习String类的常用方法 ?实验要求： 编写一个Java应用程序，判断两个字符串是否相同，判断字符串的前缀、后缀是否和某个字符串相同，按字典顺序比较两个字符串的大小关系，检索字符串，创 建字符串，将数字型字符串转换为数字，将字符串存放到数组中，用字符数组创建 字符串。。 ?程序模板： StringExample.java class StringExample { public static void main(String args[]) { String s1=new String("you are a student"),s2=new String("how are you"); if(【代码1】) // 使用equals方法判断s1与s2是否相同 { System.out.println("s1与s2相同"); }
英语基础语法知识（一） 第一节词类和句子成分 一、词类 能够自由运用的最小语言单位叫词。根据词的形式、意义及其在句中的作用所作的分类叫词类（parts of speech）。 英语的词通常分为十大类，即名词、冠词、代词、数词、形容词、副词、动词、介词、连词和感叹词。现分别叙述如下： （一）名词 名词(noun)是表示人、事物、地点或抽象概念的名称。例如： foreigner外国人 soap 肥皂Newton牛顿 law 法律freedom自由peace和平 英语名词可分为两大类： < 1。普通名词(common noun)是某一类人、事物、某种物质或抽象概念的名称。例如： teacher教师 market市场rice大米 magazine杂志sound声音production生产 2。专有名词(proper noun)是特定的某人、地方或机构的名称。专有名词的第一个字母必须 大写。例如： Hemingway海明威 Russia 俄罗斯 New York 纽约 United Nations联合国 名词又可分为可数名词(countable noun)与不可数名词(uncountable noun)两种。可数名词有单、复数之分。绝大多数名词的复数形式的构成是在单数名词的后面加-s或-es。例如： shop→shops商店 bus→buses 公共汽车 library→libraries图书馆
toy→toys玩具leaf→leaves树叶 英语中有一些名词的复数形式是不规则的。例如： man→men男人tooth→teeth牙齿datum→data数据 有关名词复数形式构成的具体规则，请参阅有关的英语语法书。 （二）冠词 冠词(article)放在名词之前，帮助说明该名词所指的对象。冠词分为不定冠词(indefinite article)和定冠词(definite article)两种。 不定冠词为a/an，用在单数名词之前，表示某一类人或事物的“一个”。a用在以辅音开头的名词之前，an用在以元音开头的名词之前。例如： a hotel 一家旅馆 a chance 一次机会 a double room一个双人间 a useful book一本有用的书 an exhibition一次展览an honest man一个诚实的人 冠词只有一个，既the，表示某一类人或事物中特定的一个或一些。可用于单数或复数名词前，也可用于不可数名词前。例如： · the TV programs那些电视节目 the house那座房子 the Olympic Games奥运会 （三）代词 代词(pronoun)是用来指代人或事物的词。代词包括： 1。人称代词，如：I, you, they, it等； 2。物主代词，如：my, his, their, our, mine, hers等； 3。反身代词，如：myself, yourself, itself, ourselves, oneself等； 4。相互代词，如：each other, one another等； 5。指示代词，如：this, that, these, those, such, same等；
JAV A类和对象及数组习题 一、选择题 （1）下列构造方法的调用方式中，正确的是（D ）--原因：在通过new实例化一个类对象时系统会自动调用该类相应的构造方法。 A．按照一般方法调用B．由用户直接调用 C．只能通过new自动调用D．被系统调用 （2）在Java中，能实现多重继承效果的方式是（C ）--原因：一个类可以同时实现多个接口。Java接口反映了对象较高层次的抽象，还弥补了Java只支持单继承的不足，可用它来完成多继承的一些功能。 A．内部类B．适配器C．接口D．同步 （3）int型public成员变量MAX_LENGTH，该值保持为常数100，则定义这个变量的语句是( D )—原因：java中定义常量用关键字final来定义。 A．public int MAX_LENGTH=100 B．final int MAX_LENGTH=100 C．public const int MAX_LENGTH=100 D．public final int MAX_LENGTH=100 （4）下列叙述中，正确的是( A )—原因：Java严格区分大小写，所以变量number 与Number不相同；Java 中的注释方式除了“//”行注释之外还有段注释“/*-------*/”和文档注释/**-------*/。Java源文件中的public类只能有一个。 A. 声明变量时必须指定一个类型 B. Java认为变量number与Number相同 C. Java中唯一的注释方式是"//" D. 源文件中public类可以有0或多个 （5）下列叙述中，错误的是( D )—原因：子类继承父类，并且可以有自己的成员变量和成员方法。所以可以认为子类是父类的扩展。
Java类数组的使用方法一 注意一定要把类数组的每一个元素都赋值，否则就报错，既对类数组对象的一空声明，如果并没有实例化，会报空指针异常：NullPointerException 1.创建类类型的数组方法一： 创建一个Person类，在main方法中创建p1,p2,p3,p4 几个Person 类的实例化对象。然后再使用如下代码创建类类型的数组p。Product [] p=new Product[]{p1,p2,p3,p4}; public class Test { public static void main(String[] args) { Product p1=new Product(); https://www.doczj.com/doc/60541651.html,="豆浆机"; Product p2=new Product(); https://www.doczj.com/doc/60541651.html,="电视机"; Product p3=new Product(); Product p4=new Product(); Product [] p=new Product[]{p1,p2,p3,p4};//创建类类型的数组方法一 for(int i=0;i } } class Product{ int Num; String name; } 2.创建类类型的数组方法二： public class Test { public static void main(String[] args) { Product p1=new Product(); Product p2=new Product(); Product p3=new Product(); Product p4=new Product(); Product [] p={p1,p2,p3};//创建类类型的数组方法二for(int i=0;i 一填空题 1)数组的元素通过数组下标来访问，数组Array的长度为元素的个数 （Array.length）。 2)Java中数组的下标的数据类型是整形。 3)不用下标变量就可以访问数组的方法是数组名。 4)数组最小的下标是0 。 5)arraycopy()的最后一个参数指明复制元素的个数。 6)向方法传递数组参数时，传递的是数组的引用。 7)数组初始化包括数组的声明，创建，初始化。 8)数组下标访问超出索引范围时抛出数组越界异常 9)浮点型数组的默认值是0.0f 。 10)对象型数组的默认值是null 。 二选择题 1.下面错误的初始化语句是_A B D__ A. char str[]="hello"; B. char str[100]="hello"; C. char str[]={'h','e','l','l','o'}; D. char str[]={'hello'}; 2.定义了一维int型数组a[10]后，下面错误的引用是_B_ A. a[0]=1; B. a[10]=2; C. a[0]=5*2; D. a[1]=a[2]*a[0]; 3.下面的二维数组初始化语句中，正确的是__B__ A. float b[2][2]={0.1,0.2,0.3,0.4}; B. int a[][]={{1,2},{3,4}}; C. int a[2][]= {{1,2},{3,4}}; D. float a[2][2]={0}; 4.引用数组元素时，数组下标可以是__D__ A. 整型常量 B. 整型变量 C. 整型表达式 D. 以上均可 5.定义了int型二维数组a[6][7]后，数组元素a[3][4]前的数组元素个数为__C__ A. 24 B. 25 C. 18 D. 17 6.下列初始化字符数组的语句中，正确的是_B___ A. char str[5]="hello"; B. char str[]={'h','e','l','l','o','\0'}; C. char str[5]={"hi"}; D. char str[100]=""; 7.数组在Java中储存在 C 中 A. 栈 B. 队列 C. 堆 D. 链表 1 数组的概念 和其他语言一样，Java也提供数组支持，数组是属于引用类型，即数组是一个 对象。 强调数组的类型是引用类型。 数组的基本概念及作用 数组是相同数据类型元素的集合 数组本身是引用数据类型，即对象。但是数组可以存储基本数据类型，也可以存储引用数据类型。 数组的举例 int [] a = new int []{1,2,3,4,5}; String [] s = new String []{"小熊","小小熊","小小小熊"}; Employee [] e=new Employee[10];（Employee是自定义类） 2 数组的声明 数组的声明的两种方式： 数据类型 [] 数组名字例如：int [] a; 数据类型数组的名字 [] 例如： int a []; 注意： 在Java语言中两种声明方法没有任何区别，但是建议大家用第一种，避免混淆a的数据类型。 数组在声明后还只是一个空指针，不能使用，要想使用必须创建。 数组创建的三种方式： ?//声明数组的同时，根据指定的长度分配内存，但数组中元素值都为默认的初始化值 char[] chAry = new char[10]; ?//声明数组并分配内存，同时将其初始化 ?int[] ary1 = new int[]{1, 2, 3, 4, 5}; ?//与前一种方式相同，仅仅只是语法相对简略 ?int[] ary2 = {1, 2, 3, 4, 5}; 从另一个角度，数组创建可以分为动态和静态两种 动态创建数组（没有为元素赋值，可以结合for循环进行赋值） char[] chAry = new char[10]; 静态创建数组，在创建的时候，即为每个元素赋初值 int[] ary1 = new int[]{1, 2, 3, 4, 5}; 数组的长度 数组的长度：length属性 int [] b1 = new int []{1,2,3,4,5,6,7}; System.out.println(b1.length); 注意：数组的长度是属性，String的长度是length（）； 创建数组的时候必须指定数组的长度，而且一经定义则不允许改变。 数组的长度虽然是7，但是在内存中实际给8个位置，另外一个存储7. 数组之间赋值 在C语言中，不可以将数组直接赋值给另一个数组； 英语基础语法知识（一）第一节词类和句子成分一、词类能够自由运用的最小语言单位叫词。根据词的形式、意义及其在句中的作用所作的分类叫词类（parts of speech）。英语的词通常分为十大类，即名词、冠词、代词、数词、形容词、副词、动词、介词、连词和感叹词。现分别叙述如下：（一）名词名词(noun)是表示人、事物、地点或抽象概念的名称。例如： foreigner外国人 soap 肥皂 Newton 牛顿 law 法律 freedom自由 peace 和平英语名词可分为两大类： 1。普通名词(common noun)是某一类人、事物、某种物质或抽象概念的名称。例如： teacher 教师 market市场 rice 大米 magazine杂志 sound 声音 production生产 2。专有名词(proper noun)是特定的某人、地方或机构的名称。专有名词的第一个字母必须大写。例如： Hemingway海明威 Russia 俄罗斯 New York 纽约 United Nations联合国名词又可分为可数名词(countable noun)与不可数名词(uncountable noun)两种。可数名词有单、复数之分。绝大多数名词的复数形式的构成是在单数名词的后面 加-s或-es。例如： shop→shops商店 bus→buses 公共汽车 library→libraries图书馆 toy→toys 玩具 leaf→leaves树叶英语中有一些名词的复数形式是不规则的。例如： man→men男人 tooth→teeth 牙齿 datum→data数据有关名词复数形式构成的具体规则，请参阅有关的英语语法书。 （二）冠词冠词(article)放在名词之前，帮助说明该名词所指的对象。冠词分为不定冠词(indefinite article)和定冠词(definite article)两种。不定冠词为a/an，用在单数名词之前，表示某一类人或事物的“一个”。a 用在以辅音开头的名词之前，an用在以元音开头的名词之前。例如： a hotel 一家旅馆 a chance 一次机会 a double room一个双人间a useful book 一本有用的书 an exhibition一次展览 an honest man一个诚实的人冠词只有一个，既the，表示某一类人或事物中特定的一个或一些。可用于单数或复数名词前，也可用于不可数名词前。例如：the TV programs 那些电视节目 the house那座房子 the Olympic Games奥运会 （三）代词代词(pronoun)是用来指代人或事物的词。代词包括： 1。人称代词，如：I, you, they, it等； 一填空题 1)数组的元素通过下标来访问，数组Array的长度为Array.length 。 2)数组复制时，"="将一个数组的引用传递给另一个数组。 3)JVM将数组存储在栈(堆或栈)中。 4)数组的二分查找法运用的前提条件是数组已经排序。 5)Java中数组的下标的数据类型是整型。 6)数组最小的下标是0 。 7)arraycopy()的最后一个参数指明复制元素的个数。 8)向方法传递数组参数时，传递的是数组的引用。 9)数组初始化包括数组的申明，创建和初始化。 10)数组下标访问超出索引范围时抛出数组越界异常 11)浮点型数组的默认值是0.0f 。 12)数组创建后其大小不能改变。 二选择题 1.下面错误的初始化语句是_ABD__ A. char str[]="hello"; B. char str[100]="hello"; C. char str[]={'h','e','l','l','o'}; D. char str[]={'hello'}; 2.定义了一维int型数组a[10]后，下面错误的引用是_B__ A. a[0]=1; B. a[10]=2; C. a[0]=5*2; D. a[1]=a[2]*a[0]; 3.下面的二维数组初始化语句中，正确的是____ A. float b[2][2]={0.1,0.2,0.3,0.4}; B. int a[][]={{1,2},{3,4}}; C. int a[2][]= {{1,2},{3,4}}; D. float a[2][2]={0}; 4.引用数组元素时，数组下标可以是_D___ A. 整型常量 B. 整型变量 C. 整型表达式 D. 以上均可 5.定义了int型二维数组a[6][7]后，数组元素a[3][4]前的数组元素个数为____ A. 24 B. 25 C. 18 D. 17 6.下列初始化字符数组的语句中，正确的是__B__ A. char str[5]="hello"; B. char str[]={'h','e','l','l','o','\0'}; C. char str[5]={"hi"}; D. char str[100]=""; 7.数组在Java中储存在 C 中 A. 栈 B. 队列 C. 堆 D. 链表 8.下面程序的运行结果是____ main() { int a[][]={{1,2,3},{4,5,6}}; System.out.printf("%d", a[1][1]); } A. 3 B. 4 C. 5 D. 6 9.下面程序的运行结果是_C___ main() { 若想要存放一连串相同数据类型的数据，使用数组是个相当好用的选择。此外，如果某个程序片段经常反复出现，那么将它定义成一个方法可以有效地简化程序代码。本章主要是介绍数组的基本用法与方法的应用，学完本章，将会对数组与方法的使用有更深一层的认识。 数组是由一组相同类型的变量所组成的数据类型，它属于引用类型。它们以一个共同的名称表示，数组中的每个元素则以下标来访问。数组依照存放元素的复杂程度分为一维数组、二维和多维数组，先来看看一维数组。 3.1 一维数组 一维数组可以存放上千万个数据，并且这些数据的类型是完全相同的。可以将它简单的理解为是相同数据类型的数据的集合。 3.1.1 一维数组的声明与内存的分配 要使用Java的数组，必须经过两个步骤： （1）声明数组 （2）给数组分配内存 这两个步骤的语法如下： 数据类型数组名[ ]; 或数据类型[ ] 数组名; // 声明一维数组 数组名= new 数据类型[个数]; // 给数组分配内存 数组的声明格式里，“数据类型”是声明数组每个元素的数据类型，常见的类型有整型、浮点型与字符型等，也可以是引用类型。“数组名”是用来统一这组相同数据类型的元素的名称，其命名规则和变量的相同，建议使用有意义的名称为数组命名。数组声明后，接下来便是要配置数组所需的内存，其中“个数”是告诉编译器，所声明的数组要存放多少个元素，而“new”则是命令编译器根据括号里的个数，在内存中开辟一块内存供该数组使用。 需要注意的是，在Java中声明数组的时候，不能在[]中指定其长度。比如：int score[3]; // 错误 下面是关于一维数组的声明并分配内存给该数组的一个范例： int score[]; // 声明整型数组score score = new int[3]; // 为整型数组score分配内存空间，其元素个数为3 在上例中的第一行，当声明一个整型数组score时，score可视为数组类型的变量，此时这个变量并没有包含任何内容，编译器仅会分配一块内存给它，用来保存指向数组实体的地址，如图3-1所示。 图3-1 声明整型数组 声明之后，接着要做内存分配的操作，也就是上例中第二行语句。这一行会开辟3个可供保存整数的内存空间，并把此内存空间的参考地址赋给score变量。其内存分配的流程如图3-2所示。 英语基础语法知识 第一节词类和句子成分 一、词类 能够自由运用的最小语言单位叫词。根据词的形式、意义及其在句中的作用所作的分类叫词类（parts of speech）。 英语的词通常分为十大类，即名词、冠词、代词、数词、形容词、副词、动词、介词、连词和感叹词。现分别叙述如下： （一）名词 名词(noun)是表示人、事物、地点或抽象概念的名称。例如： foreigner外国人soap 肥皂Newton牛顿 law 法律freedom自由peace和 平 英语名词可分为两大类： 1。普通名词(common noun)是某一类人、事物、某种物质或抽象概念的名称。例如： teacher教师market市场rice大 米 magazine杂志sound声音production生产 2。专有名词(proper noun)是特定的某人、地方或机构的名称。专有名词的第一个字母必须 大写。例如： Hemingway海明威Russia 俄罗斯 New York 纽约United Nations联合国 名词又可分为可数名词(countable noun)与不可数名词(uncountable noun)两种。可数名词有单、复数之分。绝大多数名词的复数形式的构成是在单数名词的后面加-s或-es。例如： shop→shops商店bus→buses 公共汽车library→libraries图书馆 toy→toys玩具leaf→leaves树叶 英语中有一些名词的复数形式是不规则的。例如： man→men男人tooth→teeth牙齿datum→data数据 有关名词复数形式构成的具体规则，请参阅有关的英语语法书。 （二）冠词 冠词(article)放在名词之前，帮助说明该名词所指的对象。冠词分为不定冠词(indefinite article)和定冠词(definite article)两种。 不定冠词为a/an，用在单数名词之前，表示某一类人或事物的“一个”。a用在以辅音开头的名词之前，an用在以元音开头的名词之前。例如： a hotel 一家旅馆 a chance 一次机会 a double room一个双人间 a useful book一本有用的书 an exhibition一次展览an honest man一个诚实的人 冠词只有一个，既the，表示某一类人或事物中特定的一个或一些。可用于单数或复数名词前，也可用于不可数名词前。例如： the TV programs那些电视节目the house那座房子 the Olympic Games奥运会 （三）代词 代词(pronoun)是用来指代人或事物的词。代词包括： 1。人称代词，如：I, you, they, it等； 2。物主代词，如：my, his, their, our, mine, hers等； 3。反身代词，如：myself, yourself, itself, ourselves, oneself等； 4。相互代词，如：each other, one another等； 5。指示代词，如：this, that, these, those, such, same等； 1.知识点 一维数组：定义、初始化、使用（相关的算法，常用系统类的使用） 多维数组：定义、初始化、使用 增强for循环，break、continue控制语句的学习 2.讲解 什么是数组？ 例子 //要求把一个班的一门课的成绩，加起来求平均值； import java.util.*; class Average{ public static void main(String[] args){ Scanner sc = new Scanner(System.in); float avg=0; float sum=0; int count=1; while(count<=3){ sum=sum+sc.nextFloat(); count++; } avg=sum/(count-1); System.out.println("平均值是:"+avg); System.out.println("程序结束"); } } //新要求：我要在输出平均值的同时，也要将这门课的最高分，最低分，同时也要能看到这门的成绩 数组概念：一组能够存储相同数据类型值的变量的集合。 在java中我们本着一切是对象的原则，我们把数组在java中看成是对象，数组对象。数组是最基本的引用型数据类型。 一维数组的知识点 定义方法： 1、三步法 A、int[] arr;用来申明数组的引用，在栈中为arr开辟内存； B、arr = new int[5];这是为数组arr在堆中为数组元素开辟6个存储单元； C、把数组在堆中的起始位置给了arr这个引用变量 *一般我们的程序在运行时，我们为局部变量在栈中开辟内存，而为对象(对象属性)在堆中开辟内存。为对象方法在方法区开辟内存空间。为类的属性，在静态区开辟内存空间。 具体的内存图： 初中英语语法入门基础 知识 公司内部编号：（GOOD-TMMT-MMUT-UUPTY-UUYY-DTTI- 语法基础知识 词法 规则名词单数变复数： 1)一般情况下，在名词后加-s; 2)词尾是s,x,ch,sh结尾的词，在词尾后加-es; 3)“辅音字母+y”结尾的词，变y为i，再加-es;以y结尾的专有名词或“元音字母+y”结尾的词，直接加-s; 4)以“+o”结尾的词，一般在词尾加-s;在词尾加-es的词： 黑人（Negro）英雄（hero）爱吃西红柿（tomato）土豆（potato） 5)以-f/fe结尾的词，变复数，将-f/fe改为v加es; 不规则名词单数变复数： 1）含 man（男人）的词一般变为 men 2）将 oo 改为 ee 的有foot-feet（脚）tooth-teeth（牙刷goose-geese(鹅肉笨蛋) 3）以 en结尾的有 child-childen（孩子） ox-oxen（公牛） 4）将 ouse 改为 ice 的 mouse-mice（老鼠） 5）单复数同形的是 sheep（羊）deer（鹿）Chinese（中国人） 注：fish ①作“鱼肉”讲，为不可数名词，没有复数形式 ②作“鱼类”讲，复数形式为fishes； ③作“鱼的条数”讲，复数形式为fish，单复同形。 冠词 冠词通常放在名词前，分为定冠词the，表特指，和不定冠词an（后接元音音素开头的单词）和a（后接辅音音素开头的单词），表泛指。 定冠词使用顺口溜： 特指、重提和唯一，岛屿、海峡和海湾； 海洋、党派、最高级，沙漠、河流与群山； 方位、顺序和乐器，年代、团体与机关； 船名、建筑和组织，会议、条约与报刊； 姓氏复数、国全名，请你记住用定冠； 零冠词 月，季，星期，节假、周、头衔、职务前、三餐、球类、惯用语、学科、棋类名词前，一般不用任何冠词。 基数词变序数词歌 基变序，有规律 词尾加上-th(fourth,sixth) 一、二、三，特殊例， 结尾字母t,d,d(first,second,third) 八去t,九去e,(eighth,ninth) ve要用 f替;(fifth,twelfth) ty将y改成i, th前面有个e。 若是碰到几十几， 前用基来后用序。 人称代词，物主代词和反身代词 Java中数组的声明 一维数组的声明： 在Java中，数组是独立的对象，有自身的方法，不是变量的集合。 数组的声明： 类型标识符数组名[ ] 或者类型标识符[] 数组名。 数组的长度是在创建的时候决定的。 数组的创建方法： 先声明后创建： int array[]; array = new int[10]; 在声明的同时创建： int array[] = new int[10]; 直接赋值： int array[]= new int[1,2,3,4]; 数组下标从0开始。 数组是引用类型，他的元素相当于类的成员变量，因此数组分配空间后，每个元素也被按照成员变量的规则被隐士地初始化。如： public class Testpublic static void main(Stirng [] args)?? int [] a = new int [5]; ?? Date[] days=new Date[3]; ?? System.out.println(a[3]); ?? System.out.println(days[2]);} class Dateint year,month,day; Date(int year,int month,int day)?? this.year=year; ?? this.month=month; ?? this.day=day;} 结果将是：0????? null 数组的拷贝 最有效率的方法是使用https://www.doczj.com/doc/60541651.html,ng.System类的静态方法： public static void arraycopy(object src,int srcPos,object dest, ???????????????? int destPos,int length) 可以用于数组src从第srcPos项元素开始的length个元素拷贝到目标数组从destPos项开始的length个位置。 如果源数据数目超过目标数组的边界，系统就会抛出异常。 二维数组 float[][] numthree;???????????? //定义一个float类型的2维数组 numthree=new float[5][5];?????? //为它分配5行5列的空间大小 numthree[0][0]=1.1f;??????????? //通过下标索引去访问???? 1行1列= 1.1 numthree[1][0]=1.2f;????????????????????????????????? // 2行1列=1.2 numthree[2][0]=1.3f;????????????????????????????????? // 3行1列=1.3 numthree[3][0]=1.4f;????????????????????????????????? // 4行1列=1.4 第一章词类和句子成分 第一节词类 能够自由运用的最小语言单位叫词。根据词的形式、意义及其在句中的作用所作的分类叫词类（parts of speech）。英语的词通常分为十大类，即名词、冠词、代词、数词、形容词、副词、动词、介词、连词和感叹词。 一、名词 名词(noun)是表示人、事物、地点或抽象概念的名称。例如： foreigner外国人soap肥皂Newton牛顿 law法律 freedom自由peace和平 英语名词可分为两大类： 1、普通名词(common noun)是某一类人、事物、某种物质或抽象概念的名称。例如： teacher教师market市场rice大米 magazine杂志 sound 声音production生产 2、专有名词(proper noun)是特定的某人、地方或机构的名称。专有名词的第一个字母必须大写。例如： Hemingway海明威Russia俄罗斯 New York纽约United Nations联合国 名词又可分为可数名词(countable noun)与不可数名词(uncountable noun)两种。可数名词有单、复数之分。绝大多数名词的复数形式的构成是在单数名词的后面加-s或-es。例如： shop→shops商店 bus→buses公共汽车 library→libraries图书馆 toy→toys玩具leaf→leaves树叶 英语中有一些名词的复数形式是不规则的。例如： man→men男人 tooth→teeth牙齿 datum→data数据 二、冠词 冠词(article)放在名词之前，帮助说明该名词所指的对象。冠词分为不定冠词(indefinite article)和定冠词(definite article)两种。 不定冠词为a/an，用在单数名词之前，表示某一类人或事物的“一个”。a 用在以辅音开头的名词之前，an用在以元音开头的名词之前。例如： 数组与List之间相互转换的方法详解 1.List转换成为数组。（这里的List是实体是ArrayList) 调用ArrayList的toArray方法。 toArray public T[] toArray(T[] a)返回一个按照正确的顺序包含此列表中所有元素的数组；返回数组的运行时类型就是指定数组的运行时类型。如果列表能放入指定的数组，则返回放入此列表元素的数组。否则，将根据指定数组的运行时类型和此列表的大小分配一个新的数组。 如果指定的数组能容纳列表并有剩余空间（即数组的元素比列表的多），那么会将数组中紧跟在集合末尾的元素设置为null。这对确定列表的长度很有用，但只在调用方知道列表中不包含任何null 元素时才有用。 指定者： 接口Collection 中的toArray 指定者： 接口List 中的toArray 覆盖： 类AbstractCollection 中的toArray 参数： a - 要存储列表元素的数组，如果它足够大的话；否则，它是一个为存储列表元素而分配的、具有相同运行时类型的新数组。 返回： 包含列表元素的数组。 抛出： ArrayStoreException - 如果a 的运行时类型不是此列表中每个元素的运行时类型的超类型。 具体用法： 复制代码代码如下: List list = new ArrayList(); list.add("1"); list.add("2"); finalint size = list.size(); String[] arr = (String[])list.toArray(new String[size]); 2.数组转换成为List 调用Arrays的asList方法. JDK 1.4对java.util.Arrays.asList的定义，函数参数是Object[]。所以，在1.4中asList()并不支持基本类型的数组作参数。 JDK 1.5中，java.util.Arrays.asList的定义，函数参数是Varargs, 采用了泛型实现。同时由于autoboxing 的支持，使得可以支持对象数组以及基本类型数组。 不过在使用时，当传入基本数据类型的数组时，会出现小问题，会把传入的数组整个当作返回的List中的第一个元素，例如： 复制代码代码如下: public static void main(String[] args){ int[] a1 = new int[]{1,2,3}; String[] a2 = new String[]{"a","b","c"}; System.out.println(Arrays.asList(a1)); System.out.println(Arrays.asList(a2)); } 1.打印结果如下： 复制代码代码如下: 1 2 [[I@dc8569] [a, b, c] 下面说说Arrays.asList()的返回值： JDK文档是这么说的： public static 学号 Java语言程序设计C 实验报告 实验2 数组及常用算法 学生姓名 专业、班级 指导教师 成绩 计算机与信息工程学院 年月日 一、实验目的 学习课程相关章节知识，通过上机练习，掌握以下知识： 1．掌握Java中对象和引用变量的概念 2．掌握Java数组的使用和本质 3．掌握数组相关常用算法（复制及排序方法） 二、实验内容 写一个方法，功能：定义一个一维的int 数组，长度为10，把从控制台输入整数赋值给数组,然后将它们按从小到大的顺序输出（使用冒泡排序）（知识点：数组遍历、数组元素访问） 三、实验思想 1．Java中对象和引用变量的概念 2．Java数组的使用和本质 3．数组相关常用算法（复制及排序方法） 四、实验结果 package sss; import java.util.Scanner; public class aaa { public static void main(String[] args) { // TODO自动生成的方法存根 Scanner input=new Scanner(System.in); System.out.println("排序之前的数组："); int a[]=new int[10]; for(int b=0;b 语法基础知识 词法 规则名词单数变复数： 1)一般情况下，在名词后加-s; 2)词尾是s,x,ch,sh结尾的词，在词尾后加-es; 3)“辅音字母+y”结尾的词，变y为i，再加-es;以y结尾的专有名词或“元音字母+y”结尾的词，直接加-s; 4)以“+o”结尾的词，一般在词尾加-s;在词尾加-es的词： 黑人（Negro）英雄（hero）爱吃西红柿（tomato）土豆（potato） 5)以-f/fe结尾的词，变复数，将-f/fe改为v加es; 不规则名词单数变复数： 1）含man（男人）的词一般变为men 2）将oo 改为ee 的有foot-feet（脚）tooth-teeth（牙刷goose-geese(鹅肉笨蛋) 3）以en结尾的有child-childen（孩子）ox-oxen（公牛） 4）将ouse 改为ice 的mouse-mice（老鼠） 5）单复数同形的是sheep（羊）deer（鹿）Chinese（中国人） 注：fish ①作“鱼肉”讲，为不可数名词，没有复数形式 ②作“鱼类”讲，复数形式为fishes； ③作“鱼的条数”讲，复数形式为fish，单复同形。 冠词 冠词通常放在名词前，分为定冠词the，表特指，和不定冠词an（后接元音音素开头的单词）和a（后接辅音音素开头的单词），表泛指。 定冠词使用顺口溜： 特指、重提和唯一，岛屿、海峡和海湾； 海洋、党派、最高级，沙漠、河流与群山； 方位、顺序和乐器，年代、团体与机关； 船名、建筑和组织，会议、条约与报刊； 姓氏复数、国全名，请你记住用定冠； 零冠词 月，季，星期，节假、周、头衔、职务前、三餐、球类、惯用语、学科、棋类名词前，一般不用任何冠词。 基数词变序数词歌 基变序，有规律 词尾加上-th(fourth,sixth) 一、二、三，特殊例， 结尾字母t,d,d(first,second,third) 八去t,九去e,(eighth,ninth) ve要用f替;(fifth,twelfth) ty将y改成i, th前面有个e。 若是碰到几十几， 前用基来后用序。 人称代词，物主代词和反身代词 我你她他它我们你们他们 人称代词主 格 I you she he it we you they 宾 格 me you her him it us you them 物主代词形 容 词 性 my your her his its our your their 名 词 性 mine yours hers his its ours yours theirs 反身代myself yourself herself himself itself ourselves yourselves themselves java中数组的定义及使用方法详解 数组：是一组相关变量的集合 数组是一组相关数据的集合，一个数组实际上就是一连串的变量，数组按照使用可以分为一维数组、二维数组、多维数组 数据的有点 不使用数组定义100个整形变量：int i1;int i2;int i3 使用数组定义 int i[100]; 数组定义：int i[100];只是一个伪代码，只是表示含义的 一维数组 一维数组可以存放上千万个数据，并且这些数据的类型是完全相同的，使用java数组，必须经过两个步骤，声明数组和分配内存给该数组，声明形式一 声明一维数组：数据类型数组名[]=null; 非配内存给数组：数组名=new 数据类型[长度]; 声明形式二 声明一维数组：数据类型 [] 数组名=null; java数据类型分为两大类 基本数据类型 int、long操作的时候本身就是具体的内容 引用数据类型：数组、类、接口 引用传递的就是一个内存的使用权，一块内存空间，可能有多个人同 时使用 事例声明数组 package com.qn.array; public class Test { public static void main(String[] args) { int score[]=null;//声明数组 score=new int[3];//开辟空间，大小为3 } } 数组的声明格式里，数据类型是数组元素的数据类型，常见的有整形、浮点型、与字符型等 数组名是用来统一这组相同数据类型元素的名称，其命名规则和变量的相同 数组声明后实际上是在栈内存中保存了此数组的名称，结下了是要在堆内存中配置数组所需要的内存，齐产固定是告诉编译器，所声明的数组要存放多少个元素，而new 则是命令编译器根据括号里的长度 基本数据类型偶读有其默认值：int 0;只要是引用数据类型默认值就是null 事例 package com.qn.array;Java_数组练习题目
java数组的概念和作用
英语基础语法基础版
Java数组练习题(带答案)
Java数组与方法
(完整word版)英语语法基础入门
java中数组的学习完整版一
初中英语语法入门基础知识
Java中数组的声明
英语语法基础知识适合入门基础者
JAVA数组与List之间相互转换的方法详解
Java实验报告-数组及常用算法
初中英语语法入门基础知识
java中数组的定义及使用方法详解
相关主题
文本预览