早上起来，逛论坛时看到一个关于内部类的问题。这里就不说是什么问题了，只是突然想到把内部类相关的内容来个彻底整理一下。于是我通过看自己的笔记跟在网上查找相关资料，整理了一下并发表在我的博客里：http://tangjian211085.blog.163.com/blog/static/224949027201431910315830/

但还是有几点没搞明白，我写了如下代码：
interface A
{
}

class B implements A
{
        class C implements A
        {
        }
        public void show()
        {
                class D implements A
                {
                }
        }
}

public class Test
{
        public void main(String[] args)
        {
                new B();
        }
}
以上代码是我看到这样一段话后想到写来测试一下的：每个内部类都能独立地继承自一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。编译通过，运行也不报错。
但是还有一句话就怎么理解了：接口解决了部分问题，而内部类有效地实现了“多重继承”。

另外，我在方法public void show()里加了几条语句如下：
public void show()
{
        static final int i = 10;
        class D implements A
        {
                public void seeOut()
                {
                        int a = i;
                }
        }
}
编译报错，static final int i = 10;非法的表达式开始。为什么不能加静态？（这里有人问过，没明白，这里再问一次。）好，这里可以理解为在非静态方法里不能有静态的成员。那么下面有该如何解释呢：
static public void show()
{
        static final int i = 10;
        class D implements A
        {
                public void seeOut()
                {
                        int a = i;
                }
        }
}
同样，还是报static final int i = 10;非法的表达式开始。
        

igi9009 发表于 2014-4-19 12:29
static修饰的变量，任何一个类的实例对象都可以访问，是共享的。而方法中声明的变量都是局部的，方法执行完 ...

明白。谢啦

static修饰的变量，任何一个类的实例对象都可以访问，是共享的。而方法中声明的变量都是局部的，方法执行完后就要销毁,释放缓存空间的，这与static的本意背道而驰。所以不能在方法里建立，只能在类里建立。把语句移到方法外就可以了，程序如下。

1. public  class InterfacetTest {
   
2.         interface A
   
3.         {
   
4.         }
   
5. 
   
6.          static class B implements A
   
7.         {static final int i = 10;
   
8.                   class C implements A
   
9.                 {
   
10.                           
    
11.                 }
    
12.                   public void show()
    
13.                 {               
    
14. 
    
15.                          class D implements A
    
16.                         {
    
17.                                  public void seeOut()
    
18.                             {
    
19.                                     int a = i;
    
20.                             }
    
21. 
    
22.                         }
    
23.                 }
    
24.         }
    
25. 
    
26.         public class Test
    
27.         {
    
28.                 public void main(String[] args)
    
29.                 {
    
30.                         new B();
    
31.                 }
    
32.         }
    
33. 
    
34. 
    
35. }

复制代码

静态的域（数据成员）、静态的方法都是属于类一级的。
  什么是类呢？把一些对象共有特征(属性或者数据成员)和行为(方法)抽象归纳起来，定义一下,取个名字，这就是类的基本含义了。既然是所有这一类对象共有东东，为什么非要创建对象才能调用了，麻烦哦，于是JAVA直接用（类名.方法）、（类名.数据成员）的形式就可以调用。也就是大家常说的，静态域相当于C语言的全局变量.既然加了static的变量是类一级数据成员，有什么理由放在一个方法里面。方法里面的应该是局部的只有本方法才会用的，在方法里面声明一个类一级的数据成员有何意义了，相反，对以后代码的查错和再读都不利。所以JAVA不允许这样做
   要提醒一下，不仅静成方法中不能声明静态数据成员，就算不是静态方法，其中照样不能声明静态数据成员。道理是一样的