JAVA之匿名内部类

JAVA之匿名内部类

1. 匿名内部类：他是局部内部类的一种简写形式。
2. 语法格式：new 接口名/类名(){重写方法}
3. 匿名内部类的本质：匿名内部类本质上是一个对象，是实现了该接口或者继承了该抽象类的子类对象。
4. 优点：接口和抽象类不能直接new对象只能借助继承或者实现来new子类的对象，这时候匿名内部类就起到了作用他为我们提供了匿名对象后，不需要再通过实现或者继承来new子类对象来实现方法

代码示例：抽象类示例

public class MyTest {
    public static void main(String[] args) {
        new MyClass(){
            public void show() {
                System.out.println("重写了父类的抽象方法");
            }
        }.show();//此时的new MyClass(){重写方法}就是A的对象，然后访问show方法，编译看左边运行也看左边执行重写后的show()方法
    }
}
abstract class MyClass {
        public abstract void show();
}
class A extends MyClass{
    public void show() {
    }
}

代码示例：接口示例

public class MyTest2 {
    public static void main(String[] args) {
        new MyInterface(){
            @Override
            public void show() {
                System.out.println("aaaa");
            }
        };
        new MyInterface() {
            @Override
            public void show() {
                System.out.println("bbb");
            }
        }.show();
        new MyInterface() {
            @Override
            public void show() {
                System.out.println("ccc");
            }
        }.show();
    }
}
interface  MyInterface{
    void show();
}

分析：new MyInterface(){
@Override
public void show() {
System.out.println(“aaaa”);
}
};创建了一个匿名对象后没有调用show方法

​ new MyInterface() {
​ @Override
​ public void show() {
​ System.out.println(“bbb”);
​ }
​ }.show(); 创建了一个匿名对象后去调用重写后的show方法
​ new MyInterface() {
​ @Override
​ public void show() {
​ System.out.println(“ccc”);
​ }
​ }.show(); 创建了一个对象后去调用了重写后的show方法

//三次new MyInterface(){重写方法}创建了三个匿名对象

但是以上的代码有一个缺陷就是 去调用不同的show方法，需要new不同的匿名对象，但是我想只new一个匿名对象去实现多个方法这个时候怎么办呢？

多态

public class MyTest {
    public static void main(String[] args) {
        MyInterface myInterface = new MyInterface() {
            public void aa() {
                System.out.println("aaaaaaaaaaaaaaa");
            }
            public void bb() {
                System.out.println("bbbbbbbbb");
            }
        };
        myInterface.aa();
        myInterface.bb();
    }
}
interface MyInterface {
    void aa();

    void bb();
}

分析：上面的new MyInterface() {重写方法}为实现的对象，此时防接口去接收它，相当于是多态

这个时候用接口的对象 myInterface就可以去实现多个方法

第二部分：匿名内部类的应用

1. 匿名内部类经常可以作为参数来传递。比较方便
2. 匿名内部类，作为返回值来返回

匿名内部类作参数代码：

public class MyTest {
    public static void main(String[] args) {
        MyInterface myInterface = new MyInterface() {
            @Override
            public void aa() {
                System.out.println("aaaaaaaaaaaaaaaaaa");
            }
        };
        set(myInterface);

        set(new Animal() {
            @Override
            public void eat() {
                System.out.println("猫吃鱼");
            }
        });
    }
    public static void  set(MyInterface myInterface){
        myInterface.aa();
    }
    public static void set(Animal an) {
        an.eat();
    }
}
interface MyInterface{
    void aa();
}
abstract class Animal{
    public abstract void eat();
}

匿名内部类作返回值代码：

ublic class MyTest {
    public static void main(String[] args) {
        Myinterface instance = getInstance();
        instance.aa();
        Animal instance2 = getInstance2();
        instance2.sleep();
    }
    public static Myinterface getInstance() {
        return new Myinterface() {
            @Override
            public void aa() {
                System.out.println("aaaaaaaaaaaaaaaaa");
            }
        };
    }
    public static Animal getInstance2() {
        Animal an = new Animal() {
            @Override
            public void sleep() {
                System.out.println("天天睡觉");
            }
        };
        return an;
    }
}
interface Myinterface {
    void aa();
}
abstract class Animal {
    public abstract void sleep();
}

第三部分：匿名对象中this关键字

 interface Inter {
		public static final int a = 23 ;
	}
public class Test {
	public static void main(String[] args) {
		new Inter() {
			public void show() {
				//this 代表匿名内部类 也就是接口的实现的子类对象
				System.out.println(this.a);
			}
		}.show();
	}
}