Java内部类简介

1．定义

内部类是指在一个外部类的内部再定义一个类。
内部类作为外部类的一个成员，并且依附于外部类而存在的。
内部类可为static，可用public、protected、private修饰。（而外部类不可以：外部类只能使用public和default）。

2．分类

在一个类(外部类)中直接定义的内部类(成员内部类)、局部内部类、静态内部类、匿名内部类。

3．使用方法

1).在一个类中直接定义的内部类。

外部类不能直接访问内部类的的成员，但可以通过内部类对象来访问。内部类作为外部类的成员，可以访问外部类的所有成员。成员内部类与普通的成员没什么区别，可以与普通成员一样进行修饰和限制。

注意：内部类是一个编译时的概念，一旦编译成功，就会成为完全不同的两类。对于一个名为outer的外部类和其内部定义的名为inner的内部类。编译完成后出现outer.class和outer$inner.class两类。

public classOuter {
    int outer_x = 100;
    class Inner{
        //局部变量,其范围为定义它的代码块(不受修饰符的影响)。
        public int y = 10;
        private int z = 9;
        int m = 5;
        //static int k=1;//内部类中不允许定义静态变量,除非内部类为静态内部类
        public void display1(){
            System.out.println("display outer_x:"+outer_x);
        }
        private void display2(){
            System.out.println("display outer_x:"+outer_x);
        }
    }
    void test(){
        Inner inner = new Inner();
        inner.display1();
        inner.display2();
        System.out.println("Inner y:"+ inner.y);//可以访问
        System.out.println("Inner z:"+ inner.z);//可以访问
        System.out.println("Inner m:"+ inner.m);//可以访问
    }
    public static void main(String args[]) {
        Outer outer = new Outer();
        outer.test();
    }
}

2). 在一个方法中定义的内部类

在方法中定义的内部类称为局部内部类。与局部变量类似，在局部内部类前不加修饰符public和private，其范围为定义它的代码块。其他用法和成员内部类相同。

3). 静态内部类

静态内部类：不能访问外部类的非静态成员，这是由Java语法中"静态方法不能直接访问非静态成员"所限定。若想访问外部类的变量，必须通过其它方法解决，由于这个原因，静态嵌套类使用很少。

静态内部类其实已经脱离了外部类。在创建静态内部类对象时也不需要外部类对象的存在。其实质是一个放置在别的类内部的普通类。而关键字static也只是说明其在创建对象时不依赖于外部类对象的存在，并不是说这个类本身是静态的。

·静态内部类与前面所讲的两种非静态内部类的语法基本相同。区别主要是在内部类的声明前面要加上static关键字。

·静态内部类的对象可以直接生成，而不需要外部类的对象来生成，这样实际上是使静态内部类成为了一个顶级类。这主要是因为静态内部类是外部类的静态成员，并不依赖于外部类的对象而存在。

·静态内部类与非静态内部类的区别是本质上的。非静态内部类是外部类对象组成的一部分，主要是辅助外部类对象工作的，与外部类对象存在成员变量的共享关系。

4)．匿名类

匿名内部类是一种特殊的局部内部类，这种内部类没有类名。该类适用于只使用一次并且不需要多次创建对象的类。使用匿名内部类可以使类代码与创建对象同时完成，这样做不但方便，还提高代码的可维护性。

·匿名内部类是唯一一种没有构造方法的类。正因为其没有构造方法，所以匿名内部类的使用范围非常有限。

·大部分匿名内部类用于接口回调。

·匿名内部类不能定义任何静态成员、方法和类

·匿名内部类在编译的时候由系统自动起名为Out$1.class

·匿名内部类用于继承其他类或是实现接口，并不需要增加额外的方法，只是对继承方法的实现或是重写。

语法规则：new <类或接口> <类的主体> 

interface pr {
    void print1();  
}  
public classNoNameClass {
    public pr dest() {
        //这个用法的作用是：创建一个对象的实例，并且override它的一个函数,然后返回。
        return new pr() {
        public void print1() {
             System.out.println("Hello world!!");  
            }  
        };  
   }  
 
   publicstaticvoidmain(String args[]) {
    NoNameClass c=new NoNameClass();  
        pr hw=c.dest();  
        hw.print1();  
   }  
}

备注：静态内部类和非静态内部类的区别

public classMyMain{
   privatestaticStringname= "woobo";
   privateStringnum= "X001";
 
   // 静态内部类可以用public,protected,private修饰
   staticclassPerson {
        // 静态内部类中可以定义静态或者非静态的成员
        private Stringaddress = "China";
        private static String x = "as";
        public Stringmail = "kongbowoo@yahoo.com.cn";//内部类公有成员
 
        public void display() {
            // System.out.println(num);//不能直接访问外部类的非静态成员
            // 静态内部类不能访问外部类的非静态成员(包括非静态变量和非静态方法)
            System.out.println(name);//只能直接访问外部类的静态成员
            // 静态内部类只能访问外部类的静态成员(包括静态变量和静态方法)
            System.out.println("Inner " +address);// 访问本内部类成员。
        }
   }
 
   publicvoidprintInfo() {
        Person person = new Person();
        // 外部类访问内部类的非静态成员:实例化内部类即可
        person.display();
        // System.out.println(mail);//不可访问
        // System.out.println(address);//不可访问
        System.out.println(person.address);//可以访问内部类的私有成员
        System.out.println(Person.x);//外部类访问内部类的静态成员：内部类.静态成员
        System.out.println(person.mail);//可以访问内部类的公有成员
   }
 
   publicstaticvoidmain(String[] args) {
        MyMain staticTest = new MyMain();
        staticTest.printInfo();
   }
}

1. 嵌套类的静态类对象，并不需要其外围类的对象。即它可以不依赖于外部类实例被实例化。

2. 不能从嵌套类的静态类中访问非静态的外围类对象。这是由Java语法中"静态方法不能直接访问非静态成员"所限定。

3. 外部类访问内部类的的成员有些特别,不能直接访问,但可以通过内部类实例来访问, 这是因为静态嵌套类的所有成员和方法默认为静态的了.同时注意,内部静态类Person只在类StaticTest范围内可见,若在其它类中引用或初始化, 均是错误的.

4 .静态内部类可以有静态成员，而非静态内部类则不能有静态成员。

5. 静态内部类的非静态成员可以访问外部类的静态变量，而不可访问外部类的非静态变量；

6 . 非静态内部类的非静态成员可以访问外部类的非静态变量。

    生成一个静态内部类不需要外部类成员：这是静态内部类和成员内部类的区别。静态内部类的对象可以直接生成：Outer.Inner in = new Outer.Inner();而不需要通过生成外部类对象来生成。这样实际上使静态内部类成为了一个顶级类(正常情况下，你不能在接口内部放置任何代码，但嵌套类可以作为接口的一部分，因为它是static的，只是将嵌套类置于接口的命名空间内，这并不违反接口的规则）

转自：http://www.cnblogs.com/devinzhang/archive/2012/01/11/2319193.html