语法格式：

new 类名或者接口名(){
    重写方法;
} ;

public class MyTest {
    public static void main(String[] args) {
 
        new Father() {             //new了一个父类抽象类的子类对象.匿名的
            @Override
            //重写了父类中的抽象方法
            public void hehe() {
                System.out.println("呵呵呵呵呵呵");
            }
        };
 
        //创建了父类的子类对象并且调用重写后的方法
        new Father() {
            @Override
            public void hehe() {
                System.out.println("44444444444444");
            }
        }.hehe();
    }
}
 
abstract class Father {
    public abstract void hehe();
}

给匿名内部类名命: 虽然这是匿名内部类,但是仍然可以利用多态来给匿名内部类名命的哈!

public class MyTest {
    public static void main(String[] args) {
        //匿名内部类
        new AA() {
            @Override
            public void aa() {
                System.out.println("aaaaaaaaaaaaaaaa");
            }
 
            @Override
            public void hehe() {
                System.out.println("hehehehehehhehehhe");
            }
        };
        //此时,要想用同一个对象调用多个方法时,就会很难办到.这个时候给匿名内部类名命就可以解决了!
        //利用多态进行名命
        AA aa = new AA() {
            @Override
            public void aa() {
                System.out.println("aaaaaaaaaaaaaa744444aa");
            }
 
            @Override
            public void hehe() {
                System.out.println("hehehehehe888877777hhehehhe");
            }
        };
        //这样就可以调用多个方法了
        aa.aa();
        aa.hehe();
 
    }
}
 
abstract class AA {
    public abstract void aa();
 
    public abstract void hehe();
}

匿名内部类的好处: 匿名内部类，经常作为参数，或返回值，使用比较方便。

public class MyTest {
    public static void main(String[] args) {
        //匿名内部类，经常作为参数，或返回值，使用比较方便。
       
        test(new WW() {
            @Override
            public void hehe() {
                System.out.println("111111111");
            }
        });
    }
 
    //方法的形参要一个抽象类类型，传递一个该抽象类的子类对象.
    public static void test(WW ww) {
        ww.hehe();
    }
}
 
 
abstract class WW {
    public abstract void hehe();
}

public class MyTest {
 
    public static void main(String[] args) {
        BB bb = getBB();
        bb.bb();
 
        //匿名内部类，作为返回值，返回方便
    }
 
    //方法的返回值是一个抽象类 类型，返回一个该抽象类的子类对象。
    public static BB getBB2() {
        BB b2 = new BB() {
 
            @Override
            public void bb() {
                System.out.println("bbbbbbbbbbbbbbbbb222222222");
            }
        };
        //匿名内部类，作为返回值，返回方便
        return b2;
    }
}
 
abstract class BB {
    public abstract void bb();
}

一个类中可以嵌套一个接口:

public class MyTest2 {
    public static void main(String[] args) {
        new Inter() {
            public void show() {
                //this 代表匿名内部类
                System.out.println(this.a);          
                System.out.println(Inter.a);         
 
 
            }
        }.show();
 
    }
}
 
 
interface Inter {
    public static final int a = 23;
}