什么是内部类:

在Java 1.1 中,可将一个类定义置入另一个类定义中。这就叫作“内部类”。内部类对我们非常有用,因为利用它可对那些逻辑上相互联系的类进行分组,并可控制一个类在另一个类里的“可见性”。

先看一个例子:

package c07.parcel1;
public class Parcel1
 {
  class Contents {
    private int i = 11;
    public int value() { return i; }
  }
  class Destination 
  {
    private String label;
    Destination(String whereTo) {
    Label = whereTo;
    }
    String readLabel() { return label; }
  }
  // Using inner classes looks just like
  // using any other class, within Parcel1:
  public void ship(String dest) {
    Contents c = new Contents();
    Destination d = new Destination(dest);
  }
  public static void main(String[] args) {
    Parcel1 p = new Parcel1();
    p.ship("Tanzania");
  }
}

若在ship()内部使用,内部类的使用看起来和其他任何类都没什么分别。在这里,唯一明显的区别就是它的名字嵌套在 Parcel1里面。但这其实并非唯一的区别。

更典型的一种情况是,一个外部类拥有一个特殊的方法,它会返回指向一个内部类的句柄。就象下面这样:

package c07.parcel2;
public class Parcel2 
{
  class Contents 
  {
    private int i = 11;
    public int value() { return i; }
  }
  class Destination 
  {
    private String label;
    Destination(String whereTo) {
    Label = whereTo;
    }
    String readLabel() { return label; }
  }
  public Destination to(String s) {
    return new Destination(s);
  }
  public Contents cont() {
    return new Contents();
  }
  public void ship(String dest) {
    Contents c = cont();
    Destination d = to(dest);
  }
  public static void main(String[] args) {
    Parcel2 p = new Parcel2();
    p.ship("Tanzania");
    Parcel2 q = new Parcel2();
    // Defining handles to inner classes:
    Parcel2.Contents c = q.cont();
    Parcel2.Destination d = q.to("Borneo");
  }
}

内部类分为四种:

1.成员内部类(member inner classes)

2.静态内部类(static inner classes)

3.局部内部类(local inner classes)

4.匿名内部类(anonymous inner classes)


1.成员内部类

成员内部类也是最普通的内部类,它是外围类的一个成员,所以他是可以无限制的访问外围类的所有成员属性和方法,尽管外围类的成员属性和方法是private的,但是外围类要访问内部类的成员属性和方法则需要通过内部类实例来访问。

*在成员内部类中要注意两点,第一:成员内部类中不能存在任何static的变量和方法;

第二:成员内部类是依附于外围类的,所以只有先创建了外围类才能够创建内部类。

public class Parcel1
 {
  class Contents 
  {
    Contents(){}
    public int value() { return i; }
  }
  class Destination 
  {
    private String label;
    Destination(String whereTo) {
      label = whereTo;
    }
    String readLabel() { return label; }
  }
  Private i=1;
  // Using inner classes looks just like
  // using any other class, within Parcel1:
  }
  public static void main(String[] args) {
    Parcel1 p = new Parcel1();
Parcel1.Contents c=p.new Contents();
Parcel1.Destination d=p.new Destination();
P.value();
  }
}


2.静态内部类(嵌套类)

static内部类意味着:

(1) 为创建一个 static内部类的对象,我们不需要一个外部类对象。

(2) 不能从 static内部类的一个对象中访问一个外部类对象。

但在存在一些限制:由于static成员只能位于一个类的外部级别,所以内部类不可拥有static 数据或static内部类。

public class OuterClass {
    private String sex;
    public static String name = "chenssy";
    
    /**
     *静态内部类
     */
    static class InnerClass1{
    
        /* 在静态内部类中可以存在静态成员 */
        public static String _name1 = "chenssy_static";
        
        public void display(){
            /* 
             * 静态内部类只能访问外围类的静态成员变量和方法
             * 不能访问外围类的非静态成员变量和方法
             */
            System.out.println("OutClass name :" + name);
        }
    }
    
    /**
     * 非静态内部类
     */
    class InnerClass2{
        /* 非静态内部类中不能存在静态成员 */
        public String _name2 = "chenssy_inner";
        /* 非静态内部类中可以调用外围类的任何成员,不管是静态的还是非静态的 */
        public void display(){
            System.out.println("OuterClass name:" + name);
        }
    }
    
    /**
     * @desc 外围类方法
     * @author chenssy
     * @data 2013-10-25
     * @return void
     */
    public void display(){
        /* 外围类访问静态内部类:内部类. */
        System.out.println(InnerClass1._name1);
        /* 静态内部类 可以直接创建实例不需要依赖于外围类 */
        new InnerClass1().display();
        
        /* 非静态内部的创建需要依赖于外围类 */
        OuterClass.InnerClass2 inner2 = new OuterClass().new InnerClass2();
        /* 方位非静态内部类的成员需要使用非静态内部类的实例 */
        System.out.println(inner2._name2);
        inner2.display();
    }
    
    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        outer.display();
    }
}

结果:

chenssy_static

OutClass name :chenssy

chenssy_inner

OuterClass name:chenssy


3.局部内部类

在方法中或一个作用域中定义的内部类称为局部内部类。与局部变量类似,局部内部类不能有访问说明符不能定义为public,protected,private或者static类型,因为它不是外围类的一部分,但是它可以访问当前代码块内的常量和此外围类所有的成员。只能访问final类型的变量

例子:

class LocalInner{
public void execute(){
        final int a = 1;
        /** * 创建局部内部类 */
        class InnerClass{
            public void execute(){
                System.out.println("LocalInner Class");
 
                //局部内部类只能访问final类型的变量
                System.out.println(a);
            }
        }
        //只能在所在方法区域创建
        new InnerClass().execute();
}
    public static void main(String[] args) {
        //外部不能直接创建局部内部类
        LocalInner localInner = new LocalInner();
        localInner.execute();
    }
}


4.匿名内部类

匿名内部类没有类名,没有class关键字也没有extends和implements等关键字修饰。

匿名内部类会隐式地继承一个父类或实现一个接口。

匿名类:

 一个匿名类,用于实现一个接口

 一个匿名类,用于扩展拥有非默认构建器的一个类

 一个匿名类,用于执行字段初始化

 一个匿名类,通过实例初始化进行构建(匿名内部类不可拥有构建器)

示例:

public static void main(String[] args) {
    AnonymousInnerClassTest test = new AnonymousInnerClassTest();
    /** * 创建匿名内部类 * 生成的类名:AnonymousInnerClassTest$1 */
    test.print(new Date(){
        //重写toString()方法
        @Override
        public String toString() {
            return "Hello world.";
        }
    });
    JButton button = new JButton();
    /** * 创建匿名内部类 * 该匿名内部类实现ActionListener接口 * 生成的类名:AnonymousInnerClassTest$1 */
    button.addActionListener(new ActionListener(){
        //实现接口中的方法
        @Override
        public void actionPerformed(ActionEvent e) {
            System.out.println("使用匿名内部类实现ActionListener接口");
        }
    });
}
public void print(Date date){
    System.out.println(date);
}

借鉴部分的博客链接:

http://www.cnblogs.com/chenssy/p/3388487.html


http://www.itzhai.com/java-based-notebook-a-static-inner-class-within-a-class-member-within-the-class-of-local-inner-classes-anonymous-inner-classes.html#read-more