1.匿名内部类的定义

使用匿名内部类的两种的方法

• 建立父类，重写父类的方法
• 实现接口的方法

2.普通类的实现

1. 普通类实现

实现普通类需要先声明对一个类的对象，再调用对象的方法

建立一个example类

public void student() {
        System.out.println("学生在学习");
    }

声明类，并实现对应的方法,

public static void main(String[] args) {
        example example = new example();
        example.student();
    }

对应的输出

2.继承父类，重写父类的方法

继承上述的example类,建立example1类，重写父类的方法

public class example1 extends example {
    public void student() {
        System.out.println("学生在运动");
    }
}

在主类中实现其方法

public static void main(String[] args) {
        example example = new example1();
        example.student();
    }

对应的输出

3.普通类实现对应类的缺点

从以上两个例子，我们会发现，当实现一个类的时候，无法重写对应类中的方法。想要实现重写对应类的方法就必须要继承对应的类，重写对应类大方法，再在主类中调用子类，这样在想要实现某一次的父类方法时，就显得太繁重，因此可以使用匿名内部类的方法去实现一个的方法

3.匿名内部类的实现

1.主类中直接使用类

使用new 对应的类

依旧使用上述的example类做例子，在主类中

 public static void main(String[] args) {
       new example(){
           @Override
           public void student() {
               super.student();
           }
       }.student();
    }

对应的输出

2.在主类中通过接口实现匿名内部类

建立一个接口text

public interface text {
    void setName(String name);
}

建立一个类example2类，在其中引入text类

public class example2 {
    private int num1;
    private text text;
    public void setNum1(int num1) {
        this.num1 = num1;
    }
    public void setContent(text cellback) {
        text = cellback;
    }
    public void getresult(String name) {
        if (this.num1 == 1) {
            text.setName(name);
        }
    }
}

在主类中重写接口

public static void main(String[] args) {
        example2 example2 = new example2();
        example2.setContent(new text() {
            @Override
            public void setName(String name) {
                System.out.println(name);
            }
        });
        example2.setNum1(1);
        example2.getresult("ts");
    }

对应的输出

对应的实现过程为：在主类中设置对应num为1，触发example2中的getresult()方法，对应的name为“ts”，而主类中调用了setcontent()方法，使对应的子类中的接口对象的方法重写，对应的接口对象的setname()方法实现输出对应的name值。调用getresult()方法，触发接口的方法，输出name的值。

4.对应的优点

通过实现匿名内部类，可以实现重写接口的方法，在对应的子类中设置对应的触发条件，实现接口的方法。

实现对类的方法的重写，相较于继承类，对类的方法重写，使用匿名内部列更方便