2021-01-06
day06复习
Java-day07学习笔记
一、方法
1.1 方法的重载
在同一个类中，方法名相同，参数列表不同，与返回值类型无关
参数列表不同的三种情况：
1. 个数不同
2. 类型不同
3. 个数相同，类型也相同，但是前后位置不同
public class Demo {
public static void main(String[] args) {
System.out.println(sum(3, 5));
System.out.println(sum(3.0, 5.0));
System.out.println(sum(3, 5, 8));
System.out.println(sum(3, 5, 8, 10));
}
/*
求两个整数的和
两个明确：
返回值类型： int
参数列表： int a, int b
*/
public static int sum(int a, int b){
System.out.println("int...int...");
return a + b;
}
/*
求两个小数的和
两个明确：
返回值类型： double
参数列表： double a, double b
*/
public static double sum(double a, double b){
System.out.println("double...double...");
return a + b;
}
/*
求三个整数的和
两个明确：
返回值类型： int
参数列表： int a, int b, int c
*/
public static int sum(int a, int b, int c){
System.out.println("int...int...int...");
return a + b + c;
}
/*
求四个整数的和
两个明确：
返回值类型： String
参数列表： int a, int b, int c, int d
*/
public static String sum(int a, int b, int c, int d){
System.out.println("int...int...int...int...");
return "" + (a + b + c + d);
}
}
之前见过的方法的重载：
print
println
1.2 方法的嵌套调用
在一个方法中，可以调用其它方法
public class Demo3 {
public static void main(String[] args) {
System.out.println("进入了main...");
fun1();
System.out.println("出去了main...");
}
private static void fun1() {
System.out.println("进入了fun1...");
fun2();
System.out.println("出去了fun1...");
}
private static void fun2() {
System.out.println("进入了fun2...");
System.out.println("出去了fun2...");
}
}
/*
结果：
进入了main...
进入了fun1...
进入了fun2...
出去了fun2...
出去了fun1...
出去了main...
*/
1.3 方法的递归
方法自己调用自己
注意：递归一定要有出口（要不然会造成一直互相调用，而不会停止）
练习：
求5的阶乘
/*
求5的阶乘
1! = 1
2! = 2*1
3! = 3*2*1
4! = 4*3*2*1
5! = 5*4*3*2*1
*/
public class Test {
public static void main(String[] args) {
//方式一：for循环
/*
int jc = 1;
for(int i = 1; i <= 5; i++){
jc *= i;
}
System.out.println("5的阶乘结果为：" + jc);
*/
//方式二：递归
System.out.println(jc(5));
}
/*
两个明确：
返回值类型：int
参数列表：int x
*/
public static int jc(int x){
//x = 2
if(x == 1){
return 1;
}
return x * jc(x-1);
}
}
二、数组
数组就是一个容器。数组这个容器可以存放同种数据类型的多个元素。
2.1 数组的声明
数据类型[] 数组名 = new 数据类型[数组的长度];
补充格式：数据类型 数组名[] = new 数据类型[数组的长度];
解释：
数据类型：存放元素的类型，这个类型可以是基本数据类型，也可以是引用数据类型
[]：表明了这是一个一维数组
数组名： 就是一个变量名，符合命名规范即可（第一个单词全部小写，从第二个单词开始首字母大写）
=：将创建好的数组的地址赋值给数组名
new：是一个关键字，用来在堆内存上创建对象
数据类型：同上
数组的长度：数组中能存放多少元素（一旦定义好，就不能再次修改）
2.2 数组的初始化
数组初始化就是给数组赋初始化值
方式一：动态初始化（先声明一个数组，然后赋值）
格式：
数据类型[] 数组名 = new 数据类型[数组的长度];
数组名[索引] = 数据;
方式二：静态初始化（在声明一个数组的同时就赋值）
格式：
数据类型[] 数组名 = new 数据类型[]{元素1, 元素2, 元素3, ...};
简化格式：
数据类型[] 数组名 = {元素1, 元素2, 元素3, ...};
补充：索引是什么？
索引就是数组存放数据的位置，这个位置一般是从0开始计数的。索引又被称为下标、角标
2.3 数组数据的获取
数组名[索引]
public class Demo {
public static void main(String[] args) {
//数组的声明：数据类型[] 数组名 = new 数据类型[数组的长度];
int[] arr = new int[3]; //创建了一个能存放3个int类型的元素
System.out.println(arr); //[I@1b6d3586
//方式一：动态初始化
arr[0] = 11;
arr[1] = 22;
arr[2] = 33;
//从数组中获取元素
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
}
}
public class Demo2 {
public static void main(String[] args) {
//方式二：静态初始化
// int[] arr = new int[]{11, 22, 33};
//简化格式：
int[] arr = {
11, 22, 33};
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
}
}
2.4 数组名打印出来的内容
int[] arr = new int[3];
System.out.println(arr); //[I@1b6d3586
[I@1b6d3586
解释：
[：表明这是一个一维数组
I：表明这是一个int类型的数组
@：就是一个连接符，'@'
1b6d3586：实际上是真正地址的hashCode值的十六进制表示形式（相当于是地址）
2.5 JVM中的内存划分
栈：存放局部变量以及方法执行的地方
堆：存放的都是对象（也就是new出来的内容）
方法区：存放的有静态的变量、常量、方法、字节码文件
本地方法区：存放的由C或C++等组成的本地方法
程序计数器：控制程序的执行顺序的
补充：什么是局部变量？
局部变量就是定义在方法上或者方法内部的变量
2.6 数组的内存图
① 一个数组的内存图
public class PicDemo {
public static void main(String[] args) {
int[] arr = new int[3];
System.out.println(arr); //[I@1b6d3586
System.out.println(arr[0]); //0
System.out.println(arr[1]); //0
System.out.println(arr[2]); //0
System.out.println("----------------");
arr[0] = 11;
arr[1] = 22;
arr[2] = 33;
System.out.println(arr); //[I@1b6d3586
System.out.println(arr[0]); //11
System.out.println(arr[1]); //22
System.out.println(arr[2]); //33
}
}
② 两个数组的内存图
public class PicDemo2 {
public static void main(String[] args) {
//第一个数组
int[] arr = new int[3];
arr[0] = 11;
arr[1] = 22;
arr[2] = 33;
System.out.println(arr); //[I@1b6d3586
System.out.println(arr[0]); //11
System.out.println(arr[1]); //22
System.out.println(arr[2]); //33
System.out.println("----------------");
//第二个数组
int[] arr2 = new int[3]; //每new一次，都会在堆上开辟一个新的空间
arr2[0] = 77;
arr2[1] = 88;
arr2[2] = 99;
System.out.println(arr2); //[I@4554617c
System.out.println(arr2[0]); //77
System.out.println(arr2[1]); //88
System.out.println(arr2[2]); //99
}
}
③ 两个引用指向同一个数组
public class PicDemo3 {
public static void main(String[] args) {
int[] arr = new int[3];
System.out.println(arr); //[I@1b6d3586
System.out.println(arr[0]); //0
System.out.println(arr[1]); //0
System.out.println(arr[2]); //0
System.out.println("----------------");
arr[0] = 11;
arr[1] = 22;
arr[2] = 33;
//将引用arr赋值给引用arr2
int[] arr2 = arr;
System.out.println(arr2[0]); //11
System.out.println(arr2[1]); //22
System.out.println(arr2[2]); //33
System.out.println("----------------");
arr2[1] = 99;
System.out.println(arr[0]); //11
System.out.println(arr[1]); //99
System.out.println(arr[2]); //33
System.out.println("----------------");
System.out.println(arr2[0]); //11
System.out.println(arr2[1]); //99
System.out.println(arr2[2]); //33
}
}
2.7 数组的扩容
如：一个数组int[] arr = new int[3]; 只能存三个元素，现在我们就是想让这个数组存四个元素怎么办？
import java.util.Arrays;
/**
* 数组的扩容
*/
public class Demo {
public static void main(String[] args) {
int[] arr = {
11, 22, 33};
//方式一：新建一个数组，然后将新数组的地址赋值给原数组
/*
//1. 新建一个数组，比原数组的长度大1
int[] arr_xin = new int[4];
//2. 遍历原数组将原数组中的内容，赋值给新数组
for(int i = 0; i < 3; i++){
arr_xin[i] = arr[i];
}
//3. 将新数组的地址赋值给原数组
arr = arr_xin;
*/
/*
方式二：通过Arrays中提供的copyOf方法
copyOf(int[] arr, int newLength)
参数arr：是要被扩容的原数组
参数newLength：是要扩容后的长度
*/
/*
//1. 通过Arrays的copyOf方法产生一个指定长度的新数组
int[] arr_xin = Arrays.copyOf(arr, 4);
//2. 将新数组的地址赋值给原数组
arr = arr_xin;
*/
/*
方式三：通过System类中提供的arraycopy方法
arraycopy(int[] src, int srcPos, int[] dest, int destPos, int length)
参数src：是原数组
参数srcPos：是从原数组哪个索引开始复制(starting position in the source array.)
参数dest：是新数组
参数destPos：从新数组哪个索引开始(starting position in the destination data.)
参数length：是复制多个长度
*/
int[] arr_xin = new int[4];
System.arraycopy(arr, 0, arr_xin, 0, 3);
arr = arr_xin;
//访问
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[3]);
}
}