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

合集 - Java拾贝(39)

1.Java拾贝第一天——数据类型与运算符杂记2023-10-152.Java拾贝第二天——方法、方法的重载2023-10-153.Java拾贝第二天——面向对象2023-10-154.Java拾贝第三天——面向对象22023-10-165.Java拾贝第四天——String和匿名对象2023-10-176.Java拾贝第四天——面向对象32023-10-177.Java拾贝第四天——动态绑定机制2023-10-178.Java拾贝第五天——抽象和接口2023-10-189.Java拾贝第五天——静态和代码块2023-10-1810.Java拾贝第五天——内部类2023-10-18

11.Java拾贝第六天——匿名内部类2023-10-19

12.Java拾贝第七天——包装类、BigInteger、BigDecimal2023-10-2013.Java拾贝第七天——异常2023-10-2014.Java拾贝第七天——throws和throw、自定义异常2023-10-2015.Java拾贝第七天——断言2023-10-2016.Java拾贝第八天(补档！)——访问修饰符，命名规范2023-10-2117.Java拾贝第八天——多线程的创建2023-10-2118.Java拾贝第八天——线程的状态和常用方法2023-10-2119.Java拾贝第九天——synchronized关键字2023-10-2320.Java拾贝第九天——泛型2023-10-2321.Java拾贝第十天——通配符与泛型2023-10-2422.Java拾贝第十一天——IO之File类2023-10-2523.Java拾贝第十一天——IO流之字节流2023-10-2524.Java拾贝第十一天——IO流之字符流2023-10-2525.Java拾贝第十一天——IO流之字节流复制图片、视频2023-10-2526.Java拾贝第十二天——IO流之打印流2023-10-2727.Java拾贝第十二天——System类2023-10-2728.Java拾贝第十二天——IO流之转换流2023-10-2729.Java拾贝第十二天——IO流之对象序列化与对象流2023-10-2730.Java拾贝第十三天——集合之List2023-10-3131.Java拾贝第十四天——集合之Set2023-11-0232.Java拾贝第十五天——集合之Iterator迭代器2023-11-0333.Java拾贝第十五天——集合之Map2023-11-0334.Java拾贝第十六天——集合之Queue、Stack2023-11-0435.Java拾贝第十六天——其他集合类Properties2023-11-0436.Java拾贝第十七天——反射之初识Class类2023-11-0537.Java拾贝第十七天——反射之认识反射相关类2023-11-0538.Java拾贝第十八天——反射之使用反射修改属性2023-11-0639.Java拾贝第十九天——注解2023-11-07

收起

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();//这是匿名对象