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]);
}
}