java 内部类为啥不能static

Posted 2023-05-08

java为什么非静态内部类中不能有static修饰的属性，但却可以有常量？
如：
public class InnerClassDemo
int x;
class A
static int a = 0;//这样写是不合法的.
static final int b=0;//这样写是合法的


java类加载顺序，首先加载类，执行static变量初始化，接下来执行对象的创建，如果我们要执行代码中的变量int a 初始化，那么必须先执行加载外部类，再加载内部类，最后初始化静态变量 a ,问题就出在加载内部类上面，我们可以把内部类看成外部类的非静态成员，它的初始化必须在外部类对象创建后以后进行，要加载内部类必须在实例化外部类之后完成 ，java虚拟机要求所有的静态变量必须在对象创建之前完成，这样便产生了矛盾。
(有点绕，呵呵)
而java常量放在内存中常量池，它的机制与变量是不同的，编译时，加载常量是不需要加载类的，所以就没有上面那种矛盾。 参考技术A

谁说的内部类不能用static修饰。

/**
 * @serial include
 */
private static class ArrayList<E> extends AbstractList<E>
    implements RandomAccess, java.io.Serializable

    private static final long serialVersionUID = -2764017481108945198L;
    private final E[] a;

    ArrayList(E[] array) 
        if (array==null)
            throw new NullPointerException();
        a = array;
    

    public int size() 
        return a.length;
    

    public Object[] toArray() 
        return a.clone();
    

    public <T> T[] toArray(T[] a) 
        int size = size();
        if (a.length < size)
            return Arrays.copyOf(this.a, size,
                                 (Class<? extends T[]>) a.getClass());
        System.arraycopy(this.a, 0, a, 0, size);
        if (a.length > size)
            a[size] = null;
        return a;
    

    public E get(int index) 
        return a[index];
    

    public E set(int index, E element) 
        E oldValue = a[index];
        a[index] = element;
        return oldValue;
    

    public int indexOf(Object o) 
        if (o==null) 
            for (int i=0; i<a.length; i++)
                if (a[i]==null)
                    return i;
         else 
            for (int i=0; i<a.length; i++)
                if (o.equals(a[i]))
                    return i;
        
        return -1;
    

    public boolean contains(Object o) 
        return indexOf(o) != -1;
    

这个是jdk中的Arrays类中的一个静态内部类，这不就是用static修饰的。

java 嵌套类

如果不需要内部类对象与其外围类对象之间有联系,那么可以将内部类声明为static,这通常称为嵌套类,想要理解static应用于内部类时的含义,就必须记住,普通的内部类对象隐式地保存了一个引用,指向它的外围类对象,然而,当内部类时static时,就不是这样了,嵌套类意味着:

1)要创建嵌套类的对象,并不需要其外围类的对象

2)不能从嵌套类的对象中访问非静态的外围类对象

嵌套类与普通的内部类还有一个区别,普通内部类的字段与方法,只能放在类的外部层次上,所以普通的内部类不能有static数据和static字段,也不能包含嵌套类,但是嵌套类可以包含这些东西:

//: innerclasses/Parcel11.java
// Nested classes (static inner classes).
package object;
public class Parcel11 {
  private static class ParcelContents implements Contents {
    private int i = 11;
    public int value() { return i; }
  }
  protected static class ParcelDestination
  implements Destination {
    private String label;
    private ParcelDestination(String whereTo) {
      label = whereTo;
    }
    public String readLabel() { return label; }    
    // Nested classes can contain other static elements:
    public static void f() {}
    static int x = 10;
    static class AnotherLevel {
      public static void f() {}
      static int x = 10;
    }
  }
  public static Destination destination(String s) {
    return new ParcelDestination(s);
  }
  public static Contents contents() {
    return new ParcelContents();
  }
  public static void main(String[] args) {
    Contents c = contents();
    Destination d = destination("Tasmania");
  }
} ///:~