day05_内存、递归

最新推荐文章于 2024-05-31 10:46:10 发布

coderbr

最新推荐文章于 2024-05-31 10:46:10 发布

阅读量67

点赞数

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/qq_43562097/article/details/120697814

版权

Java 专栏收录该内容

22 篇文章 0 订阅

订阅专栏

day_05 方法

方法重载

方法重载 : 方法名相同,参数列表不同
参数列表不同分为两种 : 1 类型不同 2 个数不同
相同功能,相同名字,通过不同的参数区分,容易记忆,相同功能只需要记住一个方法即可
```
 public class Method_01 {
 public static void main(String[] args) {
 	isEquestByte((byte) 1, (byte) 1);
 	isEquestShort((short) 1, (short) 1);
 	isEquestInt(12, 1);
 	isEquestLong(1, 2);
 isEquals((byte) 1, (byte) 1);
 isEquals((short) 1, (short) 1);
 isEquals(12, 1);
 isEquals(1, 2L);

 System.out.println(1);
 System.out.println(1.1);
 System.out.println(false);
```
}

public static boolean isEquestByte(byte a, byte b) {
return a == b;
}

public static boolean isEquestShort(short a, short b) {
return a == b;
}

public static boolean isEquestInt(int a, int b) {
return a == b;
}

public static boolean isEquestLong(long a, long b) {
return a == b;
}

public static boolean isEquals(byte a, byte b) {
return a == b;
}

public static boolean isEquals(short a, short b) {
return a == b;
}

public static boolean isEquals(int a, int b) {
return a == b;
}

public static boolean isEquals(long a, long b) {
return a == b;
}
}

内存划分

程序 : 可执行文件,是一堆命令的集合,是个静态概念保存在硬盘中
进程 : 就是正在执行的程序,是个动态概念,保存在运行内存中,会按照该程序的设计在内存中一步步执行，运行中的程序也就是指载入到内存中的可执行文件,操作系统会开启一个进程,用来保存运行的这个文件，如果想要关闭某个程序只需要在内存中把该进程杀死即可
Java的内存划分和管理
Java Runtime Data Area : Java运行时数据区域,一般叫JVM内存
分为五大块 :
1 静态区/方法区 2 JVM栈 3 堆内存 4 程序计数器 5 本地方法栈
程序计数器 : 是一块比较小的内存,字节码位置的指示器,比如当前执行到第几行了之类,分支,循环,跳转等
静态区 : 用来保存我们的程序文件(class),载入到内存之后的class文件保存在静态区中,还有一些静态资源（方法被调用之前也保存在静态区 , 还有常量池）
VM栈 : 又叫栈内存 , 用来执行方法，是以栈数据结构为模型创建的一段空间 : 先进后出,类似于弹夹
栈空间 : 就是栈内存,就是以栈数据结构为模型创建的内存空间,叫栈空间
栈帧 : 栈空间中的元素,就是栈帧,比如弹夹是栈空间的话,子弹就是栈帧
栈底元素 : 第一个放进去的栈帧
栈顶元素 : 最后一个放进去的栈帧
栈操作 :
压栈 : 就是指向栈空间中添加栈帧的过程,就是把子弹放到弹夹中,叫压栈
弹栈 : 就是指把栈帧在栈空间中弹出的过程
本地方法栈 : 用来执行本地方法,和栈内存一样, 使用 native 修饰的方法, 和我们没关系
堆内存 : 用来保存对象
执行流程 :
1 javac编译生成class文件
2 java命令运行
2.1 开启java虚拟机,然后把对应的文件 Method_02.class 载入内存中的静态区
2.2 载入之后,JVM自动调用该程序中main方法 ,然后再栈内存开辟main方法栈帧,开始执行
2.3 如果main方法中没有其他方法调用,则执行完结束,销毁即可
2.4 如果main方法中有其他方法调用, 如果是其他类中的方法,则把对应类也会加载到静态区,然后调用该方法
2.5 如果是当前类的方法,直接在栈内存继续压栈即可
2.6 如果被调用方法中还有其他方法调用的话,则步骤同上
2.7 一直到最后一个压栈的方法执行完,弹栈,然后再依次返回调用处继续执行
2.8 一直到main方法执行完,弹栈,程序销毁
方法的调用,就等于是压栈操作
而方法调用结束,就等于是弹栈操作
静态加载 : 程序开始执行,首先把所有和程序相关的类全部一次性载入
动态加载 : 开始执行的时候,只加载必须的类,在执行的过程中,需要用到其他类,再去加载
java中采用的是动态加载

public class Method_02 {
public static void main(String[] args) {
m1();
System.out.println(“main方法执行了”);
}
public static void m1(){
m2();
System.out.println(“m1执行了”);
}
public static void m2(){
System.out.println(“m2执行了”);
}
}

递归

递归 : 在方法体中,调用当前方法(自己调用自己)
递归的基本思想 : 递归和迭代是等价的 (迭代就是循环) 以此类推是基本思想
三要素 : 初始值,终止条件,步长
应用场景
一般树状结构的都可以使用递归操作

           比如查询地区,树状菜单,文件目录等

递归的算法比普通算法更耗内存,谨慎使用,能用循环完成,就不用递归完成,除非某些树状情况只能使用递归搞定
递归场景面试题 :
```
 1 文件夹复制
```

 2 斐波那契数列  1  1  2  3  5  8  13  21  34  55 89

需求 : 计算1~N的累加加和,并把结果返回,你可以假设N是大于等于1的

public class Recursion_02 {
	public static void main(String[] args) {
		int result = sum(5);
		System.out.println(result);
	}
// 需求 : 计算1~N的累加加和,并把结果返回,你可以假设N是大于等于1的
// public static int sum(int n){
// int sum = 0;
// for (int i = 1; i <= n; i++) {
// sum+=i;
// }
// return sum;
// }
// 需求 : 计算1~N的累加加和,并把结果返回,你可以假设N是大于等于1的
public static int sum(int n) {
	if (n == 1) {
		return 1;
	}else{
		return n + sum(n-1);
	}
}
}

需求 : 计算1~N的偶数和并返回

public class Recursion_03 {
	public static void main(String[] args) {
		int result = sum(3);
		System.out.println(result);
	}
// 需求 : 计算1~N的偶数和并返回
public static int sum(int n) {
	// 判断是否是偶数
	if (n % 2 == 1) {
		n--;
	}
	if (n < 2) {
		return 0;
	}
	// 判断是否是2
	if (n == 2) {
		return 2;
	}
	return n + sum(n - 2);
}
}

斐波那契数列
1 1 2 3 5 8 …
除了前两位是1 , 后面每一位都等于前两位的和
比如传入位数,获取对应位数的值

public class Recursion_04 {
public static void main(String[] args) {
// long result = fibonacci(45);
// 4376692037216111008
// -3586315725236682319
// 7963007762452793327
double result = test(122);
System.out.println(result);
}

public static double test(int n){
// 前两位的值,默认代表第一位
double a = 1;
// 前一位的值,默认代表第二位
double b = 1;
// 当前位的值,从第三位开始
double c = 0;
for(int i = 3; i <= n; i++){
// 计算当前位的值
c = a + b;
// 把前两位的值给了前三位,那么前三位就等于前两位
a = b;
// 把前一位的值,给了前两位,那么,前两位就等于前一位
b = c;
// i++ 之后还是只需要计算a+b即可
}
return c;
}
public static long fibonacci(int n) {
// 终止条件
if (n == 1 || n == 2) {
return 1;
} else {
// 当前等于前一位 + 前两位
return fibonacci(n - 1) + fibonacci(n - 2);
}
}
}

需求给出一个整数判断该数是否为质数 ps : 只能被1和本身整除的数是质数

public class Test_02 {
	public static void main(String[] args) {
		boolean result = isPrime(9);
		System.out.println(result);
	}
public static boolean isPrime(int num){
	// 1 判断 是否小于2 ,小于2的都不是质数
	if (num < 2) {
		return false;
	}
	// 2 从2开始到num-1结束,如果有能整除的,说明不是
	for (int i = 2; i < num; i++) {
		// 只要有能整除的 直接返回false
		if (num % i == 0) {
			return false;
		}
	}
	// 到这里说明 是质数
	return true;
}
}