一、各种初始化问题：

方法重载的问题：

方法的重载，差别是靠传入方法的參数，而不是返回值。比方f()，假设是返回值的话，easy产生歧义。

方法的重载中。会出现传入參数的类型提升或者减少；比方说假设有个方法能够接受int型。假设传入一个char类型，调用该方法的话会被自己主动提升。

假设涉及到可变參数方法的重载问题，那么会出现一些特殊情况：

        static void f(float f, Character... c) {
		System.out.println("first");
	}

	static void f(Character... c) {// 假设这里不在前面加一个char c1。则会引起编译错误
		System.out.println("second");
	}

f("1","2");//这时会出现编译错误

要将第二个方法写成以下这样的方式：

	static void f(char c1, Character... c) {// 假设这里不在前面加一个char c1，则会引起编译错误
		System.out.println("second");
	}

static相关的初始化问题：

1、对于一个类而言，静态成员变量或者静态块的初始化。会在main方法之前之前运行，假设main方法在该类里面的话。

2、静态成员变量，或者静态块之间的初始化顺序，由它们之间出现的顺序的早晚来确定。

3、static块仅仅会被运行一次，就是在类被载入的时候。所以对于一个类而言，假设通过new来调用其构造方法来建立一个对象，假设是第一次。那么static块会在这之前被运行。之后再进行new，则不会再次运行。

package com.alex.example;

class Cup {
	Cup(int maker) {
		System.out.println("Cup(" + maker + ")");
	}

	void f(int maker) {
		System.out.println("f(" + maker + ")");
	}
}

class Cups {
	static Cup cup1;
	static Cup cup2 = new Cup(2);

	static {
		System.out.println("static block in Cups is running");
		cup1 = new Cup(1);
		// cup2 = new Cup(2);
	}

	Cups() {
		System.out.println("Cups()");
	}
}

public class ExplicitStatic {
	public static void main(String[] args) {
		System.out.println("Inside main");
		Cups.cup1.f(99);
	}

	static Cups cups1 = new Cups();
	// static Cups cups2 = new Cups();
}

普通块的初始化

一个类的普通块中的代码，总是会在创建这个对象之前被调用一遍，并且是每创建一个对象。都会被调用一遍。不是像static块那样。仅仅有载入类的第一次会被调用。

package com.alex.example;

class People {

	{
		System.out.println("People中的普通块被调用了");
	}

	String name;
	int age;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public People(String name, int age) {
		super();
		System.out.println("People 两參构造被调用了");
		this.name = name;
		this.age = age;
	}

	public People() {
		super();
		System.out.println("People 无參构造被调用了");
	}

	@Override
	public String toString() {
		return "People [name=" + name + ", age=" + age + "]";
	}

}


public class Test {
	People p1;
	People p2;
	{
		System.out.println("Test中的普通块被调用了");
		p1 = new People();
	}

	public static void main(String[] args) {
		System.out.println("Inside main");
		System.out.println("t1被创建");
		Test t1 = new Test();
		System.out.println("t2被创建");
		Test t2 = new Test();
	}

}

结果：

Inside main
t1被创建
Test中的普通块被调用了
People中的普通块被调用了
People 无參构造被调用了
t2被创建
Test中的普通块被调用了
People中的普通块被调用了
People 无參构造被调用了

二、垃圾回收的问题：

Java的垃圾回收，能够简单的概括为：自适应的。分代的，停止-复制。标记-清扫式的垃圾回收。

停止-复制

就是将全部线程都停止，stop the world，然后将不要回收的数据，拷贝到一块没有使用的内存中，然后将剩下的内存内容都清理掉。

比較费时。

标记-清扫

标记-清扫也须要将线程停止，然后将要回收的数据标记出来，然后回收掉。这样一般速度会比上面的快。可是却会产生内存碎片。

自适应

自适应的意思是，Java虚拟机，会自适应的。在垃圾比較多的时候。採用停止复制，而在垃圾比較少，进入稳定期的时候，採用标记清理。

分代

分代意思是。将内存中的数据块进行标定。假设一个数据块，每熬过一次垃圾回收，那么就给它的代数加1，熬过数次的数据，就可能进行老年代的内存中。而对于一些比較大的数据，可能它产生出来就会直接进入老年代。而不会在新生代，所以我们最好不要频繁的创建一些生命周期短的。体积庞大的数据，这可能会导致JVM频繁地进行全然垃圾回收。