在静态方法里面怎么不能直接建立内部类的实例
例如：[code=java]public class Out{

        /**
         * @param args
         */
        public static void main(String[] args) {
                // TODO Auto-generated method stub
                        Inner  in=new Inner();//这里报错不能直接新建对象
        }
        class Inner{
               
        }
}[/code]内部类不是和一般的类一样么？在方法内部怎么不能直接创建对象呀？各位同仁谁能帮忙解释一下........

貌似你所说的有误。
实例内部类对象是与外部对象关联的。所以实例化实例内部类，先要获得外部类的对象。同一个类中非静态方法由于已经关联了对象，所以不必指定外部对象，但是在静态方法以及客户类中实例化实例内部类，必须先实例化外部对象。所以静态方法中是可以创建实例内部类对象的。

补充一下：

实例化静态内部类：同一个类的方法（静态与非静态）中，不能以实例化外部类的对象去访问静态内部类，即【new 外部类().new 内部静态类()】是错误的,在外面访问这样是可行的；在同一个类的方法中实例化静态内部类的候不需要指定外部类（对于普通方法，已经有一个对象，对于静态方法，有一个类绑定）；在外面实例化本类的静态内部类，需要指定外部类。

参考我的笔记：[url]http://blog.csdn.net/xjwangliang/article/details/6553185[/url]

这个问题我刚看到时也感觉到有些困惑，有种错觉之前这样用没有出现同样的问题，后来经查询资料才明白其中的原理。第一种解决方案就像大家所说的，这在张孝祥老师的面象对象基础中也有讲到。还有一种方式是在内部类的前面加上static关键字，虽然这有背内部类的思想，但同样也能解决该问题的方式为何不用呢…

道理很简单，不难想象，如果在Out里面定义一个int n,你直接运行了，这个n肯定不能被调用，因为要想调用n，要先创建一个Out的实例化对象，只有一份糖醋里脊的食谱你是吃不到糖醋里脊的。
同理，在Out中创建的类要使用也要像调用一个成员变量，一个方法那样才行，都要先有一个Out类的实例化对象才能实现
public class Out{
        int n = 5;
        public static void main(String[] args) {
                System.out.println("n");
        }
}
代码改成这样就没问题了
public class Out{
        public static void main(String[] args) {
                Out out = new Out();
                Inner in = out.new Inner();
        }
        class Inner{
        }
}

因为java不允许静态成员访问非静态成员的规则，所以外部类的静态方法、静态代码块不能访问非静态内部类，包括不能使用非静态内部类定义变量，创建实例，[code=java]package cn.itcast.heima.mythreadtest;


public class TestStatic
{
        //定义一个非静态的内部类，是一个空类
        private class In{}
        //外部类的静态方法
        public static void main(String[] args)
        {
                //下面代码引发编译异常，因为静态成员（main方法）无法访问非静态成员（In类）
                new In();
        }
}[/code]但是你可以在外部类定义一个非静态的方法，在这个方法内部来访问非静态内部类，如下[code=java]package cn.itcast.heima.mythreadtest;

public class Outer
{
        private int outProp = 9;
        class Inner
        {
                private int inProp = 5;
                public void acessOuterProp()
                {
                        //内部类可以直接访问外部类的成员
                        System.out.println("外部类的outProp属性值:" + outProp);
                }
        }
        public void accessInnerProp()
        {
                //外部类不能直接访问内部类属性,下面代码出现编译错误
                //System.out.println("内部类的inProp属性值:" + inProp);
                //如需访问内部类成员，必须显式创建内部类对象
                System.out.println("内部类的inProp属性值:" + new Inner().inProp);

        }
        public static void main(String[] args)
        {
                //执行下面代码，只创建了外部类对象，还未创建内部类对象
                Outer out = new Outer();
        }
}[/code]---------------------------------------------
总之：非静态内部类对象必须寄存在外部类的对象里面，而外部类对象则不一定有非静态内部类对象寄存在其中
，所以如果存在一个非静态内部类，这一定存在一个被他寄存的外部类对象，反之则不一定，
所以外部类对象访问非静态内部类成员时候，可能非静态普通内部类的对象根本不存在，反之则一定存在

public class Out{
      
        public static void main(String[] args) {
                        
                               
        Inner  intesd=new Out().new Inner();//这里需要使用外部类的实例
                
        }
                
        class Inner{
             
                Inner(){
                System.out.println("inner class");
                }      
        }
}

class Outer{
        class Inner{
             public void m(){
                System.out.println("cccc");
             }
        }
        public static void main(String[] args){//main是静态的
                Outer out=new Outer();
                Outer.Inner in=out.new Inner();//建内部类对象还要与外部类有关
                in.m();       
                out.n();
        }
       
        public void n(){//外部类的方法非静态，可以Inner i=new Inner();
                Inner i=new Inner();
                i.m();       
        }
}