根据我的参考资料，原始类型具有默认值，而对象为null。我测试了一段代码。
public class Main {
public static void main(String[] args) {
int a;
System.out.println(a);
}
}
当使用代码 System.out.println(a); 时，会出现关于变量 a 的错误提示，指出变量a可能尚未初始化。但是，在给定的参考中，整数将具有0作为默认值。然而，通过以下给定的代码，实际上将打印出0。
public class Main {
static int a;
public static void main(String[] args) {
System.out.println(a);
}
}
第一段代码可能会出现什么问题？类变量与局部变量的行为有何不同？
a是一个main方法的局部变量。方法局部变量需要在使用之前进行初始化。a是类成员变量，因此它将被初始化为默认值。仔细阅读参考文献：
默认值
声明变量时不总是需要赋值。 未初始化的变量将由编译器设置为合理的默认值。一般来说，这个默认值将是零或 null，具体取决于数据类型。然而，依赖这样的默认值通常被认为是不好的编程风格。
以下图表总结了上述数据类型的默认值。
...
局部变量略有不同；编译器从不向未初始化的局部变量分配默认值。如果您无法在声明时初始化本地变量，请确保在尝试使用它之前给它赋值。访问未初始化的局部变量将导致编译时错误。
这些是涉及的主要因素：
注1：您必须在每个实现的构造函数中初始化final成员变量！
注2：您必须在构造函数本身的块内初始化final成员变量，而不能调用另一个初始化它们的方法。例如，以下内容无效：
private final int memberVar;
public Foo() {
// Invalid initialization of a final member
init();
}
private void init() {
memberVar = 10;
}
注意3: 在Java中，数组即使存储原始类型，也是对象。
注意4: 当您初始化一个数组时，无论它是成员数组还是本地数组，所有项目都将被设置为默认值。
我附上了一个代码示例，展示了上述情况：
public class Foo {
// Static and member variables are initialized to default values
// Primitives
private int a; // Default 0
private static int b; // Default 0
// Objects
private Object c; // Default NULL
private static Object d; // Default NULL
// Arrays (note: they are objects too, even if they store primitives)
private int[] e; // Default NULL
private static int[] f; // Default NULL
// What if declared as final?
// Primitives
private final int g; // Not initialized. MUST set in the constructor
private final static int h; // Not initialized. MUST set in a static {}
// Objects
private final Object i; // Not initialized. MUST set in constructor
private final static Object j; // Not initialized. MUST set in a static {}
// Arrays
private final int[] k; // Not initialized. MUST set in constructor
private final static int[] l; // Not initialized. MUST set in a static {}
// Initialize final statics
static {
h = 5;
j = new Object();
l = new int[5]; // Elements of l are initialized to 0
}
// Initialize final member variables
public Foo() {
g = 10;
i = new Object();
k = new int[10]; // Elements of k are initialized to 0
}
// A second example constructor
// You have to initialize final member variables to every constructor!
public Foo(boolean aBoolean) {
g = 15;
i = new Object();
k = new int[15]; // Elements of k are initialized to 0
}
public static void main(String[] args) {
// Local variables are not initialized
int m; // Not initialized
Object n; // Not initialized
int[] o; // Not initialized
// We must initialize them before use
m = 20;
n = new Object();
o = new int[20]; // Elements of o are initialized to 0
}
}
在声明基本类型的值时需要注意以下几点：
因此，在您的代码中：
public class Main {
int instanceVariable;
static int staticVariable;
public static void main(String[] args) {
Main mainInstance = new Main()
int localVariable;
int localVariableTwo = 2;
System.out.println(mainInstance.instanceVariable);
System.out.println(staticVariable);
// System.out.println(localVariable); // Will throw a compilation error
System.out.println(localVariableTwo);
}
}
是的，实例变量将被初始化为默认值。对于局部变量，您需要在使用之前进行初始化：
public class Main {
int instaceVariable; // An instance variable will be initialized to the default value
public static void main(String[] args) {
int localVariable = 0; // A local variable needs to be initialized before use
}
}
所有成员变量必须加载到堆中，因此在创建类的实例时必须使用默认值进行初始化。
对于局部变量，它们不会加载到堆中。它们存储在栈上，直到被使用。这是在Java 7之前的情况，因此我们需要明确地对它们进行初始化。
/**
* Retrieves the default value 0 / false for any primitive representative or
* {@link Number} type.
*
* @param type
*
* @return
*/
@SuppressWarnings("unchecked")
public static <T> T getDefault(final Class<T> type)
{
if (type.equals(Long.class) || type.equals(Long.TYPE))
return (T) new Long(0);
else if (type.equals(Integer.class) || type.equals(Integer.TYPE))
return (T) new Integer(0);
else if (type.equals(Double.class) || type.equals(Double.TYPE))
return (T) new Double(0);
else if (type.equals(Float.class) || type.equals(Float.TYPE))
return (T) new Float(0);
else if (type.equals(Short.class) || type.equals(Short.TYPE))
return (T) new Short((short) 0);
else if (type.equals(Byte.class) || type.equals(Byte.TYPE))
return (T) new Byte((byte) 0);
else if (type.equals(Character.class) || type.equals(Character.TYPE))
return (T) new Character((char) 0);
else if (type.equals(Boolean.class) || type.equals(Boolean.TYPE))
return (T) new Boolean(false);
else if (type.equals(BigDecimal.class))
return (T) BigDecimal.ZERO;
else if (type.equals(BigInteger.class))
return (T) BigInteger.ZERO;
else if (type.equals(AtomicInteger.class))
return (T) new AtomicInteger();
else if (type.equals(AtomicLong.class))
return (T) new AtomicLong();
else if (type.equals(DoubleAdder.class))
return (T) new DoubleAdder();
else
return null;
}
在 Hibernate ORM 投影查询中，当底层 SQL 查询返回 null 而不是 0 时，我会使用它。
/**
* Retrieves the unique result or zero, <code>false</code> if it is
* <code>null</code> and represents a number
*
* @param criteria
*
* @return zero if result is <code>null</code>
*/
public static <T> T getUniqueResultDefault(final Class<T> type, final Criteria criteria)
{
final T result = (T) criteria.uniqueResult();
if (result != null)
return result;
else
return Utils.getDefault(type);
}
我已经在代码之间添加了注释：
public class Main {
public static void main(String[] args) {
// This is local variable.
// Look! you have declared it within the "body of a method".
// Local variables must be initialized.
int a;
System.out.println(a);
}
}
现在是下一个
public class Main {
//This is NOT a local variable. It is NOT in a method body!
//Look! you have defined it as class member ( or a property).
//Java is more generous with local variables and initiates them.
//(ex: int with 0, boolean with false, String(or any object) with null, ...)
static int a;
public static void main(String[] args) {
System.out.println(a);
}
}