本文章基于b站：BV1RK4y1g7A5 赵珊珊老师的java课程的学习加以个人理解做出的学习笔记整理。(p78-p95)
目录
方法
方法的定义与调用
【1】方法是:对特定的功能进行提取，形成一个代码片段，这个代码片段就是我们所说的方法
【2】方法和方法是并列的关系，所以我们定义的方法不能写到main方法中
【3】方法的定义--》格式:
修饰符 方法返回值类型 方法名 (形参列表) {方法体;
return 方法返回值;
}
【4】方法的作用:提高代码的复用性【5】总结方法定义的格式:
1)修饰符:暂时使用public static --->面向对象一章讲解2)方法返回值类型︰方法的返回值对应的数据类型
数据类型:可以是基本数据类型(byte,short,int,long,float,double,char,boolean)也可以是引用数据类型
3)方法名:见名知意，首字母小写，其余遵循驼峰命名, eg: addNum ,一般尽量使用英文来命名
4)形参列表:方法定义的时候需要的形式参数: int num1, int num2 -->相当于告诉方法的调用者:需要传入几个参数，需要传入的参数的类型实际参数:方法调用的时候传入的具体的参数: 10,20-->根据形式参数的需要传入的
5)方法体:具体的业务逻辑代码
6) return方法返回值;
方法如果有返回值的话: return+方法返回值，将返回值返回到方法的调用处【6】方法的定义需要注意什么?
1)形参列表要怎么写:定义几个参数，分别是什么类型的
2)方法到底是否需要返回值，如果需要的话，返回值的类型是什么
【7】方法的调用需要注意什么?
1)实际参数要怎么传入:传入几个参数，传入什么类型的2)方法是否有返回值需要接收
public static int add(int num1, int num2) {
int sum = 0;
sum = num1 + num2;
return sum;
}
public static void main(String[] args) {
// add(10,20)返回30;需要接收这个值
int sum = add(10, 20);
System.out.println(sum);
}方法的提取练习
功能：我心理有一个数，你来猜，是否猜对
(1)你猜一个数==》控制台输入一个数
(2)我心里有一个数==》随机给出一个数
(3)两数对比==》大于、等于、小于给出提示
public static void compare(int guessNum) {
int randomNum = (int) (Math.random()*6 + 1);
System.out.println("所给出的随机数：" + randomNum);
if (randomNum < guessNum) {
System.out.println("猜大了");
} else if (randomNum == guessNum) {
System.out.println("猜对了");
} else {
System.out.println("猜小了");
}
}
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print("请在[1,6]之间猜数:");
int guessNum = input.nextInt();
compare(guessNum);
}面试题
代码顺序：
①在栈中为main方法开辟栈帧，存储a 10;b 20;
②打印a、b；其中a 10;b 20;
③调用changeNum(a,b);将实参a、b传入num1、num2；在changeNum中实现num1、num2的交换，销毁changeNum的栈帧
④打印a、b; 其中a 10;b 20;
方法的重载
【1】方法的重载:在同一个类中，方法名相同，形参列表不同的多个方法，构成了方法的重载。
【2】方法的重载只跟:方法名和形参列表有关，与修饰符，返回值类型无关。
【3】注意:形参列表不同指的是什么?
(1)个数不同
add() add(int num1) add(int num1,int num2)(2)顺序不同
add(int num1,double num2) add(double num1,int num2)(3)类型不同
add(int num1) add(double num1)
【4】请问下面的方法是否构成了方法的重载?
(1)add(int a)和add(int b) --->不构成,相当于方法的重复定义
(2)public static int add(int a)和public static void add(int b) --->不构成【5】拓展：调用时匹配多个方法时，优先走完全匹配的，再走与其优先级临近的
优先级: byte,short, char-->int-->long-->float--->double
①有int 先走int，输出-----1；②2和3对比走float；③2、3和4对比走long
数组
数组的学习
数组的定义
数组是相同类型数据的有序集合。数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。其中，每一个数据称作一个元素，每个元素可以通过一个索引(下标)来访问它们。
数组的四个基本特点:
1.长度是确定的。数组一旦被创建，它的大小就是不可以改变的。2.其元素的类型必须是相同类型，不允许出现混合类型。
3.数组类型可以是任何数据类型，包括基本类型和引用类型。4.数组有索引的:索引从0开始，到数组名.length-1结束
5.数组变量属于引用类型，数组也是对象。
PS:数组变量属于引用类型，数组也是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中存储的。
数组的作用:用来存储相同类型的数据,以int类型数据为案例:数组用来存储int类型数据
【1】声明(定义数组)
int[] arr; //定义一个int类型的数组,名字叫arr// int arr2[];
//如果数组只声明，没有后续操作，那么这个数组相当于没定义
//int[] arr3 = null;//空 辨别:数组赋值为null和什么都没有赋值，不一样的效果
【2】创建
arr =new int[4];//给数组开辟了一个长度为4的空间
//编译期声明和创建会被合为一句话: int [] arr = new int[4];
【3】赋值arr[0] = 12;
【4】使用sout arr[0];//打印 sout arr[0]+10; //运算 sout arr.length；//长度
步骤【2】创建时的内存分析
数组有默认的初始化值:
要看是什么类型的数组:
基本数据类型的数组:
byte[] :0
short[] :0
int[] :0
long[] :0
float[] : 0.0
double[] :0.0
char[] : '\u0000'相当于' '
boolean[] : false
引用数据类型的数组: null
数组的遍历
增强for循环
for (int num:scores){} 对scores数组进行遍历，遍历出来的每个元素都用int类型的num接收
优点：代码简单
缺点：单纯的使用增强for循环，不能涉及跟索引相关的操作
优化：（但没必要，可以直接用普通for循环）
int count = 0; for (int num : scores) { count++; System.out.println("第" + count + "个学生的成绩为:"+num); }
// 键盘录入3个学生的成绩，求和，求平均值，求各个学生的成绩
int[] scores = new int[3];
int sum = 0;
for (int i = 1; i <= 3; i++) {
Scanner sc = new Scanner(System.in);
System.out.print("第" + i + "个学生的成绩为:");
scores[i - 1] = sc.nextInt();
sum += scores[i - 1];
}
System.out.println("总成绩为：" + sum);
System.out.println("平均成绩为：" + sum / 3);
// 普通for循环遍历
for (int i = 1; i <= 3; i++) {
System.out.println("第" + i + "个学生的成绩为:" + scores[i - 1]);
}
// 增强for循环遍历
for (int num : scores) {
System.out.println(num);
}
// 普通for循环逆向遍历
for (int i = 3; i >= 1; i--) {
System.out.println("第" + i + "个学生的成绩为:" + scores[i - 1]);
}
<h2 id="1">数组的初始化</h2>
数组的初始化方式总共有三种:静态初始化、动态初始化、默认初始化。
●静态初始化
除了用new关键字来产生数组以外，还可以直接在定义数组的同时就为数组元素分配空间并赋值。eg:
int[] arr = {12,23,45};
int[] arr = new int[]{12,23,45};注意:
1.new int[3]{12,23,45};-->错误2.int[] arr ;
arr = {12,23,45};--->错误，不能分开；int[] arr = new int[3];可以分开
●动态初始化
数组定义与为数组元素分配空间并赋值的操作分开进行。eg:
int[] arr = new int[3];arr[0] = 12;
arr[1] = 23;arr[2] = 45;
●默认初始化
数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。int[] arr = new int[3];--->数组有默认的初始化值
数组的应用
最值问题
类比“打擂台”，选一个数当擂主，其余数逐一“对战”
提取方法：①要传入的是不同的数组，故形参为数组；②返回最大值int
public static void main(String[] args) {
int[] arr = {1, 2, 3, 10, 5};
int maxNum = getMaxNum(arr);
System.out.println("该数组最大值为：" + maxNum);
}
public static int getMaxNum(int[] arr) {
int maxNum = arr[0];
for (int challenger : arr) {
if (challenger > maxNum) {
maxNum = challenger;
}
}
return maxNum;内存分析：
方法的实参传递给形参的时候一定要注意:
一切都是值传递:
如果是基本数据类型，那么传递的就是字面值
如果是引用数据类型，那么传递的就是地址值
查询问题（待完成内存分析）
【1】查询指定位置的元素
【2】查询指定元素的位置==》找到元素对应的索引
【3】将查指定元素对应的索引的功能提取为方法
// 要传入不同的数组，不同的所要查找的元素==》形参；输出索引值int
public static void main(String[] args) {
int[] arr = {11, 22, 33, 44, 55};
int index = getIndex(arr, 0);
if (index != -1) {
System.out.println("对应的索引值为:" + index);
} else {
System.out.println("查无此数");
}
}
// 要传入不同的数组，不同的所要查找的元素==》形参；输出索引值int
public static int getIndex(int[] arr, int ele) {
int index = -1;
for (int i = 0; i < arr.length; i++) {
if (arr[i] == ele) {
index = i;
}
}
return index;
}内存分析 ：
添加元素
实现思路：①数组长度确定后不可更改，所以将最后一个元素覆盖掉
int[] arr = new int[]{12, 34, 56, 7, 3, 10};
//添加前
System.out.print("添加前的数组为：");
for (int i = 0; i < arr.length; i++) {
if (i != arr.length - 1) {
System.out.print(arr[i] + ",");
} else {
System.out.print(arr[i]);
}
}
//添加操作
for (int i = 5; i >= 2; i--) {
arr[i] = arr[i - 1];
}
arr[1] = 99;
//添加后
System.out.print("\n添加后的数组为：");
for (int i = 0; i < arr.length; i++) {
if (i != arr.length - 1) {
System.out.print(arr[i] + ",");
} else {
System.out.print(arr[i]);
}
}
提取方法：
//添加操作
Scanner sc = new Scanner(System.in);
System.out.print("输入要添加的位置：");
int index = sc.nextInt();
System.out.print("输入要添加的值：");
int ele = sc.nextInt();
addEle(arr, index, ele);
// 要传入不同的数组arr，不同的位置index，不同的元素ele；无需返回
public static void addEle(int[] arr, int index, int ele) {
//添加操作
for (int i = arr.length - 1; i >= index; i--) {
arr[i] = arr[i - 1];
}
arr[index - 1] = ele;
}删除元素
【1】根据索引下标删除
【2】根据数值找到对应下标再删除
public static void main(String[] args) {
int[] arr = {12, 34, 56, 7, 3, 10};
System.out.print("删除前的数组为：");
System.out.println(Arrays.toString(arr));
//删除操作
Scanner sc = new Scanner(System.in);
System.out.print("要删除的元素：");
int ele = sc.nextInt();
deleteEle(arr, ele);
System.out.print("删除后的数组为：");
System.out.println(Arrays.toString(arr));
}
// 不同的数组arr，不同的元素ele
public static void deleteEle(int[] arr, int ele) {
int index = -1;
//找到元素对应的索引值
for (int i = 0; i < arr.length; i++) {
if (arr[i] == ele) {
index = i;
break;
}
}
if (index!=-1){
//删除操作
for (int i = index; i <= arr.length - 2; i++) {
arr[i] = arr[i + 1];
}
arr[arr.length - 1] = 0;
}else {
System.out.println("该数组中无此数");
}
}讲述main方法
【1】main方法:程序的入口，在同一个类中，如果有多个方法，那么虚拟机就会识别main方法，从这个方法作为程序的入口
【2】 main方法格式严格要求:
public static void main(String[] args){}
public static--->修饰符，暂时用这个-->面向对象一章void --->代表方法没有返回值对应的类型void
main --->见名知意名字
String[] args --->形参---》不确定因素(需要传入的)
【3】问题:程序中是否可以有其他的方法也叫main方法?可以，构成了方法的重载。
public static void main (string[] args){}
public static void main (string str){}
【4】形参为String[]那么实参到底是什么?假定有1-4种情况，最后打印出所传参数的长度，看与那种情况匹配
public static void main(String[] args) {
// 【1】只声明数组，没有后续操作，那么相当于白定义
// int[] arr1;
// 【2】Exception in thread "main" java.lang.NullPointerException
// int[] arr2 = null;
// System.out.println(arr2.length);
// 【3】0
// int[] arr3 = new int[0];
// System.out.println(arr3.length);
// 【4】4
// int[] arr4 = new int[4];
// System.out.println(arr4.length);
// 【5】0 符合第三种情况==》参数是String[],实参是 new String[0]
System.out.println(args.length);
}【5】执行/翻译(java)阶段可以手动传入实参 :有特殊符号的时候可以加上"";没有特殊符号哟用空格隔开即可;
for(String str:args){ sout str}
可变参数
【1】可变参数:作用提供了一个方法，参数的个数是可变的，解决了部分方法的重载问题（类型得保持一致）
int. ..num
double. ..numboolean. ..num
【2】可变参数在JDK1.5之后加入的新特性
【3】方法的内部对可变参数的处理跟数组是一样
【4】可变参数和其他数据一起作为形参的时候，可变参数一定要放在最后【5】我们自己在写代码的时候，建议不要使用可变参数。
Arrays工具类的使用
int[] arr = {1, 3, 7, 2, 4, 6};
// 【1】Arrays.toString(arr):对数组进行遍历查看，返回一个美化后字符串[1, 3, 7, 2, 4, 6]
System.out.println(Arrays.toString(arr));
// 【2】binarySearch(arr, 3)：二分法查找，找出指定数组arr中的指定元素3对应的索引
// 使用前提：一定要查看的是一个有序的数组：
// sort(arr):排序-->升序 [1, 2, 3, 4, 6, 7] 2
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
System.out.println(Arrays.binarySearch(arr, 3));
// 【3】copyOf(arr, 3)：完成数组的复制，复制指定数组arr，按新长度3重新生成新数组给newArr
[1, 3, 7, 2, 4, 6]==》[1, 3, 7]
int[] newArr = Arrays.copyOf(arr, 3);
System.out.println(Arrays.toString(newArr));
// 【4】copyOfRange(arr,1,4)：区间复制，复制指定数组arr,复制区间下标[1,4) [3, 7, 2]
int[] newArr2= Arrays.copyOfRange(arr,1,4);
System.out.println(Arrays.toString(newArr2));
// 【5】equals(arr, arr2)：比较两数组内的值是否相等
int[] arr2 = {1, 3, 7, 2, 4, 6};
System.out.println(Arrays.equals(arr, arr2));//true
System.out.println(arr == arr2);//false;比较的是对应的地址值
// 【6】fill(arr, 10)：将10填充满数组arr [10, 10, 10, 10, 10, 10]
Arrays.fill(arr, 10);
System.out.println(Arrays.toString(arr));
数组的复制
System.arraycopy(src,srcPos ,dest ,destPos ,length); eg:System.arraycopy(srcArr,1,destArr ,3,3);
src-源数组
srcPos – 源数组中的起始位置
dest -目标数组
destPos -目标数据中的起始位置
length -要复制的数组元素的数量
src:源数组，srcPos:3,dest:目标数组，destPos:9,length：6
二维数组的定义和遍历
四种遍历方式
// 【1】外层普通for循环、内层普通for循环
// 第一层数组长度为3
for (int i = 0; i < arr.length; i++) {
//第二层数组对应的长度
for (int j = 0; j < arr[i].length; j++) {
System.out.print(arr[i][j] + "\t");
}
System.out.println();
}
// 【2】普、增
for (int i = 0; i < arr.length; i++) {
//第一层数组的第i个内的对应的数组，遍历后赋值给int a
for (int a : arr[i]) {
System.out.print(a + "\t");
}
System.out.println();
}
// 【3】增、增
// 第一层数组遍历后，赋值给int[] arrays这也是一个数组
for (int[] arrays : arr) {
// 遍历数组arrays内部的值，赋值给int a
for (int a : arrays) {
System.out.print(a + "\t");
}
System.out.println();
}
// 【4】增、普
for (int[] arrays : arr) {
for (int i = 0; i < arrays.length; i++) {
System.out.print(arrays[i] + "\t");
}
System.out.println();
}二维数组的初始化方法
数组的初始化方式总共有三种:静态初始化、动态初始化、默认初始化。
参考：[一维数组的初始化方法](#1)
●静态初始化
除了用new关键字来产生数组以外，还可以直接在定义数组的同时就为数组元素分配空间并赋值。eg:
int[][] arr = {{1,2],{4,5,6},{4,5,6,7,8,9,9}};
int[][] arr =new int[][]{{1,2},{4,5,6},{4,5,6,7,8,9,9}};
●动态初始化
数组定义与为数组元素分配空间并赋值的操作分开进行。eg:
int[][] arr = new int[3][];//本质上定义了一维数组长度为3，每个“格子”中放入的是一个数组arr[0] = {1,2};
arr[1] = {3,4,5,6};arr[2] = {34,45,56};
●默认初始化
数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。eg:
int[][] arr = new int[3][2]
本质上：定义一维数组，长度为3，每个数组“格子”中，有一个默认的长度为2的数组，后续可以改
// arr[1] = new int[]{1,2,3,4}; //若加上打印出来0 0\n1 2 3 4\n0 0
for(int[] a :arr) {
for (int num:a){
System.out.print (num+" \t");
}
System.out.println ();}
0 0
0 0
0 0
1514
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
