[在构造函数中调用构造函数]
class Foo
{
public Foo()
{
this("Default");
}
public Foo(String s)
{
System.out.println(s);
}
}
public class
Main
{
public static void main(String[] args)
{
Foo f = new Foo();
Foo g = new Foo("Param");
}
}
[该死的gc]
public Foo(String s)
{
System.out.println(s);
}
}
public class
Main
{
public static void main(String[] args)
{
Foo f = new Foo();
Foo g = new Foo("Param");
}
}
[该死的gc]
在Java中垃圾收集是不能被强迫立即执行的。调用System.gc()或Runtime.gc()静态方法不能保证垃圾收集器的立即执行,因为,也许存在着更高优先级的线程。
[两种初始化的区别]
class T
{
String s0 = "good", s1;
public T()
{
s1 = "morning";
}
public String toString()
{
return s0 + " " + s1;
}
}
public class
Main
{
public static void main(String[] args)
{
T t = new T();
System.out.println(t);
}
}
s0和s1均被初始化了,但是它们的区别是什么?那就是:s0首先就被初始化为"good",而s1先被初始化为null,然后再被赋值为"morning"。
public T()
{
s1 = "morning";
}
public String toString()
{
return s0 + " " + s1;
}
}
public class
Main
{
public static void main(String[] args)
{
T t = new T();
System.out.println(t);
}
}
s0和s1均被初始化了,但是它们的区别是什么?那就是:s0首先就被初始化为"good",而s1先被初始化为null,然后再被赋值为"morning"。
[static型初始化的两个注意]
形如
class Cups
{
static Cup c1;
static Cup c2;
static
{
c1 = new Cup(1);
c2 = new Cup(2);
}
}
叫做static明确初始化。这种初始化有两个注意的地方:
class Cups
{
static Cup c1;
static Cup c2;
static
{
c1 = new Cup(1);
c2 = new Cup(2);
}
}
叫做static明确初始化。这种初始化有两个注意的地方:
(1) 这种初始化仅会被执行一次。
(2) 执行的时间为首次产生class对象的时候,或者为首次访问该class的static成员的时候
[实体初始化]
对于non-static型的变量,Java也提供了类似static型初始化的语法。
public class
Main
{
String s;
{
s = "good morning!";
System.out.println("initialized.");
}
Main()
{
System.out.println("constructor.");
}
public static void main(String[] args)
{
System.out.println("entry.");
Main m = new
Main
();
}
}
该程序输出:
entry.
initialized.
constructor.
执行顺序一目了然。
class Foo
{
public Foo()
{
this("Default");
}
public Foo(String s)
{
System.out.println(s);
}
}
public class
Main
{
public static void main(String[] args)
{
Foo f = new Foo();
Foo g = new Foo("Param");
}
}
[该死的gc]
public Foo(String s)
{
System.out.println(s);
}
}
public class
Main
{
public static void main(String[] args)
{
Foo f = new Foo();
Foo g = new Foo("Param");
}
}
[该死的gc]
在Java中垃圾收集是不能被强迫立即执行的。调用System.gc()或Runtime.gc()静态方法不能保证垃圾收集器的立即执行,因为,也许存在着更高优先级的线程。
[两种初始化的区别]
class T
{
String s0 = "good", s1;
public T()
{
s1 = "morning";
}
public String toString()
{
return s0 + " " + s1;
}
}
public class
Main
{
public static void main(String[] args)
{
T t = new T();
System.out.println(t);
}
}
s0和s1均被初始化了,但是它们的区别是什么?那就是:s0首先就被初始化为"good",而s1先被初始化为null,然后再被赋值为"morning"。
public T()
{
s1 = "morning";
}
public String toString()
{
return s0 + " " + s1;
}
}
public class
Main
{
public static void main(String[] args)
{
T t = new T();
System.out.println(t);
}
}
s0和s1均被初始化了,但是它们的区别是什么?那就是:s0首先就被初始化为"good",而s1先被初始化为null,然后再被赋值为"morning"。
[static型初始化的两个注意]
形如
class Cups
{
static Cup c1;
static Cup c2;
static
{
c1 = new Cup(1);
c2 = new Cup(2);
}
}
叫做static明确初始化。这种初始化有两个注意的地方:
class Cups
{
static Cup c1;
static Cup c2;
static
{
c1 = new Cup(1);
c2 = new Cup(2);
}
}
叫做static明确初始化。这种初始化有两个注意的地方:
(1) 这种初始化仅会被执行一次。
(2) 执行的时间为首次产生class对象的时候,或者为首次访问该class的static成员的时候
[实体初始化]
对于non-static型的变量,Java也提供了类似static型初始化的语法。
public class
Main
{
String s;
{
s = "good morning!";
System.out.println("initialized.");
}
Main()
{
System.out.println("constructor.");
}
public static void main(String[] args)
{
System.out.println("entry.");
Main m = new
Main
();
}
}
该程序输出:
entry.
initialized.
constructor.
执行顺序一目了然。
[继承构造函数]
如果一个类继承自某个基类,而又没有默认构造函数的话,系统会自动添加一个默认构造函数,这个默认构造函数调用基类的构造函数,比如
class A
{
A() {}
}
class B extends A
{
// 在这里会默认添加:
// B() { super(); }
}
这个和C++略有不同,C++中构造函数是不能被继承的。
其实,这个技术的实际情况是:Java编译器会自动在derived class构造函数中插入对base class构造函数的调用动作。
[缓式初始化]
其实也不算什么技术了,就是一种提高性能的方法。
对一个对象初始化有三种方式:
(1) 在对象定义的地方初始化。
(2) 在类的构造函数中。
(3) 在实际需要用到该对象的地方。
其中方式(3)就叫做缓式初始化(lazy init)。
class A
{
String _s;
A(String s)
{
_s = s;
}
public String toString()
{
return _s;
}
}
class B
{
A a;
public String toString()
{
a = new A("hello, world"); // lazy init
return a.toString();
}
}
public class
Main
{
public static void main(String[] args)
{
B b = new B();
System.out.println(b);
}
}
[再议清理] [再议清理]
垃圾清理这东西没准儿。所以:如果你希望发生清理动作,请自行撰写清理用的函数。
比如
class A
{
void cleanup()
{
// 添加清理
}
}
class B extends A
{
void clearup()
{
// 添加清理
super.cleanup();
}
}
public class Main
{
public static void main(String[] args)
{
B b = new B();
try
{
// 代码和异常处理
}
finally
{
b.cleanup();
}
}
}
class A
{
void cleanup()
{
// 添加清理
}
}
class B extends A
{
void clearup()
{
// 添加清理
super.cleanup();
}
}
public class Main
{
public static void main(String[] args)
{
B b = new B();
try
{
// 代码和异常处理
}
finally
{
b.cleanup();
}
}
}
如果一个类继承自某个基类,而又没有默认构造函数的话,系统会自动添加一个默认构造函数,这个默认构造函数调用基类的构造函数,比如
class A
{
A() {}
}
class B extends A
{
// 在这里会默认添加:
// B() { super(); }
}
这个和C++略有不同,C++中构造函数是不能被继承的。
其实,这个技术的实际情况是:Java编译器会自动在derived class构造函数中插入对base class构造函数的调用动作。
[缓式初始化]
其实也不算什么技术了,就是一种提高性能的方法。
对一个对象初始化有三种方式:
(1) 在对象定义的地方初始化。
(2) 在类的构造函数中。
(3) 在实际需要用到该对象的地方。
其中方式(3)就叫做缓式初始化(lazy init)。
class A
{
String _s;
A(String s)
{
_s = s;
}
public String toString()
{
return _s;
}
}
class B
{
A a;
public String toString()
{
a = new A("hello, world"); // lazy init
return a.toString();
}
}
public class
Main
{
public static void main(String[] args)
{
B b = new B();
System.out.println(b);
}
}
[再议清理] [再议清理]
垃圾清理这东西没准儿。所以:如果你希望发生清理动作,请自行撰写清理用的函数。
比如
class A
{
void cleanup()
{
// 添加清理
}
}
class B extends A
{
void clearup()
{
// 添加清理
super.cleanup();
}
}
public class Main
{
public static void main(String[] args)
{
B b = new B();
try
{
// 代码和异常处理
}
finally
{
b.cleanup();
}
}
}
class A
{
void cleanup()
{
// 添加清理
}
}
class B extends A
{
void clearup()
{
// 添加清理
super.cleanup();
}
}
public class Main
{
public static void main(String[] args)
{
B b = new B();
try
{
// 代码和异常处理
}
finally
{
b.cleanup();
}
}
}