Java 匿名类(匿名内部类)
 
学习的参考博文：无恨之都
 
1. 初识 匿名类
 
标准说法： 内部类包括：成员类、局部类、匿名类(匿名内部类)。
 
匿名类概念：
 
匿名类可以使你的代码更加简洁 (JDK8之后Lambda更简洁)。
你可以定义一个类的同时对其进行实例化。
它与局部类很相似，不同的是它没有类名，如果某个局部类你只需要使用一次，就可以使用匿名类代替局部类。
匿名类是表达式，而非常规的类
 
匿名类的使用场景：
 
一个局部类只需要使用一次的时候
由于匿名类没有类名，那么除了定义它的地方，其他地方无法调用，所以匿名类也可以叫匿名内部类
 

 
2. 通过示例分析局部类和匿名类区别
 
sayHello方法中有局部类和匿名类分别实现HelloWorld接口的方法
 
public class HelloWorldAnonymousClasses {

    interface HelloWorld {
        public void greet();
        public void greetSomeone(String someone);
    }

    public void sayHello() {

        /**
         * 1、局部类:EnglishGreeting实现了HelloWorld接口
         */
        class EnglishGreeting implements HelloWorld {
            String name = "无参";
            @Override
            public void greet() {
                greetSomeone(name);
            }
            @Override
            public void greetSomeone(String someone) {
                name = someone;
                System.out.println("局部类：" + name);
            }
        }
        // 创建局部类EnglishGreeting的实例化对象，使用接口类型接收
        HelloWorld englishGreeting = new EnglishGreeting();
        // 局部类：无参方法
        englishGreeting.greet();
        // 局部类：带参方法
        englishGreeting.greetSomeone("带参");


        /**
         * 2、匿名类实现HelloWorld接口并创建了实例化对象：frenchGreeting
         */
        HelloWorld frenchGreeting = new HelloWorld() {
            String name = "无参";
            @Override
            public void greet() {
                greetSomeone(name);
            }
            @Override
            public void greetSomeone(String someone) {
                name = someone;
                System.out.println("匿名类：" + name);
            }
        };

        // 匿名类：无参方法
        frenchGreeting.greet();
        // 匿名类：带参方法
        frenchGreeting.greetSomeone("带参");
    }

    public static void main(String... args) {
        HelloWorldAnonymousClasses myApp = new HelloWorldAnonymousClasses();
        myApp.sayHello();
    }
 
【输出】
 
局部类：无参
局部类：带参
匿名类：无参
匿名类：带参
 
【分析】
   代码里局部类和匿名类实现的功能是一样的，内部的方法实现的代码是也一样的，区别只在实现HelloWorld接口的地方
 
局部类的格式是：
 
创建局部类并且实现接口：class EnglishGreeting implements HelloWorld {...}
创建局部类的实例化对象并用接口类型接收：HelloWorld englishGreeting = new EnglishGreeting();
调用实例化对象的方法
 
匿名类的格式是：
 
创建匿名类实现接口同时对其进行实例化：HelloWorld frenchGreeting = new HelloWorld() {...}
调用实例化对象的方法
 
【区别】
 
局部类EnglishGreeting实现HelloWorld接口，有自己的类名：EnglishGreeting，定义完成后需要再对其实例化对象：englishGreeting才能可以使用方法
匿名类在定义时就已经实例化成对象：frenchGreeting，定义完了就可以直接使用方法
匿名类是一个表达式，因此在定义的最后用分号结束
 

 
3. 匿名内部类的语法
 
3.1 匿名类实现接口
 
其实上面的示例中的匿名类就是实现接口的方式，这个示例将实现更复杂的功能
 
public class InterfaceTest {
    public static void main(String[] args) {
        TomInterface tif = new TomInterface() {
            String name = "汤姆";
            @Override
            public void getName() {
                System.out.println(name);
            }

            TomInterface setName(String name){
                this.name = name;
                return this;
            }
        }.setName("杰瑞");
        tif.getName();
    }
}

interface TomInterface{
    void getName();
}
 
【结果】
 
杰瑞
 
【分析】
 
main方法创建匿名类实现TomInterface接口并实例化：new TomInterface{...}
调用匿名类对象的setName方法，将杰瑞赋值给匿名类的成员变量name，并返回当前实例this给接口变量tif
main方法调用匿名类对象的方法tif.getName()，而此时的匿名类的成员变量name的值已经被替换成杰瑞，所以最后输出杰瑞而不是汤姆
 

 
3.2 匿名类继承父类 (匿名子类)
 
匿名类继承父类，调用父类构造，重写父类方法
 
public class ExtendTest {

    public static void main(String[] args) {
        String name = "李四";
        // 创建父类对象，打印原始name值
        PartherClass partherClass = new PartherClass();
        System.out.println("父类的getName方法=" + partherClass.getName());
        // 使用匿名类继承父类，并打印name值
        PartherClass pc = new PartherClass(name){
            @Override
            public String getName(){
                return "匿名类 - "+super.getName();
            }
        };
        System.out.println(pc.getName());
    }
}

class PartherClass{
    private String name = "张三";
    public PartherClass(){}
    public PartherClass(String name){
        this.name = name;
    }
    public String getName(){
        return this.name;
    }
}
 
【结果】
 
父类的getName方法=张三
匿名类 - 李四
 
【分析】
 
创建父类对象并调用getName方法，这个不用细说
创建匿名类继承父类并实例化对象：pc，本次匿名类调用的是父类的带参构造，将参数赋值给了父类的name
调用匿名类重写的getName方法，得到新的name值
 
3.3 区别
 
Demo demo = new Demo(xxx){...}
 
操作符：new
一个要实现的接口或要继承的类，示例3.1 是实现接口，示例3.2 是继承类
一对括号，如果是匿名子类，那么父类有构造参数就填，不带参就空着；如果匿名类是实现接口，那么括号里需要空着
{...}，括号里括着的是匿名类的声明主体
末尾的;号，因为匿名类的声明是一个表达式，是语句的一部分，所以需要分号结尾
表面上看匿名类没有类名，没有构造参数。但其实在编译的时候，编译器会给匿名类分配类名和构造器，只是我们无法操作也不能复用。如需验证，可以看编译后的class文件，多出一个命名格式：匿名类定义类$?.class的文件。例如示例3.2，匿名类的class文件就是：ExtendTest$1.class

 
java匿名内部类
 
什么是匿名内部类？
匿名内部类的使用场景？
匿名内部类如何创建？
匿名内部类的实现和使用
例1(实现接口)
例2(继承类)
 

 
什么是匿名内部类？
 
匿名内部类，顾名思义，就是不知道这个类到底是什么名字，也就是不知道类名。
 
匿名内部类的使用场景？
 
匿名内部类适合创建那种只需要使用一次的类，也就是说创建一个匿名内部类，只需要用一次即可。
 
匿名内部类如何创建？
 
new 类名(参数) | 实现接口()
{
// 匿名内部类的类体部分
}
从上面的定义可以看出，匿名内部类必须继承一个父类，或实现一个接口，但最多只能继承一个父类，或者实现一个接口。
两个规则：
	匿名内部类不能是抽象类。
	匿名内部类不能定义构造器。由于匿名内部类没有类名，所以无法定义构造器，但匿名内部类可以初始化块，可以通过初始化块来完成构造器需要完成的工作。
 
匿名内部类的实现和使用
 
例1(实现接口)
 
首先，定义一个匿名类要实现的接口，代码如下
 
public interface Product{
 double getPrice();
 String getName();
 
然后，定义一个实体类，实体类定义一个方法，方法的参数为上述的接口对象，到时候会传入一个匿名类对象，这个匿名类实现了上述创建的接口，代码如下
 
public class Anony{
	public void test(Product product){
	System.out.println("购买了一个"+product.getName()+"，花掉了"+product.getPrice());
	}
}
 
最后测试运行：
 
pubic class Test{
	public static void main(String[] args){
		Anony anony=new Anony();
		// 注意，此处要传入一个匿名类对象
		anony.test(new Product(){
			@Override
			public double getPrice(){
					return 578.6;
				}
			@Override
			public String getName(){
					return "联想笔记本";
				}
			}
		);
	}
}
 
输出：
 
购买了一个联想笔记本，花掉了578.6
 
总结：此处匿名内部类的作用就是实现了一个接口，创建了一个实现了该接口的类的对象，然后重写了这个接口中的方法。
 
例2(继承类)
 
首先，定义一个匿名类需要实现的抽象类，代码如下：
 
public abstract class Device{
	private String name;
	public abstract double  getPrice();
	public String getName(){
	 	return name;
	}
	public Device(){}
	public Device(String name){
		this.name=name;
	}
} 
 
然后，定义一个实体类，实体类定义一个方法，方法的参数为上述的抽象类对象，到时候会传入一个匿名类对象，这个匿名类继承了上述创建的抽象类，代码如下
 
public class Anony {

    public void test(Device device){
        System.out.println("购买了一个"+device.getName()+"花费了"+device.getPrice());
    }
}
 
最后测试运行：
 
pubic class Test{
	public static void main(String[] args){
		Anony anony=new Anony();
		// 注意，此处要传入一个匿名类对象
		anony.test(new Device("海尔电视机"){
			@Override
			public double getPrice(){
					return 578.6;
				}
		);
		Device device=new Device(){
			@Override
			public double getPrice(){
				return 556.56;
			}
			@Override
			public String getName(){
				return "美的电视机";
			}
		};
		annoy.test(device);
	}
}
 
输出：
 
购买了一个海尔电视机，花掉了578.6
购买了一个美的电视机，花掉了556.56
 
总结：对象匿名类中继承抽象类，对于抽象类里面的抽象方法，必须要重写，对象抽象类里面的非抽象方法，可重写也可以不重写。

本文原创首发CSDN，本文链接 https://blog.csdn.net/qq_41464123/article/details/107480664 ，作者博客https://blog.csdn.net/qq_41464123 ，转载请带上本链接，谢谢配合。
 

 

零、为什么要写内部类？
 
 
 
之前在学习Android百度地图的时候，发现一个Activity中居然有两个嵌套的类(Class)，成功引起了我的注意，于是最近在暑假系统了学习了Java中的四种内部类。
 
最初在大二入门Java的时候，我就了解过Java的匿名类和内部类，那时候觉得这些都是理论性的东西，实际开发不一定能用到，于是就淡化了。直到最近，发现Java的内部类机制在实际开发中用处还是不小的，于是系统的学习了内部类，并写下了这篇总结。
 
 
 
 

一 、类
 
 
 
1.1 基础类
 
 
 
类的概念、访问权限修饰符，我已经在《学习Java的你，真的会面向对象编程吗？》详细讲解了。
 
类是什么？类是静态的模板，规定了 将该类实例化的对象 的共性。
 
public class People {
	
	String userName;
	int userAge;
	
	void say() {
		System.out.println("The people " + this.userName + " is "+ this.userAge + " years old!");
	}
}
 
看，这就是一个 People 类，他有成员变量 userName、userAge，还有成员方法say()；
 
 
 
1.2 封装类
 
 
 
如果结合上Java的封装原则，那么，就需要为成员变量、成员方法加上访问权限修饰符，代码就变成了这个样子：
 
public class People {
	
	private String userName;
	private int userAge;
	
	public void say() {
		System.out.println("The people " + this.userName + " is "+ this.userAge + " years old!");
	}

	public String getUserName() {
		return userName;
	}
	public void setUserName(String userName) {
		this.userName = userName;
	}
	public int getUserAge() {
		return userAge;
	}
	public void setUserAge(int userAge) {
		this.userAge = userAge;
	}
}
 
从程序功能上来说，前后两段代码的功能是一致的，但是从Java语言开发规范角度来讲，每一个实体类都必须满足封装原则，简单来讲，实体类的成员变量必须为私有类型，并且提供 set 和 get 方法让外部获取、修改变量。
 
可以说，上面这段程序才是真正意义上的Java实体类Bean。
 
 
 

二、内部类
 
 
 
我的理解：内部类就是类中类，依附于普通类中，可以间接实现Java类的多继承。
 
内部类是指在一个外部类的内部再定义一个类，内部类作为外部类的一个成员，是依附于外部类存在的。
 
内部类可以是静态的，通常用 protected 或者 private 关键字修饰，外部类只能使用public或者系统默认权限。
 
如果你对Java的访问权限不熟悉，可以看一下我这篇文章《一文搞懂Java的 构造方法 和 访问权限》
 
内部类主要有四种，分别是成员内部类、方法内部类、静态内部类、匿名内部类。（图片来源于网络，侵删）
 
 
 
 

2.1 成员内部类
 
 
 
成员内部类，顾名思义就是内部类作为成员存在于类中，和成员变量、成员方法同级。
 
比如下面这个 People 类，包含了一个内部类 Book，该类和成员变量 userName 、userAge 同级。
 
Book内部类，也可以拥有自己的成员变量、成员方法，以及自身的构造方法
 
public class People {

	class Book{
		String bookName;
		
		Book(String bookName){
			this.bookName = bookName;
		}
		
		void open() {
			System.out.println("The " + this.bookName + " was opened!");
		}
	}
}
 
我们如果要实例化这个成员内部类，就必须采用
 
外部类.内部类 内部类对象 = new 外部类().new 内部类();
 
 实际代码如下：
 
public class Main {

	public static void main(String[] args) {
		People.Book book = new People().new Book("Java程序设计"); 
		book.open();
	}
}
 
 运行效果如下，也就是调用了内部类 Book 的 open() 方法，输出这样一句话。
 
 
 
 

2.2 静态内部类
 
 
 
在讲解静态内部类之前，先讲解一下静态，也就是static关键字。
 
static是静态的意思。在Java语言中，static关键字修饰的成员是可以被所有对象共享的。
 
如果某个类加了static关键字，则直接可以使用类名直接访问。
 
将2.1小节的People类中的 Book子类，加上一个 static关键字 修饰
 
static class Book{
	String bookName;
	
	Book(String bookName){
		this.bookName = bookName;
	}
	
	void open() {
		System.out.println("The " + this.bookName + " was opened!");
	}
}
 
那么外部就直接可以使用类名进行实例化操作，就像一个普通实例类一样，如下面代码所示：
 
import cn.zwz.People.Book;

public class Main {

	public static void main(String[] args) {
		Book book = new Book("Java程序设计"); 
		book.open();
	}
}
 
 
 我们可以得到和 2.1小节所讲的一致的效果。
 

本文原创首发CSDN，本文链接 https://blog.csdn.net/qq_41464123/article/details/107480664 ，作者博客https://blog.csdn.net/qq_41464123 ，转载请带上本链接，谢谢配合。
 

2.3方法内部类
 
 
 
方法内部类是指在Java方法中定义的类。
 
我们在原有的 People 类中，定义一个say()方法，在该方法中定义一个 Issue 内部类。
 
在 Issue 内部类中，定义一个方法 speakIsser()，内容是输出话题的名称。
 
public class People {
	
	public void say(String issue) {
		class Issue {
			public void speakIsser() {
				System.out.println("My issues is " + issue);
			}
		}
		new Issue().speakIsser();
	}
}
 
接着编写测试方法，实例化一个 People 对象，并调用 people 的 say() 方法
 
public class Main {

	public static void main(String[] args) {
		People people = new People();
		people.say("Hello ZWZ!");
	}
}
 
 
运行结果显示，people 的 say() 方法，调用了 Issue内部类中的 speakIsser()方法，输出了这句话。
 
 
 

2.4匿名内部类
 
 
 
我们对第三小节的程序稍加修改
 
1. 定义一个Issue接口，或者普通类。
 
2. 在 People 类的 say()方法中，new 出来一个 Issue 对象，实现 speakIsser() 抽象方法的具体实现。
 
3. 在Issue对象的后面调用speakIsser()方法。
 
代码如下所示：
 
interface Issue{
	public void speakIsser();
}
public class People {
	
	public void say(String issue) {
		new Issue() {
			public void speakIsser() {
				System.out.println("My issues is " + issue);
			}
		}.speakIsser();
	}
}
 
测试方法程序，同第三小节的方法内部类，不做修改
 
public class Main {

	public static void main(String[] args) {
		People people = new People();
		people.say("Hello ZWZ!");
	}
}
 
运行结果如下图所示，即效果同第三小节的方法内部类。
 
 
 
 
匿名内部类是一种特殊的内部类，这种类没有名字，通过new关键字直接创建某一个类的匿名子类的对象来使用。
 
以下情况需要用到匿名类：
 
只用到类的一个实例。
类在定义后马上用到。
类非常小，通常5行代码之内。
给类命名不会导致代码更容易被理解。
但是需要注意：匿名内部类不能定义构造方法，并且功能上会受到很大的限制，如果不是很有必要，尽量不要去使用。
 
 
 

三、总结
 
 
 
以上就是Java四种内部类的常见用法。
 

1.成员内部类，就是内部类作为一个成员，存在于类中。
 
实例化方法：   外部类.内部类 内部类对象 = new 外部类().new 内部类();
 

2.静态内部类，在成员内部类的基础上，多了一个static关键字，是静态的类，所有的对象都可以直接通过类名调用。
 
实例化方法：   内部类 内部类对象 = new new 内部类(); 
 

3.方法内部类，在类的方法中，定义内部类。
 
实例化方法：   new 内部类().内部类方法();   注意只能在当前方法中实例化。
 

4.匿名内部类，直接new一个没有名字的类，并且直接调用其中的方法。
 
实例化方法：    new 内部类(){ ...... }.内部类中的方法();
 
 

参考文献：《Java语言面向对象程序设计(第二版)》 清华大学出版社

和类有关的匿名类
和接口有关的匿名类
 
 
一:和类有关的匿名类
 
 Java允许用户直接使用一个类的子类的类体创建一个子类对象
 
在创建子类对象时，除了使用父类的构造方法外还有类体，此类体被认为是一个子类去掉类声明后的类体，称为匿名类
 
使用匿名类创建对象时，要直接使用父类的构造方法
 
匿名类就是一个子类，由于无名可用，所以不可能用匿名类声明对象，但却可以直接用匿名类创建一个对象（不可声明，但可创建）
 
 
 
附加：如一个类A，他的无参数的构造方法是A(){}
 
比如假设A是类，那么下列代码是用A类的一个子类（匿名类）创建对象
 
new A(){
匿名类的类体
};
 
尽管匿名类创建的对象没有经过类声明的步骤，但匿名对象的引用可以传递给一个匹配的参数，匿名类的常用方式是向方法的参数传递
 
 
 
 
 
例子：
 
package p2;

abstract class A {
    //抽象类不能实例化
    public abstract void Aa();
}
 
匿名内部类中，可以隐含实现一个接口、或者是一个类，当然包括抽象类。只不过该匿名类一定要实现抽象类中的抽象方法才可以
 
package p2;

class B {
    void  f(A a){     //这里的a相当于形参
        a.Aa();
    }
}
 
package p2;

public class Lianxi2 {
    public static void main(String args[]){
        A a = new A(){         //匿名类创建对象，然后把对象的引用赋给a,a是一个上转型对象
            public void Aa(){    //重写方法
                System.out.println("我是A");
            }
        };
        a.Aa();            //上转型对象a调用重写的方法

        B b =new B();        //类B实例化new 一个对象b常量
        b.f(new A(){    //b调用方法f,括号里面相当于上面那部分,把对象引用传递给方法f里面的参数a
            public void Aa(){
                System.out.println("我是B");
            }
        });

    }
}
 
 
 
注意：
 
匿名类可以继承或者重写父类的方法
我们使用匿名类时候，必然是在某个类中直接用匿名类创建对象，因此，匿名类一定是内部类
匿名类可以访问外嵌类中的成员变量和方法
匿名类的类体中不可以声明static成员变量和static方法
 
 
 
 
 
 
二:和接口有关的匿名类
 
假如A是一个接口，那么Java允许直接用接口名和一个类体创建一个匿名对象，此类体被认为是实现了A接口的类去掉声明后的类体，称为匿名类
 
下面代码是用实现了A 接口的类（匿名类）创建对象：
 
new A(){
实现接口的匿名类的类体
};
 
 
 
如果某个方法的参数是接口类型，那么可以使用接口名和类体组合创建一个匿名对象传递给方法的参数，但类体必须重写接口中的所有方法
 
如:void f(A a)
 
其中的参数a是接口，那么在调用f时，可以向f的参数传递一个匿名对象
 
如:
 
f(new A(){
 
实现接口的匿名类的类体
 
})