第一篇Java基础知识复习博客
JAVA基本语法
JAVA代码基本格式
修饰符 class 类名{
程序代码
}
Java中的程序代码可分为
结构定义语句：
用于声明一个类或方法，例如{}
功能执行语句：
用于实现具体的功能
注：每条功能执行语句的最后都必须用分号（;）结束
Java语言严格区分大小写
例：定义一个类时，Computer和computer是两个完全不同的符号
JAVA程序中一句连续的字符串不能分开在两行书写
例：
System.out.println(“这是第一个
Java程序！”);
这样书写编译时将会出错
·如果字符串太长，一定要分两行进行书写，可以将这个字符串分成两个字符串，用（+）符号的形式将两个字符串连起来
例：
System.out.println(“这是第一个” +
“Java程序！”);
JAVA中的注释
对程序的某个功能或者某行代码的解释说明，编译器会自动忽略这些注释
单行注释：通常用于对程序中的某一行代码进行解释，用符号“//”表示，“//”后面为注释的内容
例：
Int c = 10; //定义一个整型变量
多行注释：注释中的内容可以为多行，以符号“/*”开头，以符号“*/”结尾
例：
/* int c = 10;
Int x = 5; */
文档注释：以“/**”开头，以“*/”结束
JAVA中的标识符
例：包名，类名，方法名，参数名，变量名等，这些符号都被称为标识符
补：标识符可以由任意大小写字母，数字，下划线（_），美元符号（$）组成，但不能以数字开头，不能是JAVA中的关键字
定义标识符要遵循的规则：
- 包名所有字母一律小写 例：cn.itcast.test
- 类名和接口名每个单词的首字母都要大写 例：ArrayList,Lterator
- 常量名所有字母都大写，单词之间用下划线连接 例：DAY_OF_MONTH
- 变量名和方法名的第一个单词首字母小写，从第二个单词开始每个单词首字母大写 例：lineNumver,getLineNumber
- 在程序中，应该尽量使用有意义的英文单词来定义标识符，使得程序便于阅读 例：使用userName表示用户名，password表示密码
JAVA中的关键字（例举）
JAVA中的常量
常量就是在程序中固定不变的值，是不能被改变的数据。
在JAVA中，常量包括整型常量，浮点数常量，布尔常量，字符常量等...
整型常量（整数类型数据）
·二进制：由数字0和1组成的数字序列，如：00110101
·八进制：以0开头并且其后由0-7范围（包括0和7）内的整数组成的数字序列，如：0342
·十进制：由数字0-9范围（包括0和9）内的整数组成的数字序列，如：198。整数以十进制表示时，第一位不能是0，0本身除外
·十六进制：以0x或者0X开头并且其后由0-9，A-F（包括0和9，A和F）组成的数字序列，如0x25AF
浮点数常量
float（单精度）后面以f或F结尾
double（双精度）后面以D或d结尾
使用浮点数时可以在结尾处不加任何后缀，虚拟机会默认为double双精度浮点数
浮点数常量还可以通过指数形式来表示，例：
2e3f 3.6d 0f 3.84d 5.022e+23f
字符常量
字符常量用于表示一个字符，一个字符常量要用一对英文半角格式的单引号('')引起来，它可以是英文字母、数字、标点符号、以及由转义序列来表示的特殊字符。例:
‘a’ ‘1’ ‘&’ ‘\r’ ‘\u0000’
上面的示例中，’\u0000'表示一个空白字符，即在单引号之间没有任何字符。之所以能这样表示是因为，Java采用的是Unicode字符集，Unicode字符以\u开头，空白字符在Unicode码表中对应的值为’\u0000'。
字符串常量
字符串常量用于表示一串连续的字符，一个字符串常量要用一对英文半角格式的双引号("") 引起来，例:
“HelloWorld” “123” “Welcome” \n XXX “”
一个字符串可以包含一个字符或多个字符，也可以不包含任何字符，即长度为零。
布尔常量
即布尔型的两个值true和false,该常量用于区分一个事物的真与假。
null常量
null常量只有一个值null,表示对象的引用为空.
变量的定义
在程序运行期间，随时可能产生一些临时数据，应用程序会将这些数据保存在一些内存单元中，每个内存单元都用一个标识符来标识。这些内存单元我们称之为变量，定义的标识符就是变量名，内存单元中存储的数据就是变量的值。
当定义一个变量时必须要有变量三要素：数据类型，变量名，赋值
注：变量名符合规范，类型和赋的值要匹配
变量的数据类型
Java是一门强类型的编程语言，它对变量的数据类型有严格的限定。在定义变量时必须声明变量的类型，在为变量赋值时必须赋予和变量同一种类型的值，否则程序会报错。
整数类型变量（默认int类型）
1.用来存储整数数值，即没有小数部分的值。
2.整数类型分为4种不同的类型:字节型(byte) 、短整型(short)、整型(int) 和长整型(long) 。
3.占用空间指的是不同类型的变量分别占用的内存大小
4.取值范围是变量存储的值不能超出的范围
为一个long类型的变量赋值时需要注意一点， 所赋值的后面要加上一一个字母“L”(或小写“l”)，说明赋值为long类型。如果赋的值未超出int型的取值范围，则可以省略字母“L”(或小写 “l”)
long num - 20000000 L; // 所赋的值超出了int型的取值范围，后面必须加上字母L
long nup = 198L; //所赋的值未超出int型的取值范围，后面可以加上字母L
long num = 198; //所赋的值未超出int型的取值范国，后面可以省略字母L
浮点数类型变量（默认double类型）
浮点数类型变量用来存储小数数值。
浮点数类型分为两种:单精度浮点数(float) 、双精度浮点数(double)，double型所表示的浮点数比float型更精确。
在取值范围中，E表示以10为底的指数，E后面的“+”号和“-”号代表正指数和负指数，例：1.4E-45表示1.4*10-45次方。
在为一个float类型的变量赋值时需要注意一点，所赋值的后面一定要加上字母“F”(或“f”)，而为double类型的变量赋值时，可以在所赋值的后面加上字符“D”’(或“d”)，也可不加。
float f = 123.4f; //为一个float类型的变量赋值，后面必须加上字母f
double d1 = 100.1;//为一个double类型的变量赋值，后面可以省略字母d
double d2 = 199.3d;//为一个double类型的变量赋值，后面可以加上字母d
在程序中也可以为一个浮点数类型变量赋予一个整数数值.
字符类型变量
用于存储一个单一字符，在Java中用char表示。
每个char类型的字符变量都会占用2个字节。
赋值时，要用英文半角格式的单引号(‘’) 把字符括起来，如'a'
也可以赋值为0~65535范围内的整数，计算机会自动将这些整数转化为所对应的字符，如数值97对应的字符为'a'。
char c = 'a'; //为一个char类型的变量赋值字符a
char ch = 97; //为一个char类型的变里赋值整数97,相当于赋值字符a
布尔类型变量
布尔类型变量用来存储布尔值，在Java中用boolean表示，该类型的变量只有两个值，即true和false。 例:
boolean flag = false;//声明一个boolean类型的变量，初始值为false
flag = true;//改变flag变量的值为true
变量的类型转换（隐式类型转换）
指两种数据类型在转换的过程中不需要显式地进行声明。
要实现自动类型转换，必须同时满足两个条件：
1.两种数据类型彼此兼容。
2.目标类型的取值范围大于源类型的取值范围。
byte b = 3;
int x = b; // 程序把byte类型的变量b转换成了int类型，无须特殊声明。
(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、强制类型转换（显式类型转换）
指两种数据类型之间的转换需要进行显式地声明。
当两种类型彼此不兼容，或者目标类型取值范围小于源类型时，自动类型转换无法进行，这时就需要进行强制类型转换。
强制类型转换格式:
目标类型 变量 = (目标类型) 值
例：
/*
*强制类型转换
*/
Int num = 4;
byte b = (byte)num;
/*
*数据精度丢失
*/
byte a;//定义byte类型变量
int a = 298;//定义int类型变量
a=(byte)b;
System.out.println(“a=”+a);
System.out.println(“b=”+b);
输出结果：
a=42
b=298
变量的作用域
变量需要在它的作用范围内才可以被使用，这个作用范围称为变量的作用域。
在程序中，变量一定会被定义在某一对大括号中，该大括号所包含的代码区域便是这个变量的作用域。
例：
public static void main(String[] args) {
int x = 4;
{
int y = 9;
......
}//蓝色部分为y的作用域
......
}//红色部分为x的作用域
算术运算符
自增自减运算符
a++ 先赋值，再+
++a 先+1，再赋值
a-- 先赋值，再-
--a 先-，再赋值
在进行取模(%)运算时，运算结果的正负取决于被模数(%左边的数)的符号，与模数(%右边的数)的符号无关。
赋值运算符
在Java中可以通过一条赋值语句对多个变量进行赋值
Int x, y, z;
x = y = z = 5; //为三个变量同时赋值 可行的
int x = y = z = 5;//这样写是错误的 不可行的
除了“=”，其它的都是特殊的赋值运算符，以“+=”为例，x +=3就相当于x = x+3,首先会进行加法运算x+3,再将运算结果赋值给变量x。-=、*=、/=、%=赋值运算符都可依此类推。
short s = 3;
int i = 5;
s = i;//系统会报错，因为5比3大，数据类型不匹配
s = (short)i;//强制进行转换
s += i;//系统会自动进行转换
比较运算符
比较运算符用于对两个数值或变量进行比较，其结果是一个布尔值，即true或false。
比较运算符在使用时需要注意一个问题， 不能将比较运算符“==”误写成赋值运算符“=”
逻辑运算符
逻辑运算符用于对布尔型的数据进行操作，其结果仍是一个布尔型
&& 与 两者都为真，结果才是真
|| 或 只要有一者为真，结果就是真
！ 非 非真即假，非假即真
& 与 两者都为1，结果才是1
| 或 只要有一者为1，结果就是1
~ 取反 0变1，1变0
^ 异或 两者相同即为0，不同为1
注：
/*
*&和&&的使用
*/
int x = 0;//定义变量x，赋值为0
int y = 0;//定义变量x，赋值为0
int z = 0;//定义变量x，赋值为0
boolean a,b ;//定义a和b两个布尔变量
a = x > 0 & y++ > 1;
System.out.println(a);
System.out.println(“y=”+y);
b = x > 0 && z++ > 1;
System.out.println(b);
System.out.println(“z=”+z);
逻辑运算符可以针对结果为布尔值的表达式进行运算。如：x > 3 && y != 0;
运算符“&"和“&&"都表示与操作，当且仅当运算符两边的操作数都为true时，其结果才为true,否则结果为false.当运算符“&”和“&&”的右边为表达式时，两者在使用上还有一定的区别。在使用“&"进行运算时，不论左边为true或者false,右边的表达式都会进行运算。如果使用“&&"进行运算，当左边为false时，右边的表达式不会进行运算，因此“&&"被称作短路与。
运算符“|”和“||”都表示或操作，当运算符两边的操作数任何一边的值为true时，其结果为true,当两边的值都为false时，其结果才为false.同与操作类似，“||” 表示短路或，当运算符“||”的左边为true时，右边的表达式不会进行运算。
运算符“^"表示异或操作，当运算符两边的布尔值相同时(都为true或都为false)，其结果为false. 当两边布尔值不相同时，其结果为true.
运算符的优先级
在对一些比较复杂的表达式进行运算时，要明确表达式中所有运算符参与运算的先后顺序，把这种顺序称作运算符的优先级。
商城库存清单程序设计
/*
*商城库存清单案例
*变量的形式对商品的数据保存
*品牌，尺寸大小，价格，配置，库存数量
*三个商品 苹果，thinkpad，华硕
*
*计算出总的库存数，和商品的总金额
*/
public class a{
Public static void main(String[] args){
//苹果笔记本电脑
String macBrand = “MacBookAir”;
double macSize = 13.3;
double macPrice = 6988.88;
String macConfig = “i5处理器4GB内存128GB固体硬盘”;
//联想Thinkpad笔记本电脑
String thinkpadBrand = “ThinkpadT450”;
double thinpadPrice = 5999.99;
double thinkpadPrice = 5999.99;
String thinkpadConfig = “i5处理器4GB内存500G固态硬盘”；
Int thinkpadCount = 10;
//华硕ASUS笔记本电脑
String ASUSBrand = “ASUS-FL5800”;
double ASUSSize = 15.6;
double ASUSPrice = 4999.50;
String ASUSConfig = “i7处理器4G内存128GB固态硬盘”;
Int ASUSCount = 18;
//列表的顶部
System.out.println(“----------商城库存清单----------”)；
System.out.println(“品牌型号 尺寸 价格 配置 库存数”)；
//列表的中部
System.out.println(macBrand + “ “ + macSize + “ “ + macPrice + “ “ + macConfig + “ “ + macConfig)；
System.out.println(thinkpadBrand + “ “ + thinpadPrice + “ “ + 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(“总库存是：”+ totclCount);
System.out.println(“库存商品总金额：”+ totalMoney);
}
}
if条件语句
if条件语句分为三种语法格式:
1.if语句
2.if..else语句
3.if..else if..else语句
if语句 是指如果满足某种条件，就进行某种处理，语法格式:
if (条件语句){
代码块
}
上述语法格式中，判断条件是一个布尔值，当值为true时， 才会执行{}中的语句。
if语句流程图：
{
int x = 5;
if( x < 10){
X++;
}
System.out.println(“x=”+x);
}
if...else语句
if..else语句是指如果满足某种条件，就进行某种处理，否则就进行另一种处理，语法格式:
if (判断条件){
执行语句1
}else{
执行语句2
}
If...else流程图
Int num = 19;
If{ num % 2 == 0){
System.out.println(“num是偶数”)；
}else{
System.out.println(“num是奇数”)；
}
}
}
三元运算，语法：
判断条件 ？ 表达式1 ： 表达式2
三元运算通常用于对某个变量进行赋值，当判断条件成立时，运算结果为表达式1的值，否则结果为表达式2的值
if...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流程图
Int grade = 75;//定义学生成绩
If( grade > 80){
//满足条件>80
System.out.println(“该成绩的等级为优”);
}else if(grade > 70){
//不满足>80,但是满足>70
System.out.println(“该成绩的等级为良”);
}else if(grade > 60){
//不满足>70,但是满足>60
System.out.println(“该成绩的等级为中”);
}else{
System.out.println(“该成绩的等级为差”);
}
}
}
Switch条件语句
switch语句也是一种很常 见的选择语句。和if条件语句不同，它只能针对某个表达式的值做出判断，从而决定执行哪一段代码。
在switch语句中， 使用switch关键字来描述一个表达式，使用case关键字来描述和表达式结果比较的目标值，当表达式的值和某个目标值匹配时，会执行对应case下的语句，swith语句的基本语法结果如下图所示。
注：在switch语句中的表达式只能是byte、short、char、int、 枚举(JDK1.5引入的)、 String类型 (JDK1.7引入的)的值，如果传入其他值，程序会报错。
例：
int week = 6;
switch (week) {
case 1:
System.out.println("星期一");
break;
case 2:
System. out.println("星期二");
break;
case 3 :
System. out.println("星期三");
break;
case 4:
Ѕуѕtеm. оut. рrіntln("星期四");
break;
case 5:
System. out.println("星期五");
break;
case б:
System.out.println("星期六");
break;
case 7
Ѕуѕtеm.оut.рrіntln("星期日");
break;
default:
System.out.println(“输入的数字不正确...”)；
break；
}
在使用switch语句的过程中，如果多个case条件后面的执行语句是一样的， 则该执行语句只需书写一次即可。
要判断一周中的某一天是否为工作日， 同样使用数字1~7来表示星期一到星期天，当输入的数字为1、2、3、4、5时就视为工作日，否则就视为休息日。
/*
* switch语句的使用(多个case条件后面的执行语句是一样的情况，
*/
int week = 2;
switch (week) {
case 1 :
case 2:
case 3:
case 4 :
case 5 :
//当week满足1,2,3,4, 5中任意一个值，处理方式相同
System. out.println("今天工作日");
break;
case 6:
case 7:
//当week满足6,7中任意的一个值，处理方式相同
System.out.println("今天是休息日"):
break;
}
}
}
While循环语句
while语句和if条件语句有点类似，都是根据条件判断来决定是否执行后面的代码，区别在于，while循环语句会反复地进行条件判断，只要条件成立，{}内的执行语句就会执行，直到条件不成立，while循环结束。
while循环语句的语法结构如下所示:
while (循环条件) {
执行语句
... ... ...
}
流程图：
/*
*while循坏
*/
int x=1;//定义变量x，初始值为1
while( x <=4 ) { //循坏条件
System.out.println("x = " + x);//条件成立,打印x的値
x++;// x进行自増
}
}
}
Do...While循环语句
语法结构：
Do{
执行语句
... ... ...
}while(循环条件)；
流程图：
/*
* do.. .while循环
*/
Int x = 1; //定义变量x，初始值为1
Do{
System. out.println("x = "+ x); //打印x的值
x++;//将x的值自增
}while(x <= 0);//循环条件
}
}
for循环语句
For循环语句是最常用的循环语句，一般用在循环次数已知的情况下，语法格式:
for (初始化表达式;循环条件;操作表达式) {
执行语句
}
在上述语法格式中，for后面的()中包括三部分内容，初始化表达式、循环条件和操作表达式，它们之间用“;"分隔， {}中的执行语句为循环体
如果用①表示初始化表达式，②表示循环条件，③表示操作表达式，④表示循环体，则for循环的执行流程如下：
/*
* for循环
*/
Int sum = 0;//定义变量sum,用于记住累加的和
for(int i= 1; i<=4; i++){ / /1的值会在1-4之间变化
sum += p; /1//实现sum变量与1的累加
}
System. out.println("sum =”+ sum);//打印累加的和
}
}
嵌套循环
嵌套循环是指在一个循环语句的循环体中再定义一个循环语句的语法结构。while、 do...while、 for循环语句都可以进行嵌套，并且它们之间也可以互相嵌套，如最常见的在for循环中嵌套for循环，格式如下:
/*
*for循环（使用*打印直角三角形）
*/
Int i,j;//定义两个循环变量
For(i = 1; i <= 9; i++){//外层循环
For(j = 1 ;j <= 1 ; j++){//内层循环
System.out.print(“*”);//打印
}
System.out.print(“\n”);//换行
}
}
}
跳转语句用于实现循环执行过程中程序流程的跳转，在java中的跳转语句有break语句和continue语句
1、break语句: 用在switch条件语句和循环语句中，它的作用是终止某个case并跳出switch结构。
2、continue语句: 用在循环语句中，它的作用是终止本次循环，执行下一次循环
/*
* break语句
*/
int x = 1; //定义变量x，初始值为1
while(x <= 4 ){ //循环条件
System.out.println("x =”+ x); //条件成立，打印x的值
if(x == 3){
break;
}
x++; // x进行自增
}
}
}
/*
* break语句(跳出外层循环)
*/
int i,j ;//定义两个循环变量
for(i=1;i<=9;i++)(//外层循环
for(j = 1;j<= i;j++){//内层循环
if(i>4){
break;
}
System.out.print("*"); //打印*
System. out.println("\n"); //换行
}
}
}
/*
*continue语句
*/
int sum= 0 ;//定义变量sum,用于记住和
for(int i = 1; i<= 100; i++) {
if(i % 2 == 0){ // 1是一个偶数,不累加
continue ;
}
sum += 1; //实现sum和i的累加
}
System. out.println (sum);
}
}
/*
*猜数字的游戏
*/
//1.通过Random类中的nextInt (n)方法，生成一个0-9之间的随机数
int randomNumber = new Random() .nextInt (10);
System. out.println("随机数已生成!");
//2.输入猜的数字
System. out.printIn("----请输入您猜的数字----");
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.println("恭喜您，答对了”);
}
}
方法
/*
*不适用方法时实现打印三个长宽不同的矩形
*/
// 下面的循环是使用*打印宽为5,高为3的矩形
for(int 1= 0;1<3; 1++){
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;1<4;j++)(
System. out.print(“*");
}
system. out.print("\n");
}
//下面的循环是使用*打印宽为10，高为6的矩形
}
}
在Java中，声明一个方法的具体语法格式如下所示:
修饰符 近回值类型 方法名([参数类型 参数名1，参数类型 参数名2....... ]}{
执行语句
return返回值;
}
修饰符:是对访问权限的限定，例如，public、 static都是
修饰符返回值类型:用于限定方法返回值的数据类型
参数类型:用于限定调用方法时传入参数的数据类型
参数名:是一个变量，用于接收调用方法时传入的数据
Return关键字:用于结束方法以及返回方法指定类型的值
返回值:被return语句返回的值，该值会返回调用者
/*
*使用方法实现打印三个长宽不同的矩形
*/
printRectangle(3,5); //调用printRectangle()实现打印矩形
printRectangle(2, 4) ;
printRectangle(6, 10) ;
//下面定义了一 个打印矩形的方法，接收两个参数，其中height表示高,width表示宽
public static void printRectangle(int height, int width) {
//下面使用嵌套循环打印矩形
for(int i=0;i
for(int j = 0;j< width ; j++){
System. out.print("*");
}
System. out.print("\n");
}
}
}
/*
*“使用有返回值的方法求矩形面积
*/
int area =getArea(3,5); //调用getArea方法
System. out.println(" The area is "+ area);
}
//下面定义了一个求矩形面积的方法，接收两个参数，其中x为高,y为宽
public static int getArea(int x ,int y){
return x * y;
}
}
方法的重载
/*
*调用不同的方法
*/
//下面针对求和的方法调用
int sum1 = add01 (1,2) ;
int sum2 = add02(1,2,3) ;
double sum3 = add03(1.2,2.3) ;
//下面的代码是打印求和的结果
System. out.println("gum1=" + gum1);
System. out.println("gum2=" + 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 int add03(double x,double y){
return x + y;
}
方法的重载
java允许在一个程序中定义多个名称相同的方法，但是参数的类型或个数必须不同
/*
*方法的重载
*/
//下面的方法实现两个整数相加
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 int add(double x,double y){
return x + y;
}
数组的定义
定义数组格式：
Int [] x = new int[100];
上述语句就相当于在内存中定义了100个int类型的变量，第一个变量的名称为x[0]，第二个变量的名称为x[1]，以此类推，第100个变量的名称为x[99],这些变量的初始值都是0。
简写上面代码为：
Int [] x;//声明一个int[]类型变量
X = new int[100];//创建一个长度为100的数组
例图：
我们可以通过“数组名.length”获取数组的长度（元素的个数）
/*
*定义数组以及访问数组中的元素
*/
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);//打印数组的长度
/*
*数组静态化
*/
Int[] arr = {1,2,3,4};
System.out.println(“arr[0]=” + arr[0]);
System.out.println(“arr[1]=” + arr[0]);
System.out.println(“arr[2]=” + arr[0]);
System.out.println(“arr[3]=” + arr[0]);
/*
*空指针异常
*/
int[] arr = new int[3]; //定义一个长度为3的数组
arr[0] = 5; //为数组的第一个元素赋值
Syatem.out.println("arr[o]=" + arr[0]); //访问数组元素
arr = null; //将变量arr置为null
Syatem. out.println("arr[0]=" + arr[0]); //访问数组元素
循环遍历数组
/*
*for循环遍历数组
*/
int[] arr = (1,2,3,4,5); //定义数组
//使用for循环遍历数组的元素
for(int i = 0 ; 1< arr.length ;i++) (
System. out.println(arr[1]); //通过索引访问元素
/*
*冒泡排序
*/
int[] arr = (9,8,3,5,2); //定义数组，赋值无序
System. out.println("冒泡排序前:");
pintArray
//定义打印数组的元素的方法
poblic static void pintArray(int[] arr) {
// 循环遍历数组的元素
for(int i = 0 ; 1 < arr.length ; i++) {
System. out.print(arr[i] + " "); //打印元素和空格
}
System. out.print ("\n") ;
//定义对数组排序的方法
pablic statie void bubbleSort(int[] arr){
//定义外层循环
for(int1 = 0;1< arr.1ength - 1; 1 ++){
//定义内层循环
for(int j = 0;j < ?; j++){
}
}
}
/*
*获取数组中的最大值
*/
int[] arr = {4,1,6,3,9,8}; //定义一个数组
int max - getMax(arr); //调用获职元素最大值的方法
System. out.println("max=" + max); //打印最大值
}
{
int max = arr[0]; //定义变量max用于记住最大数，首先保存数组中的第0个素引上的元素
//下面通过一个for循环遍历数组中的元素
for(int x = 1 ; x< arr.length ; x++) {
if(arr[x] > max){ //比较arr[x]的值是否大于max
Max = arr[x] ; //条件成立，将arr[x]的值赋给max
}
}
return max ; //返回最大值
二维数组
定义二维数组
Int[][] arr = new int[3][4];
结构
Int[][] arr = new int[3][];
结构
Int[][] arr = {{1,2},{3,4,5,6},{7,8,9}};
结构
访问二维数中的第一个元素数组的第二个元素的方式如下
Arr[0][1];
/*
*二维数组的使用
*/
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
int gropuSum= 0 ; //定义变量记录小组的销售额
for(int j = 0;J< arr[1] .length ; j++) {
gropuSum =gropuSum +arr[i] [j] ;
Sum = sum + gropuSum;
systen.out.println("第”+ ( i+1 ) +”小组销售额为: "+gropuSum +"万元");
System.cut.println("总销售额为:”+ sum+”万元”);
}
}