Java基础知识--常量、变量、运算符、循环、数组
一、常量
1、什么是常量
指在程序的运行过程中，其值是不会发生改变的量。
2、常量有哪些分类
A、 字面值常量
整数常量：3,2,-3
小数常量：1.2,-323.2
字符常量：'A'
字符串常量："HelloWorld"
布尔常量：true 和 false
空常量：null
自定义常量
类 (class)、接口( interface )、数组 ([])
3、常量的使用
//语句输出字符串常量
System.out.println("hello Java");
//整数常量
System.out.println(123);
//小数常量
System.out.println(12.345);
//字符常量
System.out.println('a');
//布尔型常量
System.out.println(true);
//空常量
System.out.println(null);
4、常见问题及注意事项
//这是错误的。如果想表示ab，用字符串常量。
System.out.println('ab');
常量常见问题：1.把字符串当作字符输出
注意：想要表示多个字符时，必须使用字符串常量，否则编译报错.
二、进制
1、什么是进制
进制：就是进位制，是人们规定的一种进位方法。
对于任何一种进制，其形式都是 X进制逢X进1。
例如:二进制就是逢2进1，八进制就是逢8进1，十进制就是逢10进1，十六进制就是逢16进1.
二进制：由数字 0 和 1 组成 。(用0b开头表示。如：0b0110)
八进制：由 数字 1-7组成。 (用0开头表示。如：025)
十进制：由数字0-9组成。 (十进制没有任何表示)
十六进制：由数字0-9，(9以后用字母)A-F表示。(用0x表示。如：0x1111)
2、进制的转换
A、 .其他进制转十进制
转换规律：
系数：表示每一位上的数据。
基数：n进制，n就表示基数。
权：数据从右往左开始从0编号，这个编号就是指定位置的数据权。
结果：
系数*基数^(权次幂)相加 例如：666 = 6*10^2+6*10^1+6*10^0
B、十进制转其他进制
转换规律：除基取余，直到商为0，余数反转。
C、进制快速转换
8 4 2 1码 规则：一位八进制 = 3位二进制
一位十六进制 = 4位二进制
例如：0000-0000 0000-0000 0000-0000 1 1 1 1 1 1 1 1
128 64 32 16 8 4 2 1
60 = 32 + 16 +4 +8 等于 111100
3、有符号的数据
有符号数据的表示法：原码、反码、补码，数据是有正负之分的。
在计算机中所有的数据都是以补码的形式存在。
例如：
数据 7和 -7
原码：是指有符号数据的最基本表现形式。最高位是符号位，其他位是数据位。
0表示正，1表示负。
7的原码：
0 0000111
-7的原码：
1 0000111
反码：正数的反码和原码相同，负数的反码和原码不同，规则是：
除去符号位不变，其他数值位取反，0变1,1变0.
7的反码：
0 0000111
-7的反码：
1 1111000
补码：正数的补码和原码相同，负数的补码和原码不同， 规则是：反码+1.
7的补码：
0 0000111
-7的补码：
1 1111001
三、变量
1、什么是变量
他是内存中的一个存储空间，在程序运行过程中，其值在 指定范围内 可以改变的量。
2、变量的命名规范
如果变量由一个单词组成，首字母小写，如果有多个单词组成，第一个首字母小写，其他的
首字母大写，要做到见名之意。
3、格式-声明变量
格式1：数据类型 变量名= 初始化值;
int num = 0;
格式 2 ：数据类型 变量名 ;
byte a ;
变量名 = 初始化值;
a = 1;
格式3：数据类型 变量名1 = 初始化值，变量名2 = 初始化值,..;
int x = 2 double = 5.23;
格式4：数据类型 变量名1，变量名2;
char b , c ;
变量名1 = 初始化值；
char = 'A ' ;
变量名2 = 初始化值;
char = 'a' ;
4、 注意事项
在一个{}内，不能存在重名的变量；
变量要先初始化再使用（在使用之前初始化即可）
为某一个变量赋值的时候尽量不要超过其能表示的范围
变量名称的定义要见名之意，不要写一写容易混淆的
定义long类型或者单精度浮点型变量的时候，一定要在数据的后面+l或者+f
四、数据类型
1、分类
（四类八种）
整型 byte short int long
浮点型float double
字符型char
布尔型 boolean
byte 的范围：-128 ——127
byte 1, short 2, int 4, long, 8, float 4, double 8
2、注意事项
整数默认是int，所以long类型后面加L或l
浮点数默认是double类型，所以float类型需要加f或F
3、数据类型转换
1、隐式转换：直接赋值
btye short char 在运算过程中自动提升为 int(直接赋值运算除外)
btye short char ->int - >long -> float ->double
2、强制转换
(数据类型) 数据或变量名
4、练习题
byte b1 = 1;
byte b2 = 1;
byte b3 = b1 + b2;//(byte)(b1 + b2);
byte b4 = 1+1;
//第四行报错还是第三行报错，为什么
第三行会报错，有运算变量加变量会自动为int类型，所以必须强制类型转换
五、算术运算符
1、分类
+, - , * , /, %,++,--
2、补充说明
+： 加法运算，字符串连接，如果做字符串连接符，会按照从左往右按照运算符
的规则计算直到遇到字符串就变成字符串连接符了
/: 如果想要结果为负数，那么/中至少有一个是负数
%： 如果想要结果为负数，那么左边必须是负数
++:
int num = 1;
前自加: ++num;
前自加的值是加之后的值
后自加:num++
后自加的值是加之前的值
System.out.println(num++ == ++ num);
num++;只有这种情况才是里存在的
3、举例：
//看区别
int a = 10;
int b = 20;
boolean b1 = (a++ > 10);//false
boolean b1 = (++a > 10);
//如果++在前面，先把a变化，后在与10进行比较。
//如果++在后面，先与10进行比较，然后a变化。
六、赋值运算符
1、分类
=，+= ,-=,%=,*=,/=
2、重点
+=: 内含强制转换
//隐式转换
byte a = 10;
int b = a;
System.out.println(b);
//强制类型转换
int i = 10;
byte b2 = (byte)i;
System.out.println(b2);
比如:
short s = 2;
s += 3;//内部隐藏着强制转换类型
s = s + 2;//编译会报错，s + 2会自动提升为int类型， 然后赋值给s，必须强制转换
等价于 s = (short)(s+3);
七、比较运算符和关系运算符
1、分类
比较运算符的结果都是boolean型，也就是要么是true，要么是false。
==,!=,>,>=,<,<=
2、特点
1、关系运算符的结果必须是boolean型
3、注意
别把== 写成 = (千万不要把用等于号的地方，写出了"=",否则可能不是你想要的结果)
八、逻辑运算符
逻辑运算符：
用于连接结果是布尔型表达式的运算。
1、分类
&，|，！，^，&&，||
详细说明
&:有假则假
|：有真则真
!：真则假，假则真
^：相同为假，不同为真
3.单&、| 和 &&、|| 的区别：
&&：短路与：如果左边为false，右边不执行
||：短路或如果左边为true，右边不执行
开发中常用&&,||,!
class OperatorDemo
{
public static void main(String[] args)
{
//&& 短路与
System.out.println(x>3 && y>4);//true & true -- true
System.out.println(x>3 && y<4);//true & false -- false
System.out.println(x<3 && y>4);//false & true -- false
System.out.println(x<3 && y<4);//false & false -- false
System.out.println("*******");
//|| 短路或
System.out.println(x>3 || y>4);//true & true -- true
System.out.println(x>3 || y<4);//true & false -- true
System.out.println(x<3 || y>4);//false & true -- true
System.out.println(x<3 || y<4);//false & false -- false
}
}
4、经验
一般情况在开发过程中用的最多的是:++,(),&&,||,!,
九、位运算符
位运算符：是针对二进制数据的运算。
& 按位与
| 按位或
^ 按位异或
~ 按位取反
<< 左移 左边的高位舍弃，右边空出的部分补齐0。
>> 右移 如果最高位是0，左边被移空的位就填入0；如果最高位是1，左边被移空的位就填入1
>>> 无符号右移 无论最高位是1还是0，左边被移空的高位都填入0
向左移动或者向右移动，其实就是把数据增大或者缩小2的指定次幂。
向左移动，数越移越大，向右移，数越移越小。
1、注意:
^:一个数据对同一个数据^两次，结果还是数据本身
举例: a ^ b ^ b = a;
举例:
class OperatorDemo { public static void main(String[] args) { int a = 3; int b = 4; System.out.println(a & b);//运行结果是 0 System.out.println(a | b);//运行结果是 7 System.out.println(a ^ b);//运行结果是 7 System.out.println(~b);//运行结果是 -5 System.out.println(~a);//运行结果是 -4 System.out.println(~8);//运行结果是 -9 //左移 System.out.println(16<<2); //16*2^2 = 64 /* 16二进制： 00000000 00000000 00000000 00010000 向左移动两位： 00000000 00000000 00000000 00010000 (00)000000 00000000 00000000 0001000000 */ //右移 System.out.println(16>>2); //无符号右移 System.out.println(16>>>2); /*推理过程：a=3,b=4把十进制转成二进制a -- 00000000 00000000 00000000 00000011b -- 00000000 00000000 00000000 00000100 00000000 00000000 00000000 00000011 &00000000 00000000 00000000 00000100 ------------------------------------ 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000011 |00000000 00000000 00000000 00000100 ------------------------------------ 00000000 00000000 00000000 00000111 00000000 00000000 00000000 00000011 ^00000000 00000000 00000000 00000100 ------------------------------------ 00000000 00000000 00000000 00000111 b: 00000000 00000000 00000000 00000100 ~ 按位取反，就是针对b这个二进制数据，所有的0变1,1变0。 补码 11111111 11111111 11111111 11111011 反码 11111111 11111111 11111111 11111010 原码 10000000 00000000 00000000 00000101*/ } }
十、流程控制语句:
A、顺序结构 代码按照顺序从上往下执行。
B、选择结构 根据以下选择或者判断做出不同的执行。
a.选择结构
b.判断结构
C、循环结构 把某些事情做很多次。
选择结构：if 语句体现。
格式1:
if(条件表达式)
{
语句体;
}
执行顺序：
根据条件表达式的返回值是true还是false决定程序的流程。
如果是true，就执行语句体;
如果是false，就什么都不做。
注意：
A、条件表达式：无论条件表达式是简单还是复杂，结果必须是boolean类型.
B、if语句后面可以不写()，但是，如果这样的话，它就只能控制后面的一条语句
如果想控制多条语句，就必须加{ }。
推荐：无论是控制一条还是多条，都加上{ }.
C、在if语句的{ }前面不要写分号，否则，会对程序的结果产生影响。
一般而言：出现{ }的时候，就不会有分号，有分号的时候，不会有{}。
作用域：
定义的变量的作用域，在它所属的那对{ }内有效。
if语句第二种格式：
if(条件表达式)
{
语句体;
}
else //否则的意思
{
语句体2;
}
if语句的第三种格式：
if(条件表达式1)
{
}
else if(条件表达式2)
{
}
else if(条件表达式3)
{
}
...
else
{
}
注意：
A:else后面是不能直接跟条件表达式。
B:最后的一个else可以不写，但是，一般建议加上。除非，你明确不需要。
C:if语句的第三种格式，一旦某个地方满足，if语句就不往下执行了。
案例：
定义x,y两个变量。
如果x大于3,y=2*x
如果x大于0小于等于3,y=5
如果x小于等于0,y=10-2*x
class IfDemo3
{
public static void main(String[] args)
{
//定义两个变量
int x = 3;
int y = 0;
//int y;
//判断语句
if(x > 3)
{
y = 2 * x;
}
else if(x>0 && x<=3)
{
y = 5;
}
else if(x <= 0)
{
y = 10 - 2 * x;
}
else
{
//y = 10;
System.out.println("运算有问题");
}
System.out.println("y:"+y);
}
}
3、注意事项
A、什么时候用哪一种if语句
第一种格式在判断条件为一种情况下使用
第二种格式在判断条件为两种情况下使用
第三种格式在判断条件为多种情况下使用
B、每一种if语句其实都是一个整体，如果有地方执行了，其他的就不执行了
C、如果if或者else里面控制的语句体是一条语句是可以省略大括号的，但是，如果是控制多条语句，必须加上大括号
建议：永远写上大括号
D 大括号和分号一般不同时出现
4、作用域
所有变量的定义只在它所属的大括号内有效
条件运算符：(三元运算符)
(条件表达式)?表达式1：表达式2；
注意：条件表达式说明这里将来只能是结果为true或者false的表达式。
执行顺序：
如果条件表达式为true，就把表达式1作为结果。
如果条件表达式为false，就把表达式2作为结果。
举例：
有三个数据，请找到最大值。
int a = 20;
int b = 40;
int c = 30;
方式1：
int d = a>b?a:b;
int e = d>c?d:c;
方式2:
int f = (a>b)?(a>c?a:c):(b>c?b:c);
2、switch语句
switch的语句格式：
switch(表达式)
{
case 取值1:
执行语句；
break；
case 取值2:
执行语句；
break；
...
default:
执行语句；
break；
}
解释：
switch:知道这里使用的是switch语句
表达式: byte,short,int,char
JDK5以后，可以是枚举。(就业班讲)
JDK7以后，可以是String类型。
case 取值1：
case就是表示这是一个选项，取值1就是这个选项的值。
break:
switch语句遇到break就结束了。
default:
就相当于if语句的else。当所有的取值都不匹配的时候，就执行default的内容。
执行流程：
从上往下，用表达式的值去和case后面的值进行匹配，如果有匹配的，就去执行该case
所包含的语句。如果没有匹配的，就会去执行default里面的内容。
class SwitchDemo
{
public static void main(String[] args)
{
//根据给定的一个数据(1-7),请输出对应的星期日期。
int week = 3;
week = 13;
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;
}
}
}
注意事项：
A:default可以省略吗?可以。
但是，一般不省略，它相当于if的else语句，可以控制所有的非正常情况。
假如你非常明确可以省略，那就省略。
B:break可以省略吗?
放在最后面的default的break是可以省略的。
放在case语句中的break是可以省略的，但是可能结果有问题。
所以，一般不省略。
C:default可以不放在最后面吗?
可以，但是一般都放在最后面。
D:switch语句什么时候结束吗?
遇到break或者执行到switch语句的末尾。
3、循环结构while、do...while、for
1、while循环格式
A、 初始化条件 ;
while(判断条件)
{ 循环体; 控制条件; }
//while循环的使用int y = 0; while(y<5) { System.out.println("我爱Java"); y++; } System.out.println(y); B、 执行流程
A:先执行初始化表达式。
B:执行判断条件。
C:根据判断条件的返回值
如果true,执行循环体。
如果false,for循环结束。
D:执行控制条件,接着返回
2、do......while循环格式
A、初始化条件; do { 循环体; 控制条件; }while(判断条件); int x = 0;
//先执行后判断，至少执行一次操作
do
{
System.out.println("我爱Java");
x++;
}while(x<5);
B、执行流程
A 先执行语句体和控制条件
B 执行判断条件
C 根据返回值
如果是true,继续执行循环体和控制条件
如果是false，就结束循环
3 、for 循环
A、 格式
for( 初始化条件 ; 判断条件 ; 控制条件 ){
语句体 ;
}
B、 执行流程
A: 先执行初始化表达式。
B: 执行判断条件。
C: 根据判断条件的返回值
如果 true, 执行循环体。
如果 false,for 循环结束。
D: 执行控制条件 , 接着返回 B 。
B、初始化条件只执行一次，判断条件比控制条件肯定多执行一次
4、while、do...while和的for 联系与区别
A、while与for循环区别
1、如果for循环的初始化条件定义到for循环里，在for循环执行完以后不能使用,比如
for(int i=0;;){ }//当循环执行完以后i变量不可使用
而while循环肯定是可以使用的
那什么情况下for循环的初始化条件在执行完毕后还可以使用?
int num =0 ;
for(; num<10; num++){}for循环中的三个条件可以都不写，或者某个不写。
B、 如果循环次数明确，则用for
如果循环次数不明确，用while
C、 do...while与while循环的区别
while是满足条件就执行，do...while是无论是否满足条件至少执行一次
do..while循环至少执行一次，而while循环可能一次都不执行
D、注意：
for 循环和 while 循环是可以等价的
而do…while循环至少执行一次循环体
5、for嵌套循环
嵌套语句：语句中包含语句(for循环里还有for循环)
外循环控制行，内循环控制列
//外循环控制行
for(int i=0; i<10; i++)
{ //内循环控制列 for(int j=0; j<=i; j++) { System.out.print("*"); }
System.out.println();
}
6. break 和continue
break:表示 结束当前循环，跳出循环不在继续
break常用于switch语句中
continue ：结束本次循环，循环进入下一次
开发过程中如果要使用break或者continue，一般在前面我们都要加一个判断
break 和continue后面不能写语句，一般配合if语句使用
举例：
continue:
//定义一个求和变量int sum = 0;
//循环遍历
for (int x =1;x<=10 ;x++ )
{
//如果是偶数就继续循环遍历
if (num%2==0)
{
continue;
}
sum +=x;
//打印输出奇数和
System.out.println(num);
} break: //定义星期变量 int week = 5;
//switch判断条件，匹配上程序遇到break就输出停止，不匹配则继续执行下一语句
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、什么是函数
定义在类中，并有特定功能的一小段程序。
2、 格式
修饰符 返回类型 函数名（参数类型 形式参数,...）{
函数体；
return 返回值;
}
解释：: public static
:就是数据类型
:见名知意，如果一个单词，首字母小写，如果多个单词组成，从第二个单词开始首字母大写
D、参数类型 ：数据类型
E、形式参数 ：接受实际参数的变量
F、实际参数 ：就是实际参与运算的变量
G、函数体：实现功能的代码
,如果没有明确返回值可以不写
I、return 返回值 ，那里调用程序，return就把结果返回到哪里 比如 int num = max(1,2);return把结果返给num3、特点
A、 函数和函数是平级关系，且只能定义在类中，不能在函数中嵌套函数
B、 函数只有被调用才会执行
4、注意
无论函数的返回值是具体的数据类型还是void，函数都是以return语句结束的
5、函数的调用
A 有明确返回值函数的调用单独调用//没有意义
输出调用//视频中老师用的最多的
赋值调用//开发中用的最多的
B 没有明确返回值函数的调用
单独调用6、函数的重载-overload(掌握)
重载：在同一个类中，函数名相同，参数列表不同(参数类型和个数)，与返回值类型无关。举例：
class Demo{
public static void print(int x, int y);
public static void print(int a,int b,int c)
public static void print(double a);
public static void print(int a);
}
7、案例 1、有明确返回值的案例 A、求两个数据的和
class FunctionDemo{
public static void main(String[] args)
{
int x = 2;
int y = 3;
System.out.println(getSum(x,y));
}
public static int getSum(int x,int y){
//方式一
//return x + y;
//方式二
int sum = x + y;
return sum;
}
}B、求两个数据的最大值B、求两个数据的最大值
class FunctionDemo{
public static void main(String[] args)
{
//定义两个变量并初始化
int a = 6;
int b = 5;
//定义一个变量获取最大值
int max = getMax(a,b);
//控制台输出最大值
System.out.println("最大值是"+max);
}
/*获取两个数的最大值*/
public static int getMax(int a,int b){
//判断大小
if (a>b)
{
//返回最大值
return a;
}
else
{
//返回最大值
return b;
}
}
}C、比较两个数是否相等
class FunctionDemo{
public static void main(String[] args)
{
//定义两个变量并初始化
int a = 6;
int b = 6;
//控制台输出结果
System.out.println(compare(a,b));
}
/*比较两个数是否相等*/
public static boolean compare(int a,int b){
if (a==b)
{
System.out.println(a+"="+b+"相等");
return true;
}
else
{
System.out.println(a+"!="+b+"不相等");
return false;
}
}
}2、没有明确返回值的案例 A 矩形案例
class FunctionDemo{
public static void main(String[] args)
{
//调用打印矩形方法
printRectangle();
}
/*打印矩形*/
public static void printRectangle(){
//外循环控制行数
for (int i=0;i<5 ;i++ )
{
//内循环控制列数
for (int j=0;j<5 ;j++ )
{
//打印输出
System.out.print("*");
}
//控制换行
System.out.println();
}
}
}B nn乘法表 (99乘法表)
class PrintDemo{
public static void main(String[] args)
{
//调用打印99乘法表方法
printRectangle();
}
/*打印99乘法*/
public static void printRectangle(){
//外循环控制行数
for (int x=1;x<=9 ;x++ )
{
//内循环控制列数
for (int y=1;y<=x ;y++ )
{
//打印输出
System.out.print(y+"*"+x+"="+x*y+" ");
}
//控制换行
System.out.println();
}
}
}
十二、数组
1、什么是数组
数组是存储多个同一类型数据元素的容器 (container)
2、数组有什么好处
数组中的元素会被自动从 0 开始编号，方便我们获取
3、格式
A int[] arr =new int[2];// 念法 :int 类型的数组 arr
B int arr[] = new int[2];//
念法
:int
类型的
arr
数组
,
不推荐这么写
,
他和第一种格式其实一样的
//
大括号内可以没有任何东西
D int[] arr = {3,4,65,4};// 大括号内可以没有任何东西
推荐使用 A D ，如果是给方法直接传递实际参数可以用 c
获取数组的长度：变量名.length;
4、内存图
堆： 所有 new 出来的东西都在堆里
1、 每一个实体都有地址值
2、 每一个实体内的内容都有默认值
整数: 0
浮点数: 0.0
字符: ’\u0000’ //char c = ‘\u0000’;
布尔 :false
5、数组操作
1、 数组遍历
2、 获取数组最值
3、 数组查找：给定一个值，查找该值在数组中对应的索引
6 、常见问题
A 数组越界异常： ArrayIndexOutOfBoundsException
你访问了不存在的索引。
B 空指针异常: NullPointerException
一个实例 ( 对象 ) 已经不存在了，你还去访问它的内容
2、二维数组
1、什么是二维数组
二维数组其实就是一个元素为一维数组的数组(也就是数组中还有数组)
2、二维数组的格式
A、格式1：
数据类型[][] 变量名 = new 数据类型[m]n[];
m: 表示这个二维数组有多少个一维数组
n: 表示每一个一维数组的元素个数
举例：
int[][] arr = new int[3][2];
定义了一个二维数组arr
这个二维数组有3个一维数组，名称是arr[0],arr[1],arr[2]
每一个一维数组有2个元素，可以通过arr[m][n]来获取
表示获取第第m+1个一维数组的第n+1个元素
B、格式2：
数据类型[][] 数组名 = new 数据类型[m][];
m: 表示这个二维数组有多少个一维数组
没有给出列数，说明列数不是固定的，可以是动态的
举例：
int[][] arr = new int[3][];
arr[0] = new int[2];
arr[1] = new int[3];
arr[2] = new int[1];
C、格式3：
数据类型[][] 变量名 = new int[][]{{元素...},{元素...},{元素...}};
简化格式:
数据类型[][] 变量名 ={{元素...},{元素...},{元素...}};
int[][] arr = {{1,2},{3,4,2},{5,6,7,8}};
例如：
class ArrayTest
{
public static void main(String[] args)
{
//定义二维数组方式1
int[][] arr = new [3][2];
//定义二维数组方式2
int[][] arr = new [3][];
//定义二维数组方式3
int[][] arr = {{1,2},{3,4},{5,6}};
//给二维数组赋值
arr[0][0] = 3;
arr[2][1] = 5;
//打印二维数组元素
System.out.println(arr[0][0]);//二维数组中第1个一维数组中的第1个元素
System.out.println(arr[0][1]);//二维数组中第1个一维数组中的第2个元素
System.out.println(arr[1][1]);//二维数组中第2个一维数组中的第1个元素
System.out.println(arr[1][2]);//二维数组中第2个一维数组中的第2个元素
System.out.println(arr[2][1]);//二维数组中第3个一维数组中的第1个元素
System.out.println(arr[2][2]);//二维数组中第3个一维数组中的第2个元素
}
}
3、二维数组的使用
1、数组遍历
2、
4、常见问题
Java中的参数传递问题:
1、基本类型：基本数据类型传递的是基本类型的数值，形式参数的改变对实际参数没有影响。
2、引用类型：引用类型传递的是地址值，形式参数的改变直接影响实际参数
A 格式
int[][] arr = new int[6][3]
int[] [] arr= new int[2][]
int[][] arr = {{2,23},{33}}
B 老师的 案例
抽烟案例
class SmokeDemo
{
public static void main(String[] args)
{
int[][] tiaoyan = new int[10][20];
tiaoyan[9] = new int[2];
for(int i=0; i<tiaoyan.length; i++)
{
int[] baoyan = tiaoyan[i];
for(int j=0; j<baoyan.length; j++)
{
System.out.println("正在抽第"+(i+1)+"盒烟中的第"+(j+1)+"根烟");
}
}
}
}
