匿名内部类

最新推荐文章于 2023-07-17 02:15:00 发布

naoguaziteng

最新推荐文章于 2023-07-17 02:15:00 发布

阅读量2w

点赞数 58

分类专栏： JAVASE基础知识文章标签： java 匿名内部类

本文链接：https://blog.csdn.net/naoguoteng/article/details/124296273

版权

JAVASE基础知识专栏收录该内容

77 篇文章 29 订阅

订阅专栏

public class MyTest {
    public static void main(String[] args) {

        new Father() {             //new了一个父类抽象类的子类对象.匿名的
            @Override
            //重写了父类中的抽象方法
            public void hehe() {
                System.out.println("呵呵呵呵呵呵");
            }
        };

        //创建了父类的子类对象并且调用重写后的方法
        new Father() {
            @Override
            public void hehe() {
                System.out.println("44444444444444");
            }
        }.hehe();
    }
}

abstract class Father {
    public abstract void hehe();
}

给匿名内部类名命: 虽然这是匿名内部类,但是仍然可以利用多态来给匿名内部类名命的哈!

public class MyTest {
    public static void main(String[] args) {
        //匿名内部类
        new AA() {
            @Override
            public void aa() {
                System.out.println("aaaaaaaaaaaaaaaa");
            }

            @Override
            public void hehe() {
                System.out.println("hehehehehehhehehhe");
            }
        };
        //此时,要想用同一个对象调用多个方法时,就会很难办到.这个时候给匿名内部类名命就可以解决了!
        //利用多态进行名命
        AA aa = new AA() {
            @Override
            public void aa() {
                System.out.println("aaaaaaaaaaaaaa744444aa");
            }

            @Override
            public void hehe() {
                System.out.println("hehehehehe888877777hhehehhe");
            }
        };
        //这样就可以调用多个方法了
        aa.aa();
        aa.hehe();

    }
}

abstract class AA {
    public abstract void aa();

    public abstract void hehe();
}

匿名内部类的好处: 匿名内部类，经常作为参数，或返回值，使用比较方便。

public class MyTest {
    public static void main(String[] args) {
        //匿名内部类，经常作为参数，或返回值，使用比较方便。
       
        test(new WW() {
            @Override
            public void hehe() {
                System.out.println("111111111");
            }
        });
    }

    //方法的形参要一个抽象类类型，传递一个该抽象类的子类对象.
    public static void test(WW ww) {
        ww.hehe();
    }
}


abstract class WW {
    public abstract void hehe();
}

public class MyTest {

    public static void main(String[] args) {
        BB bb = getBB();
        bb.bb();

        //匿名内部类，作为返回值，返回方便
    }

    //方法的返回值是一个抽象类 类型，返回一个该抽象类的子类对象。
    public static BB getBB2() {
        BB b2 = new BB() {

            @Override
            public void bb() {
                System.out.println("bbbbbbbbbbbbbbbbb222222222");
            }
        };
        //匿名内部类，作为返回值，返回方便
        return b2;
    }
}

abstract class BB {
    public abstract void bb();
}

一个类中可以嵌套一个接口:

public class MyTest2 {
    public static void main(String[] args) {
        new Inter() {
            public void show() {
                //this 代表匿名内部类
                System.out.println(this.a);          
                System.out.println(Inter.a);         


            }
        }.show();

    }
}


interface Inter {
    public static final int a = 23;
}

(小编也在努力学习更多哟!以后会多多分享哒!)

希望对友友们有所帮助!!!