学习笔记：Java基础语法（上）

最新推荐文章于 2022-03-03 23:00:42 发布

淡然一笑、

最新推荐文章于 2022-03-03 23:00:42 发布

阅读量214

点赞数 1

分类专栏：【Java】

本文链接：https://blog.csdn.net/weixin_39251617/article/details/102532594

版权

【Java】专栏收录该内容

6 篇文章 0 订阅

订阅专栏

1. 关键字

(1)被Java语言赋予特定含义的单词
(2)特点：
	全部小写。
(3)注意事项：
	A:goto和const作为保留字存在。
	B:类似于Notepad++这样的高级记事本会对关键字有特殊颜色标记

2. 标识符

(1)就是给类，接口，方法，变量等起名字的字符序列
(2)组成规则：
	A:英文大小写字母
	B:数字
	C:$和_
(3)注意事项：
	A:不能以数字开头
	B:不能是java中的关键字
	C:区分大小写
(4)常见的命名规则(见名知意)
	A:包	全部小写
		单级包：小写
			举例：liuyi,com
		多级包：小写，并用.隔开
			举例：cn.itcast,com.baidu				
	B:类或者接口
		一个单词：首字母大写
			举例：Student,Demo
		多个单词：每个单词首字母大写
			举例：HelloWorld,StudentName
	C:方法或者变量
		一个单词：首字母小写
			举例：name,main
		多个单词：从第二个单词开始，每个单词首字母大写
			举例：studentAge,showAllNames()
	D:常量
		全部大写
		一个单词：大写
			举例：PI
		多个单词：大写，并用_隔开
			举例：STUDENT_MAX_AGE

3. 注释

(1)就是对程序进行解释说明的文字
(2)分类：
	A:单行注释	//
	B:多行注释	/**/
	C:文档注释(后面讲) /** */
(3)注释的作用
	A:解释说明程序，提高了代码的阅读性。
	B:可以帮助我们调试程序。
		后面我们会讲解一个更高端的一个调试工具

4. 常量

(1)在程序执行的过程中，其值不发生改变的量
(2)分类：
	A:字面值常量
	B:自定义常量(后面讲)
(3)字面值常量
	A:字符串常量 "hello"
	B:整数常量	12,23
	C:小数常量	12.345
	D:字符常量	'a','A','0'
	E:布尔常量	true,false
	F:空常量	null(后面讲)
(4)在Java中针对整数常量提供了四种表现形式
	A:二进制	由0，1组成。以0b开头。
	B:八进制	由0，1，...7组成。以0开头。
	C:十进制	由0，1，...9组成。整数默认是十进制。
	D:十六进制	由0，1，...9,a,b,c,d,e,f(大小写均可)组成。以0x开头。

5. 进制转换

(1)其他进制到十进制
	系数：就是每一个位上的数值
	基数：x进制的基数就是x
	权：对每一个位上的数据，从右，并且从0开始编号，对应的编号就是该数据的权。
	
	结果：系数*基数^权次幂之和。
(2)十进制到其他进制
	除基取余，直到商为0，余数反转。
(3)进制转换的快速转换法
	A:十进制和二进制间的转换
		8421码。
	B:二进制到八进制，十六进制的转换

进制概述以及二进制,八进制,十六进制图解

任意进制到十进制的转换

十进制到任意进制的转换
快速的进制转换法

原码反码补码的讲解

6. 变量

(1)在程序的执行过程中，其值在某个范围内可以发生改变的量
(2)变量的定义格式：
	A:数据类型 变量名 = 初始化值;
	B:数据类型 变量名;
	  变量名 = 初始化值;

7. 数据类型

(1)Java是一种强类型语言，针对每种数据都提供了对应的数据类型。
(2)分类：
	A:基本数据类型：4类8种
	B:引用数据类型：类，接口，数组。
(3)基本数据类型
	A:整数			占用字节数
		byte			1
		short			2
		int 			4
		long			8
	B:浮点数
		float			4
		double			8
	C:字符
		char			2
	D:布尔
		boolean			1
		
	注意：
		整数默认是int类型，浮点数默认是double。
		
		长整数要加L或者l。
		单精度的浮点数要加F或者f。

8. 数据类型转换

(1)boolean类型不参与转换
(2)默认转换
	A:从小到大
	B:byte,short,char -- int -- long -- float -- double
	C:byte,short,char之间不相互转换，直接转成int类型参与运算。
(3)强制转换
	A:从大到小
	B:可能会有精度的损失，一般不建议这样使用。
	C:格式：
		目标数据类型 变量名 = (目标数据类型) (被转换的数据);
(4)思考题和面试题：
	A:下面两种方式有区别吗?
	    float f1 = (float)12.345;
		float f2 = 12.345f;
		
		答：	
		f1其实是通过一个double类型转换过来的。
	    而f2本身就是一个float类型。
	    
	B:下面的程序有问题吗，如果有，在哪里呢?
		byte b1 = 3;
		byte b2 = 4;
		byte b3 = b1 + b2;
		byte b4 = 3 + 4;
		
		答：
		b = b1 + b2;是有问题的。
	    因为变量相加，会首先看类型问题（参与运算byte转成了int），最终把结果赋值的也会考虑类型问题。
	    常量相加，首先做加法，然后看结果是否在赋值的数据类型范围内，如果不是，才报错。
		
		
	C:下面的操作结果是什么呢?
		byte b = (byte)130;
		
		答：
		我们要想知道结果是什么，就应该知道是如何进行计算的。
		而我们又知道计算机中数据的运算都是补码进行的。
		而要得到补码，首先要计算出数据的二进制。
		
		A:获取130这个数据的二进制。
			00000000 00000000 00000000 10000010
			这是130的原码，也是反码，还是补码。
		B:做截取操作，截成byte类型的了。
			10000010 
			这个结果是补码。
		C:已知补码求原码。
					符号位		数值位
			补码：	1			0000010
			
			反码：	1			0000001
			
			原码：	1			1111110
		D：-126
		
	D:字符参与运算
		是查找ASCII里面的值
		'a'		97
		'A'		65
		'0'		48
		
		System.out.println('a'); // a
		System.out.println('a' + 1); // 98
		
	E:字符串参与运算
		这里其实是字符串的连接

		System.out.println("hello"+'a'+1);// helloa1
		System.out.println('a'+1+"hello");// 98hello
		System.out.println("5+5="+5+5);// 5+5=55
		System.out.println(5+5+"=5+5");// 10=5+5

不同数据类型变量参与运算图解

9. 常用ASCII

ASCII码	键盘	ASCII 码	键盘	ASCII 码	键盘	ASCII 码	键盘
27	ESC	32	SPACE	33	!	34	"
35	#	36	$	37	%	38	&
39	’	40	(	41	)	42	*
43	+	44	’	45	-	46	.
47	/	48	0	49	1	50	2
51	3	52	4	53	5	54	6
55	7	56	8	57	9	58	:
59	;	60	<	61	=	62	>
63	?	64	@	65	A	66	B
67	C	68	D	69	E	70	F
71	G	72	H	73	I	74	J
75	K	76	L	77	M	78	N
79	O	80	P	81	Q	82	R
83	S	84	T	85	U	86	V
87	W	88	X	89	Y	90	Z
91	[	92	\	93	]	94	^
95	_	96	`	97	a	98	b
99	c	100	d	101	e	102	f
103	g	104	h	100	i	106	j
107	k	108	l	109	m	110	n
111	o	112	p	113	q	114	r
115	s	116	t	117	u	118	v
119	w	120	x	121	y	122	z
123	{	124	\|	125	}	126	~

10. 运算符

(1)算术运算符

	A:+,-,*,/,%,++,--
	B:+的用法
		a:加法
		b:正号
		c:字符串连接符
	C:/和%的区别
		数据做除法操作的时候，/取得是商，%取得是余数
	D:++和--的用法
		a:他们的作用是自增或者自减
		b:使用
			**单独使用
				放在操作数据的前面和后面效果一样。
				a++或者++a效果一样。
			**参与操作使用
				放在操作数的前面：先自增或者自减，再参与操作
					int a = 10;
					int b = ++a;
				放在操作数的后面：先参与操作，再自增或者自减
					int a = 10;
					int b = a++;

(2)赋值运算符

	A:=,+=,-=,*=,/=,%=等
	B:=叫做赋值运算符，也是最基本的赋值运算符
		int x = 10; 把10赋值给int类型的变量x。
	C:扩展的赋值运算符的特点
		隐含了自动强制转换。
		
		面试题：
			short s = 1;
			s = s + 1;
			
			short s = 1;
			s += 1;
			请问上面的代码哪个有问题?
			s = s + 1;有问题，s参与运算时提升为int型，不能再用short接收
			
			s += 1;
			不是等价于 s = s + 1;
			而是等价于 s = (s的数据类型)(s + 1);

(3)比较运算符

	A:==,!=,>,>=,<,<=
	B:无论运算符两端简单还是复杂最终结果是boolean类型。
	C:千万不要把==写成了=

(4)逻辑运算符

	A:&,|,^,!,&&,||
	B:逻辑运算符用于连接boolean类型的式子
	C:结论
		&:有false则false
		|:有true则true
		^:相同则false，不同则true。
			可以想象情侣关系：男女true，男男false，女女false
		!:非true则false，非false则true
		
		&&:结果和&是一样的，只不过有短路效果。左边是false，右边不执行。
		||:结果和|是一样的，只不过有短路效果。左边是true，右边不执行。

(5)三元运算符

	A:格式
		比较表达式?表达式1:表达式2;
	B:执行流程：
		首先计算比较表达式的值，看是true还是false。
		如果是true，表达式1就是结果。
		如果是false，表达式2就是结果。
	C:案例：
		a:比较两个数据是否相等
		b:获取两个数据中的最大值
		c:获取三个数据中的最大值

(6)位运算符(了解)

    A:基本用法
    
    System.out.println(3 & 4);
	System.out.println(3 | 4);
	System.out.println(3 ^ 4);
	System.out.println(~3);
	
    分析：因为是位运算，所以我们必须先把数据换算成二进制。
    
    3的二进制：11
	00000000 00000000 00000000 00000011
    4的二进制：100
	00000000 00000000 00000000 00000100

&位与运算：有0则0。
	00000000 00000000 00000000 00000011
   &00000000 00000000 00000000 00000100
	-----------------------------------
	00000000 00000000 00000000 00000000
	结果是：0
	
|位或运算：有1则1。
	00000000 00000000 00000000 00000011
   |00000000 00000000 00000000 00000100
	-----------------------------------
	00000000 00000000 00000000 00000111
	结果是：7
	
^位异或运算：相同则0，不同则1。
	00000000 00000000 00000000 00000011
   &00000000 00000000 00000000 00000100
	-----------------------------------
	00000000 00000000 00000000 00000111
	结果是：7
	
~按位取反运算符：0变1，1变0
    ~3
	~00000000 00000000 00000000 00000011
     11111111 11111111 11111111 11111100 (计算机显示补码)
   
   补码：11111111 11111111 11111111 11111100
   反码：11111111 11111111 11111111 11111011
   原码：10000000 00000000 00000000 00000100
   结果：-4
	
	B:^的特殊用法
		一个数据针对另一个数据位异或两次，该数不变
	C:面试题
		a:请实现两个变量的交换
			**采用第三方变量
			**用位异或运算符
				左边a,b,a
				右边a^b
				
				a = a ^ b;
				b = a ^ b;
				a = a ^ b;
		b:请用最有效率的方式计算出2乘以8的结果
			2<<3

11. 键盘录入

(1)实际开发中，数据是变化的，为了提高程序的灵活性，我们加入键盘录入数据。
(2)如何实现呢?目前就记住
	A:导包
		import java.util.Scanner;
		位置：在class的上边
	B:创建对象
		Scanner sc = new Scanner(System.in);
	C:获取int数据
		int x = sc.nextInt();
    D:获取String数据
        String s = sc.nextLine();

12. 流程控制语句

(1)顺序结构 从上往下，依次执行
(2)选择结构	按照不同的选择，执行不同的代码
(3)循环结构 做一些重复的代码

(1)选择结构

1. 选择结构-if语句

(1)三种格式
	A:格式1
		if(比较表达式) {
			语句体;
		}
		
		执行流程：
			判断比较表达式的值，看是true还是false
			如果是true，就执行语句体
			如果是false，就不执行语句体
	
	B:格式2
		if(比较表达式) {
			语句体1;
		}else {
			语句体2;
		}
		
		执行流程：
			判断比较表达式的值，看是true还是false
			如果是true，就执行语句体1
			如果是false，就执行语句体2
			
	C:格式3
		if(比较表达式1) {
			语句体1;
		}else if(比较表达式2){
			语句体2;
		}
		...
		else {
			语句体n+1;
		}
		
		执行流程：
			判断比较表达式1的值，看是true还是false
			如果是true，就执行语句体1
			如果是false，就继续判断比较表达式2的值，看是true还是false
			如果是true，就执行语句体2
			如果是false，就继续判断比较表达式3的值，看是true还是false
			...
			如果都不满足，就执行语句体n+1
(2)注意事项
	A:比较表达式无论简单还是复杂，结果是boolean类型
	B:if语句控制的语句体如果是一条语句，是可以省略大括号的；如果是多条，不能省略。
		建议：永远不要省略。
	C:一般来说，有左大括号，就没有分号，有分号，就没有左大括号。
	D:else后面如果没有if，是不会出现比较表达式的。
	E:三种if语句其实都是一个语句，只要有一个执行，其他的就不再执行。

(3)三元运算符和if语句第二种格式的关系
	所有的三元运算符能够实现的，if语句的第二种格式都能实现。
	反之不成立。
	
	如果if语句第二种格式控制的语句体是输出语句，就不可以。
	因为三元运算符是一个运算符，必须要有一个结果返回，不能是一个输出语句。
	
	
2. 选择结构——switch语句

(1)格式：
	switch(表达式) {
		case 值1:
			语句体1;
			break;
		case 值2:
			语句体2;
			break;
		...
		default:
			语句体n+1;
			break;
	}
	
	格式解释说明：
		switch:说明这是switch语句。
		表达式:可以是byte,short,int,char
			JDK5以后可以是枚举
			JDK7以后可以是字符串
		case:后面的值就是要和表达式进行比较的值
		break:表示程序到这里中断，跳出switch语句
		default:如果所有的情况都不匹配,就执行这里,相当于if语句中的else
(2)面试题
	switch语句的表达式可以是byte吗?可以是long吗?可以是String吗?
	答案：可以,不可以,JDK7以后可以
(3)执行流程:
	A:首先计算表达式的值
	B:和每一个case进行匹配，如果有就执行对应的语句体，看到break就结束。
	C:如果没有匹配，就执行default的语句体n+1。
(4)注意事项:
	A:case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的
	B:default可以省略吗?
		可以省略，但是不建议，因为它的作用是对不正确的情况给出提示。
		特殊情况：
			case值固定范围。
			A,B,C,D
	C:break可以省略吗?
		可以省略，但是结果可能不是我们想要的。
		会出现一个现象：case穿透。
		最终我们建议不要省略
	D:default一定要在最后吗?
		不是，可以在任意位置。但是建议在最后。
	E:switch语句的结束条件
		a:遇到break就结束了
		b:执行到末尾就结束了
	F：default并不代表结束，如果default不在末尾且没有break，将会继续执行后面的case
(5)if语句和switch语句各自的场景
	A:if
		针对boolean类型的判断
		针对一个范围的判断
		针对几个常量的判断
	B:switch
		针对几个常量的判断

(2)循环语句

(1)有三种:for,while,do...while
(2)for循环语句
	A:格式
		for(初始化语句;判断条件语句;控制条件语句){
			循环体语句;
		}
		
		执行流程：
			a:执行初始化语句
			b:执行判断条件语句
				如果这里是true，就继续
				如果这里是false，循环就结束
			c:执行循环体语句
			d:执行控制条件语句
			e:回到b
	B:注意事项
		a:判断条件语句无论简单还是复杂，结果是boolean类型
		b:循环体语句如果是一条，可以省略大括号，但是不建议
		c:有分号就没有左大括号，有左大括号就没有分号
(3)while循环
	A:基本格式
		while(判断条件语句) {
			循环体语句;
		}
		
		扩展格式：
		
		初始化语句;
		while(判断条件语句){
			循环体语句;
			控制条件语句;
		}
		
		通过查看这个格式，我们就知道while循环可以和for循环等价转换。
	B:while的练习
		把for语句的练习用while改进
	C:for和while的区别
		a:使用上的区别
			for语句的那个控制条件变量,在循环结束后不能在使用了。
			而while的可以继续使用。
		b:理解上的区别
			for适合于一个范围的判断
			while适合次数不明确的

(4)do...while循环
	A:基本格式
		do {
			循环体语句;
		}while(判断条件语句);
		
		扩展格式：
		
		初始化语句;
		do {
			循环体语句;
			控制条件语句;
		}while(判断条件语句);
		
		通过查看格式，我们就可以看出其实三种循环的格式可以是统一的。
	B:三种循环的区别
		a:do...while循环至少执行一次循环体
		b:for和while必须先判断条件是否是true，然后后才能决定是否执行循环体
		
(5)循环使用的注意事项(死循环)
	A:一定要注意修改控制条件,否则容易出现死循环。
	B:最简单的死循环格式
		a:while(true){...}
		
		b:for(;;){}

经典案例：

/*
	需求：统计”水仙花数”共有多少个
	
	分析：
		A:首先必须知道什么是水仙花数
			所谓的水仙花数是指一个三位数，其各位数字的立方和等于该数本身。
			举例：153就是一个水仙花数。
			153 = 1*1*1 + 5*5*5 + 3*3*3 = 1 + 125 + 27 = 153
		B:定义统计变量，初始化值是0
		C:三位数告诉了我们范围，用for循环就可以搞定
		D:获取每一个三位数的个，十，百的数据
		E:按照要求进行判断
		F:如果满足要求就计数。
*/
class ForDemo8 {
	public static void main(String[] args) {
		//定义统计变量，初始化值是0
		int count = 0;
		
		//三位数告诉了我们范围，用for循环就可以搞定
		for(int x=100; x<1000; x++) {
			//获取每一个三位数的个，十，百的数据
			int ge = x%10;
			int shi = x/10%10;
			int bai = x/10/10%10;
			
			//按照要求进行判断
			if(x == (ge*ge*ge+shi*shi*shi+bai*bai*bai)) {
				//如果满足要求就计数。
				count++;
			}
		}
		
		System.out.println("水仙花数共有"+count+"个");
	}
}

/*
	需求：求5的阶乘。
	
	什么是阶乘呢?
		n! = n*(n-1)! 规则
		n! = n*(n-1)*(n-2)*...*3*2*1
		
	求和思想。
	求阶乘思想。
*/
class ForDemo5 {
	public static void main(String[] args) {
		//定义最终结果变量
		int jc = 1;
		
		//这里的x其实可以直接从2开始
		//for(int x=1; x<=5; x++) 
		
		for(int x=2; x<=5; x++) {
			jc *=x;
		}
		
		System.out.println("5的阶乘是："+jc);
	}
}

13. 控制跳转语句

(1)break:中断的意思
	A:用在循环和switch语句中，离开此应用场景无意义。
	B:作用
		a:跳出单层循环
		b:跳出多层循环，需要标签语句的配合
(2)continue:继续
	A:用在循环中，离开此应用场景无意义。
	B:作用
		a:跳出单层循环的一次，可以继续下一次;也可以带标签使用
	C:填空题
		for(int x=1; x<=10; x++) {
			if(x%3 == 0) {
				//补齐代码
			}
			System.out.println("Java基础班");
		}
		如何让控制台输出2次：Java基础班  // break; （x等于1、2时打印）
		如何让控制台输出7次：Java基础班  // coutinue; （x等于3、9时不打印）
		如何让控制台输出13次：Java基础班 // System.out.println("Java基础班");
(3)return:返回
	A:用于结束当前方法的，后面还会在继续讲解和使用。
	B:一旦遇到return,当前方法未执行部分就不会在再执行。

// 跳出多层循环示例：

wc:for(int x=0; x<3; x++) {
	nc:for(int y=0; y<4; y++) {
		if(y == 2) {
			//break nc;
			break wc;
		}
		System.out.print("*");
	}
	System.out.println();
}

14. 方法

(1)方法：就是完成特定功能的代码块。
	注意：在很多语言里面有函数的定义，而在Java中，函数被称为方法。
	
(2)格式：
	修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...) {
		方法体语句;
		return 返回值;
	}

	修饰符：目前就用 public static。后面再详细讲解其他修饰符
	返回值类型：就是功能结果的数据类型
	方法名：就是起了一个名字，方便我们调用该方法。
	参数类型：就是参数的数据类型
	参数名：就是变量
	参数分类：
		实参：实际参与运算的数据
		形参：方法上定义的，用于接收实际参数的变量
	方法体语句：就是完成功能的代码块
	return：结束方法
	返回值：就是功能的结果，由return带给调用者。
	
(3)两个明确：
	返回值类型：结果的数据类型
	参数列表：参数的个数及对应的数据类型
	
(4)方法调用
	A:有明确返回值的方法
		a:单独调用，没有意义
		b:输出调用，不是很好，因为我可能需要结果进行进一步的操作。
		c:赋值调用，推荐方案
	B:void类型修饰的方法
		a:单独调用

(5)方法的注意事项
	A:方法不调用不执行
	B:方法之间是平级关系，不能嵌套定义
	C:方法定义的时候，参数是用,隔开的
	D:方法在调用的时候，不用在传递数据类型
	E:如果方法有明确的返回值类型，就必须有return语句返回。
	
(6)方法重载
	在同一个类中，方法名相同，参数列表不同。与返回值无关。
	
	参数列表不同：
		参数的个数不同。
		参数的对应的数据类型不同。

15. 数组

(1)数组：存储同一种数据类型的多个元素的容器。

(2)特点：每一个元素都有编号，从0开始，最大编号是长度-1。
         编号的专业叫法：索引
         
(3)定义格式
	A:数据类型[] 数组名;
	B:数据类型 数组名[];
	
	推荐是用A方式，B方法就忘了吧。
	但是要能看懂
	
(4)数组的初始化
	A:动态初始化
		只给长度，系统给出默认值
		
		举例：int[] arr = new int[3];
	B:静态初始化
		给出值，系统决定长度
		
		举例：int[] arr = new int[]{1,2,3};
		简化版：int[] arr = {1,2,3};
		
(5)Java的内存分配
	A:栈 存储局部变量
	B:堆 存储所有new出来的
	C:方法区(面向对象部分详细讲解)
	D:本地方法区(系统相关)
	E:寄存器(CPU使用)
	
	注意：
		a:局部变量 在方法定义中或者方法声明上定义的变量。
		b:栈内存和堆内存的区别
			栈：数据使用完毕，就消失。
			堆：每一个new出来的东西都有地址
			    每一个变量都有默认值
					byte,short,int,long 0
					float,double 0.0
					char '\u0000'
					boolean false
					引用类型 null
			    数据使用完毕后，在垃圾回收器空闲的时候回收。
			    
(6)数组的常见操作
	A:遍历
		方式1：
			public static void printArray(int[] arr) {
				for(int x=0; x<arr.length; x++) {
					System.out.println(arr[x]);
				}
			}
			
		方式2：
			public static void printArray(int[] arr) {
				System.out.print("[");
				for(int x=0; x<arr.length; x++) {
					if(x == arr.length-1) {
						System.out.println(arr[x]+"]");
					}else {
						System.out.println(arr[x]+", ");
					}
				}
			}
	B:最值
		最大值：
			public static int getMax(int[] arr) {
				int max = arr[0];
				
				for(int x=1; x<arr.length; x++) {
					if(arr[x] > max) {
						max = arr[x];
					}
				}
				
				return max;
			}
			
		最小值：
			public static int getMin(int[] arr) {
				int min = arr[0];
				
				for(int x=1; x<arr.length; x++) {
					if(arr[x] < min) {
						min = arr[x];
					}
				}
				
				return min;
			}
	C:逆序
		方式1：
			public static void reverse(int[] arr) {
				for(int x=0; x<arr.length/2; x++) {
					int temp = arr[x];
					arr[x] = arr[arr.length-1-x];
					arr[arr.length-1-x] = temp;
				}
			}
			
		方式2：
			public static void reverse(int[] arr) {
				for(int start=0,end=arr.length-1; start<=end; start++,end--) {
					int temp = arr[start];
					arr[start] = arr[end];
					arr[end] = temp;
				}
			}
	D:查表
			public static String getString(String[] strArray,int index) {
				return strArray[index];
			}
	E:基本查找
		方式1：
			public static int getIndex(int[] arr,int value) {
				for(int x=0; x<arr.length; x++) {
					if(arr[x] == value) {
						return x;
					}
				}
				
				return -1;
			}
			
		方式2：
			public static int getIndex(int[] arr,int value) {
				int index = -1;
			
				for(int x=0; x<arr.length; x++) {
					if(arr[x] == value) {
						index = x;
						break;
					}
				}
				
				return index;
			}

(7) 数组常见问题
   * 数组角标越界
        ArrayIndexOutOfBoundsException
        访问到了数组中的不存在的索引时发生。
   * 空指针异常
        NullPointerException
        数组引用没有指向实体，在操作实体中的元素时发生。

3. 二维数组

(1)定义：元素是一维数组的数组。

(2)格式：
	A:数据类型[][] 数组名 = new 数据类型[m][n];  》 动态初始化
	B:数据类型[][] 数组名 = new 数据类型[m][];   》 动态初始化
	C:数据类型[][] 数组名 = new 数据类型[][]{{...},{...},{...}};》 静态初始化
	D:数据类型[][] 数组名 = {{...},{...},{...}};》 静态初始化
	
(3) 举例：
	int[][] arr = new int[3][2];
    定义了一个二维数组arr
    这个二维数组有3个一维数组，名称是arr[0],arr[1],arr[2]
    每个一维数组有2个元素，可以通过arr[m][n]来获取

(4) 注意：
	A:以下格式也可以表示二维数组
		a:数据类型 数组名[][] = new 数据类型[m][n];
		b:数据类型[] 数组名[] = new 数据类型[m][n];
	B:注意下面定义的区别
		int x;
		int y;
		int x,y; // 声明x,y两个int类型变量
		
		int[] x;
		int[] y[]; // 声明名为y的二维数组
		
		int[] x,y[]; // 声明x一维数组和y二维数组

16. Java中的参数传递问题

Java中只有值传递。基本类型传递的是具体的数值，引用类型传递的是引用的地址值

基本类型：形式参数的改变不影响实际参数
引用类型：形式参数的改变直接影响实际参数

淡然一笑、

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
学习笔记：Java基础语法（上）

1. 关键字(1)被Java语言赋予特定含义的单词(2)特点：全部小写。(3)注意事项： A:goto和const作为保留字存在。 B:类似于Notepad++这样的高级记事本会对关键字有特殊颜色标记2. 标识符(1)就是给类，接口，方法，变量等起名字的字符序列(2)组成规则： A:英文大小写字母 B:数字 C:$和_(3)注意事项： A:不能以数字开头 B:...
复制链接

扫一扫

专栏目录