Java第七作业总结

    （1）Java中的程序代码可分为结构定义语句和功能执行语句。其中结构定义语句用于声明一个类或方法功能执行语句用于实现具体的功能，每条功能执行语句的最后都必须用分号（；）结束。
    （2） Java语言严格区分大小写。
    （3）虽然Java没有严格要求，用什么样的格式来编排程序代码，但是出于可读性的考虑，应该让自己编写的程序代码，整齐美观，层次清晰。
    （4） Java程序中一句连续的字符串不能分开在两行中书写。
               如果为了便于阅读，想将一个太长的字符串分在两行中书写，可以先将这个字符串分成两个字符串，然后用加号将这两个字符串连起来，在加号处断行。

Java中的注释

在编写程序时为了使代码与阅读，通常会在实现功能的同时为代码写一些注释。
注释是对程序的某个功能或某行代码的解释，说明它是在Java源文件中有效，在编译程序时编译器会忽略这些注射信息，我会将其注释到class字节码文件中去。
‌优点：方便阅读，方便记忆，阅读性强。
Java中的注释有三种类型，具体如下：

单行注释：通常用于对程序中的某一行代码进行解释，用符号“//”，“//”后面为被注释的内容。
多行注释：顾名思义就是在注释中的内容可以为多行，它以符号“/*”开头，以符号“*/”结尾。
文档注释：以“/**”开头，并在注释内容末尾以“*/”结束。

Java的标识符

在编程过程中，经常需要在程序中定义一些符号来标记一些名称，如:包名、类名、方法名、参数名、变量名等，这些符号被称为标识符。

标识符可以由任意顺序的大小写字母、数字、下划线、()和美元符号 ($)组成，但不能以数字开头，不能是Java中的关键字。

定义标识符还应对应一下规则:

1.包名所有字母一律小写。例如: cn.itcast.test。

2.类名和接口名每个单词的首字母都要大写。如AeeayList、 lterator。

3.常量名所有字母都要大写，单词之间用下划线连接。例如: DAY OF MONTH。

4.变量名和方法名的第一个单词首字母小写，从第二个单词开始每个单词首字母大写。例如:
lineNumber、getlineNumber。

5.在程序中，应该尽量使用有意义的英文单词来定义标识符，使得程序便于阅读。例如使用userName表示用户名，password表示密码。

Java中的关键字

关键字是编程语言里事先定义好并赋予了特殊含义的单词，也称作保留字。和其他语言一样，Java中保留了许多关键字，例如，class、public等，定义标识符的时候要避开程序中的关键字，以免造成误读或者报错。

Java中的常量

常量是在程序中固定不变的值，是不可以改变的数据。
在Java中，常量包括整型常量、浮点型常量、布尔常量、字符常量等。
1、整型常量：整型常量是整数常量的数据，它有四种形式。如：

二进制：有数字1和0组成的数字序列，如:000110010。生活中所有的整数——十进制是生活中最常的。
八进制：0~7的范围（包括0和7），没有7以后的数。如：0324。
十进制：数字0~9范围（包括0和9），如：198。整数以十进制表示时，第一位不能是0。
十六进制：以0x或者0X组成，后面是0~9、A~F(包括0、9、A、F)，如：0x25AF.
2、浮点数常量：

浮点数常量就是在数学中用到的小数，生活中带有小数点的小数。分为float单精度浮点数和double双精度浮点数两种类型。其中，单精度浮点数后面以F或f结尾，而双精度浮点数则以D或d结尾。当然，在使用浮点数时也可以在结尾处不加任何的后缀，此时虚拟机会默认为double双精度浮点数。浮点数常量还可以通过指数形式来表示。具体示例如下:2e3f 3.6d 0f 3.84d 5.022e+23f+

3、字符常量：

字符常量用于表示一个字符，一个字符常量要用一对英文半角格式的单引号('')引起来，它可以是英文字母、数字、标点符号、以及由转义序列来表示的特殊字符。具体示例如下:'a' '1' '&' '\r' '\u0000'
上面的示例中，"u0000表示一个空白字符，即在单引号之间没有任何字符。之所以能这样表示因为，Java采用的是Unicode字符集，Unicode字符以lu开头，空白字符在Unicode码表中对应的值为'\u0000'。
4、字符串常量：

字符串常量用于表示一串连续的字符，一个字符串常量要用一对英文半角格式的双引号("")引起来，具体示例如下:"HelloWorld" "123" "Welcome \n XXX" " "
一个字符串可以包含一个字符或多个字符，也可以不包含任何字符，即长度为零。
5、布尔常量:
布尔常量即布尔型的两个值true和false，该常量用于区分一个事物的真与假。它是一种真假的状态。一般条件成立或执行成功就用true表示;条件不成立或执行失败就用false表示。
6、null常量:
null常量只有一个值null，表示对象的引用为空。它是一个关键字。

变量的定义及其数据类型

变量的定义

在程序运行期间，随时可能产生一些临时数据，应用程序会将这些数据保存在一些内存单元中，每个内存单元都用一个标识符来标识。这些内存单元我们称之为变量，定义的标识符就是变量名，内存单元中存储的数据就是变量的值。
右边的代码中，第一行代码的作用是定义了两个变量x和y，也就相当于分配了两块内存单元，在定义变量的同时为变量x分配了一个初始值0，而变量y没有分配初始值，变量x和y在内存中的状态如图所示。

变量的数据类型

Java是一门强类型的编程语言，它对变量的数据类型有严格的限定。在定义变量时必须声明变量的类型，在为变量赋值时必须赋予和变量同一种类型的值，否则程序会报错。

1、整型类型变量

用来存储整数数值，即没有小数部分的值。
整数类型分为四种：字节型（byte）、短整型（short）、整型（int）和长整型（long）。

占用空间指的是不同类型的变量分别占用的内存大小。

取值范围是变量存储的值不能超出类型的范围，如果超出取值范围将会报错。

long类型：

当定义整数常量的时候，一般用long类型在数值后面用加字母“L”（或小写“l”）。

2、浮点数类型变量：

浮点数类型变量用来存储小数数值。
浮点数类型分为两种：单精度浮点数（float)，双精度浮点数（double)，double型所表示的浮点数比float型更精确。

float在为一个float类型的变量赋值时需要注意一点。所复制的后面一定要加上字母“F”（或“f”），而为double类型的变量赋值时，可以在所复制的后面加上字母“D”（或“d”），也可不加。

在程序中也可以为一个浮点类型变量赋予一个整数数值；但是一个整数不可以赋予一个浮点类型。

3.字符类型变量：

用于存储一个单一字符，在Java中用char表示。
每个char类型的字符变量都会占用两个字节。
赋值时要用英文半角格式的单引号（' '）把字符括起来，如'a'。
也可以赋值为0~65535范围内的整数。计算机会自动将这些整数转化为所对应的字符，如数值97对应的字符为'a'。

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

变量，数据类型以及赋值，就构成了变量定义的三要素

变量的类型转换

当把一种数据类型的值赋给另一种数据类型的变量时，需要进行数据类型转换。
根据转换方式的不同，数据类型转换可分为两种:自动类型转换和强制类型转换。(布尔类型不包括)

声明：
布尔类型不参与其中的转换，因为我们说过布尔类型的值只有两个值，所以它不能和其他类型混在一起使用要显式地进行声明

1、自动类型转换
也叫隐式类型转换，指的是两种数据类型在转换的过程中不需要显式地进行声明。
第一是两种数据类型彼此兼容，
第二是目标类型的取值范围大于源类型的取值范围。

byte b = 3:.int x= b; 
// 程序把 byte类型的变里b转换成了int 类型，无须特殊声明

(1) 整数类型之间可以实现转换，如byte类型的数据可以赋值给short、int、long类型的变量，short、char类型的数据可以赋值给intlong类型的变量，int类型的数据可以赋值给long类型的变量(2) 整数类型转换为float类型，如byte、char、short、int类型的数据可以赋值给float类型的变量。
(3) 其它类型转换为double类型，如byte、char、short、int、longfloat类型的数据可以赋值给double类型的变量。

2、强制类型转换
强制类型转换也叫显式类型转换，指的是两种数据类型之间的转换需要进行显式地声明
当两种类型彼此不兼容，或者目标类型取值范围小于源类型时，自动类型转换无法进行，这时就需要进行强制类型转换。

强制类型转换的格式如下所示:

目标类型变量 =（目标类型）值

（注意）在对变量进行强制类型转换时，会发生取值范围较大的数据类型向取值范围较小的数据类型的转换，如将一个int类型的数转为byte类型，这样做极容易造成数据精度的丢失。

变量的作用域

变量需要在它的作用范围内才可以被使用，这个作用范围称为变量的作用域。
在程序中，变量一定会被定义在某一对大括号中，该大括号所包含的代码区域便是这个变量的作用域。如果超出大括号范围，就会无效。（变量的作用域在编程中尤为重要）

双引号内部的是直接输出的，+就是说出多个内容起个连接作用，x表示x变量的值

算术运算符

算术运算符就是用来处理四则运算的符号，这是最简单、最常用的运算符号

算术运算符看上去比较简单，也很容易理解，但在实际使用时有很多需要注意的问题，具体如下:
(1)在进行自增 (++) 和自减 (--) 的运算时，如果运算符放在操作数的前面则是先进行自增或自减运算，再进行其它运算。反之，如果运算符放在操作数的后面则是先进行其它运算再进行自增或自减运算。
(2)在进行除法运算时，当除数和被除数都为整数时，得到的结果也是一个整数。如果除法运算有小数参与，得到的结果会是一个小数
(3) 在进行取模(%) 运算时，运算结果的正负取决于被模数(%左边的数)的符号，与模数(%右边的数)的符号无关

赋值运算符

赋值运算符的作用就是将常量、变量或表达式的值赋给某一个变量，表中列出了Java中的赋值运算符及用法。

在赋值运算符的使用中，需要注意以下几个问题!
(1) 在Java中可以通过一条赋值语句对多个变量进行赋值

int.X，Y，z；
X=Y=Z=5；//为三个变量同时赋值
intx=y=z=5；//这样写是错误的

（2）除了“_”，其它的都是特殊的赋值运算符，以“+=”为例，x += 3就相当于x=x+3，首先会进行加法运算x+3，再将运算结果赋值给变量x。-=、*=、/=、%=赋值运算符都可依此类推

在为变量赋值时，当两种类型彼此不兼容，或者目标类型取值范在为变量赋值时围小于源类型时，需要进行强制类型转换。

然而在使用+=、-=、*=、/=、%= 运算符进行赋值时，强制类型转换会自动完成，程序不需要做任何显式地声明。

比较运算符

比较运算符用于对两个数值或变量进行比较，其结果是一个布尔值，即true或false。

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

逻辑运算符

逻辑运算符用于对布尔型的数据进行操作，其结果仍是一个布尔型。

在使用逻辑运算符的过程中，需要注意以下几个细节:

(1)逻辑运算符可以针对结果为布尔值的表达式进行运算。如:x >3 &&y!=0。
(2)运算符“&”和“&&”都表示与操作，当且仅当运算符两边的操作数都为true时，其结果才为true，否则结果为false。当运算符“&”和“&&”的右边为表达式时，两者在使用上还有一定的区别。在使用“&”进行运算时，不论左边为true或者false，右边的表达式都会进行运算。如果使用“&&”进行运算，当左边为false时，右边的表达式不会进行运算，因此“&&”被称作短路与。

(3) 运算符“”和“|”都表示或操作，当运算符两边的操作数任何一边的值为true时，其结果为true，当两边的值都为false时，其结果才为false同与操作类似，“I1”表示短路或，当运算符“1”的左边为true时，右边的表达式不会进行运算
(4)运算符“^”表示异或操作，当运算符两边的布尔值相同时 (都为true或都为false)，其结果为false。当两边布尔值不相同时，其结果为true。

运算符的优先级

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

商城库存清单程序设计

 
 
/*
 * 商城库存清单案例
 * 变量的形式对商品的数据保存
 * 品牌，尺寸大小，价格，配置，库存数量
 * 三个商品 苹果，thinkpad,华硕
 * 
 * 计算出总的库存数，和商品的总金额
 */
public class Souhn {
 
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		//苹果笔记本电脑
		String macBrand = "MacBookAIR";
		double macSize = 13.3;
		double macPrice = 5998.99;
		String macConfig = "i5处理器4GB内存128GB固体硬盘";
		int macCount = 5;
		
		//联想Thinkpad笔记本电脑
		String thinkpadBrabd = "ThinkpadT450";
		double thinkpadSizs = 14.0;
		double thinkpadPrice = 5999.99;
		String thinkpadConfig = "i5处理器4GB内存500G硬盘";
		int thinkpadCount = 10;
		
		//华硕笔记本电脑
		String ASUSBrand = "ASUS-FL5800";
		double ASUSSize = 15.6;
		double ASUSPrice = 4999.50;
		String ASUSConfig = "i7处理器4G内存128G固态硬盘";
		int ASUSCount = 18;
		
		//列表的顶部
		System.out.println("------------------------------商城库存清单------------------------------");
		System.out.println(" 品牌型号          尺寸        价格            配置                 库存数");
		
		//列表的中部
		System.out.println(macBrand + "      "+macSize + "      "+macPrice + "   "+macConfig+"     "+macCount);
		System.out.println(thinkpadBrabd + "    "+thinkpadSizs + "      "+thinkpadPrice + "   "+thinkpadConfig+"        "+thinkpadCount);
		System.out.println(ASUSBrand + "     "+ASUSSize + "      "+ASUSPrice + "    "+ASUSConfig+"      "+ASUSCount );
		
		//统计总库存数 总库存金额
		int totalCount = macCount + thinkpadCount + ASUSCount;
		double totalMoney = (macPrice*macCount)+(thinkpadPrice*thinkpadCount)+(ASUSPrice*ASUSCount);
		
		//列表底部
		System.out.println("---------------------------------------------------------------------");
		System.out.println("总库存是:"+totalCount);
		System.out.println("库存商品总金额:"+totalMoney);
	}
 
}

代码运行结果如下：

if条件语句

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

(1) if语句
(2) if...else语句
(3) if...else if...else语句

由于这三种语法格式都有自身的特点，

1、if语:
if语句是指如果满足某种条件，就进行某种处理，其语法格式如下所示:

if； (条件语句]{
代码块

上述语法格式中，判断条件是一个布尔值，当值为true时，才会执行0中的语句。

2、if...else语句

if...else语句是指如果满足某种条件，就进行某种处理，否则就进行另一种处理，其语法格式如下所示：

it (判断){

执行语句1
--
}else{

执行语句2

--

}

3、if...else if...else语句

if...else if ...else语句用于对多个条件进行判断，进行多种不同的处理，其语法格式如下所示：

if（判断条件1）｛
执行语句1
｝else if（判断条件）｛
执行语句2
｝
…
else if（判断条件n）｛
执行语句n
｝else｛
执行语句n+1
｝

Switch条件语句

Switch语句也是一种很常见的选择语句。和if条件语句不同，他只能针对某个表达式的值做出判断，从而决定执行哪一段代码。
在Switch语句中，使用Switch关键词来描述一个表达式，使用case关键字来描述和表达式结果比较的目标值，当表达式的值和某个目标值匹配时，会执行对应case下的语句，Switch语句的基本语法结果如下图所示：

case 目标值 n:
执行语句 n

break;
default:

switch (表达式){

case 目标值 1:

执行语句 1

break;

case 目标值 2:

执行语句 2

break;

…………

执行语句 n+1

break;

}

注意:
1、条件表达式的返回值类型必须是以下类型之一:int 、byte、 char、short 、string(如果传入其他值，程序会报错。)
2、case子句中的值常量N必须是常量，而且所有case子句中的值应是不同的。
3、break语句用来在执行完一个case分支后，是程序跳出switch语句，即终止 switch语句的执行。
4、在一些特殊情况下，多个不同的case值执行一组相同的操作，这时可以不用break

while以及do..while循环嵌套

while循环语句

while语句和if条件语句有点类似，都是根据条件判断来决定是否执行后面的代码，区别在于，while循环语句会反复的进行条件判断，只要条件成立，｛｝内的执行语句就会执行，直到条件不成立，while循环结束。
While循环语句的语法结构如下所示：

while(循环条件) {

执行语句

.......

}

do...while循环语句

do...while循环语句和while循环语句功能类似。其语句结构如下：

do {

执行语句

.........

} while(循环条件);

for循环语句

For循环语句是最常用的循环语句，一般用在循环次数已知的情况下，其语法格式如下：

for(初始化表达式；循环条件；操作表达式）{

执行语句

......

}

在上述语法格式中， For后面的（）中包括三部分内容，初始化表达式、循环条件和操作表达式，他们之间用“；”分隔，｛｝中的执行语句为循环体。
如果用1表示初始化表达式（从for循环开始带结束只执行一次）、2表达循环条件、3表示操作表达式、4表示循环体，则for循环的执行流程如下：

for(1；2；3；){

4
}

第一步，执行1

第二步，执行2，如果判断结果为 true，执行第三步，如果判断结果为 false，执行第五步

第三步，执行4

第四步，执行3，然后重复执行第二步

第五步，退出循环

循环嵌套

外循环循环一次，内循环循环多次，所以他的总都循环次数，就是内外的乘积。
嵌套循环是指在一个循环语句的循环体中，再定义一个循环语句的语法结

for（初始化表达式；循环条件；操作表达式；）｛
….
for（初始化表达式；循环条件；操作表达式；）｛
执行语句
…….
｝

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

跳转语句（break）

用在switch条件语句和循环语句中，它的作用是终止某个case并跳出switch结构。出现在嵌套循环的内层时，他只能跳出内层循环，如果想跳出外层循环，则需要对外层循环添加标记

跳转语句（continue）

用在循环语句中，它的作用是终止本次循环，执行下一次循环。可以立刻重新开始下一轮循环，而不在循环循环后面的语句。

猜数字游戏

import java.util.Random;
import java.util.Scanner;
public class Hello {
 
 public static void main(String[] args) {
  //1、通过RANDOM类中的nextInt（n）方法，生成一个0-9之间的随机数
  int randomNumber =new SecureRandom().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) {
   //如果猜大了，打印sorry,您猜大了！继续下一次循环
    System.out.println("sorry,您猜大了！");
   }
   else {
    //如果猜小了，打印sorry,您猜小了！继续下一次循环
    System.out.println("打印sorry,您猜小了！");
   }
   //输入猜的数字
   System.out.println("-----请输入您的数字：-------");
   enterNumber=sc.nextInt();
  }
  System.out.print("恭喜您，答对了！");
 }
}

运行结果如下:

方法的定义及使用

什么是方法
假如在一个程序里需要重复的编写100行代码，这样程序就会变得很臃肿，可读性也非常差。所以我们需要把这100行代码抽取出来放在一个地方,在Java里面可以放在一个大括号里面,规定一个范围在这个范围里取个名字就叫做“方法”,当你想运行的时候只要拿出来用就可以了,这个时候你的程序就会变得设计的很好，代码的重复问题也得到了解决，阅读性增强,需要的时候调用那个方法即可。方法可以看作是一个完成一个功能的，具有独立性的代码的一个小片段,片段的范围就是Java中大括号里的范围。
在Java中，声明一个方法的具体语法格式如下：

修饰符返回值类型方法名（[参数类型参数名1，参数类型参数名2……]){
执行语句
……
return 返回值；
}

修饰符：是对访问权限的限定，例如，public、static都是修饰符
返回值类型：用于限定方法返回值的数据类型
参数类型：用于限定调用方法时传入参数的数据类型
参数名：是一个变量，用于接收调用方法时传入的数据
return关键字：用于结束方法以及返回方法指定类型的值
返回值：被return语句返回的值，该值会返回调用者

方法的重载

/*
 * 调用不同的方法
 */
public class Fangf {
 
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//下面针对求和的方法调用
		int sum1 = add01(1,2);
		int sum2 = add02(1,2,3);
		double sum3 = add03(1,2);
		//下面的代码是打印求和的结果
		System.out.println("sum1="+sum1);
		System.out.println("sum2="+sum2);
		System.out.println("sum3="+sum3);
	}
	//下面的方法实现两个小数相加
	private static double add03(double i, double j) {
		// TODO Auto-generated method stub
		return i+j;
	}
	//下面方法实现了三个整数相加
	private static int add02(int i, int j, int k) {
		// TODO Auto-generated method stub
		return i+j+k;
	}
	//下面的方法实现两个数整数相加
	private static int add01(int i, int j) {
		// TODO Auto-generated method stub
		return i+j;
	}
 
}

代码运行结果如下：

重载的特点： Java允许在一个程序中定义多个名称相同的方法，但是参数的类型或个数必须不同（个数不一样，类型不一样，顺序不一样也是重载），这就是方法的重载。（方法名相同，但是这个参数列表不一样）
重载和前面的内容没有关系，返回值没关系修饰符也没关系。只和方法名和参数列表有关系。

数组的定义

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

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

int[] x=new int[100]:

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

为了更好地理解数组的定义方式，可以把上述代码定义为两行来写，具体如下:

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

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

接下来，通过两张内存图来说明数组在创建过程中的内存分配情况，具体如下所示:

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

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

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

1.类型[] 数组名 = new 类型[](元素,元素，…………}；
2.类型[] 数组名 = (元素,元素，元素,…………};

1、每个数组的索引都有一个范围，即0~length-1。在访问数组的元素时，索引不能超出这个范围，否则程序会报错。

2、在使用变量引用一个数组时，变量必须指向一个有效的数组对象，如果该变量的值为null，则意味着没有指向任何数组，此时通过该变量访问数组的元素会出现空指针异常。

数组的常见操作

1.数组遍历
在操作数组时，经常需要依次访问数组中的每一个元素，这种操作叫做数组的遍历。
2.数组最值
在操作数组时，经常需要获取数组中元素的最值

定义变量 max 保存数组中0索引上的元素
max=arr[0]
max和数组中的其他索引上的元素进行比较
如果数组中的元素大于了变量max变量max记住住较大的数值
数组中所有的元素都遍历并且比较完成变量max,保存的就是数组中的最大值
3.数组排序
在操作数组时，经常需要对数组中的元素进行排序，其中冒泡排序是比较常见的一种算法。冒泡过程中，不断比较数组中相邻的两个元素，较小者向上浮，较大者往下沉，整个过程和水中气泡上升的原理相似。

数组排序的过程如下所示:
(1)从第一个元素开始，将相邻的两个元素依次比较，直到最后两个元素完成比较，如果第一个元素比后一个大，则交换位置。整个过程完成后，数组中最后一个元素就是最大值

(2) 除最后一个元素，将剩金的元素继续进行两两比较，过程与第一步类似，这样数组中第二大的元素放在了倒数第二个位置

(3)以此类推，持续对越来越少的元素重复上面的步骤，直到没有任何一个元素需要比较为止

多维数组的定义及使用

多维数组

多维数组可以简单地理解为在数组中嵌套数组。在程序中比较常见的就是二维数组。
二维数组的定义有很多方式，具体如下:
方式一:

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

上面的代码定义了一个3行4列的二维数组，它的结构如下图所示

方式二:

int[][] arr = neint[3][];

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

方式三:

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

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

接下来，通过一张图来描述方式三定义的数组结构

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

arr[0][1];

/*
 * 二维数组的使用
 */
public class Dhj {
 
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int [] [] arr = new int[3] [];//定义一个长度为3的二维数组
		arr[0] = new int[] {11,12};//为数组的元素赋值
		arr[1] = new int[] {21,22,23};
		arr[2] = new int[] {31,32,33,34};
		int sum = 0;//定义变量记录总销售额
		for(int i =0;i<arr.length;i++) {
			int gropuSum = 0;//定义变量记录小组的销售额
			for(int j = 0;j<arr[i].length;j++) {
				gropuSum = gropuSum+arr[i][j];
			}
			sum = sum + gropuSum;
			System.out.println("第"+(i+1)+"小组销售额为:"+gropuSum+"万元");
		}
		System.out.println("总销售额为:"+sum+"万元");
	}
 
}

运行结果如下：

随机点名器

/*
 * 随机点名器
 * */
 
import java.security.SecureRandom;
import java.util.Scanner;
public class Bhs {
 
   // 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 + 1)+"个姓名：");
   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+1)+"个学生姓名："+name);
  }
 }
 // 3、随机点其中一人
  
 public static String randomStudentName(String[] studrents) {
  //根据数组产孤独，获取随机数
  int index =new SecureRandom().nextInt(studrents.length);
  //通过随机索引从数组中获取名字
  String name =studrents[index];
  return name;
 }
 
public static void main(String[]args) {
 System.out.println("-----随机点名器--------");
 String[] students=new String[3];
 addStudentName(students);
 printStudentName(students);
 String randomName=randomStudentName(students);
 System.out.println("被点到名字的同学是："+randomName);
 
}
}

代码运行结果如下：

煦柒安

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java第七作业总结

当把一种数据类型的值赋给另一种数据类型的变量时，需要进行数据类型转换。根据转换方式的不同，数据类型转换可分为两种:自动类型转换和强制类型转换。布尔类型不包括声明不玩类型不参与其中的转换，因为我们说过布尔类型的值只有两个值，所以它不能和其他类型混在一起使用要显式地进行声明1、自动类型转换也叫隐式类型转换，指的是两种数据类型在转换的过程中不需要显式地进行声明。第一是两种数据类型彼此兼容，第二是目标类型的取值范围大于源类型的取值范围。
复制链接

扫一扫