java中的内部类和匿名内部类的使用

部分内容参考http://www.imooc.com/

内部类：

什么是 Java 中的内部类

问：什么是内部类呢？

答：内部类（ Inner Class ）就是定义在另外一个类里面的类。与之对应，包含内部类的类被称为外部类。

问：那为什么要将一个类定义在另一个类里面呢？清清爽爽的独立的一个类多好啊！！

答：内部类的主要作用如下：

1. 内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类

2. 内部类的方法可以直接访问外部类的所有数据，包括私有的数据

3. 内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便，重写外部类的方法

问：内部类有几种呢？

答：内部类可分为以下几种：

1. 成员内部类

2. 静态内部类

3. 方法内部类

4. 匿名内部类

下面是一个内部类例子

//外部类HelloWorld
public class HelloWorld {

    // 内部类Inner，类Inner在类HelloWorld的内部
    public class Inner {

        // 内部类的方法
        public void show() {
            System.out.println("welcome to imooc!");
        }
    }

    public static void main(String[] args) {

        // 创建外部类对象
        HelloWorld hello = new HelloWorld();
        // 创建内部类对象
        Inner i = hello.new Inner();
        // 调用内部类对象的方法
        i.show();
    }
}

匿名内部类:

是不能有名称的类，所以没办法引用它们。必须在创建时，作为new语句的一部分来声明它们。这就要采用另一种形式的new语句，如下所示： new <类或接口> <类的主体>

作用是：

1.和内部类一样，可以对外部类进行扩展，重写或新增加方法。

2.用于实现接口

3.没有类名

//新建一个接口
public interface Animal {
    void eat();

    void sleep();
}

//新建一个类，在类里面使用 内部类和内部匿名类去实现接口
public class Zoo {
    private class Tiger implements Animal {
        public void eat() {
            System.out.println("tiger eat");
        }

        public void sleep() {
            System.out.println("tiger sleep");
        }
    }

    /**
     *  这里不明白，Animal不是接口么，怎么可以定义方法？
     *  ---答案 接口可以作为返回类型,指定返回的类型必须是实现当前接口的类.
     * @return
     */

    /**
     * // 由于接口不是不能实例化的，所以必须通过类来实现，这里使用返回一个（已实现该接口的对象）
     * 具体写法有两种，写法2容易理解
     * @return
     */
    //---------------------------写法1-----匿名内部类--------------------------------
    Animal getAnimal1(){
        return new Animal(){
            public void eat() {
                System.out.println("---1---animal eat");
            }

            public void sleep() {
                System.out.println("---1---animal sleep");
            }
        };
    }

    //---------------------------写法2------内部类--------------------------
    Animal getAnimal2(){
        return new TempAnimal();
    }

    class TempAnimal implements Animal{
        int a = 0;
        public void eat() {
            System.out.println("---2---animal eat");
        }

        public void sleep() {
            System.out.println("---2---animal sleep");
        }   
    }

}

//新建一个测试类
public class Test {
    public static void main(String[] args) {
        Zoo z = new Zoo();
        Animal an = z.getAnimal1();
        an.eat();
        an.sleep();

        Animal one = z.getAnimal2();
        one.eat();
        one.sleep();
    }
}

匿名内部类是内部类的一种简化写法：return new Wrapper{...};等价于：Wrapped extends Wrapper{...}return new Wrapped();难道匿名内部类就只这一点作用吗？考虑一下这样的case:

interface ICount {
    int count();
}

class Parent {
    int i = 0;

    int count() {
        return i++;
    }
}
有一个类Child，它既想继承Parent的count()方法，又想实现ICount接口中的count方法，这个时候怎么办呢？内部类就可以大显身手了：

class Child extends Parent {
    ICount getCount() {
        return new ICount {
            int i = 0;

        int count() {
            return (i *= 2);
        }
    }
}