Java基础之匿名内部类，匿名内部类是什么?为什么要用匿名内部类，匿名内部类详解。

什么是匿名内部类？

顾名思义 匿名 就是没有名字，一个没有名字的内部类，称为匿名内部类。
下面先看一个例子，比如说你想和你的女朋友去看春节档的《唐人街探案三》

这个时候我们要先定义一个接口，去看唐探3的接口

public interface MyInterface {
    // 看电影的抽象方法
    void watchFilm();
}

OK！现在我们有了一个接口，接口里面有一个看电影的抽象方法。而现在你要去看电影了，你要实现接口里面的方法，但是接口不能直接 new 出来，所以你就要先定义一个实现类去实现这个接口，代码如下：

public class MyInterfaceImpl implements MyInterface{

    public void watchFilm() {
        System.out.println("实现方法里带着女朋友去看电影！");
    }
}

现在我们实现了这个接口，也可以去看电影了，我们现在要写一个主方法；

public class GoWatchFilm {
    public static void main(String[] args) {
        MyInterfaceImpl myInterface = new MyInterfaceImpl();
        myInterface.watchFilm();
    }
}

而这个时候，我们要先 new 一个看电影的实现类，然后调用里面看电影的方法，如图：

现在你和你心爱的女朋友成功的看到了电影…
因为我们已经知道多态，我们还可以使用多态的方式，" = " 的左边时接口，右边是实现类也是没毛病的，

到这里！那么问题来了，这个电影你就看了一次，只有在 new 的时候才看了一次，没有再看第二次。所以这个时候我们就可以使用 匿名内部类 了。

如果接口的实现类（或者父类的子类）只需要使用唯一一次，那么这种情况下我们就可以省略掉对该类的定义，而改为使用匿名内部类。

匿名内部类的定义格式：
上面我们有说到接口不能直接 new ,如果直接new就会报错，而这次，我们就直接new接口，但是这里的new和new对象又有一点小差别，格式如下：

接口名称 对象名 = new 接口名称(){
	 // 覆盖重写所有抽象方法
}

那我们就代码实现一下：

如上图，我们new了一个接口，而接口下面的 { } 里面就是一个匿名内部类，所以现在我们使用匿名内部类就可以带着女朋友把电影看玩了，而之前我们定义的一个实现类就可以不用了，虽然说这样写法有点怪异，但是我们是想带着女朋友看电影，并且这个电影只需要看一次就行了，往后就不看了，却还要写一个实现类去实现它，使用匿名内部类就可以省掉一个类的单独定义，看到这想必小伙伴已经对匿名内部类了解的差不多了，不过匿名内部类也有一些注意事项，我们接着往下看。

匿名内部类的注意事项:

首先对格式 “new 接口名称 () {…}” 进行解析:

1.new 代表创建对象的动作；

2.接口名称就是匿名内部类需要实现哪个接口；

3. {…} 这才是匿名内部类的内容； PS：没有class，没有名称

另外还要注意以下几点问题：
如果现在你的女朋友还想要看完电影去吃个海底捞，那么我们现在在接口里再写一个方法。并且第二天的时候你美丽的女朋友还要重复昨天做的事情，看电影，吃火锅，开始撸代码：

public interface MyInterface {
    // 看电影的抽象方法
    void watchFilm();
    // 吃海底捞的抽象方法
    void eatHotPot();
}

public class GoWatchFilm {
    public static void main(String[] args) {
       /* MyInterface myInterface = new MyInterfaceImpl();
        myInterface.watchFilm();*/
        MyInterface day01 = new MyInterface() {
            @Override
            public void watchFilm() {
                System.out.println("第一天在匿名内部类里面实现了带女朋友看电影了！！！！！！");
            }
            @Override
            public void eatHotPot() {
                System.out.println("第一天看完电影我们去吃一个火锅吧！！！！");
            }
        };
        day01.watchFilm();
        day01.eatHotPot();
        // 来一条分割线
        System.out.println("-------------------------------------------------------------------------------------------");
        new MyInterface() {
            @Override
            public void watchFilm() {
                System.out.println("第二天在匿名内部类里面实现了带女朋友看电影了！！！！！！");
            }
            @Override
            public void eatHotPot() {
                System.out.println("第二天看完电影我们去吃一个火锅吧！！！！");
            }
        }.watchFilm();
        new MyInterface() {
            @Override
            public void watchFilm() {
                System.out.println("第二天在匿名内部类里面实现了带女朋友看电影了！！！！！！");
            }
            @Override
            public void eatHotPot() {
                System.out.println("第二天看完电影我们去吃一个火锅吧！！！！");
            }
        }.eatHotPot();

    }
}

输出内容：

第一天在匿名内部类里面实现了带女朋友看电影了！！！！！！
第一天看完电影我们去吃一个火锅吧！！！！
-------------------------------------------------------------------------------------------
第二天在匿名内部类里面实现了带女朋友看电影了！！！！！！
第二天看完电影我们去吃一个火锅吧！！！！

可以看到，当我们第一天的时候，看完电影再吃火锅时是用的匿名内部类，是有对象名称的，可以直接用对象名称调用吃火锅和看电影的方法，而当第二天想再次调用的时候如果我们是用到了匿名对象，是直接new接口没有对象名称就要new两次，然后分别调用看电影和吃火锅，并且每次都要重写接口里的所有方法。

1、匿名内部类，在创建对象的时候只能使用一次，如果希望多次创建对象，而且内容一样的话，那么此时我们就要使用单独定义的实现类了。
2、匿名对象，在调用方法的时候，只能调用唯一一次，如果希望同一个对象调用多次方法，就必须给对象起一个名字。
3、匿名内部类是省略了“实现类/子类名称”，但是匿名对象是省略了“对象名称”

到这里小伙伴们差不多已经知道匿名内部类的含义了吧，并且我们什么时候能用到匿名内部类，什么时候要定义一个实现类去实现接口里的方法了吧！！！！

1.什么是匿名内部类

定义 ：
1.匿名内部类是定义在类的局部位置，如方法中、代码块中，且没有明确的类名；
2.是一个内部类，本质还是一个类；
3.没有类名；
4.同时还是一个对象。

2.匿名内部类的特性（关键）

 *         1.匿名内部类可以访问所有的外部类的成员，包括私有的；
 *         2.不能添加访问修饰符，因为匿名内部类也是一个局部变量；
 *         3.作用域 ： 仅在定义它的方法或代码块中有效；
 *         4.匿名内部类 访问 外部类的成员的方式 ： 直接访问；
 *         5.外部其他类 访问 匿名内部类的方式 ： 不可以访问，匿名内部类是一个局部变量；
 *         6.如果 外部类 和 匿名内部类 的成员重名时，默认遵循就近原则，
 *           如果就是想访问 外部类的成员时，使用 【外部类名.this.成员】 的方式；
 *         7.匿名内部类是没有名字的，所以也无需写构造器；
 *         8.匿名内部类的运行时类型是 【外部类名+$+数字】

3.匿名内部类的语法

 *  匿名内部类有两种实现方式：1.实现接口；2.继承一个类。
 *  格式如下 ： 
 *         new 接口名/类名(args...){
 *             //内容
 *         };

4.匿名内部类的示例代码

4.1 声明一个接口

package com.northcastle.B_niming_innerClass;

/**
 * author : northcastle
 * createTime:2022/2/9
 */
public interface InterfaceA {
    void sayHello();
}

4.2 声明一个抽象类

package com.northcastle.B_niming_innerClass;

/**
 * author : northcastle
 * createTime:2022/2/9
 */
public abstract class ClassA {
    abstract void sayHi();
}

4.3 真正的匿名内部类的代码(核心代码，必看)

package com.northcastle.B_niming_innerClass;

/**
 * author : northcastle
 * createTime:2022/2/9
 */

/**
 * 本案例演示 ： 匿名内部类
 */
public class NimingInnerClass {

    //1.外部类的成员
    private String field01 = "外部类的私有属性field01";
    public String field02 = "外部类的共有属性field02";
    //2.外部类的构造器
    public NimingInnerClass() {
    }
    public NimingInnerClass(String field01, String field02) {
        this.field01 = field01;
        this.field02 = field02;
    }
    //3.外部类的方法

    /**
     * 3.1 一个普通的方法
     */
    public void method01(){
        System.out.println("外部类的方法：method01");
    }

    /**
     * 3.2 实现接口的匿名内部类
     */
    public void method02(){
        //这个方法中包含实现接口的匿名内部类
        //1.匿名内部类的定义
        InterfaceA interfaceA_niming = new InterfaceA() {
            public String field01 = "接口+匿名内部类中的field01";
            @Override
            public void sayHello() {
                System.out.println("接口+实现接口的匿名内部类对你说 ： Hello");
                //2.使用匿名内部类的属性
                System.out.println("接口匿名内部类的field01 : "+field01);
                System.out.println("外部类的field01 : "+NimingInnerClass.this.field01);
                System.out.println("外部类的field02 : "+field02);
            }
        };
        //3.判断匿名内部类类型 ： 编译类型、运行时类型
        System.out.println("接口+匿名内部类 的运行时类型 ： "+interfaceA_niming.getClass());
        //4.运行匿名内部类对象的方法
        interfaceA_niming.sayHello();

    }

    /**
     * 3.3. 继承类的匿名内部类
     */
    public void method03(){
        //这个方法中包含实现类的匿名内部类
        //1.匿名内部类的定义
        ClassA classA_niming = new ClassA() {

            public String field01 = "类+匿名内部类中的field01";

            @Override
            void sayHi() {
                System.out.println("类+匿名内部类对你说 ： Hi");
                //2.使用匿名内部类的属性
                System.out.println("类+匿名内部类的field01 : "+field01);
                System.out.println("外部类的field01 : "+NimingInnerClass.this.field01);
                System.out.println("外部类的field02 : "+field02);
            }
        };
        //3.判断匿名内部类类型 ： 编译类型、运行时类型
        System.out.println("类+匿名内部类 的运行时类型 ： "+classA_niming.getClass());
        //4.运行匿名内部类的对象的方法
        classA_niming.sayHi();

    }

    /**
     * 3.4 作为实参的匿名内部类
     * @param interfaceA
     */
    public void method04(InterfaceA interfaceA){
        // 这里演示最常用的使用方式 ： 匿名内部类作为实参传入方法中
        interfaceA.sayHello();
    }

}

4.4 外部其他类对匿名内部类的使用

package com.northcastle.B_niming_innerClass;

/**
 * author : northcastle
 * createTime:2022/2/9
 */
public class Application {
    public static void main(String[] args) {
        //1.定义一个外部类的对象
        NimingInnerClass nimingInnerClass = new NimingInnerClass();

        //2.调用外部类对象的方法
        nimingInnerClass.method01();//普通方法
        System.out.println("==============================");
        
        nimingInnerClass.method02();//包含匿名内部类的方法
        System.out.println("==============================");
        
        nimingInnerClass.method03();//包含匿名内部类的方法
        System.out.println("==============================");
        
        nimingInnerClass.method04(new InterfaceA() { //匿名内部类作为参数的方法
            @Override
            public void sayHello() {
                System.out.println("实参中的匿名内部类向你说 Hello啦");
            }
        });
    }
}

4.5 运行结果

运行结果与特性中表述的一致。

5.完成

Congratulations!
You are one step closer to success!

个人简介

• 大家好，我是翰慧腾。一名正在努力学JAVA的大一小白，本文章为初学的笔记，希望各位多多指教。💙
• 欢迎点赞+收藏+留言💜
• 生活不止眼前的苟且，还有诗和远方🧡

一、内部类

• 内部类顾名思义就是在一个类内部声明另一个类，包含内部类的称为外部类。内部类一般用来实现一些没有通用意义的功能逻辑,可以访问外部类的成员，包括私有的成员。（TIP：外部类只可以用public 默认修饰，但是内部类可以用private protected修饰，增强了其封装性。）
• 创建的内部类都会产生class文件。

内部类分类：

1.静态内部类（了解即可）

静态内部类首先肯定要有static修饰，可以访问外部类的非静态变量、静态变量，不能访问外部类的非静态变量（需要实例化）。该类同之前学的类相同，只是在内部罢了，代码可以证明一切。如下：

package CSDN1;

public class Outter {
	//外部类的两个成员变量
    String name;
	int age;
    //内部类如下
	public static class inner{
		//同外部类一样，可以定义成员变量
        String name;
		private int age;//为了其封装性，任然可以私密修饰
		public inner() {
			
		}//同外部类一样的无参构造方法
		public inner(String name,int age) {
			this.name=name;
			this.age=age;
		}//同外部类一样的带参构造方法
		public int getAge() {
			return age;
		}
		public void setAge(int age) {
			this.age = age;
		}
        public void show() {
			System.out.println(name+","+age);
		}

		
	}
}

静态内部类创建对象格式：

 接上述代码：

package CSDN1;

public class Outter_Demo {
	public static void main(String[] args) {
		Outter.inner s=new Outter.inner("小明",19);//创建内部类对象，调用带参构造方法
		s.show();//调用内部类的对象
}
}

2.成员内部类： 无static修饰，属于外部类的对象（jdk16之后开始支持内部类中定义静态成员变量、方法。在jdk之前是不支持的），相当于是外部类的对象，通过创建对象来调用。内部类中的实例方法可以直接访问外部类的实例成员、静态成员。创建对象格式：

package CSDN1;

public class Outter {
	String name;
	int age;
	public class inner{
		String name;
		private int age;
		public inner() {
			
		}
		public inner(String name,int age) {
			this.name=name;
			this.age=age;
		}
		public int getAge() {
			return age;
		}
		public void setAge(int age) {
			this.age = age;
		}
		public void show() {
			System.out.println(name+","+age);
		}
		
	}
}

package CSDN1;

public class Outter_Demo {
	public static void main(String[] args) {
		Outter.inner s=new Outter().new inner("小明",19);//创建内部类对象，调用带参构造方法
		s.show();//调用内部类的对象
}
}

此处附赠一道很有意思的面试题：

 答案：

package Stickto;

public class PeopleDemo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		people.heart s=new people().new heart();//创建内部类对象
		s.show();//调用内部类show方法
	}

}
class people{
	private int heartbeat=150;
	public class heart{
		private int heartbeat=110;
		public void show() {
			int heartbeat=78;
			System.out.println(heartbeat);//78
			System.out.println(this.heartbeat);//110
			System.out.println(people.this.heartbeat);//150
            //要牢记访问外部类成员对象的方法
		}
	}
}

3.局部内部类（了解即可）：很多人都会认为局部内部类就是函数内部定义的类。其实并不一定在方法内，只要在局部（非外部类的成员部分）都叫做是局部内部类。

二、匿名内部类（重点，开发中常用）

• 匿名内部类本质上就是没有类名、没有class修饰的局部内部类，定义在方法中、代码块中等。方便创建子类对象，简化代码的编写。
• 抽象类不能直接创建对象，需要重写抽样方法后才可以直接创建。

废话不多说，直接上代码

package Stickto;

public class AnimalDemo {
	public static void main(String[] args) {
		Animal s=new Animal() {

			@Override
			public void eat() {
				// TODO 自动生成的方法存根
				System.out.println("猫吃老鼠");
			}

			@Override
			public void sleep() {
				// TODO 自动生成的方法存根
				System.out.println("猫睡着了");
			}
		};//这就是一个匿名内部类，本身抽象类由于有抽象方法不能创建对象，匿名内部类就是重写抽象类内部抽象方法的，以便于直接创建抽象类对象，简化了之前创建子类的程序。特别提醒：匿名内部类后面是有分号的	
		s.eat();
		s.sleep();
		}
}
//创建一个抽象动物类
abstract class Animal{
	String name;
	int age;
	public Animal() {
		
	}
	public Animal(String name,int age) {
		this.name=name;
		this.age=age;
	}
	public abstract void eat() ;
	public abstract void sleep();
}

总而言之，匿名内部类就是针对之前不能对抽象类、接口创建对象的情况。当然，有了匿名内部类之后也不能创建接口、抽象类的对象，而是通过创建匿名内部类对象达到了不用写子类的效果。匿名内部类就是对其抽象方法进行了重写。