目录
本笔记参考自： 《On Java 中文版》
初始化和清理的不到位，很容易导致编程上的“不安全”。Java引入了构造器，以此来保证对象的初始化，同时通过垃圾收集器来回收内存的资源。
通过构造器进行初始化
Java中，类的设计者可以通过编写构造器来确保每一个对象的初始化。当一个类中存在构造器时，Java就会在创建该对象时自动调用它。而为了防止构造器的命名与类中的成员冲突，Java规定：构造器的名字就是类的名字。例如：
class Cla {
Cla() { // 和类名一致，这就是一个构造器
System.out.println("这是一条信息，表示构造器被执行。");
}
}
public class SimpleConstructor {
public static void main(String[] args) {
for (int i = 0; i < 10; i++)
new Cla();
}
}
程序运行的结果如下：
上述程序使用循环创建对象，当语句new Cla();被执行时，会发生两件事：① 为这一对象分配空间；② 调用这个类的构造器。Java通过构造器保证一个对象在被使用之前已经被正确地初始化了。
构造器的命名就是类名，是大小写敏感的。
构造器可以被分为两种：
- 默认构造器：也称为零参数构造器，这种构造器不带有参数；
- 含参构造器：和方法类似，构造器也可以通过传入参数来指定创建对象的方式。这种构造器一般由程序员编写。
使用含参数的构造器的方式与上述例子类似：
class Cla2 {
Cla2(int i) {
System.out.println("这是第" + (i + 1) + "次的初始化");
}
}
public class SimpleConstructor2 {
public static void main(String[] args) {
for (int i = 0; i < 10; i++)
new Cla2(i);
}
}
程序运行的结果是：
若一个对象只有唯一的一个构造器，那么编译器不会运行通过任何其他方法进行对象的创建。
注意：在Java中，创建和初始化是一个统一的概念，二者是缺一不可的。
构造器是一种特殊的方法，这种方法没有返回类型。这和返回类型为空（void）是不同的，对于空返回类型而言，虽然方法不会返回任何内容，但是仍然可以修改返回类型，使其存在一个返回值。但构造器不同，无法进行这种修改。
构造器常被用于对象的初始化。但对类而言，所有的基本类型的对象引用都会被自动初始化，这一过程是先于构造器的，因此使用构造器进行初始化不是强制的。
无参构造器
之前提到过，无参构造器，即没有参数的构造器，通常被用于创建“默认对象”。另外，即使我们没有为自定义的类创建构造器，编译器也会自动为这个类添加一个无参构造器。但是，如果我们已经创建了一个构造器，那么编译器就不会再自动进行无参构造器的创建了。例如：
class Tmp {
Tmp(int i) {
}
Tmp(double d) {
}
}
public class NoSynthesis {
public static void main(String[] args) {
// Tmp t = new Tmp();
Tmp t1 = new Tmp(1);
Tmp t2 = new Tmp(1.0);
}
}
若在上述程序中，执行被注释的语句Tmp t = new Tmp();的话，编译器会提示找不到匹配的构造器，并进行报错：
方法的重载
在编程语言中，命名是一个很重要的特性，比如方法就是对动作的命名。重载的含义在于，同一个词可以表达多种不同的含义，这更加接近我们使用语言的习惯。
Java之所以需要使用重载，有两个原因：
- 一个原因是因为不是每一个元素都需要一个唯一的标识符（即使省略一些不必要的词汇，语义依旧是连贯的）；
- 而另一个原因，就是因为构造器。在编程中，我们可能会需要通过不同的方式进行对象的创建，这就需要多个构造器。但无论有几个构造器，它们都只会有一个相同的名字：类名。为此，就需要使用方法重载来区分不同的构造器。
构造器和方法的重载用法都较为简单：
class Tree {
int height;
Tree() {
System.out.println("这是一颗树苗");
height = 0;
}
Tree(int init) {
height = init;
System.out.println("创建一棵高度为" + height + "米的树");
}
void info() {
System.out.println("树的高度是" + height + "米");
}
void info(String s) {
System.out.println(s + "：树的高度是" + height + "米");
}
}
public class Overloading {
public static void main(String[] args) {
for (int i = 0; i < 3; i++) {
Tree t = new Tree(i);
t.info(); // 调用重载的方法
t.info("系统提示");
System.out.println("--------------------------");
}
System.out.println(); // 调用重载的构造器
new Tree();
}
}
上述程序执行的结果是：
区分重载
重载中，不同的方法有相同的名字，为了区分它们，规定：每一个重载方法都必须有独一无二的参数类型列表。（实际上，就算只是参数顺序的不同也可以区分方法，但是这样产生的代码通常更难维护。）
通过返回值无法区分重载。这是因为有时我们并不关心返回值，而仅仅只是调用了该方法，此时Java可能无法区分有返回值的方法和无返回值的方法。因此，不使用返回值区分重载。
使用基本类型的重载
已知，基本类型可以从较小的类型自动提升到较大的类型。这一特性有时也会发生重载中：
public class PrimitiveOverloading {
void f1(char x) {
System.out.print("f1(char) ");
}
void f1(int x) {
System.out.print("f1(int) ");
}
void f2(int x) {
System.out.print("f2(int) ");
}
void testChar() {
char x = 'x';
System.out.print("char: ");
f1(x);
f2(x);
System.out.println();
}
void testint(){
int x = 0;
System.out.print("int: ");
f1(x);
f2(x);
System.out.println();
}
public static void main(String[] args) {
PrimitiveOverloading p = new PrimitiveOverloading();
p.testChar();
p.testint();
}
}
程序运行的结果如下：
注意，方法f2()的重载中并没有关于char类型的参数列表。因此char在f2()中并没有被精确匹配，而是被提升为了int类型。除此之外，若传入的数据类型比重载方法的参数类型大，就必须使用窄化转型，否则编译器会发生报错。
this关键字
当多个同一类型的对象分别调用同一个方法时，编译器会进行一些幕后工作，以此保证被调用的方法能够知道自己是被谁调用。这就是隐藏参数。例如：
class Banana{
void peel(int i ){
// ...
}
}
public class BananaPeel {
public static void main(String[] args) {
Banana a = new Banana();
Banana b = new Banana();
a.peel(1); //a、b调用了同一个方法
b.peel(2);
}
}
在上述的程序中，方法peel()有一个隐藏参数，位于所以参数之前，代表着被操作对象的引用。所以，上述a和b调用方法的语句也可以写成：
Banana.peel(a, 1);
Banana.peel(b, 2);当然，我们不能通过这种形式进行程序的编写。
上述这个被隐藏的引用是无法通过一般方式进行使用的，因为它根本不在参数列表中。这时就需要使用到一个Java提供的关键字：this（该关键字只能在非静态方法中使用）。这一关键字就代表了对象的引用，可以像使用任何其他对象一样使用this。
另外，若在类的一个方法内部调用该类的另一个方法，并不需要使用this：
public class Apricot {
void pick() {
// ...
}
void pit() {
pick(); // 此处可以直接调用pick()
// ...
}
}上述代码的语句pick();原本应该是this.pick();，但这样写是不必要的。因为编译器会自动进行补充。需要用到this的场景一般是：当必须明确指出当前对象的引用时。例如：
public class Leaf {
int i = 0;
Leaf increment() {
i++;
return this;
}
void print() {
System.out.println("i = " + i);
}
public static void main(String[] args) {
Leaf x = new Leaf();
x.increment().increment().increment().print();
}
}
上述程序的输出结果是：i = 3。因为increment()方法会返回当前对象的引用，因此可以轻易执行对同一对象的若干操作。
this本身也可以被作为参数传递到其他方法中：
class Person {
public void eat(Apple apple) {
Apple peeled = apple.getPeeled();
System.out.println(("有人吃了一个苹果"));
}
}
class Peeler {
static Apple peel(Apple apple) {
return apple;
}
}
class Apple {
Apple getPeeled() {
return Peeler.peel(this);
}
}
public class PassingThis {
public static void main(String[] args) {
new Person().eat(new Apple());
}
}
程序执行后，会显示一行输出：有人吃了一个苹果。在上述的代码中，类Apple调用了外部的方法Peeler.peel()，此时为了将自身传递出去，就需要使用this。
在构造器中调用构造器
若一个类有多个构造器，为了避免代码的重复，就需要从一个构造器调用另一个构造器。这种情况就可以使用this关键字进行调用。
在构造器中，this关键字可以有两个含义：
- 即通常的含义，表示对当前对象的引用；
- 若在this后加上参数列表，此时的this会显式调用与参数列表相匹配的构造器。
下面是一个调用其他构造器的例子：
public class Invoke {
int count = 0;
String s = "初始值";
Invoke(int x) {
count = x;
System.out.println("该构造器只有一个int类型的参数，count = " + count);
}
Invoke(String ss) {
System.out.println("该构造器只有一个String类型的参数，初始值s = " + s);
}
Invoke(String s, int x) {
this(x);
// this(s); // 不能同时调用两个构造器
this.s = s;
System.out.println("该构造器有String类型和int类型的参数");
}
Invoke() {
this("Hello World", 100);
System.out.println("无参构造器被调用");
}
void printCount() {
// this(11); // 不能在非构造器中调用其他构造器
System.out.println("count = " + count + ", s = " + s);
}
public static void main(String[] args) {
Invoke i = new Invoke();
i.printCount();
}
}
程序执行的结果是：
虽然可以通过this调用另一个构造器，但是不能同时调用两个。并且，构造器的调用必须出现在方法的最开始部分，否则会报错。
在构造器语句Invoke(String s, int x)中，有一个参数s和成员s名字相同。为了防止产生歧义，可以使用this.s来表示成员数据。
最后，编译器禁止在非构造器的普通方法中调用构造器。
static的含义
一个带有static关键字的方法是没有this的。这种方法可以在没有创建对象的时候，通过类直接进行调用（Java中不允许使用全局方法）。一个类的静态方法可以访问其他静态方法和静态字段。
然而，静态方法本身并不符合面向对象的思想。所以在设计静态方法之前，需要好好考虑。
成员初始化
Java对于变量的初始化有很严格的要求。对于方法的局部变量，若未进行初始化，就会出现报错。例如：
public class Tmp {
public static void main(String[] args) {
int i;
i++;
}
}若编译上述程序，会发生编译时错误：
上述信息指出变量i未被初始化。尽管编译器可以赋予这种变量默认值，但强制程序员进行初始化很显然更加安全。另外，之前也提到过，如果类的字段是基本类型，那么这些字段都会得到一个初始值。例如：
public class InitialValues {
boolean t;
char c;
byte b;
int i;
void printInitalValues() {
System.out.println("数据类型 默认值");
System.out.println("boolean " + t);
System.out.println("char " + c);
System.out.println("byte " + b);
System.out.println("int " + i);
}
public static void main(String[] args) {
new InitialValues().printInitalValues();
}
}
程序运行的结果如下：
即使没有指定初始值，类的字段也会被自动初始化（char类型的初始值为0，但笔者的系统进行输出时未显示）。这种做法规避了未初始化变量的风险。
若未进行初始化的字段是一个对象的引用，那么这个引用会被赋予一个特殊的初始值：null。
还可以通过方法来提供初始值，但方法的参数必须是已经初始化的：
public class MethodInit {
int i = f();
int j = g(i);
int f() {
return 1;
}
int g(int n) {
return n * 2;
}
}
但是，Java不允许使用前向引用，这意味着Java对初始化的顺序做出了明确要求。所以如果将上述代码稍加修改：
public class MethodInit {
int j = g(i);
int i = f();
int f() {
return 1;
}
int g(int n) {
return n * 2;
}
}
就会得到一个警告：
使用默认的初始化有时不会得到我们想要的结果。当进行手动的初始化时，我们就能得到更大的灵活性。
初始化顺序
类中的变量定义的顺序会决定初始化的顺序。即使将定义分散到方法之间，变量定义依旧会在任何方法（包括构造器）调用之前被初始化。例如：
class Window {
Window(int i) {
System.out.println("Window(" + i + ")");
}
}
class House {
Window w1 = new Window(1); // 在构造器之前被定义
House() { // 构造器
System.out.println();
System.out.println("已进入构造器House");
w3 = new Window(3); // w3在构造器之后被定义
}
Window w2 = new Window(2);
void f() { // 方法
System.out.println();
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对象的定义被分散到了方法之间，但显然它们在所以方法被调用之前就已经被初始化了。其中，对象w3被初始化了两次，一次在构造器被调用之前，一次在构造器中。一般建议在使用对象时再进行一次初始化，以保证正确的初始化。
静态数据的初始化
对于类而言，无论创建了多少个该类的对象，这个类中的静态数据都只会占用一份存储空间。static关键字只能对字段使用，而不能用于局部变量。并且静态的字段也会被初始化。例如：
class Bowl {
Bowl(int market) {
System.out.println("Bowl(" + market + ")");
}
void f1(int marker) {
System.out.println("f1(" + market + ")");
}
}
class Table {
Bowl bowl1 = new Bowl(1); // 这是一个非静态的变量
Table() {
System.out.println("调用构造器Table()");
bowl2.f1(1);
}
void f2(int marker) {
System.out.println("f2(" + market + ")");
}
static Bowl bowl2 = new Bowl(2);
}
public class StaticInitialization {
public static void main(String[] args) {
table.f2(1);
}
static Table table = new Table();
}
上述程序执行的结果如下：
static初始化仅在必要的时候发生。在上述例子中，若不创建Table对象，并且不引用Table.bowl1或Table.bow2，那么Bowl类型的bowl1和bowl2将永不被创建。
若一个类存在静态成员，那么当第一次创建该类的对象，或者第一次访问该类的静态成员时，该类的所有静态数据将被初始化。（实际上，构造器也是一个静态方法。）
||| 初始化的顺序：静态字段 → 非静态字段。
显式的静态初始化（静态块）
静态子句，又称静态块。在一个类中，可以将多个静态初始化语句放在一个“静态子句”中，例如：
public class Spoon {
static int i;
static {
i = 47;
}
}这段由static开头的语句块，与其他的静态初始化语句有一样的功能只执行一次，即使之前没有创建过该类的对象。例如：
class Day {
Day(int marker) {
System.out.println("Day(" + marker + ")");
}
void f(int marker) {
System.out.println("f(" + marker + ")");
}
}
class Days {
static Day day1;
static Day day2;
static {
day1 = new Day(1);
day2 = new Day(2);
}
Days() {
System.out.println("Days()");
}
}
public class ExplicitStatic {
public static void main(String[] args) {
System.out.println("进入main()");
Days.day1.f(99); // [1]
}
// static Days days1 = new Days(); // [2]
// static Days days2 = new Days(); // [2]
}
程序运行的结果是：
其中，无论是[1]还是[2]，只要有其中一段语句存在，Cups的静态初始化就会发生。
非静态实例的初始化
对于对象的非静态变量，Java提供了一种名为实例初始化的类似语法：
class Mug {
Mug(int maker) {
System.out.println("Mug(" + maker + ")");
}
}
public class Mugs {
Mug mug1;
Mug mug2;
{ // 实例初始化
mug1 = new Mug(1);
mug2 = new Mug(2);
System.out.println("mug1 和 mug2 完成初始化");
}
Mugs() {
System.out.println("Mugs()");
}
Mugs(int i) {
System.out.println("Mugs(int)");
}
public static void main(String[] args) {
System.out.println("进入main()方法");
System.out.println("-----------------");
new Mugs();
System.out.println("完成Mugs()操作");
System.out.println();
new Mugs(1);
System.out.println("完成Mugs(1)操作");
}
}程序执行的结果是：
该语法可用①于支持匿名内部类的初始化，以及②用于确保无论调用哪个显式的构造器，一些操作都会发生。
数组初始化
Java可以通过两种语法定义数组：
int[] a1;
int a1[]; // C和C++的语法，但是Java也可以用在Java中，编译器不被允许指定数组的大小。当我们通过上述的方式使用数组时，我们还仅仅是拥有了这个数组的引用。但数组对象本身的空间却没有被分配。因此，就需要进行初始化。数组可以在代码的任何地方被初始化。而在创建数组时进行初始化有特殊的语法，例如：
int[] a1 = {1, 2, 3, 4};另外，由于a1是一个数组的引用，因此也存在下方的用法：
int a2[] = {1, 2};
a1 = a2;在Java中，所有的数组都有一个固定的成员length，它可以查询数组内的元素个数。同时，Java中的数组也是从元素0开始计数，因此数组索引的最大下标值为length - 1。
但是，Java的数组是不允许越界访问的。
动态数组的创建
可以使用new关键字创建数组中的元素，例如：
import java.util.Arrays;
import java.util.Random;
public class ArrayClassObj {
public static void main(String[] args) {
Random rand = new Random(47);
Integer[] a = new Integer[rand.nextInt(20)];
System.out.println("数组a的长度为" + a.length);
for (int i = 0; i < a.length; i++)
a[i] = rand.nextInt(500); // 自动装箱
System.out.println(Arrays.toString(a));
}
}
程序运行的结果是：
当使用语句Integer[] a = new Integer[rand.nextInt(20)];之后，我们可以得到一个元素是引用的数组。此时这些引用都没有关联上任何元素。直到通过后面的自动装箱为每一个引用进行初始化后，才真正完成这个数组的初始化。
若未创建对象，而试图直接使用数组中的引用，程序就会出错。
通过花括号，还可以通过下述语法初始化对象数组：
Integer[] a = { 1, 2, 3, }; //最后的逗号是可选的
Integer[] b = new Integer[] { 1, 2, 3, };通过上述对数组b初始化的方式，还可以将一个String类型的数组传递给另一个类的main()方法：
public class DynamicArray {
public static void main(String[] args) {
Other.main(new String[] { "你", "好", "呀" });
}
}
class Other {
public static void main(String[] args) {
for (String s : args)
System.out.print(s + " ");
System.out.println();
}
}程序执行的结果如下：
可变参数列表
Java的可变参数列表包括：数量可变的参数和未知类型的参数。一种使用方式是通过Java的公共根类Object，可以创建一个接受Object数组的方法，例如：
import java.rmi.server.ObjID;
class A {
}
public class VarArgs {
static void printArray(Object[] args) {
for (Object obj : args)
System.out.print(obj + " ");
System.out.println();
}
public static void main(String[] args) {
printArray(new Object[] { 12, (float) 3.14, 1, 11 });
printArray(new Object[] { "Hello", "World" });
printArray(new Object[] { new A(), new A(), new A() });
printArray((Object[]) new Integer[] { 1, 2, 3, 4 }); // 通过强制类型转换，将数组作为列表传输
}
}程序执行的结果如下：
在第三行输出中，可以发现打印出来的类名都是@符号后面跟着十六进制数字。这就是在没有处理情况下，print()的默认行为：打印类名和对象的地址。
除了上述的可变参数列表的表达方式外，还可以使用省略号定义一个可变参数列表：
static void printArray(Object... args) { // ...当然，无论通过哪种方式，最终得到的args都会是一个数组。
但是，若是想要传递空参数列表（不传递参数，类似于printArray();）时，需要使用带有省略号的语法，即第二个语法。
下面是一个使用省略号的可变参数列表的例子，这种参数列表在面对可选的尾随参数时很有用：
public class OptionalTrailingArguments {
static void f(int required, String... trailing) { // 一个非Object类型的可变参数列表
System.out.print("required: " + required + " ");
for (String s : trailing)
System.out.print(s + " ");
System.out.println();
}
public static void main(String[] args) {
f(1, "多出来的字符");
f(2, "多出来了", "很多字符");
f(3);
}
}程序运行的结果如下：
在可变参数列表中，可以使用任何类型的参数。另外，可变参数列表也可以像数组一样触发自动装箱机制，因此可以对这种参数使用for-in语句：
public class Var {
public static void f(Integer... args) {
for (for i : args)
// ...
}
}但是，因为这种参数列表的加入，重载过程会变得更加复杂。当有多个带有可变参数列表的类存在时，编译器可能会因此找不到目标。例如：
public class OverloadingVarargs {
static void f(Character... args) {
System.out.println("这个重载有一个Character类型的可变参数列表");
}
static void f(Integer... args) {
System.out.println("这个重载有一个Integer类型的可变参数列表");
}
public static void main(String[] args) {
f(1);
f('a');
f(); // 编译器不明白这到底对应着哪一个重载
}
}若试图编译上述程序，会得到报错：
为了解决上述的这种问题，可能会为某个方法添加一个非可变参数（但这样还不够）。尝试改写上面的列子：
public class OverloadingVarargs {
static void f(float t, Character... args) {
System.out.println("这个重载多了一个float类型的变量");
}
static void f(Character... args) {
System.out.println("这个重载有一个Character类型的可变参数列表");
}
public static void main(String[] args) {
f(1, 'a');
f('a', 'b');
}
}即使如此，还是无法顺利运行代码。对上述程序而言，参数列表还是存在歧义的：
比较常见的做法是为每一个方法都添加一个非可变参数：
public class OverloadingVarargs {
static void f(float t, Character... args) {
System.out.println("这个重载多了一个float类型的参数");
}
static void f(char c, Character... args) {
System.out.println("这个重载多了一个char类型的参数");
}
public static void main(String[] args) {
f(1, 'a');
f('a', 'b');
}
}不过最好的办法是在一个重载上面使用可变参数列表，或者更不不用。
清理
Java的垃圾收集器可以回收不再被使用的对象内存，但有一些特殊情况除外：对象不使用new进行分配，而垃圾收集器只能释放由new分配的内存，此时这块空间就得不到回收。为此，Java允许在类中定义一个名为finalize的方法。
若存在finalize()方法，那么回收内存的动作应该是：
- 调用finalize()方法；
- 在下一次垃圾收集动作发生时，回收内存。
finalize()方法并不对标C++中的析构函数。
Java中的清理有这样的一些特点：
- 对象可能不会被回收：当程序在运行时还没有耗尽储存空间时，一些对象存储空间可能不会被回收（因为垃圾收集本身也会有开销）；
- 垃圾收集不是析构；
- 垃圾收集只和内存有关：任何与垃圾收集有关的动作（包括finalize()方法），都必须与内存及其的回收有关。
调用finalize()方法的时机
一般情况下，finalize()方法是不需要被调用的，因为垃圾收集器就已经可以完成大部分的内存回收工作。但正如上面所述，若对象是以某种特殊方式被分配了存储空间，此时就会用到finalize()方法。
之所以会发生这种情况，是因为Java允许调用本地方法，而通过本地方法又可以调用非Java代码。Java的本地代码目前只支持C和C++，但C和C++又能调用其他方法。所以，Java实际上可以调用的代码范围十分广泛。
为了处理这种可能的由非Java代码分配的空间，就会需要使用finalize()方法进行处理。
必须执行的清理
Java不允许创建本地对象，任何对象的创建都离不开new。并且，Java并不存在用于释放对象的操作符（像delete），这是因为垃圾收集器可以处理这一切。但除了内存释放之外，还可能存在其他的清理操作。此时就需要显式调用恰当的方法，这些方法类似于C++的析构函数。
finalize()的特殊用法
finalize()本身并不依赖于每次都被调用。因此，可以通过这一特性对程序进行一定的检测：
class Book {
boolean checkedOut = false;
Book(boolean checkOut) {
checkedOut = checkOut;
}
void checkIn() {
checkedOut = false;
}
@SuppressWarnings("deprecation") // 用于禁止在JDK 8以上的版本在编译时通过警告信息
@Override
public void finalize() {
if (checkedOut)
System.out.println("错误：检测失败");
// super.finalize(); // 调用基类版本
}
}
public class TerminationCondition {
public static void main(String[] args) {
Book novel = new Book(true);
novel.checkIn(); // 通过checkIn()进行正常的清理流程
new Book(true); // 引用丢失
System.gc(); // 向JVM请求进行垃圾收集和finalize()
}
}
程序执行后，打印结果：错误：检测失败。通过这种方式，就可以对未正确清理的对象进行验证，以提供更多的错误信息。
另外，在上述代码中出现了@Override。其中，@表示注解，用于提供代码的额外信息。在这里，@Override是为了告诉编译器，我们要自定义finalize()方法。并且由于finalize()方法在JDK 8之后不被推荐使用，所以需要用@SuppressWarnings("deprecation")来屏蔽警告。
应该假设finalize()的基类版本做了某些重要的工作，因此要使用super.finalize();。由于异常处理，上述例子为使用该语句。
垃圾收集器的工作原理
对许多编程语言而言，在堆上分配对象需要较大的代价。但对于Java而言，由于垃圾收集器的存在，其在堆上分配储存的速度，不亚于其他语言在栈上分配储存的速度。
这种看起来挺神奇的操作源于一些Java虚拟机（JVM）的工作方式。对于Java而言，在堆上分配空间只意味着让“堆指针”简单地移动到尚未分配的区域。因此它的效率可以与C++的栈分配相媲美。
当然，如果原理仅仅只是那么简单，那么内存终究有被耗尽的时候。当“堆指针”过度远离其的起始位置时，就有可能发生缺页错误。这就需要垃圾处理器的介入了：在回收垃圾的同时，垃圾处理器会压缩堆中的空间，让“堆指针”重新往起点靠近。由此，就形成了一个高速、且空间巨大的堆模型。
垃圾收集器会通过不同的方案提高回收垃圾收集的速度。一些有多个方案的JVM还会使用一种自适应的垃圾收集方案。
除了垃圾收集方案以外，Java也有其他的附加技术用以提升速度。例如编译器会将程序部分或者全部编译为本地机器码。
枚举类型
Java 5添加了enum关键字，使得Java编程能够使用枚举类型。例如：
public enum Color {
BLUE, RED, YELLOW
}枚举类型的实例都是常量，因此一般使用全大写的形式。
使用枚举的方式也很简单，只需要创建引用，并且分配其的实例即可。例如：
Color col = Color.BLUE;另外，Java为枚举类型添加了一些方法，例如：
- toString()方法，可用于显示enum实例的名字，在打印枚举类型时这个方法也会被自动调用；
- ordinal()方法，表示特定enum常量的声明顺序；
- values()方法，按照声明顺序生成一个enum常量值的数组；
- ......
这些方法的使用方式可参考下方的例子：
public class EnumOrder {
public enum Color {
BLUE, RED, YELLOW
}
public static void main(String[] args) {
for (Color col : Color.values())
System.out.println(col + ", ordinal: " + col.ordinal());
}
}程序运行的结果如下：
同时，枚举类型也经常在switch语句中被使用。
局部变量类型判断
在JDK 10中加入了一个新的特性：类型推断。在JDK 11中，这一用来简化局部变量定义的特性得到了改进。通过var关键字就可以启用：
class Tmp {
}
public class TypeInfrence {
void meth() {
String s1 = "Hello";
var s2 = "Hello"; // 可用于显式类型
Tmp t1 = new Tmp();
var t2 = new Tmp(); // 也可用于用户定义的类型
}
static void staticMethod() { // 也可用于静态方法
var s3 = "Hello";
var t3 = new Tmp();
}
}但是，var在使用时也存在一些限制，例如：
- 不能在字段上使用类型推断，例如：
class NoInference { String field1 = "可以这样做"; var field2 = "不能这样做"; }其中，field2的初始化方式就是不被允许的；
- 必须提供初始化数据，但不能是null，例如：
class NoInference { void method() { var noInitializer; // 初始化数据不存在，报错 var aNull = null; // 初始化数据为null，报错 } } - 不能用于方法的参数，例如：
class NoInference { void method(var no) { //参数为空，报错 // ... } }
类型推断多用于for循环，下面是一个正确使用类型推断的例子：
public class ForTypeInference {
public enum Color {
BLUE, RED, YELLOW
}
public static void main(String[] args) {
for (var col : Color.values())
System.out.println(col);
}
}Java由于向后兼容的关系，类型推断受到限制。在使用的时候，可以先进行尝试，然后让编译器来提示是否可行。
98
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
