day04

婷婷学java

于 2021-05-06 16:49:56 发布

阅读量70

点赞数

分类专栏： java基础

本文链接：https://blog.csdn.net/weixin_46046848/article/details/116457506

版权

java基础专栏收录该内容

24 篇文章 1 订阅

订阅专栏

day04

一、for循环的嵌套

实际上就是一个for循环中可以再放很多for循环

1.1 格式

//外层for
for(初始化语句; 条件表达式; 初始化语句的改变){
	//内层for
    for(初始化语句; 条件表达式; 初始化语句的改变){
	
		循环体语句;
	}
}

注意：外层for每执行一次，内层for就会全部执行完毕

class Demo {
	
	public static void main(String[] args) {
		
		//外层for
		for(int i = 0; i < 3; i++){
			//内层for
			for(int j = 0; j < 5; j++){
			
				System.out.println("i: " + i + ", j:" + j);
			}
		}
		
	}
}

练习：
	1. 打印如下图形
			*
		   ***
		  *****
		 *******
	2. 打印如下图形	 
		 *****
		 *   *
		 *   *
		 *****

/*
			*
		   ***
		  *****
		 *******
*/
class Test {
	
	public static void main(String[] args) {
		
		//控制行
		for(int i = 1; i <= 4; i++) {
			
			for(int k = 1; k <= 4-i; k++) {   // 3 2 1 0
				
				System.out.print(" ");
			}
			
			//控制打印星星
			for(int j = 1; j <= (2*i-1); j++) {  // j = 1 3 5 7   
				
				System.out.print("*");
			}
			
			System.out.println();
		}
		
	}
}

/*
		 *****
		 *   *
		 *   *
		 *****
*/
class Test2 {
	
	public static void main(String[] args) {
		
		for(int i = 1; i <= 4; i++) {
			if(i == 1 || i == 4) {
				
				System.out.println("*****");
			}
			if(i == 2 || i == 3) {
				
				System.out.println("*   *");
			}
			
		}
		
		System.out.println(" ");
	}
}

二、方法

将需要重复使用的代码统一写到一起，用大括号括起来，并给这个大括号起一个名字。以后我们使用这些代码的时候，就不需要再去写了，而是只通过名字就可以调用大括号中的代码实现相应的功能。

2.1 格式

修饰符 返回值类型 方法名(参数列表) {
	
	方法具体的内容;
	return 返回值;
}

格式的解释：
	修饰符：  	目前先记为public static
	返回值类型： 
		1. 可以是基本数据类型，也可以是引用数据类型。 
		2. 方法要完成相应的功能，可能会有相应的结果产生
				有具体的结果产生，那么需要一个明确的返回值类型
				没有结果产生，那么不需要一个明确的返回值类型，而只需要一个void即可
	方法名：    就是一个变量名，见名知意即可。但是需要符合方法的命名规范（一个单词全部小写，从第二个单词开始首字母大写）
	参数列表：  方法完成某些功能，可能会需要一些资源。（需要的资源方法并不会自己提供，而是需要外界调用这个方法的时候由外界提供），而参数列表的作用就是声明方法需要使用哪种类型的几个资源。
		1. 不需要任何资源，参数列表为空即可
		2. 需要资源， 参数列表就需要制定具体的类型了。 如需要两个int类型的数据，那么参数列表就需要声明为 int a, int b
	方法具体的内容：  完成方法功能的核心代码
    return：   
    	1. 如果方法有具体的结果产生的时候，需要通过return将这个具体的结果（return 返回值;）返回给方法的调用者，并结束方法
    	2. 如果方法没有结果产生，那么return就不需要写（如果非要写的话，那么就写为return ;）

案例：
	求两个数的和

2.2 方法的使用

注意：方法不调用不执行
调用的格式：方法名(实际参数);

三种调用方式

调用方式	格式	例子	使用
直接调用	方法名(实际参数);	sum(3, 5)	没有返回值的方法（也就是返回值为void的方法）
输出调用	System.out.println(方法名(实际参数));	System.out.println(sum(3, 5));	有明确返回值的方法
赋值调用	数据类型变量名 = 方法名(实际参数); System.out.println(变量名);	int result = sum(3, 5); System.out.println(result);	有明确返回值的方法

class Demo2 {
	
	public static void main(String[] args) {
		
		int m = 3;
		int n = 5;
		//输出调用
		//System.out.println(qiuHe(m, n));
		
		//赋值调用
		//int result = qiuHe(m, n);
		//System.out.println(result);
		
		//直接调用
		qiuHe(m, n);
	}
	
	/*
		求两个整数的和
		
		这个方法会求得一个和，而这个和我们有两种处理方案：
			1. 返回给方法的调用者
			2. 直接在方法中打印出来，不返回
	*/
	/*
	//方案1：有明确返回值的方法
	public static int qiuHe(int a, int b) {
	
		int result = a + b;
		return result;
	}
	*/
	
    //方案2：没有明确返回值的方法
	public static void qiuHe(int a, int b) {
	
		int result = a + b;
		System.out.println(result);
	}
	
}

2.3 方法的注意事项

1. 方法之间是平级的，不能嵌套进行定义
2. 方法的返回值类型和return有关系
		有明确返回值类型，就一定要写return 返回值; 并且return返回的值和类型必须和返回值类型保持一致
		没有明确返回值类型，就不需要写return
3. 方法可以嵌套调用，甚至可以自己调用自己

2.3 方法的递归

练习：
	求5!的阶乘。  如：5! = 5 * 4 * 3 * 2 * 1;  
	分析：5的阶乘可以分解为：
			5! = 5 * 4! 
			4!= 4 * 3! 
			3! = 3 * 2! 
			2! = 2 * 1! 
			1! = 1

class Demo5 {
	
	public static void main(String[] args) {
		
		System.out.println(getJC(5));
	}
	
	/*
		求阶乘
	*/
	public static int getJC(int n) {
		
		if(n == 1){
			return 1;
		}else {
			return n * getJC(--n);
		}
			
	}
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-45ODBh1p-1620290932416)(img/递归1.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Zb8x2oVO-1620290932419)(img/递归2.png)]

2.4 方法的重载

在同一个类中，方法名相同，参数列表不同，与返回值类型无关的方法，被称为方法的重载 @Overload

参数列表不同的几种情况：

1. 参数的个数不同
2. 参数的类型不同
3. 参数的位置不同

见过的方法重载

print
println

三、数组

数组是存储同种数据类型的多个元素的容器。

3.1 格式

数据类型[] 数组名 = new 数据类型[数组的长度];

格式的解释：
	数据类型：存储到数据中元素的类型，这个类型可以是基本数据类型，也可以是引用数据类型。
	[]：     表明这是一个数组
	数组名： 可以认为是一个变量名。但是数组名有特殊的作用：数组名指向了真正的数组，我们可以通过数组名访问数组中的数据
	=：     将new出来的数组地址赋值给数组名
	new：   new是一个关键字，用来在堆上给数组开辟一个空间
	数据类型： 同上
	数组的长度： 数组中可以最多可以装多少个元素

3.2 数组名打印出来的内容

[I@6f75e721

[：表明了这是一个一维数组
I：表明这是一个int类型的数组
@：就是一个字符'@'
6f75e721：地址的hashCode值的16进制表示形式

注意：[I@6f75e721可以认为是指向数组的地址

3.3 如何访问数组中的内容

格式

数组名[索引]

索引是什么？
	索引相当于是数组中存储数据的位置，这个位置从0开始，到数组的长度-1。
	比如一个3个长度的数组，索引的范围就是0-2，我们可以通过0访问数组中第一个元素，1访问第二个元素，2访问第三个元素

3.4 数组中默认的数据

不同类型的数组，在创建的时候都会有一个默认的值

整数类型    0
小数类型    0.0
布尔类型    false
字符类型    '\u0000'  （这个内容打印出来的效果是空）
引用数据类型  null

3.5 数组的初始化

数组的初始化就是给数组赋值

动态初始化

先声明好的一个数组，然后再逐一的给数组赋值

数据类型[] 数组名 = new 数据类型[数组的长度];

数组名[索引] = 数据;

如：
int[] arr = new int[3];
		
arr[0] = 11;
arr[1] = 22;
arr[2] = 33;

静态初始化

在创建一个数组的同时就给数组赋值

数据类型[] 数组名 = new 数据类型[]{元素1, 元素2, 元素3, ...};
简化格式：
数据类型[] 数组名 = {元素1, 元素2, 元素3, ...};   【常用】

如：
int[] arr2 = new int[]{66, 77, 88};
简化格式：
int[] arr2 = {66, 77, 88};

3.6 数组的常见异常

数组索引越界异常 ArrayIndexOutOfBoundsException

class Demo3 {
	
	public static void main(String[] args) {
		
		int[] arr = {11, 22, 33};
		
		System.out.println(arr[0]);
		System.out.println(arr[1]);
		System.out.println(arr[2]);
		//System.out.println(arr[3]);   //数组索引越界异常
		
	}
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Yb34d653-1620290932421)(img/image-20210409155255300.png)]

空指针异常 NullPointerException

class Demo4 {
	
	public static void main(String[] args) {
		
		int[] arr = {11, 22, 33};
		
		arr = null;
		
		System.out.println(arr[0]);
		System.out.println(arr[1]);
		System.out.println(arr[2]);
	}
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qwSt4y4g-1620290932424)(img/image-20210409155854805.png)]

.println(arr[3]); //数组索引越界异常

}


[外链图片转存中...(img-Yb34d653-1620290932421)]

##### 空指针异常 NullPointerException

```java
class Demo4 {
	
	public static void main(String[] args) {
		
		int[] arr = {11, 22, 33};
		
		arr = null;
		
		System.out.println(arr[0]);
		System.out.println(arr[1]);
		System.out.println(arr[2]);
	}
}

[外链图片转存中…(img-qwSt4y4g-1620290932424)]