java 匿名内部类整理

转载：
https://blog.csdn.net/weixin_33824385/article/details/114452126
匿名内部类之间的写法也项目中用过和见过，但是一直没有对这这种写法有个全面的认识，也怪自己基础太差。最近终于知道了，原来有个专业的称呼：匿名内部类。感觉其他网友也总结的挺好的，就奉行拿来主义，直接转载吧，也算个整理；
网友一：

一、匿名内部类的

java内部类分为： 成员内部类、静态嵌套类、方法内部类、匿名内部类 。java提供了匿名内部类语法，用于帮助大家简化代码，本文简要从接口，抽象类以及常规类以代码的形式描述其常用模式。其实不管是接口中，抽象类，还是常规类派生出来的匿名内部类，其用法都是一样的

1. 接口模式

public interface IWriter
{
    void write();
}
public static void main(String[] args)
{
    IWriter writer = new IWriter()
    {
        Override
        public void write()
        {
            System.out.println("IWriter write...");
        }
    };
    writer.write();
}

2.抽象类

public abstract class AbstractWriter
{
    public abstract void write();
}
public static void main(String[] args)
{

/** 1.等号右边:是匿名内部类，定义并创建该接口的子类对象
 * 2.等号左边:是多态赋值,接口类型引用指向子类对象
**/
    AbstractWriter abstractWriter = new AbstractWriter()
    {
        Override
        public void write()
        {
            System.out.println("AbstractWriter write...");
        }
    };
   //调用 fly方法,执行重写后的方法

    abstractWriter.write();
}

3.常规类

public class TextWriter implements IWriter
{
    Override
    public void write()
    {
        System.out.print("text writer..");
    }
}
public static void main(String[] args)
{
    TextWriter textWriter = new TextWriter()
    {
        Override
        public void write()
        {
            System.out.println("TextWriter 2 write...");
        }
    };
    textWriter.write();
}

4.在线程中使用

public static void main(String[] args)
{
    Thread thread = new Thread()
    {
        Override
        public void run()
        {
            new IWriter()
            {
                Override
                public void write()
                {
                    System.out.println("IWriter thread write...");
                }
            }.write();
        }
    };
    thread.run();
}

匿名内部类作为参数传递

通常在方法的形式参数是接口或者抽象类时，也可以将匿名内部类作为参数传递。代码如下：

public class InnerDemo3 {
    public static void main(String[] args) {           
        /*
           创建匿名内部类,直接传递给showFly(FlyAble f)
        */
        showWriter( new IWriter(){
            public void IWriter() {
                System.out.println("我写了~~~");
            }
        });
    }

    public static void showWriter(IWriter f) {
        f.write();
    }
}

内部类编译后的文件

综上可以看出，其实不管是接口中，抽象类，还是常规类派生出来的匿名内部类，其用法都是一样的。之所以说这个是一个语法糖，其本质是编译器在编译的时候，将匿名内部类单独编译成不多个不同的class，这个和单独写实现类后再调用其实本质是一样，具体可以参见编译后生成目录.如下截图所示：

网友二：
转载：https://baijiahao.baidu.com/s?id=1600814193634680238&wfr=spider&for=pc

匿名内部类格式

本质：匿名内部类会隐式的继承一个类或者实现一个接口，或者说，匿名内部类是一个继承了该类或者实现了该接口的子类匿名对象。

格式

new 类名/接口/抽象类(){

}

例如：

new Interface(){


}

网友三
转载：
https://www.cnblogs.com/libinhong/p/10990602.html

内部类总结

内部类访问特点

成员内部类可以直接访问外部类的成员变量和成员方法
外部类不可以直接访问内部类的成员变量和成员方法

外部类想要访问内部的成员: 得创建内部类对象来访问内部类成员

外部类名.内部类名 对象名 = new 外部类名().new 内部类名();

举个例子

public class Person {
    private  boolean live = true;
    class Heart {
        public void jump() {
            // 直接访问外部类成员
            if (live) {
                System.out.println("心脏在跳动");
            } else {
                System.out.println("心脏不跳了");
            }
        }
    }

    public boolean isLive() {
        return live;
    }

    public void setLive(boolean live) {
        this.live = live;
    }

}

public class InnerDemo {
    public static void main(String[] args) {
        // 创建外部类对象 
        Person p  = new Person();
        // 创建内部类对象
        Heart heart = p.new Heart();

        // 调用内部类方法
        heart.jump();
        // 调用外部类方法
        p.setLive(false);
        // 调用内部类方法
        heart.jump();
    }
}
输出结果:
心脏在跳动
心脏不跳了