JAVA (static) 简述

前言：

在力扣上提交代码，发现用static定义变量，和不用static修饰变量，虽然每次运行的结果都一样，但是提交的结果却有通过与不通过两种情况。

测试题目：组合（力扣）dfs + 回溯 + 剪枝 JAVA

static修饰全局变量：

代码：

class Solution  {
	public static List<List<Integer>> nums = new ArrayList<>();
	public static List<Integer> num = new ArrayList<>();
	public static List<List<Integer>> combine(int n, int k) {
           dfs(1, n, k);
           return nums;
	}
	public static void dfs(int i, int n, int k) {
		if(num.size() + n - i + 1 < k) return;//剪枝
		if(num.size() == k) {
		  nums.add(new ArrayList<Integer>(num));
		  return;
		}//重要的事情最先做
		
		num.add(i);//装
		dfs(i + 1, n, k);
		num.remove(num.size() - 1);//回溯（不装）
		dfs(i + 1, n, k);
	}
}

不用static修饰：

代码：

class Solution {
    List<List<Integer>> nums = new ArrayList<>();
    List<Integer> num = new ArrayList<>();
	public  List<List<Integer>> combine(int n, int k) {
           dfs(1, n, k);
           return nums;
	}
	public  void dfs(int i, int n, int k) {
		if(num.size() + n - i + 1 < k) return;//剪枝
		if(num.size() == k) {
		  nums.add(new ArrayList<Integer>(num));
		  return;
		}//重要的事情最先做
		
		num.add(i);//装
		dfs(i + 1, n, k);
		num.remove(num.size() - 1);//回溯（不装）
		dfs(i + 1, n, k);
	}
}

值得注意的是，上述两个代码算法完全一样，不同点出在，全局变量是否用static修饰

---

抱着些许疑惑我写了一个程序分别测试了两个代码：

代码：

import java.util.*;    
public class Main {         
    public static void main(String args[]) {        
    int i[] = {4, 1};
    int k[] = {2, 1};
   
    for(int x = 0; x < 2; x ++) { 
    	Solution s = new Solution();
    	Solution_promax ss = new Solution_promax();
    	System.out.println(s.combine(i[x], k[x]));
    	System.out.println("\033[36m");
    	System.out.println(ss.combine(i[x], k[x]));
    	System.out.println("\033[0m");
    	 
    }
//    Solution_promax ss = new Solution_promax();
//    System.out.println(ss.combine(4, 2));
//    
//    Solution_promax ss1 = new Solution_promax();
//    System.out.println(ss1.combine(4, 2));
//    
//    System.out.println(ss.combine(4, 2));
    
    }
}
class Solution {
    List<List<Integer>> nums = new ArrayList<>();
    List<Integer> num = new ArrayList<>();
	public  List<List<Integer>> combine(int n, int k) {
           dfs(1, n, k);
           return nums;
	}
	public  void dfs(int i, int n, int k) {
		if(num.size() + n - i + 1 < k) return;//剪枝
		if(num.size() == k) {
		  nums.add(new ArrayList<Integer>(num));
		  return;
		}//重要的事情最先做
		
		num.add(i);//装
		dfs(i + 1, n, k);
		num.remove(num.size() - 1);//回溯（不装）
		dfs(i + 1, n, k);
	}
}
class Solution_promax {
	public static List<List<Integer>> nums = new ArrayList<>();
	public static List<Integer> num = new ArrayList<>();
	public static List<List<Integer>> combine(int n, int k) {
           dfs(1, n, k);
           return nums;
	}
	public static void dfs(int i, int n, int k) {
		if(num.size() + n - i + 1 < k) return;//剪枝
		if(num.size() == k) {
		  nums.add(new ArrayList<Integer>(num));
		  return;
		}//重要的事情最先做
		
		num.add(i);//装
		dfs(i + 1, n, k);
		num.remove(num.size() - 1);//回溯（不装）
		dfs(i + 1, n, k);
	}
}

输出：

1.惊奇的发现用static修饰的变量，不会因为创建新的对象，而恢复初始化

2.不用static修饰的全局变量创建的新对象，内容会恢复初始化

而力扣测试一组代码，就是不断创建新对象，带入数据比对结果，而static修饰全局变量会导致数据叠加。这就是为什么我用static修饰全局变量无法通过的原因。

---

那么static修饰得全局变量，只需要每次调用函数人为初始化即可：

代码：

class Solution  {
	public static List<List<Integer>> nums = new ArrayList<>();
	public static List<Integer> num = new ArrayList<>();
	public static List<List<Integer>> combine(int n, int k) {
           nums = new ArrayList<>();
           num = new ArrayList<>();//初始化
           dfs(1, n, k);
           return nums;
	}
	public static void dfs(int i, int n, int k) {
		if(num.size() + n - i + 1 < k) return;//剪枝
		if(num.size() == k) {
		  nums.add(new ArrayList<Integer>(num));
		  return;
		}//重要的事情最先做
		
		num.add(i);//装
		dfs(i + 1, n, k);
		num.remove(num.size() - 1);//回溯（不装）
		dfs(i + 1, n, k);
	}
}

---

得出简略结论：

1、static目的：java中的static关键字主要用于内存管理。

2.静态变量可以被类的所有实例共享，因此静态变量可以作为实例之间的共享数据，增加实例之间的交互性。

3.如果类的所有实例都包含一个相同的常量属性，则可以把这个属性定义为静态常量类型，从而节省内存空间。