初始化小结:
在c++中,我们知道了类的初始化基本上是通过构造函数来实现的,或者通过set()函数,或者其他的一些方法,关键是类中不能够实现初始化.
现在开始学习java,我发现可以有以下几个初始化的方法:
一:初始化方法
(1):
类中默认的初始化.
Java尽力保证所有的基本变量在使用前都能够得到适当的初始化,对于定义在方法内部的局部变量,java就以编译时错误的形式来保证,所以如果写成
Void f(){
Int I;
I++;// error,because I is not initilized.
}
但是类中的每个基本类型(数据成员)都会保证有一个初始值.
如 boolean false
Char \u0000(null)
Byte (byte)0
Short (short)0
Int 0
Long 0
Float 0.0f
Double 0.0d
(2):指定初始化.
在类定义成员的时候初始化,这种情况在c++中时绝对不允许的,但是转到java中时可以的.;.
(3):构造器初始化.
在运行的时候可以通过调用方法或者执行某些动作来确定初始值,这为编程带来了很大的
方便.
如
class F{
Int I;
F(){ I = 7;};
}
那样,i就会先被赋值为0,然后再被赋值为7;
如下面的程序就演示了三种情况…
public class initialize {
boolean t; //1:类中基本成员的默认初始化
char c;
byte b;
short s;
int i;
//2 :int i = 6;
//2:c++中部允许在类的定义中初始化成员变量.这种初始化无法被阻止,
//2:必定在构造器调用之前发生了,所以i先被赋值0,后又被赋值6
long l;
float f;
double d;
initialize(){ //3:构造器中初始化.
f = 3.4f;
d = 23.44d;
}
void print(String s){
System.out.println(s);
}
void printInitiaValve(){
print("Data type Inital 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){
initialize d = new initialize();
d.printInitiaValve();
}
}
二 :初始化的顺序.
1:没有静态变量的初始化.
在类的内部,变量定义的先后顺序决定了初始化的顺序.即使变量定义分散在方法定义的之间,他们仍旧会在任何方法(包括构造器)被调用之前得到初始化..
例如:
class A{
A( int marker ){
System.out.println("A:" + marker + " ");
}
}
class Card{
A a1 = new A(1);
Card(){
System.out.println("Card()");
a3 = new A(33);
//a3这个引用被用了两次,一次在调用构造器之前,还有一次就在调用期间
//此时第一次引用的对象被丢弃了,并作为垃圾回收了,
}
A a2 = new A(2);
void f(){
System.out.println(" f() ");
}
A a3 = new A(3);
}
public class initialize{
public static void main(String[]args){
Card C = new Card();
C.f();
}
}
打印结果是:
A:1
A:2
A:3
Card()
A:33
f()
2:有静态变量的初始化
如果数据是静态的,情况并无不同:如果它属于某个基本类型,而且没有进行初始化,那么它就会获得基本类型的标准初值,如果它是一个对象引用,那么除非新创建一个对象,并指派给该引用,否则就是空值(null).
如果想在定义的时候进行初始化,采取的方法和非静态数据没有什么不同,无论创建了多少对象,静态数据都只占有一份存储区域,但是要对这个静态存储区域进行初始化就有 了问题,如:
class Bowl{
Bowl( int marker ){
System.out.println("Bowl(" + marker + ")");
}
void f( int marker ){
System.out.println("f(" + marker + ")");
}
}
class Table{
static Bowl b1 = new Bowl(1);
Table(){
System.out.println("Table()");
b2.f(1);
}
void f2(int marker) {
System.out.println("f2(" + marker + ")");
}
static Bowl b2 = new Bowl(2);
}
class Cupboard{
Bowl b3 = new Bowl(3);
static Bowl b4 = new Bowl(4);
Cupboard(){
System.out.println("Cupboard()");
b4.f(2);
}
void f3( int marker ){
System.out.println("f3(" + marker + ")");
}
static Bowl b5 = new Bowl(5);
}
public class initialize{
public static void main(String [] args){
System.out.println("Creating new Cupboard() in main() .");
new Cupboard();
System.out.println("Creating new Cupboard() in main() .");
new Cupboard();
t2.f2(1);
t3.f3(1);
}
static Table t2 = new Table();
static Cupboard t3 = new Cupboard();
}
打印结果是:
Bowl(1)
Bowl(2)
Table()
f(1)
Bowl(4)
Bowl(5)
Bowl(3)
Cupboard()
f(2)
Creating new Cupboard() in main() .
Bowl(3)
Cupboard()
f(2)
Creating new Cupboard() in main() .
Bowl(3)
Cupboard()
f(2)
f2(1)
f3(1)
由输出可以看出,静态初始化只有在必要的时候才会进行,如果不创建Table对象,也不引用Table.b1, Table.b2,那么静态的Bow b1,b2永远都不会被创建,只有在第一个Table对象被创建的 时候他们才会被初始化,此后,静态变量不会再被初始化.
初始化的顺序是先”静态”对象
3:明确进行的静态初始化
在java中,允许多个静态初始化动作组成一个特殊的 “静态字句”(有时候也叫静态块)
如:
class A{
static int I;
statci{
I =34;
}
}
举个例子来说看看.
class Cup{
Cup( int market ){
System.out.println("Cup(" + market + ")");
}
void f( int market ){
System.out.println("f(" + market + ")");
}
}
class Cups{
static Cup c1;
static Cup c2;
static {
c1 = new Cup(1);
c2 = new Cup(2);//疑问的地方,为什么c2会执行….
}
Cups(){
System.out.println("Cups");
}
}
public class initialize{
public static void main(String[] args){
System.out.println("inside Main()");
//Cups.c1.f(99); (1)
}
//static Cups x = new Cups(); (2)
//static Cups y = new Cups(); (2)
}
如果执行1的代码则生成.
inside Main()
Cup(1)
Cup(2)
f(99)
如果执行2的代码则生成
Cup(1)
Cup(2)
Cups
Cups
inside Main()
4:非静态的初始化.
class Mug{
Mug( int market ){
System.out.println("Mug(" + market + ")");
}
void f( int market ){
System.out.println("f(" + market + ")");
}
}
class Mugs{
Mug c1;
Mug c2;
{
c1 = new Mug(1);
c2 = new Mug(2);
System.out.println("c1 & c2 initilized");
}
Mugs(){
System.out.println("Mugs()");
}
}
public class initialize{
public static void main(String[] args){
Mugs x = new Mugs();
Mugs y = new Mugs();
}
}
执行结果如下:
Mug(1)
Mug(2)
c1 & c2 initilized
Mugs()
Mug(1)
Mug(2)
c1 & c2 initilized
Mugs()
