黑马程序员—Java基础知识--常量、变量、运算符、循环、数组
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------
Java基础知识--常量、变量、运算符、循环、数组
一、常量
1、什么是常量 指在程序的运行过程中，其值是不会发生改变的量。 2、常量有哪些分类 A、
字面值常量 整数常量：3,2,-3 小数常量：1.2,-323.2 字符常量：'A' 字符串常量："HelloWorld" 布尔常量：true 和 false 空常量：null B、
自定义常量 类 (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 11111111 128 6432168421 60 = 32 + 16 +4 +8 等于 111100 3、有符号的数据 有符号数据的表示法：原码、反码、补码，数据是有正负之分的。 在计算机中所有的数据都是以补码的形式存在。 例如： 数据 7和 -7 原码：是指有符号数据的最基本表现形式。最高位是符号位，其他位是数据位。 0表示正，1表示负。 7的原码： 00000111 -7的原码： 10000111 反码：正数的反码和原码相同，负数的反码和原码不同，规则是： 除去符号位不变，其他数值位取反，0变1,1变0. 7的反码： 00000111 -7的反码： 11111000 补码：正数的补码和原码相同，负数的补码和原码不同， 规则是：反码+1. 7的补码： 00000111 -7的补码： 11111001 三、变量 1、什么是变量 他是内存中的一个存储空间，在程序运行过程中，其值在 指定范围内 可以改变的量。 2、变量的命名规范 如果变量由一个单词组成，首字母小写，如果有多个单词组成，第一个首字母小写，其他的 首字母大写，要做到见名之意。 3、格式-声明变量 格式1：数据类型变量名= 初始化值; intnum= 0; 格式 2 ：数据类型变量名 ; byte a ; 变量名 = 初始化值; a = 1; 格式3：数据类型变量名1 = 初始化值，变量名2 = 初始化值,..; intx=2double= 5.23; 格式4：数据类型变量名1，变量名2; charb,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、分类 &，|，！，^，&&，||
2、详细说明
&:有假则假
|：有真则真
!：真则假，假则真
^：相同为假，不同为真
3.单&、| 和 &&、|| 的区别：
&&：短路与：如果左边为false，右边不执行
||：短路或如果左边为true，右边不执行
开发中常用&&,||,!
classOperatorDemo
{
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;
举例:
classOperatorDemo { 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 0000010000000000 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语句
2、switch语句 switch的语句格式：第一种格式在判断条件为一种情况下使用
第二种格式在判断条件为两种情况下使用
第三种格式在判断条件为多种情况下使用
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);
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(判断条件)
{循环体;控制条件;}
A:先执行初始化表达式。//while循环的使用int y = 0;while(y<5){System.out.println("我爱Java");y++;}System.out.println(y);B、 执行流程
B:执行判断条件。
C:根据判断条件的返回值
如果true,执行循环体。
如果false,for循环结束。
D:执行控制条件,接着返回 2、do......while循环格式
A 先执行语句体和控制条件A、初始化条件;do {循环体;控制条件;}while(判断条件);int x = 0;B、执行流程
//先执行后判断，至少执行一次操作
do
{
System.out.println("我爱Java");
x++;
}while(x<5);
B 执行判断条件
C 根据返回值
如果是true,继续执行循环体和控制条件
如果是false，就结束循环
3 、for 循环4、while、do...while和的for 联系与区别
A、 格式
for( 初始化条件 ; 判断条件 ; 控制条件 ){
语句体 ;
}
B、 执行流程
A: 先执行初始化表达式。
B: 执行判断条件。
C: 根据判断条件的返回值
如果 true, 执行循环体。
如果 false,for 循环结束。
D: 执行控制条件 , 接着返回 B 。
B、初始化条件只执行一次，判断条件比控制条件肯定多执行一次
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++)
6.break 和continue{//内循环控制列for(int j=0; j<=i; j++){System.out.print("*");}
System.out.println();
}
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: //定义星期变量intweek = 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、什么是函数A、修饰符: public static
定义在类中，并有特定功能的一小段程序。
2、 格式
修饰符 返回类型 函数名（参数类型 形式参数,...）{
函数体；
return 返回值;
}
解释：
B、返回值类型 :就是数据类型
C、函数名:见名知意，如果一个单词，首字母小写，如果多个单词组成，从第二个单词开始首字母大写
D、参数类型 ：数据类型
E、形式参数 ：接受实际参数的变量
F、实际参数 ：就是实际参与运算的变量
G、函数体：实现功能的代码
H、返回值 程序的结果,如果没有明确返回值可以不写
I、return 返回值 ，那里调用程序，return就把结果返回到哪里 比如 int num = max(1,2); return把结果返给num
3、特点单独调用//没有意义
A、 函数和函数是平级关系，且只能定义在类中，不能在函数中嵌套函数
B、 函数只有被调用才会执行
4、注意
无论函数的返回值是具体的数据类型还是void，函数都是以return语句结束的
5、函数的调用
A 有明确返回值函数的调用
输出调用//视频中老师用的最多的
赋值调用//开发中用的最多的
B没有明确返回值函数的调用
单独调用6、函数的重载-overload(掌握)
重载：在同一个类中，函数名相同，参数列表不同(参数类型和个数)，与返回值类型无关。
举例：7、案例
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);}
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、 每一个实体内的内容都有默认值
整数: 05、数组操作 1、 数组遍历 2、 获取数组最值 3、 数组查找：给定一个值，查找该值在数组中对应的索引
【黑马程序员—Java基础知识--常量、变量、运算符、循环、数组】浮点数: 0.0
字符: ’\u0000’//char c = ‘\u0000’;
布尔 :false
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 = newint[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}}; 例如：
classArrayTest
{
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------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------
推荐阅读
- 急于表达——往往欲速则不达
- 慢慢的美丽
- 《真与假的困惑》???|《真与假的困惑》??? ——致良知是一种伟大的力量
- 2019-02-13——今天谈梦想（）
- 考研英语阅读终极解决方案——阅读理解如何巧拿高分
- Ⅴ爱阅读，亲子互动——打卡第178天
- 低头思故乡——只是因为睡不着
- 取名——兰
- 每日一话（49）——一位清华教授在朋友圈给大学生的9条建议
- 广角叙述|广角叙述 展众生群像——试析鲁迅《示众》的展示艺术