黑马程序员----基础学习第十天

                                        ------- android培训、java培训、期待与您交流！ ----------

 

            

内部类是定义在另一个类中的类。使用内部类的主要原因有以下三点：

1. 内部类方法可以访问该类定义所在的作用域的数据，包括私有的数据；

2. 内部类可以对同一个包中的其他类隐藏起来；

3. 当想要定义一个回调函数且不想编写大量代码时，使用匿名内部类比较便捷。

内部类分为四种：

静态内部类(static inner classes)
成员内部类(member inner classes)
局部内部类(local inner classes)
匿名内部类(anonymous inner classes)

1、静态内部类(static inner classes)

最简单的内部类。

只能访问外部类的静态成员变量与静态方法。

生成静态内部类对象的方法：

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

1.1、相关使用例子：

静态内部类：

class StaticInner{

    private static int a = 1;

    /**

　　 * 静态内部类

 　　* 生成的类名：StaticInner$InnerClass

 　　*/

    public static class InnerClass{

        //静态内部类可以声明静态的成员变量，其他的内部类不可以

        private static int b = 1;

        public void execute(){

            //静态内部类只能访问静态程序

            System.out.println(a + b);

        }

    }

}

main方法中使用：

public static void main(String[] args) {

    //创建静态内部类

    StaticInner.InnerClass innerClass = new StaticInner.InnerClass();

    innerClass.execute();

}

2、成员内部类(member inner classes)：

成员内部类可以访问外部类的静态与非静态的方法和成员变量。

生成成员内部类对象的方法：

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

在局部内部类中访问外部类的成员变量的方法：

OuterClass.this.a;

2.1、相关使用例子：

成员内部类：

class MemberInner{

    private int a = 1;

    public void execute(){

        //在外部类中创建成员内部类

        InnerClass innerClass = this.new InnerClass();

    }

    /**

 * 成员内部类

 */

    public class InnerClass{

        //内部类可以创建与外部类同名的成员变量

        private int a = 2;

        public void execute(){

            //this引用的是内部类

            System.out.println(this.a);

            //在内部了中使用外部类的成员变量的方法

            System.out.println(MemberInner.this.a);

        }

    }

}

在main方法中使用：

public static void main(String[] args) {

    //创建成员内部类

    MemberInner.InnerClass innerClass = new MemberInner().new InnerClass();

    innerClass.execute();

}

3、局部内部类(local inner classes)：

类似于局部变量，不能定义为public，protected，private或者static类型。

定义方法中，只能方法中声明为final类型的变量。

3.1、相关使用例子：

局部内部类：

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();

    }

}

在main方法中使用：

public static void main(String[] args) {

    //外部不能直接创建局部内部类

    LocalInner localInner = new LocalInner();

    localInner.execute();

}

4、匿名内部类(anonymous inner classes)：

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

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

4.1、相关使用例子：

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);

}