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

内部类

Java中的类有两种重要的成员，即成员变量和方法。其实Java还允许类有一种成员，即在一个类中声明另一个类，这就是内部类，而包含内部类的类叫做外嵌类。
内部类和外嵌类之间的关系如下：
1.内部类可以使用其外嵌类的成员变量和方法。
2.内部类中不可以声明类变量和类方法。
3.外嵌类可以使用内部类声明对象作为外嵌类的成员。
4.内部类仅供它的外嵌类使用，其他类不可以用某个类的内部类声明对象。
具体示例：

class RedCowFarm{  //外嵌类
    static String farmName;   
    class RedCow{   //内部类开始
        String cowName="红牛";
        int height,weight;
        RedCow(int h,int w){
            height=h;
            weight=w;
        }
        void speak(){
            System.out.println("我是"+cowName+",身高:"+height+"cm,体重:"+weight+"kg,生活在"+farmName);
        }
    }       // 内部类结束
    RedCow cow=new RedCow(150,112);
    RedCowFarm(String s){
        farmName=s;
    }
}

public class Test {
    public static void main(String[] args) {
        RedCowFarm redCowFarm=new RedCowFarm("红牛农场");
        redCowFarm.cow.speak();
    }
}

内部类可以被修饰为static内部类，即上面的示例中可以将内部类声明为static class RedCow，类是一种数据类型，那么static内部类就是外嵌类中的一种静态数据类型，这样其它类就可以使用static内部类来声明创建对象了。
注意：static内部类不能操作外嵌类中的实例成员变量。
假如上面示例中内部类是static class RedCow的话，则可以作如下变动：
1.删除掉外嵌类的 RedCow cow=new RedCow(150,112); 对象声明和创建；
   删除掉Test类main方法中的redCowFarm.cow.speak();
2.直接在Test类的main方法中添加以下代码也可以达到同样的运行效果：

RedCowFarm.RedCow redCow=new RedCowFarm.RedCow(150,112);
        redCow.speak();

匿名类

一、和类有关的匿名类

1.我们可以直接使用一个类的子类的类体创建一个对象。在创建子类对象时，使用的是父类的构造方法和类体，这个类体被认为是子类去掉类声明之后的类体，称作匿名类。
2.匿名类主要是为了实现，要执行的任务或者方法需要一个对象，但是又不值得创建一个全新的对象。
3.匿名类可以继承，重写父类的方法，使用匿名类的时候，必然是在某个类当中直接使用匿名类创建对象，因此，匿名类一定是内部类。
4.由于匿名类是一个子类，但是没有类名，所以在使用匿名类创建对象时必须使用父类的构造方法。
5.匿名对象的引用可以传递给一个匹配的参数，匿名类常用的方式是向方法的参数传值。
具体示例：

abstract class Speak{
    public abstract void speakHello();
}

class Student {
    void f(Speak sp){
        sp.speakHello();
    }
}

public class Test {
    public static void main(String[] args) {
        Speak speak;
        speak=new Speak() {  //使用匿名类创建匿名对象,并且将匿名对象的引用传给父类声明的对象speak，可以理解为对象的上转型
            @Override
            public void speakHello() {
                System.out.println("嗨喽");
            }
        };
        speak.speakHello();
        Student student=new Student();
        student.f(new Speak() {   //使用匿名类创建匿名对象，并且将匿名对象的引用传递给匹配的参数
            @Override
            public void speakHello() {
                System.out.println("hello");
            }
        });
    }
}

二、和接口有关的匿名类

1.我们可以直接使用接口名和一个类体创建一个匿名对象，这个类体被称为是实现了这个接口的类去掉类声明后的类体，称为匿名类。
2.如果某个方法的参数是接口类型，那么可以使用接口名和类体组合创建一个匿名对象传递给这个方法的参数，但类体必须重写接口中的所有方法。
具体示例：

interface Cubic{
    double getCubic(double x);
}

class A{
    void f(Cubic cu){
        double result=cu.getCubic(3);
        System.out.println("result="+result);
    }
}

public class Test {
    public static void main(String[] args) {
        Cubic cubic=new Cubic() { //使用实现了接口的匿名类创建匿名对象，并且将对象的引用赋值给接口变量。
            @Override
            public double getCubic(double x) {
                return x*x*x;
            }
        };
        System.out.println(cubic.getCubic(5)); // 接口回调
        A a=new A();
        a.f(new Cubic() { //使用实现了接口的匿名类创建匿名对象，并且将对象的引用传递给匹配的参数
            @Override
            public double getCubic(double x) {
                return x*x*x;
            }
        });
    }
}

既然都看完了，那就点个赞支持一下再走呗~ ~ 蟹蟹o

一、java中的匿名类

java的观察者模式：

//观察者
public interface Observer{	
	public void update();
}

//被观察主体
public class Subject{
	private Array<Observer> observers;
	
	public void attach(Observer observer){
		observers.add(observer);
	}
	
	public void notifyAllObservers(){
		for (Observer observer : observers) {
        	observer.update();
        }
	}
}

主函数

class Main{
	public static void main(String[] args) {
        Subject subject = new Subject();
        subject.attach(new Observer(){
        	private int state = 0;//状态
        	public void update(){
        		state++;
				System.out.println("当前状态为" + Integer.toString(state));
			}
		})
    }
}

二、C++匿名类模仿实现

C++没有直接提供匿名类，但说到底，java匿名类主要解决问题如下：
1、保证依赖于接口提供方法的具体实现，从而保证解耦，使得添加的匿名类对同一接口能够有不同的行为。
2、提高可读性，因为添加的匿名类的方法实现就在附近，可以直接阅读，而无需跳到对应的类文件阅读。
3、保持简洁性，这是匿名性所带来的，因为没有命名一个具体的类占用命名空间，因此不会导致类的数目过多，而导致后期难以维护。

C++虽然没有匿名类，但是有匿名对象和匿名函数，可以实现类似的效果。

#include<vector>
#include<iostream>
#include<memory>
using namespace std;
//观察者
class Observer 
{
public: 
	Observer(void  (*doA)()) :doAction(doA) {}
	void (*doAction)();//函数指针
};

//被观察主体
class Subject 
{
	vector<Observer> observers;
public:
	void attach(Observer observer) 
	{
		observers.push_back(observer);
	}
	void notifyAllObservers() 
	{
		for (auto it = observers.begin(); it != observers.end(); it++)
		{
			it->doAction();
		}
	}
};

int main() 
{
	Subject sj;
	sj.attach(Observer([] {static int state = 0; state++; cout << "匿名类1当前状态为"<<state<<endl; }));//匿名函数
	sj.attach(Observer([] {static int state = 2; state++; cout << "匿名类2当前状态为"<<state<<endl; }));
	sj.notifyAllObservers();
}

这种方式虽然没有像java一样约定一个接口类，然后在用匿名类去实现接口方法，但也通过函数指针的方式，约定了函数名、函数的参数列表以及函数的返回值。