匿名内部类的实现

匿名内部类是内部类的一种写法，一般实现的类只需要使用一次则可以使用匿名内部类来写。
其中两种情况可以使用匿名类部类 ：1 实现一个接口 2.实现抽象父类的抽象方法

首先我们看如果不使用匿名类部类的实现方式：

//首先定义一个接口
public interface MyInterface {
    void f();
}

//定义一个类叫Niming，成员方法的形参是接口对象
public class Niming {
    //成员方法
    public void Niming(MyInterface my){
        my.f();
    }
}

//定义一个实现类实现接口中方法。
public class Mympl implements MyInterface{
    public void f(){
        System.out.println("这是实现类的实现方法");
    }
}

//下面是测试类

public class Text2 {
    public static void main(String[] args) {
        Niming niming = new Niming();
        MyInterface my = new Mympl();
        niming.Niming(my);

    }
}

最后会输出：这是实现类的实现方法
上面这种事不使用匿名内部类的方法，通过定义一个接口实现类，实现接口后传入参数。
比较一下下面的匿名类部类的写法你会觉得代码简洁很多

下面是匿名内部类的写法：

//首先定义一个接口

public interface MyInterface {
    void f();
}

//定义一个类叫Niming，成员方法的形参是接口对象
public class Niming {
    //成员方法
    public void Niming(MyInterface my){
        my.f();
    }
}

//下面是测试类

public class Text2 {
    public static void main(String[] args) {
        Niming niming = new Niming();

        //实现MyInterface接口的类的一个对象（匿名类）的一个对象
        niming.Niming(new MyInterface() {
            //重写接口的抽象方法
            @Override
            public void f() {
                System.out.println("匿名内部类");                
            }
        });
    }
}

最后输出是：匿名内部类
比较上面那种，使用匿名内部类不需要再写一个实现类，直接通过new接口的方式然后自己实现该接口就行了，减少代码量
第二种使用匿名内部类的场景是实现抽象父类：

//首先定义一个抽象父类，抽象父类中有抽象方法
public abstract class Parent {
public abstract void f();
}

//定义一个测试类测试类中的成员方法的形参是抽象父类
public class Text3 {
public void text3(Parent parent){
    parent.f();
}
  public static void main(String[] args) {
    Text3 text3 = new Text3();
    text3.text3(new Parent() {  
        @Override
        public void f() {
            // TODO Auto-generated method stub
            System.out.println("抽象父类的实现");
        }
    });
}
}

最后输出的是:抽象父类的实现。
好了匿名内部类的两种实现基本上就是这样。