小编Paw*_*wel的帖子

编译器禁止访问枚举构造函数中的静态字段.下面的源代码可行,它使用静态字段:

public enum TrickyEnum
{
    TrickyEnum1, TrickyEnum2;

    static int count;

    TrickyEnum()
    {
        incrementCount();
    }

    private static void incrementCount()
    {
        count++;
    }

    public static void main(String... args)
    {
        System.out.println("Count: " + count);
    }
}

输出:

数:2.

但是,尽管差别很小,但下面的代码不起作用:

public enum TrickyEnum
{
    TrickyEnum1, TrickyEnum2;

    static int count;

    TrickyEnum()
    {
        count++; //compiler error
    }

    public static void main(String... args)
    {
        System.out.println("Count: " + count);
    }
}

从我的搜索中,人们通常声称问题是由于静态字段初始化的顺序.但是第一个例子是有效的,那么为什么Java开发人员会禁止第二个例子呢？它也应该工作.

我创建了界面TwoMethods.源代码:

interface TwoMethods<T>
{
    public void method(T t);
}

然后我创建了实现这个接口的类,在反汇编后我看到了2个方法.类:

class A implements TwoMethods<A>
{
    @Override
    public void method(A a) {}
}

拆解后:

class A implements TwoMethods<A> {
   A();
   public void method(A); //first
   public void method(java.lang.Object); //second
}

同样适用于Comparable界面.为什么当我创建参数化接口时,我有两种方法.总是,当我使用参数时？我还有另外的方法Object作为参数？

我想知道为什么这段代码编译成功？

源代码:

abstract class A<K extends Number>
{
    public abstract <M> A<? super M> useMe(A<? super M> k);
}

编译成功

它是如何工作的,为什么编译？M是任何类型,为什么它可以使用？应该是:<M extends Number>？这不会编译:

abstract class A<K extends Number>
{
    public abstract <M> A<? super M> useMe(A<M> k);
}

错误信息:

类型参数M不在类型变量K的范围内,其中M,K是类型变量:M extends方法useMe中声明的Object(A)K extends A类中声明的Number

有什么不同？

它很详细,但我想知道为什么会这样.

示例代码:

Class klasa = Enum.class;
for(Type t : klasa.getGenericInterfaces())
   System.out.println(t);

计划的输出:

java.lang.Comparable<E>
interface java.io.Serializable

为什么输出之前没有接口字java.lang.Comparable<E>.这是界面,是吗？

在我看来,输出应该是:

**interface** java.lang.Comparable<E>
interface java.io.Serializable

可比较是特别对待？

在我看来它应该有效,但事实并非如此.为什么？源代码:

package javaapplication1;

import java.util.*;

class A
{
    public static <K,V> Map<K,V> map()
    {
        return new HashMap<K,V>();
    }
}

class Person {}
class Dog {}

public class JavaApplication1
{

    static void f(Map<Person, List<? extends Dog>> peopleDogList) {}

    public static void main(String[] args)
    {
        f(A.<Person, List<Dog>>map());
    }
}

非常简单的代码.编译器错误:类JavaApplication1中的方法f不能应用于给出类型; required:Map<Person, List<? extends Dog> found:Map<Person, List<Dog>> reason:实际参数Map<Person, List<Dog>>无法Map<Person, List<? extends Dog>通过方法调用转换转换为.

Map<Person, List<? extends Dog> 更一般,所以编译器应该能够转换？

这也是:Map<Person, List<? extends Dog>> peopleDogList = A.<Person, List<Dog>>map();不起作用. …

我安装了带有JDK 7的NetBeans 7.2.1和插件 - Java ME SDK 3.2(里面有Wireles Toolkit 2.5.2).

我尝试通过单击File/New Project/Java ME/Mobile Application来创建新项目.然后我点击下一步.在下一个窗口中显示消息:

每个CLDC项目都需要分配CLDC兼容的SDK /平台/模拟器.

按" 安装SDK /平台/仿真器"按钮可打开"平台安装"向导,该向导允许您"添加平台".

我尝试单击Install SDK/Platform/Emulator按钮,然后我尝试指示安装Java ME 3.2的文件夹.它可以识别模拟器,但无法启动项目.

选择后,会出现几种选择.如何在新版本中制作？互联网上的大多数东西都与旧版本相关联.

这不会编译:

public class Methods
{

    public static void method(Integer... i)
    {
        System.out.print("A");
    }

    public static void method(int... i)
    {
        System.out.print("B");
    }

    public static void main(String args[])
    {
        method(7);
    }
}

这将编译和工作:

public class Methods
{

    public static void method(Integer i)
    {
        System.out.print("A");
    }

    public static void method(int i)
    {
        System.out.print("B");
    }

    public static void main(String args[])
    {
        method(7);
    }
}

第一个和第二个例子非常相似.首先使用varargs,其次不使用varargs.为什么一个有效,第二个没有.7是原始的,因此在两种情况下都应该调用第二种方法.这是正常的行为吗？

我发现了: 错误报告 堆栈溢出

为什么这段代码会编译？

int[] array = new int[][]{{1}}[0];

左侧是一维数组.在右边我认为那是三维的,但事实并非如此？

在Collection课堂上有两种toArray()方法:<T> T[] toArray(T[] a)和Object[] toArray().没有E[] toArray()方法.为什么？它与类型擦除有关,但有例如方法 - boolean add(E e).为什么可以创建参数化add,并且无法创建toArray()方法？

java 中禁止访问类static的构造函数中的变量。enum为什么在枚举中静态初始化的顺序没有交换？

正确代码示例：

enum Test
{
    TEST1, TEST2;

    static int x;
}

为什么java的开发者没有创建这样的正确代码：

enum Test
{
    static int x;

    TEST1, TEST2;
}

然后static可以在构造函数中使用变量。现在已被禁止。

有什么原因或者只是他们的设计吗？