Java中静态类为什么也可以实例化

Question

这是我在书中看到的代码，代码中有把实例化静态内部类。静态类怎么可以实例化？为什么要这么做？

import java.util.concurrent.*;
import java.util.concurrent.locks.*;

public class Consumerproducer {
    private static Buffer buffer = new Buffer();

    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(2);
        executor.execute(new Producertask());
        executor.execute(new ConsumerTask());
    }

    static class Producertask implements Runnable {
        public void run() {
            int i = 10;
            try {
                while (true) {
                    System.out.println("Producer writes " + i);
                    buffer.write(i++);
                    Thread.sleep((int) (Math.random() * 10000));
                }
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        }
    }

    static class ConsumerTask implements Runnable {
        public void run() {
            try {
                while (true) {
                    System.out.println("\t\tConsumer reads " + buffer.read());
                    Thread.sleep((int) (Math.random() * 10000));
                }
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        }
    }

    private static class Buffer {
        private static final int CAPACITY = 1;
        private java.util.LinkedList<Integer> queue =
                new java.util.LinkedList<>();

        private static Lock lock = new ReentrantLock();
        private static Condition notEmpty = lock.newCondition();
        private static Condition notFull = lock.newCondition();

        public void write(int value) {
            lock.lock();
            try {
                while (queue.size() == CAPACITY) {
                    System.out.println("Wait for notFull condition");
                    notFull.await();
                }

                queue.offer(value);
                notEmpty.signal();
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        }

        public Integer read() {
            int value = 0;
            lock.lock();
            try {
                while (queue.isEmpty()) {
                    System.out.println("Wait for notEmpty condition");
                    notEmpty.await();
                }
                value=queue.remove();
                notFull.signalAll();
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            } finally {
                lock.unlock();
                return value;
            }
        }
    }
}

Answer 1

题主混淆了static和abstract。
static nested class是指该内部类不需要依赖外部类的实例，就像其他的静态成员。

参考：http://docs.oracle.com/javase/specs/jls/...

Answer 2

static修饰的类不是说它自己是静态类，而是说它是外部类的静态成员。

这跟c#不一样的，c#的外部类等效于一个同名的名字空间，直接通过外部类的名字而不是外部类的对象访问。其static是静态类的意思。

Answer 3

static 修饰的内部类可以被外部类通过 外部类.静态内部类 直接访问，而没用static 修饰的类在new 对象的时候要通过外部类的实例.内部类点类名访问。

Answer 4

这是因为有些类实例化对象比较大，然后如果运行时加载时耗费的资源和时长都比较多，静态类在运行前加载。。所以在性能上会有提升。。

Answer 5

静态内部类为什么不能实例化？
没记错的话静态内部类是Effective Java推荐内部类用法。

Answer 6

静态类为什么不能实例化？
静态类跟实例化从来没有矛盾。
只要抽象类才不能实例化。

Answer 7

静态类是不能实例化，但楼主这里是静态内部类是可以实例化的