Java基础知识复习一
目录
2.1 Java的基本语法
Java中的注释
Java中的标识符
Java中的关键字
Java中的常量
2.2 Java中的变量
变量的定义
变量的数据类型
变量的类型转换
变量的作用域
2.3Java中的运算符
算术运算符
赋值运算符
比较运算符
逻辑运算符
编辑
运算符的优先级
案例篇：
2.4 选择结构语句
if条件语句
switch条件语句
2.5 循环结构语句
while循环语句
do...while循环语句
for循环语句
循环嵌套
跳转语句（break、continue)
猜数字游戏（案例篇）
2.6 方法
什么是方法
方法的重载
2.7 数组
数组的定义
数组的常见操作
多维数组
随机点名器（案例篇）
2.1 Java的基本语法
在Java代码中，代码必须放在一个类里面，类需要使用class关键词定义，class前面可以放一些修饰词，格式如下：
写Java代码时，要注意的关键的：
1、Java中的程序代码可分为结构程序语句和功能执行语句，结构定义语句用于声明一个类或方法，功能执行语句用于实现具体的功能。
public class Diyige {//定义类
public static void main(String[] args) {//主方法
// TODO Auto-generated method stub
System.out.print("我写的第一个程序");//输出
}
}
2、Java语言严格区分大小写。例如，定义一QQ个类时，Computer和computer是两个完全不同的符号，使用时一定要注意。
3、格式编排出于可读性的考虑，应该把代码写的整齐美观，层次清晰。以下两种方法都可以，但是建议使用后一种。
方法一：
方法二：
- 4、Java程序中一句连续的字符串不能分开在两行中书写，否则会报错。例如：
- 如果字符串太长，不方便阅读，想要分成两行，可以先将这个字符串分成两个字符串，然后用加号（+）将这两个字符串连起来，在加号（+）处断行，可以直接在换行的地方点回车键，就会自动加上加号（+）。上面的语句可以修改成如下形式：
Java中的注释
- 在编写程序时，为了使代码易于阅读，通常会在实现功能的同时为代码加一些注释。
- 注释是对程序的某个功能或某行代码的解释说明，它只在Java源文件中有效，在编译时会忽略注释，不会出现在class文件中。优点：方便阅读，方便记忆，阅读性强。
Java中的注释分三种，如下：
- 单行注释：通常用于解释某一行的代码，用符号“//”表示，“//”后面为注释内容。单行注释可以写在要解释的这行代码后面也可以加在前面。如：
- 多行注释：就是在注释中的内容可以为多行，它以符号“ /* ”开头，以符号” */ “结尾。注释中再添加注释：多行注释里面可以添加单行注释，多行注释只看开头结尾，不管中间内容，但是不能再次添加另外一个多行注释。如：
- 文档注释：以” /** “开头，并以” */ ”结束。
Java中的标识符
在编译过程中，经常需要在程序中定义一些符号来标记一些名称，如：包名、类名、方法名、参数名、变量名等，这些符号被称为标识符。
标识符可以是任意顺序的大小写字母、数字、下划线（_）和美元符号（$）组成。数字不能做开头，不能是关键字。
- 标识符：所有字母有五十二个，严格区分大小写。
- 包名：全都是小写字母
- 类名：首字母大写，如果是两个单词或以上，每个单词的首字母都要大写，如：HowAreYou
- 常量名所有字母都大写，单词之间用下划线连接。例如:DAY_OF_MONTH。
- 变量名和方法名的第一个单词首字母小写，从第二个单词开始每个单词首字母大写。例如:lineNumber、getlineNumber。
- 在程序中，应该尽量使用有意义的英文单词来定义标识符，使得程序便于阅读。例如使用userName表示用户名，password表示密码。
Java中的关键字
关键字是编程语言里事先定义好并赋予了特殊含义的单词，也称作保留字。如：class，public。
定义标识符的时候要避开程序中的关键字，以免造成误读或者报错。下面例举的是java中所有的关键字：
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，表示对象的引用为空。它是一个关键字。
2.2 Java中的变量
变量的定义
- 在程序运行期间，随时可能产生一些临时数据，应用程序会将这些数据保存在一些内存单元中，每个内存单元都用一个标识符来标识。这些内存单元我们称之为变量，定义的标识符就是变量名，内存单元中存储的数据就是变量的值。
- 右边的代码中，第一行代码的作用是定义了两个变量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.自动类型转换
- 也叫隐式类型转换，指的是两种数据类型在转换的过程中不需要显式的进行声明。
- 要实现自动类型转换，必须同时满足两个条件：第一是两种数据类型彼此兼容。第二是目标类型的取值范围大于源类型的取值范围。
自动类型转换就是把小的转化为大的数。
（1）整数类型之间可以实现转换。 如byte类型的数据可以赋值给short、int、long类型的变量，short、char类型的数据可以赋值int、long类型的变量， int类型的数据可以赋值给long类型的变量。
（2）整数类型转换为float类型。如byte、char、short、int类型的数据可以赋值给float类型的变量。
（3）其他类型转换为double类型，如byte、char、short、int、long、float类型的数据可以赋值给double类型的变量。
2.强制类型转换
- 强制类型转换也叫显示类型转换，指的是两种数据类型之间的转换需要进行显式的声明。
- 当两种类型彼此不兼容，或者目标类型取值范围小于源类型时，自动类型转换无法进行，这时就需要进行强制类型转换。
- 强制类型转换的格式如下所示：目标类型 变量 =（目标类型）值
强制类型转换就是大的转换成小的数。
变量的作用域
- 变量需要在它的作用范围内才可以被使用，这个作用范围称为变量的作用域。
- 在程序中，变量一定会被定义的某一对大括号中，该大括号所包含的代码区域便是这个代码的作用域。如果超出大括号范围，就会无效。
2.3Java中的运算符
算术运算符
算术运算符就是用来处理四则运算的符号，这就是最简单、最常用的运算符号。
算术运算符需要注意的问题：
- 在进行自增（++）和自减（--）的运算时，如果运算符放在操作数的前面则是先进行自增或自减运算，再进行其他运算。反之，如果运算符放在操作数的后面。则是先进行其他运算再进行自增或自减运算。
- 在进行除法运算时，当除数和被除数都为整数时，得到的结果也是一个整数。如果除法运算有小数参与，得到的结果也是一个小数。
- 在进行取模（%）运算时，运算结果的正负取决于被模数（%左边的数）的符号，与模数（%右边的数）的符号无关。
赋值运算符
赋值运算符的作用就是将常量、变量或表达式的赋值给某一个变量，表中列出了Java中的赋值运算符及用法。
在赋值运算符的使用中，需要注意以下几个问题：
- 在Java中可以通过一条赋值语句对多个变量进行赋值
- 除了“=”，其他的都是特殊的赋值运算符，以“+=”为例，X+=3就相当X=x+3，首先会进行加法运算x+3，再将运算结果赋值给变量x。-=、*=、/=、%=赋值运算符都可依此类推。
- 在为变量赋值时，当两种类型彼此不兼容，或者目标类型取值范围小于源类型时，需要进行强制类型转换。
- 然而在使用+=, -=, *=, /=, %=运算符进行赋值时，强制类型转换会自动完成，程序不需要做任何显式的声明。
比较运算符
- 比较运算符 两个数值或变量进行比较，比较运算结果是一个布尔值，即true或false。
- 在比较运算中，不能将比较运算符“==”误写成赋值运算符“=”。 要注意两个符号之间不能隔开
逻辑运算符
逻辑运算符用于对布尔型的数据进行操作，其结果仍是一个布尔值。
逻辑与，两者都为真，结果才是真；逻辑或，只要有一者为真，结果就是真；逻辑非，非真即假，非假即真
- 逻辑运算符可以针对结果为布尔值的表达式进行运算。
运算符的优先级
在对一些比较复杂的表达式进行运算时，要明确表达式中所有运算符参与运算的先后顺序，把这种顺序称作运算符的优先级。
案例篇：
/*
* 商城库存清单案例
* 变量的形式对商品的数据保存
* 品牌，尺寸大小，价格，配置，库存数量
* 三个商品 苹果，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);
}
}运算结果：
2.4 选择结构语句
if条件语句
if语句是指如果满足某种条件就进行某种处理。
语法：
if（条件语句）｛
代码块
｝
流程图：
if...else语句是指如果没有满足某种条件就进行某种处理，否则就进行另一种处理。
语法如下：
if（判断条件）｛
执行语句1
……
｝
else｛
执行语句
…..
｝
在java中有一种特殊的运算叫做三元运算，它和if…else语句类似，语法如下：
判断条件 ？ 表达式1 ：表达式2
三元运算通常用于对某个变量进行赋值，当判断条件成立时，运算结果为表达式一的值，否则结果为表达2的值
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语句的基本语法结果如下图所示：
/*
* Switch语句
*/
public class Tdshj {
public static void main(String[] args) {
// TODO Auto-generated method stub
int week = 8;
switch(week) {
case 1:
System.out.println("星期一");
break;
case 2:
System.out.println("星期二");
break;
case 3:
System.out.println("星期三");
break;
case 4:
System.out.println("星期四");
break;
case 5:
System.out.println("星期五");
break;
case 6:
System.out.println("星期六");
break;
case 7:
System.out.println("星期日");
break;
default:
System.out.println("输入的数字不正确...");
break;
}
}
}
运行结果：
注意:
1、条件表达式的返回值类型必须是以下类型之一:int 、byte、 char、short 、string(如果传入其他值，程序会报错。)
2、case子句中的值常量N必须是常量，而且所有case子句中的值应是不同的。
3、break语句用来在执行完一个case分支后，是程序跳出switch语句，即终止 switch语句的执行。
4、在一些特殊情况下，多个不同的case值执行一组相同的操作，这时可以不用break
2.5 循环结构语句
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（初始化表达式；循环条件；操作表达式；）｛
….
for（初始化表达式；循环条件；操作表达式；）｛
执行语句
…….
｝
……
｝
/*
* for循环(使用*打印直角三角形)
*/
public class Ghj {
public static void main(String[] args) {
// TODO Auto-generated method stub
int i,j;//定义两个循环变量
for(i = 1;i<=9;i++) {//外层循环
for(j = 1;j<=i;j++) {//内层循环
System.out.print("*");//输出
}
System.out.print("\n");//换行
}
}
}运行结果：
跳转语句（break、continue)
跳转语句用于实现循环执行过程中程序流程的跳转，在Java中的跳转语句有break语句和continue语句
-
break语句：用在switch条件语句和循环语句中，它的作用是终止某个case并跳出switch结构。出现在嵌套循环的内层时，他只能跳出内层循环，如果想跳出外层循环，则需要对外层循环添加标记
-
continue语句：用在循环语句中，它的作用是终止本次循环，执行下一次循环。可以立刻重新开始下一轮循环，而不在循环循环后面的语句。
break语句:
/*
* break语句
*/
public class Hello{
public static void main(String[] args) {
int x=1;//定义变量x，初始化值为1
while(x<=4) {//循环条件
System.out.println("x="+x);//条件成立，打印x的值
if(x==3) {
break;
}
x++;//x进行自增
}
}
}
运行结果：
/*
* break语句（跳出外层循环）
*/
public class Hello{
public static void main(String[] args) {
int i,j;//定义两个循环变量
incast:for(i=1;i<=9;i++) {//外层循环
for(j=i;j<=i;j++) {//内层循环
if(i>4) {
break incast;
}
System.out.print("*");//打印
}
System.out.println("\n");//换行
}
}
}运行结果：
continue语句：
/*
* continue语句
*/
public class Contiu {
public static void main(String[] args) {
// TODO Auto-generated method stub
int sum = 0;//定义变量sum，用于记住和
for(int i=1;i<=100;i++) {
if(i%2==0) {//i是一个偶数，不累加
continue;//结束本次循环
}
sum += i;//实现sum和i的累加
}
System.out.println(sum);
}
}
运行结果：
猜数字游戏（案例篇）
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("恭喜您，答对了！");
}
}运算结果：
2.6 方法
什么是方法
- 假设一个游戏程序，程序在运行过程中，要不断的发射炮弹。发射炮弹的动作需要编写100行的代码，在每次实现发射炮弹的地方，都需要重复的编写这100行代码，这样程序会变得很臃肿，可读性也非常差。
- 为了解决代码重复编写的问题，可以将发射炮弹的代码提取出来放在一个｛｝中，并为这段代码起个名字，然后每次发射炮弹的地方通过这个名字来调用代码就可以了。
- 上述过程中所提取出来的代码可以被看作是程序中的一个方法，程序在需要发射炮弹时调用该方法即可。
- 方法可以看成完成一个功能的，具有独立性的代码的一个小的片段。
/*
* 不适用方法时实现打印三个长宽不同的矩形
*/
public class Ff {
public static void main(String[] args) {
// TODO Auto-generated method stub
//下面的循环是使用*打印宽为5，高为3的矩形
for(int i = 0; i<3 ; i++) {
for(int j = 0;j < 5; j++) {
System.out.print("*");
}
System.out.print("\n");
}
//下面的循环是使用*打印宽为4，高为2的矩形
for(int i = 0; i < 2; i++){
for(int j = 0; j < 4; j++) {
System.out.print("*");
}
System.out.print("\n");
}
//下面的循环是使用*打印宽为10，高为6的矩形
for(int i = 0;i < 6; i++){
for(int j = 0;j < 10; j++) {
System.out.print("*");
}
System.out.print("\n");
}
}
}
运行结果：
在Java中，声明一个方法的具体语法格式如下：
修饰符 返回值类型 方法名([参数类型 参数名1，参数类型 参数名2，......]){
执行语句
..........
return 返回值
}
- 修饰符：是对访问权限的限定，例如：public、static都是修饰符
- 返回值类型：用于限定方法返回值的数据类型。
- 参数类型：用于限定调用方法时传入参数的数据类型。
- 参数名：是一个变量，用于接收调用方法时传入的数据。
- return关键字：用于结束方法以及返回方法指定类型的值。
- 返回值：被return语句返回的值，该值会返回调用者。
- 方法名首字母需要大写。
/*
* 使用有返回值的方法求矩形面积
*/
public class FangDing {
public static void main(String[] args) {
// TODO Auto-generated method stub
int area = getArea(3,5);//调用getArea方法
System.out.println("The area i7" + area);//输出
}
//下面定义了一个求矩形面积的方法，接收两个参数，其中x为高，y为宽
private static int getArea(int i, int j) {
// TODO Auto-generated method stub
return i * j;
}
}
运行结果：
方法的重载
/*
* 调用不同的方法
*/
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允许在一个程序中定义多个名称相同的方法，但是参数的类型或个数必须不同（个数不一样，类型不一样，顺序不一样也是重载），这就是方法的重载。（方法名相同，但是这个参数列表不一样）
重载和前面的内容没有关系，返回值没关系修饰符也没关系。只和方法名和参数列表有关系。
2.7 数组
数组的定义
是用来存储一组或多组相同类型数据的数据类型
在程序中，可以通过“数组名.length”的方式来获取数组的长度，也就是元素的个数。
正在初始化数组时还有一种方式叫做静态初始化，就是在定义数组的同时就为数组的每个元素赋值。数组的静态初始化有两种方式。
- 类型【】数组名=new类型【】｛元素，元素，……｝；
- 类型【】数组名=｛元素，元素，….｝；
/*
* 定义数组以及访问数组中的元素
*/
public class Dmi {
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] arr;//声明变量
arr = new int[100];//创建数组的容器
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.length);//输出数组的长度
}
}
运行结果：
1、每个数组的索引都有一个范围，从0～length-1，在访问数组的元素时，索引不能超过这个范围，否则程序会报错
2、在使用变量引用一个数组时，变量必须指向一个有效的数组对象，如果该变量的值为null，则意味着没有指向任何数组，此时通过该变量访问数组的元素会出现空指针异常。
数组的常见操作
- 数组遍历：在操作数组时，经常需要依次访问数组中的每个元素，这种操作叫做数字的遍历。
索引思想，操作数组中的元素，赋值还是获取值，都是依赖索引 arr［0］
索引思想：操作数组。arr［0］赋值，获取
循环：循环的变量，从0开始，每次递增。
/*
* for循环遍历数组
*/
public class Ujs {
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] arr = {1,2,3,4,5};//定义数组
//使用for循环遍历数组的元素
for(int i = 0;i运行结果：
- 数组排序：在操作数组时，经常需要对数组中的元素进行排序，其中冒泡排序是比较常见的一种算法。冒泡过程中，不断比较数组中相邻的两个元素，较小者向上浮，较大者往下沉，整个过程中水中气泡上升的原理相似。
- 从第1个元素开始，将相邻的两个元素依次比较，直到最后两个元素完成比较，如果第1个元素比后一个大，则交换位置。整个过程完成后，触组中最后一个元素就是最大值。（相邻的两个元素进行比较换位 ）（数组元素换位：临时变量）
/*
* 冒泡排序
*/
public class Maopao {
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] arr = {9,4,5,3,7};//定义数组，赋值无序
System.out.println("冒泡排序前：");
pintArray(arr);//输出数组元素
bubbleSort(arr);//调用排序的方法
System.out.println("冒泡排序后：");
pintArray(arr);//输出数组元素
}
//定义打印数组的元素的方法
public static void pintArray(int[] arr) {
//循环遍历数组的元素
for(int i=0;iarr[j+1]) {//比较相邻的元素
//
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1]=temp;
}
}
}
}
}
运行结果：
- 除最后一个元素，将剩下的元素继续进行两两比较，过程与第1步类似，这样数组中第二大的元素放在了倒数第2个位置。
- 以此类推，持续对越来越少的元素重复上面的步骤，直到没有任何一个元素需要比较为止。
/*
* 获取数组中的最大值
*/
public class Rji {
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] arr = {4,1,16,3,9,8};//定义一个数组
int max = getMax(arr);//调用获取最大值的方法
System.out.println("max="+max);//输出最大值
}
private static int getMax(int[] arr) {
// TODO Auto-generated method stub
int max = arr[0];//定义变量max用于记住最大值。首先保存数组中的第0个索引上的元素
//下面通过一个for循环遍历数组中的元素
for(int x=1;xmax) {//比较arr[x]的值是否大于max
max=arr[x];//条件成立，将arr[x]的值赋值给max
}
}
return max;//返回最大值
}
}
运行结果：
多维数组
多维数组可以简单地理解为在数组中的嵌套数组。在程序中比较常见的就是二维数组。
二维数组的定义方式:
方式一：int【】【】arr=new int【n】【m】
特点：元素固定
方式二：int【】【】arr=new int【n】【】
特点：可以让一维数组储存的元素是可变的
方式三：int【】【】arr=｛｛1，2｝，｛3，4，5，6｝，｛7，8，9｝｝；
直接把里面的所有元素的都附上
二维数组的访问同样也是通过索引去访问的
/*
* 二维数组的使用
*/
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运行结果：
随机点名器（案例篇）
/*
* 随机点名器
* */
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运行结果：
