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接口的地方

局部类的格式是：

1. 创建局部类并且实现接口：class EnglishGreeting implements HelloWorld {...}
2. 创建局部类的实例化对象并用接口类型接收：HelloWorld englishGreeting = new EnglishGreeting();
3. 调用实例化对象的方法

匿名类的格式是：

1. 创建匿名类实现接口同时对其进行实例化：HelloWorld frenchGreeting = new HelloWorld() {...}
2. 调用实例化对象的方法

【区别】

1. 局部类EnglishGreeting实现HelloWorld接口，有自己的类名：EnglishGreeting，定义完成后需要再对其实例化对象：englishGreeting才能可以使用方法
2. 匿名类在定义时就已经实例化成对象：frenchGreeting，定义完了就可以直接使用方法
3. 匿名类是一个表达式，因此在定义的最后用分号结束

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();
}

【结果】

杰瑞

【分析】

1. main方法创建匿名类实现TomInterface接口并实例化：new TomInterface{...}
2. 调用匿名类对象的setName方法，将杰瑞赋值给匿名类的成员变量name，并返回当前实例this给接口变量tif
3. 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方法=张三
匿名类 - 李四

【分析】

1. 创建父类对象并调用getName方法，这个不用细说
2. 创建匿名类继承父类并实例化对象：pc，本次匿名类调用的是父类的带参构造，将参数赋值给了父类的name
3. 调用匿名类重写的getName方法，得到新的name值

3.3 区别

Demo demo = new Demo(xxx){...}

1. 操作符：new
2. 一个要实现的接口或要继承的类，示例3.1 是实现接口，示例3.2 是继承类
3. 一对括号，如果是匿名子类，那么父类有构造参数就填，不带参就空着；如果匿名类是实现接口，那么括号里需要空着
4. {...}，括号里括着的是匿名类的声明主体
5. 末尾的;号，因为匿名类的声明是一个表达式，是语句的一部分，所以需要分号结尾
6. 表面上看匿名类没有类名，没有构造参数。但其实在编译的时候，编译器会给匿名类分配类名和构造器，只是我们无法操作也不能复用。如需验证，可以看编译后的class文件，多出一个命名格式：匿名类定义类$?.class的文件。例如示例3.2，匿名类的class文件就是：ExtendTest$1.class

前言：
Lambda流式操作是Java8中重要的特性，lambda表达式核心概念为 函数式接口、::、-> 等基本语法，可以大大减少代码量的编写，使代码更加优雅
1、只有一个抽象函数的接口，就是函数式接口
2、:: 可以称之为域运算符，主要是用来获取方法
3、-> 的语法为 (变量或参数)->{代码体}，是匿名函数的写法。也叫变量和代码的分隔符
4、当只获取一个方法属性的时候 :: 和 -> 可以通用

介绍：

1. 接口：
   1】接口可以定义在另一个类的内部
   2】接口中的方法都是抽象方法
   3】接口中的常量都是静态常量

2. 类
   1】类可以定义在另一个类的内部
   2】也可以定义为内部静态类，使用 static 关键字
   3】还可以定义为局部内部类，定义在方法中

一、什么是Lambda表达式？
        lambda表达式是为了简写代码的写法

二、什么是函数式接口？
        1】只有一个抽象方法的接口就是函数式接口

//1.定义一个函数式接口。只有一个抽象方法的接口就是函数式接口
interface ILike{
    void testLambda();
}

三、什么是匿名内部类？
        匿名内部类的特点：
        1】没有类名
        2】必须借助接口或父类
        3】通过实例化函数式接口就可以完成匿名内部类实现此接口并重写方法

//5.匿名内部类，没有类名称，必须借助接口
like = new ILike() {
    @Override
    public void testLambda() {
        System.out.println("i like lambda4");
    }
};
like.testLambda();

四、用 Lambda 简化匿名内部类的写法
        1】匿名内部类是为了省去类名的写法
        2】Lambda 简化写法不但可以省去类名，还可以省去接口名和函数名。因为只有一个抽象方法，可以直接实现并指向这个抽象方法和方法体

//6.用lambda简化，因为接口中只有一个函数，所以可以直接省略实例化的接口名和函数名
like = () -> {
    System.out.println("i like lambda5");
};
like.testLambda();

概括：
1】匿名函数写法和匿名类写法的前提必须基于函数式接口
2】匿名函数写法和匿名类写法其本质是同一个东西，只是简化写法不同
3】使用Lambda表达式简写匿名函数时，可以同时省略实现类名、函数名。除此外也可以使用传统写法

浅析匿名类的使用方法

匿名类是某种已定义的类的继承，该父类必须真实存在。匿名类属于内部类无法构造静态代码块。
构造匿名类对象主要有以下几种方式：

1. new 类名{类体}
   这种方式的例子是注册事件监听器
2. new 类名{类体}.方法

public class Practice {
	public static void main(String[] args)
	{
			new Outer() {
			public void print()
			{
				System.out.println("你好");
			}
			public void printOut(){
				System.out.println("hello");
			}
		}.printOut();
	}
}
class Outer{
	private int value;
	public void printOut()
	{
		System.out.println(value);
	}
}

在匿名类里你可以重写父类方法或定义新的方法。
3. 类名 对象名=new 类名{类体}

public class Practice {
	public static void main(String[] args)
	{
		Outer o=new Outer() {
			public void print2()
			{
				System.out.println("you are a cat");
			}
			public void printOut()
			{
				System.out.println("hehe");
			}
		};
		o.printOut();
}
}
class Outer{
	private int value;
	public void printOut()
	{
		System.out.println(value);
	}
}

在这里需要注意的是o已由新构造的匿名类的类型被转化为父类Outer类型。所以你在匿名类中新定义的方法无法使用。但是对父类方法的重写仍然有效。