关于java初始化,动静态初始化块,动静态变量执行顺序的memo

本文详细解析了Java中类的加载过程,包括静态成员变量、静态初始化块、动态成员变量及动态初始化块的执行顺序,并通过具体示例阐述了在继承场景下这些元素的执行流程。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

package com.hxw.T2;

public class ExtendsMemo {

	public static void main(String[] args) {
		/*
		 * 几大原则
		 * 一、静态成员变量(Static)
		 * 	1、静态成员变量为类变量,所有对象共享同一内存空间
		 * 	2、静态成员变量的声明和定义仅在首次加载类时执行一次
		 * 	3、首次加载类时首先对所有静态成员变量根据类型默认赋初值,然后再对有右值的附右值
		 * 二、静态初始块
		 * 	1、静态初始化块仅在首次加载类时执行一次
		 * ······多个静态成员变量与静态始化快参照出现顺序先后执行······
		 * 三、动态成员变量
		 * 	1、动态成员变量定义在每次实例化对象时在构造函数之前执行
		 * 四、动态初始化块
		 * 	1、动态初始化块在每次实例化对象时在构造函数之前执行
		 * ······多个动态成员变量与动态初始化块参照出现顺序先后执行······
		 * 总结:总的来说,在不涉及继承的前提下,当首次加载类时,按照如下顺序执行
		 * 	1、按照出现顺序先后执行静态成员变量定义与静态初始化块
		 * 	2、按照出现顺序先后执行动态成员变量定义与动态初始化块
		 * 	3、执行构造函数
		 * 	再次实例化对象时只执行第2、3步即可
		 * 
		 * ············成员变量与定义与初始化块先于构造函数执行·········
		 * 五、当涉及到继承时,按照如下顺序执行
		 * 	1、执行父类的静态成员变量定义与静态初始化块,执行子类的静态成员变量定义与静态初始化块
		 * 	2、执行父类的非静态成员变量定义与动态初始化块,执行父类构造方法
		 * 	3、执行子类的非静态成员变量定义与动态初始化块,执行子类构造方法
		 * 另:父类构造方法中用到的方法如果已被子类重写,那么在构造子类对象时在调用父类构造函数中使用子类重写的方法
		 */	
		int i = 0;
		switch(i) {
		case 0:
			
			new A();
			new A();
			
			break;
		case 1:
			
			A ab = new B();
			
			break;
		case 2 :
			
			C c1 = new C();
			System.out.println("c.i1 = " + c1.i1);//2
			System.out.println("c.i2 = " + c1.i2);//3
			
			break;
		} 
        /* 对i=2时的解释
         * 为什么是2和3呢?
         * 其实代码的执行顺序是这样的:在初始化c1的时候首先加载类
         * 定义静态变量t1,i1,i2并赋初值null,0,0
         * 然后计算右值表达式new C(),准备将此对象赋给静态成员变量c
         * 		然而上步中静态成员变量已定义,直接执行c的构造函数即可
         * 		这样i1++,i2++被执行,i1,i2都变为1
         * 继续执行到int i1;没有赋值语句, i1,i2的值仍然是1
         * 继续执行到int i2 = 2时i2被赋值2,即i1 = 1,i2 = 2
         * 继续执行到c1的构造函数,i1,i2再执行++,此时i1 = 2,i2 = 3
         * 输出i1,i2,结果就是:c1.i1 = 2,c1.i2 = 3
         * 通过上面的代码我们可以认为系统默认值的给予比通过等号的赋予先执行。
         */
	}
}

class A {
	public A() {
		System.out.println("construct A");
		m();
		System.out.println();
	}
	
	private int ai = getAI();
	
	{
		System.out.println("dynamic block in A");
	}

	static {
		System.out.println("static block in A");
	}
	
	private static int asi = getASI();
	
	static int getASI() {
		System.out.println("initial static int asi");
		System.out.println();
		return 5;
	}
	
	static int getAI() {
		System.out.println("initial int ai");
		return 10;
	}
	
	public void m() {
		System.out.println("A.m()");
	}
}

class B extends A{
	public B() {
		System.out.println("construct B");
		super.m();
		m();
	}
	
	{
		System.out.println("dynamic block in B");	
	}
	private int bi = getBI();
	private static int bsi = getBSI();

	
	static {
		System.out.println("static block in B");
		System.out.println();
	}
	
	static int getBSI() {
		System.out.println("initial static int bsi");
		return 5;
	}
	
	static int getBI() {
		System.out.println("initial int bi");
		return 10;
	}
	
	public void m() {
		System.out.println("B.m() bi=" + bi);
	}
}

class C{
    private static C c = new C();
    public static int i1;
    public static int i2 = 2;
    
    public C(){
        i1++;
        i2++;
    }
}

 转自:http://blog.youkuaiyun.com/shijinupc/article/details/7692315

<think>嗯,用户想用C++实现动态规划算法,我得先理清楚动态规划的基本概念步骤。首先,动态规划通常用于解决有重叠子问题最优子结构的问题。常见的例子包括斐波那契数列、背包问题、最长公共子序列等。用户可能需要一个具体的例子来理解如何在C++中实现。 接下来,我需要确定用户可能的背景。他们可能已经了解动态规划的理论,但需要实际的代码示例。或者,他们可能对动态规划还不熟悉,需要从基础开始解释。根据用户的问题,他们明确提到的是实现,所以应该侧重于代码结构方法。 然后,我需要选择合适的例子。斐波那契数列是一个简单的入门例子,但可能不够实用。背包问题或最小平方数问题可能更好,因为这些问题更复杂,能展示动态规划的不同方面。比如,引用中的第二个引用提到了用静态动态规划解决平方数之的问题,这可能是一个不错的例子。 然后,考虑代码结构。动态规划通常涉及数组或向量的使用来存储中间结果。比如,在解决最小平方数问题时,可以创建一个数组,其中每个元素代表达到该数所需的最小平方数个数。这需要遍历并填充数组,利用之前的结果来计算当前值。 还要注意用户提到的C++语言特性,比如静态变量。在引用2中,使用了静态变量来存储之前计算的结果,这在多次调用函数时可以优化性能。这可能是一个值得提到的优化技巧。 另外,用户可能对时间复杂度空间复杂度感兴趣,所以应该在解释代码时分析这些方面。例如,最小平方数问题的时间复杂度是O(n*sqrt(n)),空间复杂度是O(n)。 最后,需要确保代码示例正确,符合C++标准,并且有适当的注释,帮助用户理解每一步的作用。同时,要避免常见的错误,比如数组越界或初始化不当的问题。 总结一下,我需要分步骤解释动态规划的实现,选择一个合适的例子,提供清晰的代码,并解释其工作原理优化方法。同时,结合用户提供的引用内容,特别是引用2中的静态变量使用,来增强回答的相关性实用性。</think>### 动态规划在C++中的实现步骤 #### 1. 核心思想与基本结构 动态规划通过存储中间结果(记忆化)避免重复计算,适用于具有**重叠子问题****最优子结构**的问题。C++实现通常包含以下要素: - 状态定义(如`dp[i]`表示第i步的最优解) - 状态转移方程 - 初始化边界条件 - 递推填充数组 #### 2. 经典案例:最小平方数 以LeetCode 279题为例,求组成整数n的最小完全平方数个数[^2]: ```cpp #include <vector> #include <algorithm> #include <climits> int numSquares(int n) { // 静态变量存储历史计算结果 static std::vector<int> dp = {0}; while (dp.size() <= n) { int m = dp.size(); int min_count = INT_MAX; // 遍历所有可能的平方数 for (int i = 1; i*i <= m; ++i) { min_count = std::min(min_count, dp[m - i*i] + 1); } dp.push_back(min_count); } return dp[n]; } ``` $$ dp[m] = \min_{1 \leq i^2 \leq m}(dp[m - i^2] + 1) $$ #### 3. 关键实现技巧 1. **状态压缩**:当状态只与有限前驱相关时,可使用滚动数组 ```cpp // 0-1背包问题的空间优化 int knapsack(int capacity, vector<int>& weights, vector<int>& values) { vector<int> dp(capacity + 1, 0); for (int i = 0; i < weights.size(); ++i) { for (int j = capacity; j >= weights[i]; --j) { dp[j] = max(dp[j], dp[j - weights[i]] + values[i]); } } return dp[capacity]; } ``` 2. **记忆化搜索**:自顶向下递归实现 ```cpp vector<int> memo; int fib(int n) { if (n <= 1) return n; if (memo[n] != -1) return memo[n]; return memo[n] = fib(n-1) + fib(n-2); } ``` #### 4. 性能优化建议 - 使用静态变量存储重复计算结果[^2] - 优先使用迭代代替递归(避免栈溢出) - 合理选择遍历顺序(如背包问题逆序遍历) - 使用位运算加速状态转移[^5] #### 5. 复杂度分析 以最小平方数为例: - 时间复杂度:$O(n \sqrt{n})$ - 空间复杂度:$O(n)$
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值