【21天学习挑战赛】—Java编程进阶之路(3)

​
​

活动地址：CSDN21天学习挑战赛

学习的最大理由是想摆脱平庸，早一天就多一份人生的精彩；迟一天就多一天平庸的困扰。各位小伙伴，如果您：
想系统/深入学习某技术知识点…
一个人摸索学习很难坚持，想组团高效学习…
想写博客但无从下手，急需写作干货注入能量…
热爱写作，愿意让自己成为更好的人…
…

个人名片：

🐼作者简介：一名大一在校生
🐻‍❄️个人主页：小新爱学习.
🐼个人WeChat：hmmwx53
🕊️系列专栏：零基础学java ----- 重识c语言
🐓每日一句：人生没有一劳永逸，想不被抛弃，只有自己努力

​

活动地址：CSDN21天学习挑战赛

学习的最大理由是想摆脱平庸，早一天就多一份人生的精彩；迟一天就多一天平庸的困扰。各位小伙伴，如果您：
想系统/深入学习某技术知识点…
一个人摸索学习很难坚持，想组团高效学习…
想写博客但无从下手，急需写作干货注入能量…
热爱写作，愿意让自己成为更好的人…
…
欢迎参与CSDN学习挑战赛，成为更好的自己，请参考活动中各位优质专栏博主的免费高质量专栏资源（这部分优质资源是活动限时免费开放喔~），按照自身的学习领域和学习进度学习并记录自己的学习过程。您可以从以下3个方面任选其一着手（不强制），或者按照自己的理解发布专栏学习作品，参考如下：

**

创作计划

**
1，机缘

我是一名普二学生，由于疫情原因大一下班学期也是没有开学，不甘堕落于是在互联网这片汪洋大海中，摸寻着前进的方向，也是偶然的机会接触到了CSDN，在这里有一群志同道合的朋友一起努力，于是自己也加入了进了，一篇两篇，也收获了很多的粉丝，推动着我前进…

2，收获

在CSDN这个大家庭里，每天都过得很充实，尤其是有不错的粉丝量，文章上了热榜，都会让我高兴半天，也结识了很多优质博主，像凉哥，哪吒…

3，日常

创作已经成为记录生活的一部分了，这里有我成长的点滴…

4，憧憬

有朝一日我也能成为优质博主，有自己的铁粉团队…

**

学习计划

**
1，学习目标

这21天我们可以分为3周，每周更新三篇

2，学习内容

• 第一周：周一
• 搭建 Java 开发环境
• 掌握 Java 基本语法
  第一周：周三
• 掌握条件语句
• 掌握循环语句
  第一周： 周六
• 掌握方法
• 掌握数组

3，学习时间
每周一，周三，周六

4，学习产出
技术笔记每周3篇
Blink若干

**

学习日记

第一周周六：

一、方法method：

1.概念：将具有独立功能的代码组织成一个整体，使其具有独立功能的代码集。

1. 方法的分类

1.按照参数来看：

1.无参数方法
1.方法定义：public static void 方法名(){方法体} 比如：public static void getPrint(){for循环}
2.方法使用(调用)：在main方法中，直接编写：方法名(); 比如：getPrint();

2.有参数的方法
1.方法定义：public static void 方法名(参数){方法体} ;public static void getPrint(int num){for循环}
参数：数据类型 变量名; 比如：(int num)
作用：就是用来传递数值的。

2.按照返回值类型

1.无返回值：void
public static void 方法名(){}

2.有返回值:数据类型 方法名();
public static 数据类型 方法名(){return 数据值}

注意：return处理的数值必须和方法上的定义的数据类型保持一致。 ​

2.方法调用：

在main方法中，直接编写：方法名(数值); 比如：getPrint2(10);

注意事项：

• 1.一个类中，各个方法的定义都是并列关系。
• 2.程序执行的时候，先main方法， 如果main方法里有其他方法调用，再会去执行其他方法。
  如果main方法里没有其他方法调用，不去执行其他方法。
• 3.一个类中各个方法定义的先后顺序没有要求，它一定先执行main方法。

4.方法的参数使用

	1.参数是基本数据类型
		方法调用时，传递获取的就是数值。 sum(1,2);
	2.参数是引用数据类型
		方法调用时，传递获取的就是地址值。
1
2
3
4

5.方法重载

	1.概念：同一个类中，方法名相同，参数列表不同。
	2.参数列表不同：
		1.个数不同
		2.数据类型不同
		3.数据类型顺序不同
1
2
3
4
5

代码示例：

public class Demo3Method {
	public static void main(String[] args) {
		sum(1,2);
		sum(1,2,3);
		sum(1,2.0);
		sum(1.2,3);
	}
	public static int sum(int a,int b) {
		return a+b;
	}
	//1.个数不同
	public static void sum(int a,int b,int c) {
		System.out.println(a+b+c);
	}
	//2.类型不同
	public static void sum(int a,double b) {
		System.out.println(a+b);
	}
	//3.顺序不同
	public static void sum(double b,int a) {
		System.out.println(a+b);
	}
	//定义四个方法，实现相减的操作，要求他们实现方法重载   
	public static int sub(int a,int b) {
		return a-b;
	}
	//1.个数不同   方法命名：见名知意思，首字母小写，驼峰命名法； getSum()
	public static void sub(int a,int b,int c) {
		System.out.println(a-b-c);
	}
	//2.类型不同
	public static void sub(int a,double b) {
		System.out.println(a-b);
	}
	//3.顺序不同
	public static void sub(double b,int a) {
		System.out.println(a-b);
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

二、数组：

1.数组的概念：
存储多个相同数据类型，可以存放基本数据类型，也可以存放引用数据类型，数组是java中唯一底层容器，集合的底层也是使用的是数组

1、数组的初始化：

为数组开辟连续的内存空间，并为每个数组元素赋值

a.静态初始化：指定数组内容，数组的长度是由jvm自动判断，在创建数组的同时，给数组赋值（存元素） 数据类型[] 数组名 = new
数据类型[]{元素,元素,元素}; 数据类型[] 数组名 = {元素,元素,元素};

b.动态初始化：创建数组时不存元素，但是一定要指明数组的容量，因为不指明容量，jvm没办法知道要开辟多大的空间，数组中的元素由jvm给出默认值
数组类型[] 数组名 = new 数组类型[数组长度];

注意：数组一旦创建，长度不可以改变，数组的长度允许为0，必须存放的是相同数据类型，数组属于引用数据类型，数组的下标是从0开始，下标最大值是数组的长度-1（length-1）

2.数组在内存中存储

1.栈内存：方法运行时使用的内存，比如main方法。
1.特点：先进后出，压栈操作。
2.比如main方法里定义的基本数据类型变量，都在栈内存中。

2.堆内存：用于存储对象或者数组。 特点：1.凡是new出来的东西，都在堆内存中存在。

	3.例子：
		int[] a=new int[2];
		a[0]=10;
		1.在栈内存中定义一个数组类型的对象，对象名叫做a
		2.在堆内存中创建一个真实的数组对象，它的长度是2;初始值是0;把它的地址值赋值给了a;
		3.通过a找到那个真实的对象，通过下标，去修改第一个数值为10;
1
2
3
4
5
6

3.数组中常见的异常(Exception)

	1.异常：程序出错，报错来的错误，是可以通过代码修改来避免或者解决的。
	2.分类：
		1.ArrayIndexOutOfBoundsException:数组下标越界异常
		      1.意思：访问数组时，下标超出了数组的下标范围。
		      2.解决:修改数组下标
		2.NullPointerException:空指针异常
			  1.意思：就是数组对象里存储的地址值为null,找不到堆内存中真实存在的那个对象了
			  2.解决：查看数组对象是否为null,代码修改。
1
2
3
4
5
6
7
8

public class Demo3ArrayException {
	public static void main(String[] args) {
		int[] array1= {10,20,30};
		System.out.println(array1[0]);
		System.out.println(array1[1]);
		System.out.println(array1[2]);
		//1.ArrayIndexOutOfBoundsException:数组下标越界异常
		//System.out.println(array1[3]);
		array1=null;
		System.out.println(array1);
		//2.NullPointerException:空指针异常
		System.out.println(array1[0]);
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

数组的遍历：

	1.概念:访问数组里的每一个元素。
	2.访问要求：
		1.通过索引访问。
		2.通过循环结构
		3.通过数组的长度去限定下标的范围。
			1.数组长度：array1.length;	
	 		注意事项：int a=10;a就是int类型的变量
	 		         int[] a=new int[2];a是一个数组对象名。  
1
2
3
4
5
6
7
8

代码示例：

public class Demo4ArrayBianLi {
	public static void main(String[] args) {
		int[] array1= {10,20,30,40,50,60,70,80,10,20,30,40,50};
		System.out.println(array1[0]);
		System.out.println(array1[1]);
		System.out.println(array1[2]);
		System.out.println(array1[3]);
		System.out.println(array1[4]);
		System.out.println(array1[5]);
		System.out.println(array1[6]);
		System.out.println("----------------------------------------------");
		/*for循环：解决重复问题
			for(int i=1;i<5;i++) {
				System.out.println("HelloWorld");
			}
		*/
		//array1.length：获取数组长度
		System.out.println("数组的长度："+array1.length);
		for(int i=0;i<array1.length;i++) {
			System.out.println(array1[i]);	
		}
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

5.冒泡排序

package cn.tedu.day04;

import java.util.Arrays;
import java.util.Random;
/**
 * 冒泡排序
 * @author 86182
 */
public class Test_Bubble {

	public static void main(String[] args) {
		int[] a = new int[10];
		Random r = new Random();
		for (int i = 0; i < a.length; i++) {
			a[i]= r.nextInt(100);
		}
		System.out.println("随机数组是："+Arrays.toString(a));
		System.out.println("排序后的数组是："+Arrays.toString(bubble(a)));
		//第一种，给出一组静态数组，对数组中的元素进行冒泡排序
//		int[] a = {23,45,12,25,65,11,34,15};
//		for (int i = 0; i < a.length-1; i++) {//轮数，8个数遍历7轮，第一轮遍历7次，第二轮遍历6次等等
//			for (int j = 0; j < a.length-1-i; j++) {//因为轮数越大，遍历的次数越少，所以要减去i--对比次数
//				if(a[j]>a[j+1]){//相邻比较
//					int t = a[j];//交换数据
//					a[j] = a[j+1];
//					a[j+1] = t;
//				}
//			}
//			System.out.println("第"+(i+1)+"轮的结果："+Arrays.toString(a));
//		}
//		System.out.println(Arrays.toString(a));//[11, 12, 15, 23, 25, 34, 45, 65]
		 	
	}
	//第二种，随机产生10个数（1到100之内），进行冒泡排序
	public static int[] bubble(int[] a){
		for (int i = 1; i < a.length; i++) {//外层循环，控制比较的轮数，假设有n个数，最多比较n-1次
			for (int j = 0; j < a.length-i; j++) {//内层循环：相邻比较+互换位置
				if (a[j]>a[j+1]) {//相邻比较
					int t = a[j];//交换数据，a[j]代表前一个元素，a[j+1]代表后一个元素
					a[j] = a[j+1];
					a[j+1] = t;
				}
			}
			System.out.println("第"+i+"轮的结果："+Arrays.toString(a));
		}
		return a;//把排序好的数组a返回
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

6.Arrays数组工具类

主要是对数组进行查找、排序、填充、比较等操作

• A.Arrays.toString(数组)
  把数组里的数据，用逗号连接成一个字符串[值1,值2]
• B.Arrays.sort(数组)
  对数组进行排序，对于基本数据类型的数组使用的是优化后的快速排序算法，效率高；对于引用数据类型数组，使用的是优化后的合并排序算法
• C.Arrays.copyOf(数组,新的长度)
  把数组复制称为一个指定长度的新数组
  新数组的长度大于原数组，相当于复制，并增加位置（扩容）
  新数组的长度小于原数组，相当于截取了一部分数据
• D.copyOfRange(数组, 开始下标, 结束下标)