据我了解,下面的代码应该打印出来true.
但是,当我运行此代码时,它正在打印false.
匿名类总是隐式最终的
public class Test {
public static void main(String args[]) {
Object o = new Object() {
};
System.out.println("Annonymous class is final: " + Modifier.isFinal(o.getClass().getModifiers()));
}
}
有人可以帮我理解这种行为.
这段代码:
interface Config {
int MAX_CONN = 20;
}
编译和按我的预期工作.它看起来像是:
interface Config {
public static final int MAX_CONN = 20;
}
对于Java接口中的常量,"public static final"是多余的吗？这对于Java 1.1,1.2,1.3,1.4,...,1.8是否适用,或者是否在Java版本中进行了更改？
鉴于以下课程:
class?Foo?{
public?volatile?int?number;
public?int?method1()?{
int?ret?=?number?=?1;
return?ret;
}
public?int?method2()?{
int?ret?=?number?=?2;
return?ret;
}
}
并且在同一个实例上调用多个线程method1()并method2()同时执行Foo,对method1()的调用是否可以返回除1以外的任何内容？
术语内部类通常用于表示"需要封闭实例的嵌套类".但是,JLS声明如下:
8.1.3.内部类和封闭实例
[...]
内部类包括本地(§14.3),匿名(§15.9.5)和非静态成员类(§8.5).
[...]
声明在静态上下文中发生的内部类的实例没有词法封闭的实例.
也,
15.9.5.匿名类声明
[...]
匿名类始终是内部类(第8.1.3节); 它永远不会
static(§8.1.1,§8.5.1).
众所周知,匿名类可以在静态上下文中声明:
class A {
int t() { return 1; }
static A a = new A() { int t() { return 2; } };
}
要尖锐地描述它,
new A() {} 是一个没有封闭实例的嵌套类,在静态上下文中定义,但它不是静态嵌套类 - 它是一个内部类.我们是否都在日常使用中为这些条款赋予了不恰当的含义？
作为一个相关的兴趣点,这个历史规范文档将术语顶层定义为内部的反面:
作为
static类成员的类和作为包成员的类都称为顶级类.它们与内部类的不同之处在于顶级类只能直接使用它自己的实例变量.
而在常见用法中,顶层被认为是嵌套的反面.
据我所知,Java 8 JLS表达式(1/0)被认为是一个常量表达式,但是当我尝试使用OpenJDK 8编译以下程序时出现错误
public class Switch {
public static void main(String[] args) {
switch(42) {
case (1/0):
return;
default:
return;
}
}
}
错误说(1/0)不是一个常量表达式
Switch.java:4: error: constant expression required
case (1/0):
^
1 error
我错过了什么吗？或者它是OpenJDK 8中的错误？
对于百万分之一的时间,我本来希望IN在Java中使用运算符,类似于INSQL中的运算符.它可以作为编译器语法糖实现.所以这
if (value in (a, b, c)) {
}
else if (value in (d, e)) {
}
......真的很棒.事实上,上面的内容与这里相当冗长(并且不适用于原语)的构造相同:
if (Arrays.asList(a, b, c).contains(value)) {
}
else if (Arrays.asList(d, e).contains(value)) {
}
或者这样的int,long和类似的形式:
switch (value) {
case a:
case b:
case c:
// ..
break;
case d:
case e:
// ..
break;
}
或者可能有更高效的实现.
这样的东西会成为Java 8的一部分吗？如果没有,我怎么能提出这样的建议呢？或者,我现在可以使用任何等效的构造吗？
我试图简单地测试JLS保证的最终字段的初始化安全性.这是我写的一篇论文.但是,根据我当前的代码,我无法让它"失败".有人可以告诉我我做错了什么,或者这只是我必须反复运行然后看到一个不幸的时机失败？
这是我的代码:
public class TestClass {
final int x;
int y;
static TestClass f;
public TestClass() {
x = 3;
y = 4;
}
static void writer() {
TestClass.f = new TestClass();
}
static void reader() {
if (TestClass.f != null) {
int i = TestClass.f.x; // guaranteed to see 3
int j = TestClass.f.y; // could see 0
System.out.println("i = " + i);
System.out.println("j = " + j);
}
}
}
我的线程正在调用它:
public class TestClient {
public static void …我最近发现并写了一篇关于这样一个事实的博客:有可能通过javac编译器偷看一个已检查的异常,并将它扔到不能抛出它的地方.这在Java 6和7中编译并运行,抛出一个SQLExceptionwithout throws或catch子句:
public class Test {
// No throws clause here
public static void main(String[] args) {
doThrow(new SQLException());
}
static void doThrow(Exception e) {
Test.<RuntimeException> doThrow0(e);
}
static <E extends Exception> void doThrow0(Exception e) throws E {
throw (E) e;
}
}
生成的字节码表示JVM并不真正关心已检查/未检查的异常:
// Method descriptor #22 (Ljava/lang/Exception;)V
// Stack: 1, Locals: 1
static void doThrow(java.lang.Exception e);
0 aload_0 [e]
1 invokestatic Test.doThrow0(java.lang.Exception) : void [25]
4 return
Line numbers:
[pc: …下面是一些在尚未初始化的类上调用静态方法Af()的代码.有人可以用JLS来解释这段代码的行为吗？
class A {
final static Object b = new B();
final static int S1 = 1;
final static Integer S2 = 2;
static void f() {
System.out.println(S1);
System.out.println(S2);
}
}
class B {
static {
A.f();
}
}
public class App
{
public static void main( String[] args )
{
A.f();
}
}
输出:
1
null
1
2
System.out.println(Integer.MAX_VALUE + 1 == Integer.MIN_VALUE);
是真的.
我知道Java中的整数是32位,不能超过2 ^ 31-1,但我不明白为什么在MAX_VALUE中加1会导致MIN_VALUE而不是某种异常.没有像Ruby那样透明地转换为更大的类型.
是否在某处指定了此行为？我可以依靠它吗？