1.用构造器确保初始化
- 以下为带有构造器的简单类
class Rock{ Rock(){ System.out.println("Rock"); } } public class Test{ public static void main(String[] args){ Rock r = new Rock(); } }
在创建对象时，new Rock（）将会为对象分配内存，并调相应的构造器。不接受任何参数的构造器是默认构造器。构造器也可以带参数，以便于指定如何创建对象。
- 对默认构造器，如果你已经创建了一个构造器（无论是否有参数），编译器就不会为你自动创建默认构造器。例如
class Bird2{ Bird2 int }
2. this 关键字
this关键字表示对“调用方法的那个对象”的引用。例如
class Leaf{ int i = 0; Leaf increment(){ i++; return this; } void print(){ System.out.println(i); } public static void main(String [] args){ Leaf l = new Leaf(); l.increment().increment().increment().print(); } }this关键字将当前对象传递给其他方法。
class Person{ public void eat(Apple apple){ Apple peeled = apple.getPeeled(); System.out.println("Yummy"); } } class Apple{ Apple getPeeled() { return Peeler.peel(this); } } class Peeler{ static Apple peel(Apple apple){ return apple; } } public class PassingThis { public static void main(String[] args) { new Person().eat(new Apple()); } }
Apple需要调用Peeler.peel()方法，它是一个外部的工具方法，将执行由于某种原因必须放在Apple外部的操作（可能是因为该外部方法要应用于不同的类，而却不想重复这段代码）。为了将其自身传递给外部方法，Apple必须使用this关键字。在构造器中调用构造器
public class Flower { int petalCount = 0; String s = "initial value"; Flower(int petals) { petalCount = petals; System.out.println(petalCount); } Flower(String ss){ s = ss; System.out.println(s); } Flower(int petals,String s){ this(petals); //this(s); this.s = s; System.out.println("String & int args"); } Flower() { this(5,"hi"); } void printPetalCount(){ //this(); System.out.println(petalCount+" "+ s); } public static void main(String[] args) { Flower f = new Flower(); f.printPetalCount(); } }
可以用this调用一个构造器，不能调用两个，另外，必须将构造器调用置于最起始处。除构造器外，编译器禁止其他任何方法中调用构造器。当参数和数据成员名字相同时可以用this区分。
3.static
- static方法就是没有this的方法。static方法中不能调用非静态方法，反过来可以。可以在没有创建任何对象的情况下 ，通过类本身来调用static方法。它很像全局方法，java中禁止全局方法。
4.清理
java的垃圾回收器；finalize（）方法。
无论是垃圾回收还是终结，都不保证一定会发生。如果java虚拟机（JVM）并未面临内存耗尽的情况，它是不会浪费时间去执行垃圾回收以恢复内存的。
5. 初始化顺序
在类的内部，即使变量定义散布于方法定义之间，它们仍然会在任何方法被调用之前得到初始化。
package com.zhangyue.learn;
class Window{
public Window(int maker) {
System.out.println("window"+maker);
}
}
class House{
public House() {
System.out.println("House");
w3 = new Window(1);
}
Window w2 = new Window(2);
public 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();
}
}
/* output
window2
House
window1
f()
*/
6. 静态数据的初始化
package com.zhangyue.learn;
class Bowl{
public Bowl(int marker) {
System.out.println("Bowl"+marker);
}
void f1(int marker){
System.out.println("f1"+marker);
}
}
class Table{
static Bowl b1 = new Bowl(1);
public Table() {
System.out.println("Table");
b2.f1(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);
public Cupboard() {
System.out.println("Cupboard");
b4.f1(2);
}
void f3(int marker){
System.out.println("f3"+marker);
}
static Bowl b5 = new Bowl(5);
}
public class StaticOrderOfInitialization {
public static void main(String[] args) {
System.out.println(1);
new Cupboard();
System.out.println(2);
new Cupboard();
t.f2(1);
// c.f3(1);
}
static Table t = new Table();
// static Cupboard c = new Cupboard();
/*Bowl1
Bowl2
Table
f11
1
Bowl4
Bowl5
Bowl3
Cupboard
f12
2
Bowl3
Cupboard
f12
f21
*/
}
静态对象初始化过之后就不会再被初始化了，从第一个Cupboard和第二个Cupboard对象的初始化比较可看出。
初始化的顺序是先静态对象，后非静态对象。
7. 数组的初始化
package com.zhangyue.learn;
public class DynamicArray {
public static void main(String[] args) {
Other.main(new String[]{"a","b","c"});
}
}
class Other{
static void main(String[] args){
for (String s : args) {
System.out.print(s+" ");
}
}
}
8. 可变参数列表
public class DynamicArray {
public static void printArray(Object ... c){
for (Object a : c) {
System.out.print(a);
}
}
public static void main(String[] args) {
printArray(1,2,3);
}
}
9. 枚举类型
public enum Spiciness {
NOT,MILD,MEDIUM,HOT,FLAMING
}
创建enum时，编译器会自动添加一些有用的特性，如toString（），以便于方便显示实例内容，还有ordinal（），表示顺序，还有static values（），按顺序构成数组。
与switch连用显示了它的特性
package com.zhangyue.learn;
public class SimpleEnumUse{
Spiciness degree;
public SimpleEnumUse(Spiciness degree){
this.degree = degree;
}
public void describe(){
System.out.println("aaaa");
switch(degree){
case NOT:System.out.println(1);break;
case MILD:System.out.println(2);break;
case MEDIUM:System.out.println(3);break;
case HOT:System.out.println(4);break;
case FLAMING:System.out.println(5);break;
default : System.out.println(0);
}
}
public static void main(String[] args){
SimpleEnumUse
s = new SimpleEnumUse(Spiciness.NOT),
m = new SimpleEnumUse(Spiciness.FLAMING),
n = new SimpleEnumUse(Spiciness.HOT);
s.describe();
m.describe();
n.describe();
}
}
/*aaaa
1
aaaa
5
aaaa
4
*/
10. 引用的初始化
编译器不是为每个引用都创建默认对象，如果想初始化这些引用有下面几种方法
package com.zhangyue.learn;
class Soap{
private String s;
//构造器初始化
Soap() {
System.out.println("Soap()");
s = "Constructed";
}
public String toString(){
return s;
}
}
public class YinYongInitialization {
//在定义的位置初始化
private String
s1 = "Happy",
s2 = "Happy",
s3,s4;
private int i;
private Soap castille;
private float toy;
public YinYongInitialization(){
System.out.println("Inside class");
s3 = "Joy";
toy = 3.14f;
castille = new Soap();
}
//使用实例初始化
{i = 47;}
public String toString(){
//在正要使用对象之前初始化，即惰性初始化
if (s4 == null) {
s4 = "Joy";
}
return s1+s2+s3+s4+toy+i+castille;
}
public static void main(String[] args) {
YinYongInitialization y = new YinYongInitialization();
System.out.println(y);
}
}