Impossible is Nothing !
如果我QQ上线但又没有给你发消息. 那请你原谅 因为我那时候正专心于我的事业中. 但这并不代表我没有把你放在第一位 恰恰因为我把你放在了第一位 所以才利用没有和你在一起的时间做完我该做的事. 而当我们在一起的时候. 我才能全心全意地和你在一起
posts - 17,comments - 0,trackbacks - 0
一段时间没写程序(虽然看JAVA也没几天).居然连最基本的数组初始化都忘了.
现在把基本知识归纳下. 以备以后查询.

Java Array:

declare: 
int[] a; // a 是一个指向整数数组的指针
int a[];

initialization:
int[] a = {1,2,3,4,5,6}; // 不是 int[] a = [1, 2, 3, 4, 5, 6];

Java Object

member initialization:

void f(){
   int i;
   i++;// 成员没有初始化
}

类中自动初始化成员
public class InitialInClass{
    boolean t;
    char c;
    byte b;
    short s;
    int i;
    long l;
    float f;
    double d;

    void print(String s)
    {
         System.out.println(s);
     }

    void printInitialVals()
    {
         print("Data Type          Initial value");
         print("boolean     " + t);
         print("char         [" + c + "]");
         print("byte         " + b);
         print("short        " + s);
         print("int            " + i);
         print("long         " + l);
         print("float         " + f);
         print("double      " + d);
     }

     public static void main(String args[])
     {
         InitialInClass in = new InitialInClass();
         in.printInitialVals();
     }
}


Specifying initialization:
class InitialVal{
    boolean b = true;
    char c = 'k';
    byte B = 47;
    short s = 0xff;
    int i = 21;
    float f = 3.5f;
    double d = 3.521;
    //.........
}

也可以在类中定义其他类
class InitialVal{
    myClass mc  = new myClass();
   //..
}
当然如下的初始化调用的不是你自己定义的构造函数(后面会讲到初始化顺序)
class Initial{
   Initial in = new Initial();

   Initial(){
       System.out.println("In Constructor.");
   }

   public static void main(String args[])
   {
       System.out.println("In Main");
   }
}
输出结果为: In Main


Constructor initialization:

class Counter{
    int i;

    Counter(){
        i = 5;
    }
}

Order of initialization:
1. 变量初始化在任何方法调用之前
2. 静态成员初始化在非静态成员之前.

class Tag{
    Tag(int marker)
    {
        System.out.println("Tag(" + marker + ")" );
    }
}

class Card{
    Tag t1 = new Tag(1);// 写在构造函数之前
    Card(){
        System.out.println("In Card()");
        t4 = new Tag(4); // 写在构造函数内
    }
    Tag t2 = new Tag(2);// 写在构造之后 普通函数之前

    void f(){
        System.out.println("In f()");
    }

    Tag t3 = new Tag(3);//写在普通方法后
}

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

Output:
Tag(1)
Tag(2)
Tag(3)
In Card()
Tag(4) // 这个就是构造函数内的
In f();

静态成员初始化(静态成员只初始化一次):
class myStatic{
   static int i;
   static{
       i = 47;
   }
}

初值(虽然自动赋予缺省值.但对每个变量都赋值是必要的)
----------------------------------------
Primitive type      Default
----------------------------------------
boolean               false
char                    '\u0000'(null)
byte                    (byte)0
short                   (short)0
int                       0
long                    0L
float                    0.0f
double                 0.0d
----------------------------------------
posted on 2006-03-28 20:49 kinns 阅读(40) 评论(0)  编辑 收藏 引用 所属分类: Java
只有注册用户登录后才能发表评论。