构造器：
构造器与类名相同。
它是一种特殊类型的方法，没有返回值。
class Rock {
Rock() { // 无参构造器/默认构造器
System.out.print("Rock ");
}
Rock(int i) {
System.out.print("Rock " + i + " ");
}
}
public class SimpleConstructor {
public static void main(String[] args) {
for(int i = 0; i < 10; i++)
new Rock();
}
public static void main(String[] args) {
for(int i = 0; i < 8; i++)
new Rock2(i);
}
}
输出：
Rock Rock Rock Rock Rock Rock Rock Rock Rock Rock
Rock 0 Rock 1 Rock 2 Rock 3 Rock 4 Rock 5 Rock 6 Rock 7
区分方法重载：
1.每个重载方法都要有独一无二的参数类型列表
2.参数顺序不同
返回值不能区分重载
成员初始化：
全局变量无需初始化，局部变量必须初始化
public class InitialValues {
boolean t;
char c;
byte b;
short s;
int i;
long l;
float f;
double d;
InitialValues reference;
void printInitialValues() {
System.out.println("Data type Initial value");
System.out.println("boolean " + t);
System.out.println("char [" + c + "]");
System.out.println("byte " + b);
System.out.println("short " + s);
System.out.println("int " + i);
System.out.println("long " + l);
System.out.println("float " + f);
System.out.println("double " + d);
System.out.println("reference " + reference);
}
void f(){
int i;
// System.out.println(i); //Error, i未初始化
}
public static void main(String[] args) {
InitialValues iv = new InitialValues();
iv.printInitialValues();
/* 也可以写成:
new InitialValues().printInitialValues();
*/
}
}
输出：
Data type Initial value
boolean false
char []
byte 0
short 0
int 0
long 0
float 0.0
double 0.0
reference null
为变量赋值：
public class InitialValues2 {
boolean bool = true;//基本类型赋值
char ch = 'x';
byte b = 47;
short s = 0xff;
int i = 999;
long lng = 1;
float f = 3.14f;
double d = 3.14159;
InitialValues2 iv = new InitialValues2();//非基本类型赋值
// 也可以调用某个方法来提供初值
int i1 = f();
int f(){
return 11;
}
// 错误方式：程序的正确性取决于初始化的顺序
// int j = g(a);
// int a = f();
}
初始化顺序：
在类的内部，变量定义的先后顺序决定了初始化的顺序。即使变量定义散布在方法定义之间，它们仍旧在任何方法（包括构造器）被调用之前得到初始化。
class Window {
Window(int marker) { System.out.println("Window(" + marker + ")"); }
}
class House {
Window w1 = new Window(1);
House() {
System.out.println("House()");
w3 = new Window(33); // Reinitialize w3
}
Window w2 = new Window(2);
void f() { System.out.println("f()"); }
Window w3 = new Window(3);
}
public class OrderOfInitialization {
public static void main(String[] args) {
House h = new House();
h.f();
}
}
输出：
Window(1)
Window(2)
Window(3)
House()
Window(33)
f()
静态数据的初始化：
静态数据只初始化一次，static关键字不能应用于局部变量，只能作用于域；静态的基本类型域，未初始化，那么它就会获得基本类型的标准初值，如果它是一个对象引用，那么它的默认初始值是null。
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();
}
输出：
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永远都不会创建。只有在第一个Table对象被创建（或者第一次访问静态数据）时，他们才会被初始化。此后，静态对象不会再被初始化。
初始化的顺序：先静态对象，然后是非静态对象。
代码块：
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);
print("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");
}
}
结果：
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
执行顺序（优先级从高到低）：
静态代码块（只执行一次） > main方法 > 普通代码块（每次创建对象都会执行一次） > 构造方法
