匿名内部类，最全讲解

最新推荐文章于 2024-08-09 13:50:59 发布

李属实

最新推荐文章于 2024-08-09 13:50:59 发布

阅读量2.7k

点赞数 23

分类专栏：面向对象再理解文章标签： java 面向对象编程

本文链接：https://blog.csdn.net/qq_43660004/article/details/115640627

版权

面向对象再理解专栏收录该内容

1 篇文章 0 订阅

订阅专栏

匿名内部类讲解

1.定义

我们在使用对象的时候，假如对对象只使用一次，就定义为匿名对象。
同样，假如一个功能，单单指只靠方法是实现不了的。只能定义成一个类的形式，才能实现这个功能（就是我们所说的内部类）。但是这个功能使用的次数很少，定义为内部类有点吃力不讨好。所以我们就定义为匿名内部类，只有在需要使用的时候在初始化。
再理解：

匿名内部类，首先他一定是内部类。
再说为什么要是匿名内部类；
因为这个类我们使用的次数少，定义一个完整的类麻烦，而且用的次数少，所以定义一个匿名内部类，
简单又实惠

2.公式

A a = new A(){ 
//实现A中的抽象方法
 //或者重写A中的普通方法 
 };
 注:这个大括号里面其实就是这个内部类的代码,只不过是声明该内部类的同时就是要new创建了其对象, 
 并且不能反复使用,因为没有名字。 
 例如: 
 B是一个接口，依托于B接口创建一个匿名内部类对象 
 B b = new B(){ 
 //实现B中的抽象方法
  };

2.基本实现方式

依赖一个类（抽象类或普通类），或者接口实现
 * 1.依赖抽象类，一般是实现抽象类中的抽象方法，或者是重写父类方法。
 * 2.依赖普通类：重写父类的方法
 * 3.依赖接口；实现接口的方法。
 * 一般不在匿名内部类里重新定义方法。
 *

3.代码

/**
 * @author 赛
 * 2021-04-12-19:59
 */
public class UnNameClass {

    public static void main(String[] args) {
        //1.依赖普通类实现匿名内部类，主要就是重写父类方法。
        Student student = new Student() {
            @Override
            public void print1() {
                System.out.println("依赖普通类实现匿名内部类，一般用它来重写父类的方法。");
            }
        };
        student.print1();
        student.print2();

        System.out.println("---------------");

        //2.依赖抽象类实现匿名内部类。主要就是实现父类的抽象方法，或者是重写父类的普通方法
        Teacher teacher = new Teacher() {
            @Override
            public void test() {
                System.out.println("这是实现后的抽象方法");
            }
        };
        teacher.test();
        teacher.test2();

        System.out.println("---------------");

        //3.依赖接口实现匿名内部类
        CatClass cat = new CatClass();
        cat.test();

    }

}


//1.普通类
class Student {

    private int id = 10;
    private static String name = "sai";

    public void print1 () {
        System.out.println("非静态方法。");
    }

    public void print2 () {
        System.out.println("静态方法。");
    }

}

//2.抽象类
abstract class Teacher {

    private int id = 10;
    private static String name = "sai";

    //抽象方法
    public abstract void test ();

    //普通方法
    public void test2 () {
        System.out.println("这是普通的方法，既有声明也有实现。当然我也能被通过匿名内部类重写，但是现在还没被重写。");
    }

}

//3-1.接口
interface Cat {
    void display (int id);
}

//3-2.在这个类里面实现 依赖接口实现匿名内部类。
class CatClass {

    private int id = 100; //外部类属性
    private static String name = "sai";

    public void sai1 () {
        System.out.println("非静态方法");
    }
    public static void sai2 () {
        System.out.println("静态方法。");
    }

    //通过接口具体实现匿名内部类。将他放在这个方法里。
    public void test () {
        Cat cat = new Cat() {
            int id = 10; //匿名内部类的属性
            @Override
            public void display(int id) {
                System.out.println(id); //形参
                System.out.println(this.id); //匿名内部列的属性
                System.out.println(CatClass.this.id); //外部类属性

                sai1(); // 等价于 CatClass.this.sai1();
                sai2(); //等价于 CatClass.sai2();
            }

        };
        cat.display(1);
    }


}