/**
* 打印类加载器
*/
public class ClassLoaderInfoT {
	public static void main(String[] args) {
		ClassLoader loader = Thread.currentThread().getContextClassLoader();
		System.out.println("当前类加载器：" + loader);
		System.out.println("当前类的父亲加载器（根加载器）：" + loader.getParent());
		System.out.println("当前类父亲的父亲加载器（无）：" + loader.getParent().getParent());
	}
}

/**
 * 输出浮点数在虚拟机的实际表示
 */
public class FloatInJvm {
	public static void main(String[] args) {
		float a = -5;
		// 输出-5的补码，即虚拟机内部实际表示
		System.out.println(Integer.toBinaryString(Float.floatToRawIntBits(a)));
	}
}

class Parent {
	static {
		System.out.println("Parent init");
	}
	public static int v = 100;
}

class Child extends Parent {
	static {
		System.out.println("Child  init");
	}
}

public class InitMain {
	public static void main(String[] args) {
		new Child();// new关键字初始化 注释开启和未开启作比较
		System.out.println("======");
		// 通过子类调用从父类继承过来的静态属性，不会引起子类初始化
		System.out.println(Child.v); // 此时Child已经被加载，但未被初始化
	}
}

/**
 * 负整形数在Jvm中的表示
 * 
 */
public class IntegerInJvm {
	public static void main(String[] args) {
		int a = -10;
		for (int i = 0; i < 32; i++) {
			int t = (a & 0x80000000 >>> i) >>> (31 - i);
			System.out.print(t);
		}
		System.out.println();
		System.out.println(Integer.toBinaryString(a));
	}
}

/**
 * 打印堆内存 input: java -Xmx256m org.jvmcore.heap.JvmXmxArgs a b 打印始终小于 256M ,
 * 因为GC在不同区域采用不同回收算法，可用内存的减少为了其使用空间换时间的策略。
 */
public class JvmXmxArgs {
	
	public static void main(String[] args) {
		for (String arg : args)
			System.out.println("参数为" + arg);
		// 堆内存
		System.out.println("-Xmx:" + Runtime.getRuntime().maxMemory() / 1024 / 1024 + "M");
	}
}

/**
 * 打印GC信息 input: -XX:+PrintGC
 */
@SuppressWarnings("unused")
public class LocalVarGC {

	public void localVarGc1() {
		byte[] bytes = new byte[6 * 1024 * 1024];
		System.gc();
	}

	public void localVarGc2() {
		byte[] bytes = new byte[6 * 1024 * 1024];
		bytes = null;
		System.gc();
	}

	public void localVarGc3() {
		{
			byte[] bytes = new byte[6 * 1024 * 1024];
		}
		System.gc();
	}

	public void localVarGc4() {
		{
			byte[] bytes = new byte[6 * 1024 * 1024];
		}
		int a = 4;
		System.gc();
	}

	public void localVarGc5() {
		localVarGc1();
		System.gc();
	}

	public static void main(String[] args) {
		LocalVarGC ins = new LocalVarGC();
		 ins.localVarGc1();
		 ins.localVarGc2();
		 ins.localVarGc3();
		 ins.localVarGc4();
		ins.localVarGc5();
	}
}

/**
 * 堆栈溢出的理解 input: // -Xss128K
 */
public class StackDeep {
	private static int count = 0;

	public static void recursion() {
		count++;
		recursion();
	}

	@SuppressWarnings("unused")
	public static void recursion(long a, long b, long c) {
		long e = 1, f = 2, g = 3, h = 4, j = 5, k = 6, l = 7, q = 8, w = 10, r = 9;
		count++;
		recursion(a, b, c);
	}

	public static void main(String[] args) {
		try {
			// recursion(0L,0L,0L);
			recursion();
		} catch (Throwable e) {
			System.out.println("counts = " + count);
			e.printStackTrace();
		}
	}
}

/**
 * 显示类加载，获取方法签名
 */
public class StringCL {
	public static void main(String[] args) throws ClassNotFoundException {
		Class<?> clzStr = Class.forName("java.lang.String");
		// 返回对象方法数组
		// 返回已加载类声明的所有成员变量的Field对象数组,不包括从父类继承的成员变量.
		Method[] methods = clzStr.getDeclaredMethods();
		for (Method m : methods) {
			// 获取修饰符标志的字符串
			String mod = Modifier.toString(m.getModifiers());
			System.out.print(mod + " " + m.getName() + "(");
			Class<?>[] ps = m.getParameterTypes();
			if (ps.length == 0)
				System.out.print(')');
			for (int i = 0; i < ps.length; i++) {
				char end = i == ps.length - 1 ? ')' : ',';
				System.out.print(ps[i].getSimpleName() + end);
			}
			System.out.println();
		}
	}
}

/**
 * final的static字段比普通static字段初始化快【final实际上是在类加载的准备阶段初始化
 * static在此阶段只会初始化为0/null值，在解析之后的初始化阶段【类的cinit方法】才是真正使用用户给的值进行初始化】
 */
class FinalFieldClass {
	public static final String CONST_STR = "CONSTSTR";

	static {
		System.out.println("FinalFieldClass init");
	}
}

public class UseFinalField {
	public static void main(String[] args) {
		System.out.println(FinalFieldClass.CONST_STR);
	}
}

/**
 * 实现自己的类加载器
 */
public class PathClassLoader extends URLClassLoader {
	private String packageName = "cn.edu.jxnu.classloader";

	PathClassLoader(URL[] classPath, ClassLoader parent) {
		super(classPath, parent);
	}

	@Override
	protected Class<?> findClass(String name) throws ClassNotFoundException {
		Class<?> aClass = findLoadedClass(name);
		if (aClass != null) {
			return aClass;
		}
		if (!packageName.startsWith(name)) {
			return super.loadClass(name);
		} else {
			return findClass(name);
		}
	}
}