Java_day_04_方法、递归、内存分析_java中递归内存分析

1 定义方法(入参,出参)

package _01_Method;
 
/**
 * 根据需求 定义方法
 		1 入参: 做这件事 需要的未知条件
 		2 出参: 做完这件事之后进行的反馈 
 * 
 * @author 16200
 *2021年12月31日上午10:14:14
 */
public class Method_03 {
 
	public static void main(String[] args) {
		int Sum = sum(1,2);
		System.out.println(Sum);
		
	}
	//1 需求 : 向控制台打印1-10
	public static void print_01(){
		for (int i = 1;i < 11; i++){
			System.out.println(i);
		}
	}
	//2 需求: 向控制台打印1-N的值
	//参数列表中的变量是局部变量
	public static void print_01(int n){
		for (int i = 1;i <=n; i++){
			System.out.println(i);
		}
	}
	//3 需求 : 计算a+b的值
	public static int sum(int n,int m){
		int sum = n + m;
		return sum;
	}
	
}

2 方法重载

package _01_Method;
/**
 * 方法重载
 * 	
 		方法唯一性:
 			方法名 和 参数
 			
 		方法重载(overload): 方法名相同,参数列表不同
 			列表不同分为: 个数不同和类型不同
 			
 		优势:方便记忆,编码好看
 			不是方法复用
	
 * 
 * @author 16200
 *2021年12月31日上午10:26:01
 */
public class Method_04 {
 
	public static void main(String[] args) {
		
	}
	//计算n+m的值
	//相同功能同名,但类型不同即可,即为方法重载
	//同名但不是同一个方法
	public static int sum(int n,int m){
		int sum = n + m;
		return sum;
	}
	public static double sum(double n,double m){ 
		double sum = n + m;
		return sum;
	}
	public static long sum (long n,long m){
		long sum = n + m;
		return sum;
	}
}

 3 方法内存划分：

Java Runtime Data Aare ：Java运行时 区域， 一般叫JVM内存

package _01_Method;
/**
 * 方法内存划分：
Java Runtime Data Aare ：Java运行时 区域， 一般叫JVM内存
 
	程序计数器：
		一块较小的内存区域，可以看作是当前程序执行的位置指示器
			
	静态区/方法区：
		保存程序文件(class文件) 以及静态数据,方法被调用之前,也保存才静态区,内部还有运行时常量池
		
	VM栈: 又叫栈内存
		栈内存是一站数据解雇为模型开辟的一段空间,特性是先进后出
		栈: 是一种数据结构,先进后出
		
			栈的构成因素
				栈空间: 栈内存就是栈空间
				栈帧:栈空间里的每一个栈元素
				栈底元素: 第一个放进去的栈帧
				栈顶元素: 最后一个放进去的栈帧
				
			栈操作
				压栈: 把元素放入栈空间的过程
				弹栈: 把元素弹出的过程
		
	栈内存:
		是用来执行方法的, 所有得方法的执行,必须在栈内执行
	
	本地方法栈:
		用来执行一些本地方法,比如hashCoad等,模型和操作都和VM栈一致,不用管
		
	堆内存:
		用来保存对象
		
		
		1 java程序编写
		2 javac编译得到class文件
		3 Java命令 运行
				3.1 开启jvm,把运行的程序载入内存,把class文件保存到静态区
				3,2 加载完之后,JVM自动调用程序中的main方法
				3.3 在栈内存开辟栈帧,用来执行main方法
						如果 main 方法中,没有其他方法调用,则运行完 弹栈 销毁 结束 JVM关闭
						如果 main 方法中,有其他方法调用,则在main方法之上再开辟栈帧,用来执行相应 方法
							如果调用的方法是其他类的方法,则需要吧对应的类先加载进来
		方法调用: 就等于是压栈操作
		方法执行完成: 就等于弹栈操作
		
		加载
			静态加载 : 值程序开始运行 , 就把相关的所有文件全部一次性载入内存
			动态加载: 程序运行开始,只载入核心文件,当用到其他文件的时候,再去加载
		java中采用动态加载机制
		
 * @author 16200
 *2021年12月31日上午10:37:54
 */
public class Method_05 {
 
	public static void main(String[] args) {
		
		System.out.println(0);
	}
	public static void test(){
		test2();
		System.out.println(1);
	}
	public static void test2(){
		System.out.println(2);
	}
}

4 递归

package _02_Recursion;
/**
 递归:方法中调用当前方法
 
 递归思想
 		递归和迭代是等价的,就是循环
 		基本思想就是以此类推
 	
 应用场景:
 	循环能做的,递归都能做,但是这种情况 优先使用循环,因为递归非常消耗内存,运行效率低
 	但是 像树状结构之类的,循环是没法做的,只能通过递归
 	
 常见的问题
 	所有树状结构
 	文件夹复制
 	斐波那契数列
 	
 		
 难点: 不容易理解,递归思想
 	解决方法:画图,栈帧调用图
 	
 注意 :必须要有终止条件,否则就等于死循环一样 ,导致一直压栈不会弹栈而出现 栈内存溢出问题
 
 * 
 * @author 16200
 *2021年12月31日上午11:33:43
 */
public class Recursion_01 {
//未设置终止条件,栈内存溢出
//	public static void main(String[] args) {
//		test();
//	}
//	public static void test(){
//		test();
//		System.out.println(1);
//	}
	public static void main(String[] args) {
		int q = sum1(5);
		System.out.println(q);
	}
	public static int sum(int n){
		int sum = 0;
		for (int i=1; i<= n;i++){
			sum+=i;
		}
		return sum;
	}
	public static int sum1(int n){
		if (n == 1){
			return 1;
		}else{
			return n + sum (n - 1);
		}
	}
}

4.1 斐波那契数列

package _02_Recursion;
/**
 * 斐波拉契数列
 * 
 * 1 1 2 3 5 8 13 21 34 55 89.....
 * 
 * 计算第n位数是多少
 * 
 * @author 16200
 *2021年12月31日上午11:50:35
 */
public class Recursion_02 {
 
	public static void main(String[] args) {
		int result = factorial(5);//如果数太大,这会导致栈满报错
		System.out.println(result);
		System.out.println(count);
	}
	static int count=0;
	public static int factorial(int n ){
		count++;
		if(n == 1| n== 2 ){
			return 1 ;
		}else{
			return factorial(n-1)+factorial(n-2);
		}
		
	}
 
}