Java拾贝第六天——匿名内部类

Java拾贝不建议作为0基础学习，都是本人想到什么写什么

匿名内部类

匿名对象没忘吧？

new Person();//语法同匿名内部类

匿名内部类就是匿名的局部内部类，地位同局部变量。

有两种形式：基于接口的匿名内部类，基于类的匿名内部类

基于接口的匿名内部类

常规方式实现接口并重写其方法

public class Test6 {
    public static void main(String[] args) {
        A a=new B();
        a.say();
    }
}
interface A{//定义接口
    void say();
}

class B implements A{//定义其实现类
    @Override
    public void say() {
        System.out.println("常规方式实现接口并重写方法");
    }
}
//常规方式实现接口并重写方法

常规方式的实现接口：

1. 先定义接口
2. 再定义实现类
3. 再初始化对象并调用方法

如果该实现类复用率不高的话其实非常不方便(这种显式定义实现类的方式也叫硬编码)。

如果某实现类使用次数少的话可以采用匿名内部类的方式：

public class Test6 {
    public static void main(String[] args) {
        A a = new A() {//对象a指向的一个实现A接口的匿名内部类
            @Override
            public void say() {
                System.out.println("匿名内部类实现接口");
            }
        };
        a.say();
    }
}
interface A{
    void say();
}
//匿名内部类实现接口

其内部结构如下：

        A a=new A(){//匿名内部类的好处就是可以马上初始化
            @Override
            public void say() {
                System.out.println("匿名内部类实现接口");
            }
        };
        a.say();

其实就是一个匿名的局部内部类

        class XXX$1 implements A{
	//匿名内部类 类名一般是外部类名 ($后的数字是匿名内部类出现次数)
            @Override
            public void say() {
                System.out.println("匿名内部类实现接口");
            }
}
A a=XXX;
a.say();

至此，相对于常规方式实现接口：

1. 定义接口
2. 直接初始化并调用方法

基于类的匿名内部类

常规方式继承类并重写其方法(类与类的关系肯定是继承)

public class Test6 {
    public static void main(String[] args) {
        A a=new B();
        a.say();
    }
}

abstract class A {//抽象类普通类都可以
    public abstract void say();
}

class B extends A {
    @Override
    public void say() {
        System.out.println("常规方式继承类并重写方法");
    }
}

常规方式重写类方法：

1. 先定义父类
2. 再定义子类
3. 再初始化对象并调用方法

如果该类复用率不高的话其实非常不方便(硬编码别忘了)。

如果某类使用次数少的话可以采用匿名内部类的方式：

public class Test6 {
    public static void main(String[] args) {
      A a=new A() {
            public A(String name){//匿名内部类不允许重写构造方法
            }
            @Override
            public void say() {
                System.out.println("匿名内部类重写类方法");
            }
        };
        a.say();

    }
}

abstract class A {
    public A(){
        System.out.println("抽象类也可以有构造方法");
    }
    public abstract void say();
}
/*
抽象类也可以有构造方法
匿名内部类重写类方法
*/

其内部结构如下：

        A a=new A() {
            @Override
            public void say() {
                System.out.println("匿名内部类重写类方法");
            }
        };
        a.say();
//或者可以写成如下：

        new A() {
            @Override
            public void say() {
                System.out.println("匿名内部类重写类方法");
            }
        }.say();//但是只能使用一次，连引用的变量都没了

其实就是一个匿名的局部内部类

       class XXX$1 extends A{
            @Override
            public void say() {
                System.out.println("匿名内部类重写类方法");
            }
        }
A a=new XXX$1();
a.say();

至此，相对于常规方式重写类方法：

1. 定义父类
2. 直接初始化并调用方法

注意！！！！！！！

new A(){//这是匿名内部类

};

new A();//这是匿名对象