Java4Android类和对象的初始化详解

1,成员初始化

Java尽力保证:所有变量在使用前都能够恰当的初始化。

 1)方法的局部变量。Java以编译时错误来贯彻这种保证。eg:

void f(){
    int i;
    i++; //Error , i not initialized
}
 2)类的数据成员。如果是基本类型,他们都会有一个初始值;如果是对象引用,那么这个引用将会被初始化为null。

指定初始化

如果想为某个变量赋值,该怎么做?

1)直接在定义类成员变量的地方为其赋值(注意,C++里面是不可以的,尽管C++新手们总想这么做)

class Depth{}

public class InitialValues{
    boolean bool = true;
    char ch = 'x';
    int i = 999;
    Depth d = new Depth();
}
2)调用某个方法来提供初始值。

public class MethodInit{
int i = f();
int f(){return 11;}
}
这个函数还可以带参数,但必须是初始化过的参数。

public class MethodInit2{
int i = f();
int j = g(i);
int f(){
    return 11;
}
int g(int n){
   return n*10;
}
}
但下面的写法确实错误的

public class MethodInit3{
// int j = g(i) ; //Illegal forward reference
int i = f();
int f(){return 11;}
int g(int n){return n*10;}
}
显然,上述程序的正确性取决于 初始化的顺序。编译器会发出“向前引用”的警告。

上述这种在定义的地方就初始化,简单快捷,这样创造出来的每个对象都会具有相同的值。

2,构造器初始化

在C++里面叫做构造函数,这里我们叫做构造器,都一个东西。上一节讲到的自动初始化是一定会被执行的,而且会在构造器之前执行。

public class Counter{
int i;
Counter(){i = 8;}
}
上述代码,i首先会被置为0,然后变为7.

初始化顺序

在类的内部,变量定义的先后顺序决定了初始化的顺序。即使变量定义散布于方法定义之间,他们仍然会在任何方法(包括构造器)被调用之前得到初始化。
class Window{
Window(int marker){print("window("+marker+")");}
}
class House{
window w1 = new Window(1);
House(){
print("house()");
w3 = new Window(33);
}
Window w2 = new Window(2);
void f(){print("f()");}
Window w3 = new Window(3);

}
public class OrderOfInitialization{
public static void main(String[] args){
    House h = new House();
   h.f();
}
}

/**Output**/
/*
Window(1)
Window(2)
Window(3)
House()
Window(33)
f()*/

静态数据的初始化

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

class Table{
static Bowl bowl1 = new Bowl(1);
Table(){
    print("Table()");
    bowl2.f1(1);
}
void f2(int marker){
    print("f2("+marker+")");
}
static Bowl bowl2 = new Bowl(2);
}

class Cupboard{
Bowl bowl3 = new Bowl(3);
static Bowl bowl4 = new Bowl(4);
Cupboard(){
    print("Cupboard()");
    bowl4.f1(2);
}
void f3(int marker){
    print("f3("+marker+")");
}
static Bowl bowl5 = new Bowl(5);
}

public class StaticInitialization{
public static void main(String[] args){
print("Creating new Cupboard() in main");
new Cupboard();
print("Creating new Cupboard() in main");
new Cupboard();
table.f2(1);
cupboard.f3(1);
}
static Table table = new Table();
static Cupboard cupboard = new Cupboard();
}
/**output*/
/*
Bowl(1)
Bowl(2)
Table()
f1(1)
Bowl(4)
Bowl(5)
Bowl(3)
Cupboard()
f1(2)
Creating new Cupboard in main
Bowl(3)
Cupboard()
f1(2)
Creating new Cupboard in main
Bowl(3)
Cupboard()
f1(2)
f2(1)
f3(1)
*/
请务必细心的看上述代码和结果。最好自己能够运行一遍。
初始化的顺序是先静态对象,后非静态对象。
静态初始化只有在必要的时刻才会进行。如果不创建Table对象,也不引用Table.b1,Table.b2,那么静态的Bowl b1 和b2 永远都不会被创建。下面的步骤我们会解析为什么。

对象创建过程

总结下对象创建的过程。假如有一个名为Dog的类:
1)即使没有显式的使用static关键字,构造器实际上也是静态方法。因此,当首次创建类型为Dog的对象时(构造器可以看成是静态方法),或者Dog类的静态方法,静态域首次被访问的时候,Java解释器必须查找路径,以定位Dog.class文件。
2)然后载入Dog.class(这将创建一个Class对象),有关静态初始化的所有动作都会执行。因此,静态初始化只在Class对象首次加载的时候进行一次。
3)当用new Dog()创建对象的时候,首先将在堆上为Dog对象分配足够的存储空间。
4)这块存储空间会被清零。这就自动的将Dog对象中的所有基本类型数据都设置成了默认值,而引用则被设置成了null。(再次强调方法内部的局部变量不会被初始化,如果使用未初始化的局部变量会提示编译错误)。
5)执行所有出现于字段定义处的初始化动作。
6)执行构造器。

显式的静态初始化(静态块)

Java允许将多个静态初始化动作组织成一个特殊的“静态子句”(也叫静态块)。
public class Spoon{
static int i;
static {
    i = 47;
}
}
上述代码和静态初始化动作是一样的,代码仅在必要的时刻仅执行一次。
class Cup{
Cup(int marker){
    print("Cup("+marker+")");
}
void f(int marker){
    print("f("+marker+")");
}
}

class Cups{
static Cup cup1;
static Cup cup2;
static {
    cup1 = new Cup(1);
    cup2 = new Cup(2);
}
Cups(){
    print("Cups()");
}
}

public class ExplicitStatic{
    public static void main(String[] args){
     print("Inside main()");
     Cups.cup1.f(99);//(1)
}
    //static Cups cups1 = new Cups();//(2)
    //static Cups cups2 = new Cups();//(3)
}
/**output*/
/*
Inside main()
Cup(1)
Cup(2)
f(99)
*/
上述代码无论是运行(1)还是把(1)注释了运行(2),Cups的静态初始化都会得到执行。(3)也可以打开看看,无关紧要,因为静态初始化动作只进行一次。

非静态实例初始化

它在静态初始化之后,在构造函数之前,前面我们讲述过这个步骤。我们来看一段代码:
class Mug{
Mug(int marker){
    print("Mug("+marker+")");
}
void f(int marker){
    print("f("+marker+")");
}
}

public class Mugs{
Mug mug1;
Mug mug2;
{
    mug1 = new Mug(1);
    mug2 = new Mug(2);
    printf("mug1 & mug2 initialized");
}
Mugs(){
    print("Mugs()");
}
Mugs(int i){
    print("Mugs(int)");
}
public static void main(String[],args){
    print("Inside main()");
    new Mugs();
    print("new Mugs() completed");
    new Mugs(1);
    print("new Mugs(1) completed");
}
}
/** output*/
/*
Inside main()
Mug(1)
Mug(2)
mug1 & mug2 initialized
Mugs()
new Mugs() completed
Mug(1)
Mug(2)
mug1 & mug2 initialized
Mugs(int)
new Mugs(1) completed
*/

这种语法对于支持“匿名内部类”的初始化是必须的。
累了。今天学习到这里。










你可能感兴趣的:(初始化,静态块,JAVA4android,实例初始化)