Java初始化与清理

目录：
1、方法重载
2、this关键字
3、垃圾回收
4、Java初始化顺序

 1、方法重载

 产生的原因：构造器的名字已经由类所决定，如果想用多种方式创建一个对象，需要不同的构造器。为了让方法名相同而形式参数不同的构造器同时存在，就要用到方法重载。

 区分重载的方法：

1. 每个重载方法都应该有一个独一无二的形参列表。
2. 参数顺序不同，也可以区分两个方法。（但是这样难以维护代码，不推荐使用）

 注意事项：

• 不能够以返回值的不同来区分重载方法；
• 传入的数据类型，小于方法中形参类型，实际数据类型将会被提升；
• 传入数据类型，大于方法中形参类型，会通过类型转换来执行窄化转换。

  2、this关键字

 定义： this关键字只能在方法内部使用，表示对“调用方法的那个对象”的引用。
 当需要明确指出对当前对象的引用时，才需要使用this关键字。例如：

public class Leaf{
	int i = 0;
	Leaf increment(){
		i++;
		return this;
	}
	void print(){
		System.out.println("i = " + i);
	}
	public static void main(String[] args){
		Leaf x = new Leaf();
		x.increment().increment().print();
	}
}
/*output:
i = 3
*/

 

 

  2.1、在构造器中调用构造器

 使用this关键字，在一个构造器中调用构造器，避免重复代码。

 注意事项：

• 在一个构造方法中，不能同时调用两个构造器；
• 必须将构造器调用置于最起始处；
• 除构造方法外，其他任何方法中都不得调用构造器；

import static net.mindview.util.Print.*;

public class Flower{
	int petalCount = 0;
	String s = "initial value";
	Flower(int petals){
		petalCount = petals;
		print(petalCount);
	}
	Flower(String ss){
		s = ss;
		print(s);
	}
	Flower(String s, int petals){
		this(petals);
		this.s = s;//使用this.s，用来区分类成员变量与方法中的局部变量s
		print("String and int");
	}
	Flower(){
		this("hi",47);
		print("no args");
	}
	public static void main(String[] args){
		Flower x = new Flower();
	}
}

/*OutPuts:
47
String and int
no args
*/

  2.2、static的含义

  static方法又称为“类方法”。

1. static方法是没有this的方法
2. static方法内部不能调用非静态方法
3. 非静态方法内部可以调用static方法
4. 可以通过类本身来调用static方法

  3、垃圾回收机制

 垃圾回收不保证一定会发生。如果JVM并未面临内存耗尽的情形，它是不会浪费时间去执行垃圾回收以恢复内存的。
 垃圾回收器对于提高对象的创建速度，具有显著的效果。这也意味着Java从堆分配空间的速度，可以和其他语言从堆栈分配空间的速度相媲美。

垃圾回收器至关重要。JVM主要采用了一下几种方式，进行垃圾回收：

1. 停止-复制： 先暂停程序运行，将所有存活的对象从当前堆复制到另一个堆中。
   优点： 复制到新堆后，对象总是一个挨着一个的，保持紧凑排列，可以简单直接的分配新的空间。
   缺点： 需要两块堆空间；复制起来效率低；当只有少量垃圾产生时，会很浪费资源。
2. 标记-清扫：遍历所有引用，找出存活的对象并设一个标记（这个过程不经行清理）。当全部标记完以后，没有标记的对象将被释放。但是剩下的堆空间不是连续的。
3. 自适应技术：Java虚拟机进行监视，如果对象都很稳定，垃圾回收器效率低，会不采用停止-复制策略，而采取标记-清扫策略。

  Java及时编译技术：将全部或部分程序翻译成本地机器码，从而提升程序运行效率。
 当需要装载某个类时：1、编译器找到.class文件；2、将该类的字节码装入内存；3、可以采取Java及时编译技术或者进行惰性评估。

  4、初始化顺序

1. 初始化静态对象
2. 普通对象
3. 静态方法、构造器
4. 普通方法

  如下代码，展示了初始化顺序：

class Bowl
{
    Bowl(int marker)
    {
        print("Bowl(" + marker + ")");
    }

    void f1(int marker)
    {
        print("f1(" + marker + ")");
    }
}

class Table
{
    static Bowl b1 = new Bowl(1);

    Table()
    {
        print("Table()");
        b2.f1(1);
    }


    void f2(int marker)
    {
        print("f2(" + marker + ")");
    }

    static Bowl b2 = new Bowl(2);
}

class Cupboard
{
     Bowl b3 = new Bowl(3);
     static Bowl b4 = new Bowl(4);

     Cupboard()
     {
         print("Cupboard()");
         b4.f1(2);
     }

     void f3(int marker)
     {
         print("f3(" + marker + ")");
     }

     static Bowl b5 = new Bowl(5);
 }
public class Staticlnitialization
{
    public static void main(String[] args)
    {
        print("在main()中新建一个Cupboard");
        new Cupboard();

        print("在main()中再建一个Cupboard");
        new Cupboard();

        table.f2(1);
        cupboard.f3(1);
    }

    static Table table = new Table();//1
    static Cupboard cupboard = new Cupboard();

}/*Output
    Bowl(1)
    Bowl(2)
    Table()
    f1(1)

    Bowl(4)
    Bowl(5)
    Bowl(3)
    Cupboard()
    f1(2)

    在main()中新建一个Cupboard
    Bowl(3)
    Cupboard()
    f1(2)

    在main()中再建一个Cupboard
    Bowl(3)
    Cupboard()
    f1(2)

    f2(1)
    f3(1)
    *///:~