JavaSE-匿名内部类

说明

匿名内部类就是没有名称的内部类，在调用包含有接口类型参数的方法时，可以直接通过匿名内部类的形式传入一个接口类型的参数，在匿名内部类中直接完成方法的实现。

当某个抽象类或接口只有一个抽象方法的时候，不想通过子类或者实现类来进行定义时，就可以通过匿名内部类实现了。

抽象类的匿名内部类

public class Demo {
    public static void main(String[] args) {
        /*
        格式：
        new 类名/接口名(){
            重写抽象方法
        }
         */
        //传统方法
        Dog d = new Dog();
        d.eat();
        //此时感觉Dog类定义起来很麻烦而且没有意义，因为我们的目的仅仅是调用这个方法
        /*
        new Animal(){

        }
        整体等效于Animal父类的子类对象,这样就不用创建实现类或者子类了
         */
        new Animal(){
            public void eat(){
                System.out.println("吃");
            }
        };
        //调用方式1：类.方法
        new Animal(){
            public void eat(){
                System.out.println("吃");
            }
        }.eat();
        //调用方式2：用父类引用指向这个对象
        Animal a = new Animal(){
            public void eat(){
                System.out.println("吃");
            }
        };
        a.eat();
        
        //注意一点，在JDK8版本之前，必须加final关键字，之后不需要加了，但在匿名内部类用到的变量也不允许更改值
        String name = "泰迪";
        //name = "二哈";     
        new Animal(){
            public void eat(){
                System.out.println(name+"吃");
            }
        };


    }
}

abstract class Animal{
    public abstract void eat();
}

class Dog extends Animal{
    public void eat(){
        System.out.println("吃");
    }
}

接口的匿名内部类

public class Demo {
    public static void main(String[] args) {
       //传统方法
        Dog d = new Dog();
        d.eat();

        //匿名内部类
        //相当于实现类
        new Animal(){
            public void eat(){
                System.out.println("吃");
            }
        };

        //调用方式1：
        new Animal(){
            public void eat(){
                System.out.println("吃");
            }
        }.eat();

        //调用方式2：
        Animal c = new Animal() {
            @Override
            public void eat() {
                System.out.println("吃");
            }
        };
        c.eat();
    }
}

interface Animal{
    public abstract void eat();
}

class Dog implements Animal{
    public void eat(){
        System.out.println("吃");
    }
}

匿名内部类的作用

常在作为参数时进行传递

public class Demo {
    public static void main(String[] args) {
       //传统方法
        Dog d = new Dog();
        d.eat();

        //匿名内部类
        //相当于实现类
        new Animal(){
            public void eat(){
                System.out.println("吃");
            }
        };

        //调用方式1：
        new Animal(){
            public void eat(){
                System.out.println("吃");
            }
        }.eat();

        //调用方式2：
        Animal c = new Animal() {
            @Override
            public void eat() {
                System.out.println("吃");
            }
        };
        c.eat();
        
        /*
        在以前，想要调用这个以接口引用类型为参数的方法，需要创建实现类
        Dog d = new Dog();
        或者
        Animal an = new Animal();
        method(d);接口看作是父类，所以可以传子类类型
        method(an);
        
        But NOW！通过这种方式传递
         */
        method(new Animal() {
            @Override
            public void eat() {
                System.out.println("吃");
            }
        });
        
    }
    
    public static void method(Animal an){
        an.eat();
    }
}

interface Animal{
    public abstract void eat();
}

class Dog implements Animal{
    public void eat(){
        System.out.println("吃");
    }
}

总结：

当抽象类或者接口中只有一个抽象方法时，通常用匿名内部类，并且常常用在传递接口或者抽象类型的引用类型参数时使用。