内部类总结

• 定义：指在一个外部类的内部再定义一个类。

1.  内部类方法可以访问该类定义所在的作用域中的数据，包括私有数据。
2. 内部类可以对同一个包中的其他类隐藏起来。
3. 当想要定义一个回调函数且不想编写大量代码时，使用匿名内部类比较便捷。
4. 内部类是一个编译时的概念，一旦编译成功，就会成为完全不同的两类。对于一个名为outer的外部类和其内部定义的名为inner的内部类。编译完成后出现outer.class和outer$inner.class两类。所以内部类的成员变量/方法名可以和外部类的相同。

 

• 使用内部类访问对象状态

　　内部类可以是静态static的，也可用public，default，protected和private修饰，而常规的类只能具有包的可见性（default），或公有的可见性（public）。

　　内部类的对象有一个隐式引用（这个引用在内部类的定义中是不可见的），它引用了实例化该内部类对象的外围类对象。通过这个指针，可以访问外围类对象的全部状态。

　　所以，内部类既可以访问自身的数据域，也可以访问创建它的外围类对象的数据域。

•  内部类的特殊语法规则

　　使用外围类引用的正规语法：

　　OuterClass.this

　　可以采用下列语法格式更加明确地编写内部对象的构造器：

　　OuterObject.new InnerClass(construction parameters)

　　在外围类的作用域之外，可以这样引用内部类：

　　OuterClass.InnerClass

 

• Java中内部类共分为四种：

静态/嵌套内部类 static inner class (also called nested class)

成员内部类 member inner class

局部内部类 local inner class

匿名内部类 anonymous inner class

 

---

 

 

静态/嵌套内部类 static inner class (also called nested class)

1. 最简单的内部类形式。
2. 类定义时加上static关键字。不需要内部类对象和外部类对象之间的联系，可直接引用outer.inner，即不需要创建外部类，也不需要创建内部类。
3. 不能和外部类有相同的名字。
4. 只可以访问外部类的静态成员和静态方法，包括了私有的静态成员和方法。
5. 嵌套类和普通的内部类还有一个区别：普通内部类不能有static数据和static属性，也不能包含嵌套类，但嵌套类可以。而嵌套类不能声明为private，一般声明为public，方便调用。
6. 注意，声明在接口中的内部类自动成为public和static。

 

声明静态内部类对象的方式为：

OuterClass.InnerClass inner = new OuterClass.InnerClass();

 

public class StaticInner {
    static int a=1;
    int b=2;
    /*  也可在外部类里生成内部类对象：
     * StaticInner.Inner inner = new StaticInner.Inner();
     */
    //定义一个内部类
    public static class  Inner{
        int a = 3;
        int b = 4;
        public void display(){
            System.out.println(a);//此时调用Inner类中的a
            System.out.println(StaticInner.a);//此时调用StaticInner类中的a
            System.out.println(b);//此时调用Inner类中的b
        }
    }
    
    public static void main(String[] args) {
        /*  声明静态内部类对象的方式为
         * OuterClass.InnerClass name = new OuterClass.InnerClass();
         */
        StaticInner.Inner inner = new StaticInner.Inner();
        inner.display();
    }

}

 

3
1
4

 

 

---

 

成员内部类Member Inner Class

1. 定义时不用static修饰，成员内部类就像一个实例变量。
2. 成员内部类不能含有static的变量和方法，因为成员内部类需要先创建了外部类，才能创建它自己的。
3. 可直接使用外部类的所有变量和方法，不管是静态的还是非静态的都可以，即使是private的。
4. 外部类要访问内部类的所有成员变量/方法，则需要通过内部类的对象来获取。

 

在外部类里面创建成员内部类的实例：

this.new Innerclass();

在外部类之外创建内部类的实例：

(new Outerclass()).new Innerclass();

在内部类里访问外部类的成员：                         访问外部类static成员：

Outerclass.this.member                           Outerclass.member

public class Outer {
    int a=0;
    int b=1;
    
    Inner inner = this.new Inner();// 在外部类里面创建成员内部类的实例
    
    //定义一个内部类
    public class Inner{
        int a = 2;
        public void display(){
            System.out.println(b);//直接访问外部类对象
            System.out.println(Outer.this.a);// 访问外部类成员
            
            System.out.println(a);// 访问内部类成员
            System.out.println(this.a);// 访问内部类成员
        }
    }
    
    public static void main(String[] args) {
        /*在外部类之外创建内部类的实例：
          Outer.Inner inner = new Outer().new Inner();
        */
        Outer outer = new Outer();
        outer.inner.display();
    }

}

1
0
2
2

 

 

 

---

 

局部内部类Local Inner Class

1. 局部内部类定义在方法中，比方法的范围还小。是内部类中最少用到的一种类型。
2. 像局部变量一样，不能被public, protected, private和static修饰。
3. 只能访问方法中定义的final类型的局部变量，对它进行初始化后不能够再修改。
4. 局部类的一个优势即对外部世界可以完全地隐藏起来。
5. 局部内部类在方法中定义，所以只能在方法中使用，即只能在方法当中生成局部内部类的实例并且调用其方法。

class LocalInner
{
    int a = 1;

    public void doSomething()
    {
        int b = 2;
        final int c = 3;
        // 定义一个局部内部类
        class Inner3
        {
            public void test()
            {
                System.out.println("Hello World");
                System.out.println(a);

                // 不可以访问非final的局部变量
                // error: Cannot refer to a non-final variable b inside an inner
                // class defined in a different method
                // System.out.println(b);

                // 可以访问final变量
                System.out.println(c);
            }
        }

        // 创建局部内部类的实例并调用方法
        new Inner3().test();
    }
}

public class LocalInnerClassTest
{
    public static void main(String[] args)
    {
        // 创建外部类对象
        LocalInner inner = new LocalInner();
        // 调用外部类的方法
        inner.doSomething();
    }

}

点击查看代码

Hello World
1
3

 

---

 

匿名内部类Anonymous Inner Class

1. 假如只创建这个类的一个对象，就不必为它命名了，这种没有名字的局部内部类被称为匿名内部类。

   　通常的语法格式为：

   　　new SuperType(construction parameters)

   　　{

         　　 inner class methods and data

   　　}

   　SuperType可以是类也可以是接口，匿名内部类隐式地继承了一个父类或者实现了一个接口。

2. 不能加访问修饰符，不使用关键字class, extends, implements。
3. 由于构造器的名字必须和类名相同，而匿名类没有类名，所以匿名类不能有构造器。
4. 匿名内部类中使用的外部局部变量是final变量。
5. 匿名内部类使用得比较多，通常是作为一个方法参数。

import java.util.Date;

public class AnonymouseInnerClass
{

    @SuppressWarnings("deprecation")
    public String getDate(Date date)
    {
        return date.toLocaleString();

    }

    public static void main(String[] args)
    {
        AnonymouseInnerClass test = new AnonymouseInnerClass();

        // 打印日期：
        String str = test.getDate(new Date());
        System.out.println(str);
        System.out.println("----------------");

        // 使用匿名内部类
        String str2 = test.getDate(new Date()
        {
        });// 使用了花括号，但是不填入内容，执行结果和上面的完全一致
            // 生成了一个继承了Date类的子类的对象
        System.out.println(str2);
        System.out.println("----------------");

        // 使用匿名内部类，并且重写父类中的方法
        String str3 = test.getDate(new Date()
        {

            // 重写父类中的方法
            @Override
            @Deprecated
            public String toLocaleString()
            {
                return "Hello: " + super.toLocaleString();
            }

        });

        System.out.println(str3);
    }
}

 生成的.class文件中，匿名类会生成OuterClass$1.class文件，数字根据是第几个匿名类而类推。

 

 

---

 

 

参考网站：

http://android.blog.51cto.com/268543/384844/

http://www.cnblogs.com/mengdd/archive/2013/02/08/2909307.html