我们知道静态是不能访问非静态的  大家看下面这个程序  ：

class Demo
{       
        public void func()
        {
              new  Inner();  // 正确               
        }
        class Inner{}
        public static void main(String[] args)
        {
                Demo d=new Demo();
                        new Inner();//不可以   
        }
}

我的问题是  红色的new Inner(0是不可以的  因为静态的不能访问非静态的  但是Demo d=new Demo();可以  我想说的是  是不是由于内部类可以被static修饰   外部类不可以被static修饰  所以  导致了同样是new一个对象   内部类在主函数中new必须是静态内部类  外部类就没有这个概念呢?

不是那样的。

要取得内部类的实例必须先实例化一个外部类的对象 然后用这个外部类的对象来实例化内部类

所以你的代码可以改成：

1. class Demo
   
2. {        
   
3.          public void func()
   
4.          {
   
5.                new  Inner();  // 正确               
   
6.          }
   
7.          class Inner{}
   
8.          public static void main(String[] args)
   
9.          {
   
10.                  Demo d=new Demo();
    
11.                  //new Inner();//不可以   
    
12.                  d.new Inner();   //这样就可以引用内部类了 。
    
13.          }
    
14. }

复制代码

唐志兵 发表于 2012-6-12 15:36
不是那样的。

要取得内部类的实例必须先实例化一个外部类的对象 然后用这个外部类的对象来实例化内部类

  我的重点不是在这里  我就想问  为什么在主函数中new一个不是静态的内部类不行   new一个外部类就可以

李海 发表于 2012-6-12 15:50
我的重点不是在这里  我就想问  为什么在主函数中new一个不是静态的内部类不行   new一个外部类就可以 ...

main函数中是可以引用一个内部类的 不管这个内部类是不是静态的，你可能没有看懂我说的那句话。

要取得内部类的实例必须先实例化一个外部类的对象 然后用这个外部类的对象来实例化内部类

你要再main函数中 引用内部类  因为这个内部类不是静态的，所以你是不是需要先把外部类实例化了，然后利用外部类的引用在实例化里面的内部类。

1. Inner in = new domo().new Inner();

复制代码

class Demo
{        
               public void func()
               {
                       new  Inner();  // 正确               
               }
               class Inner{}
               public static void main(String[] args)
               {
                       Demo d=new Demo();
                       new Inner();    //不可以
                       new Test().method();    //这样可以
               }
}

class Test {
              public void method() {               
                      System.out.println("Hello");
              }        
}

原因：你知道静态方法只能访问静态成员，OK？
没有说对象吧，new Inner();是不是一个对象？这里为什么不能访问，这是内部类的特点，如上面哥们说的那样
不是静态的，在这里你想访问，就要先创建外部类对象new Demo().new Inner();才OK

静态和非静态在加载到内存中存在差异，静态是随着类加载，非静态是对象创建后调用才加载。所以静态不能访问非静态。在主函数中可创建普通类的对象，不能创建内部类对象我觉得可以理解为是一种封装性的体现。对内部类实现了隐藏。如果要访问就要通过外部类对象。当内部类被static修饰是成为了静态的，加载上优先。不知是否理解了您的意思。

其实这里我感觉这样说更容易理解：
main（）方法是一个静态代码块，是不依附于类存在可，如你上面的代码，完全可以把main方法换到另外一个类中，
所以我们可以向main（）方法在另外一个类中，如果要在这个main（）方法中调用你定义的内部类，如果直接这样
new Inner（）；肯定是找不到报错的。这是就应该明白要先找到包含这个内部类的类，就是你的Demo类，然后再通过
这个类找到内部类Inner，体现在代码上就是，Inner in = new Domo().new Inner();
这个问题主要是理解静态的main（）方法是程序的入口是，静态的独立于类存在的。这样就很容易理解为什么要通过外部类来new内部类了
希望能加技术分，急需分数报名考试

唐志兵 发表于 2012-6-12 16:02
main函数中是可以引用一个内部类的 不管这个内部类是不是静态的，你可能没有看懂我说的那句话。

要取得 ...

  恩   你这种情况  是正确的  但是  我现在把代码改成这样：
class Demo
{        
        public void func()
        {
              new  Inner();  // 正确               
        }
       static  class Inner{}  //我把内部类静态了          public static void main(String[] args)
        {
                Demo d=new Demo();
                        new Inner();//不可以 现在变成可以了        }
}

我的问题还是  为什么在主函数中new一个不是静态类就不行  new一个外部类就可以  是不是内部类可以被static修饰的原因   还有你看清楚的是  内部类和主函数在同一个类中  没必要还把外部类实例化来引用内部类吧？

首先内部类也是属于外部类的一个成员，只不过他是一个比较特殊的成员
作为成员我们调用的时候都应该遵循 静态是不能调用非静态成员的规则

1. class DayDemo
   
2. {
   
3.         class Demo //定义一个非静态成员内部类
   
4.         {
   
5.                 public void show()
   
6.                 {
   
7.                         System.out.println("内部类Demo！");
   
8.                 }               
   
9.         }
   
10.         int a =1; //定义一个非静态成员变量
    
11.         public static void main(String[] args)
    
12.         {
    
13.                 new DayDemo();
    
14.                 new DayDemo().new Demo();
    
15.                 //a = 10;        这里的两处调用都是非静态的，所以不会编译通过
    
16.                 //new Demo();
    
17.         }
    
18. 
    
19. }

复制代码