Android里的匿名内部类

(转)https://blog.csdn.net/qq_25827845/article/details/52598319

匿名内部类也就是没有名字的内部类,正因为没有名字,所以匿名内部类只能使用一次,它通常用来简化代码编写。

但使用匿名内部类还有个前提条件:必须继承一个父类或实现一个接口

1、继承一个父类的匿名内部类实现:

abstractclassPeople{

publicabstractvoideat();

}

publicclassDemo{

publicstaticvoidmain(String[] args){

People p =newPeople() {

publicvoideat(){

System.out.println("I can eat ");

            }

        };

        p.eat();

    }

}

2、在接口上使用匿名内部类:

interfacePeople{

publicvoideat();

}

publicclassDemo{

publicstaticvoidmain(String[] args){

People p =newPeople() {

publicvoideat(){

System.out.println("I can eat ");

            }

        };

        p.eat();

    }

}

 此处 new People( )看似实例化了一个接口,事实并非如此,接口式的匿名内部类是实现了一个接口的匿名类。而且只能实现一个接口。

ps再来说一下线程创建的两种方式:

(1)继承Thread类的方式因为耦合性太强,所以一般不用。

(2)常用实现Runnable接口的创建线程方式。

但是我们更喜欢用匿名内部类的方式来创建一个线程。代码如下:

newThread(newRunnable() {

@Override

publicvoidrun(){

inti=0;

while(true){

i++;

System.out.println("this is 线程"+i);

}

}

}).start();


就这一句话就可以创建并且启动一个线程,相对来说比较方便。而且特别直观易懂。

此处的new Runnable( )并没有实例化了一个接口,切记切记!!!!

匿名内部类(Anonymous Inner Class),在创建实例的同时给出类的定义,所有这些在一个表达式中完成。

Runnable rn = newRunnable() {

    public void run() {

    }

};

相当于:

classAnomymous implementsRunnable {

    public void run() {

    }

}

Runnable rn = newAnomymous();

可以看到前者更简洁。(注意前者最后的分号不能省略,编译器把整个看作一条语句)

不过,匿名内部类仅限于只实例化一次的内部类,如果内部类需要多次实例化,通常用后者。

另外,匿名内部类要么继承一个父类,要么实现一个接口,不能两者兼有,实现接口时也不能实现多个接口。


参考示例(转)

匿名内部类也就是没有名字的内部类

正因为没有名字,所以匿名内部类只能使用一次,它通常用来简化代码编写

但使用匿名内部类还有个前提条件:必须继承一个父类或实现一个接口

实例1:不使用匿名内部类来实现抽象方法

abstract class Person {

    public abstract void eat();

}

class Child extends Person {

    public void eat() {

        System.out.println("eat something");

    }

}


public class Demo {

    public static void main(String[] args) {

        Person p = new Child();

        p.eat();

    }

}

运行结果:eat something

可以看到,我们用Child继承了Person类,然后实现了Child的一个实例,将其向上转型为Person类的引用

但是,如果此处的Child类只使用一次,那么将其编写为独立的一个类岂不是很麻烦?

这个时候就引入了匿名内部类


实例2:匿名内部类的基本实现

abstract class Person {

    public abstract void eat();

}

public class Demo {

    public static void main(String[] args) {

        Person p = new Person() {

            public void eat() {

                System.out.println("eat something");

            }

        };

        p.eat();

    }

}

运行结果:eat something

可以看到,我们直接将抽象类Person中的方法在大括号中实现了

这样便可以省略一个类的书写

并且,匿名内部类还能用于接口上


实例3:在接口上使用匿名内部类

interfacePerson {

    publicvoideat();

}


publicclassDemo {

    publicstaticvoidmain(String[] args) {

        Person p = newPerson() {

            publicvoideat() {

                System.out.println("eat something");

            }

        };

        p.eat();

    }

}

运行结果:eat something


由上面的例子可以看出,只要一个类是抽象的或是一个接口,那么其子类中的方法都可以使用匿名内部类来实现

最常用的情况就是在多线程的实现上,因为要实现多线程必须继承Thread类或是继承Runnable接口


实例4:Thread类的匿名内部类实现

publicclassDemo{

publicstaticvoidthreadMethod(String name){

Thread t =newThread(name) {

publicvoidrun(){

for(inti =1; i <=5; i++) {

System.out.print(Thread.currentThread().getName()+":"+i +"  ;  ");

                }

            }

        };

        t.start();

}

publicstaticvoidmain(String[] args){

threadMethod("线程1");

threadMethod("线程2");

    }


}

运行结果(不确定):线程1:1   ;   线程1:2   ;   线程1:3   ;   线程2:1   ;   线程1:4   ;   线程2:2   ;   线程1:5   ;   线程2:3   ;   线程2:4   ;   线程2:5   ;   


实例5:Runnable接口的匿名内部类实现

publicclassDemo{

publicstaticvoidthreadMethod(){

Runnable r =newRunnable() {

publicvoidrun(){

for(inti =1; i <=5; i++) {

System.out.print(Thread.currentThread().getName()+":"+i +"   ;   ");

                }

            }

        };

Thread t1 =newThread(r,"线程1");

Thread t2 =newThread(r,"线程2");

        t1.start();

        t2.start();

    }

publicstaticvoidmain(String[] args){

    threadMethod();

    }


}

运行结果(不确定):线程1:1   ;   线程2:1   ;   线程1:2   ;   线程2:2   ;   线程1:3   ;   线程2:3   ;   线程1:4   ;   线程2:4   ;   线程2:5   ;   线程1:5   ;   


---------------------------------------------------------------

ps:上面的继承Thread和实现Runnable是常用的

之前没写过多线程,也记一下下面的吧

packagecom;

publicclassTestRunnableimplementsRunnable{

privateinti =10;

@Override

publicvoidrun(){

System.out.println("TestRunnable class "+Thread.currentThread().getName()+":"+(--i));

}

publicstaticvoidmain(String[] args){

TestRunnable t1 =newTestRunnable();

TestRunnable t2 =newTestRunnable();

//执行出的结果的顺序不确定  变量i copy

newThread(t1).start();

newThread(t2).start();

//执行出的结果的顺序不确定  变量i 共享

/*new Thread(t1,"thread1").start();

new Thread(t1,"thread2").start();*/

}

}

©著作权归作者所有,转载或内容合作请联系作者
平台声明:文章内容(如有图片或视频亦包括在内)由作者上传并发布,文章内容仅代表作者本人观点,简书系信息发布平台,仅提供信息存储服务。

推荐阅读更多精彩内容

  • 1. Java基础部分 基础部分的顺序:基本语法,类相关的语法,内部类的语法,继承相关的语法,异常的语法,线程的语...
    子非鱼_t_阅读 31,754评论 18 399
  • Spring Cloud为开发人员提供了快速构建分布式系统中一些常见模式的工具(例如配置管理,服务发现,断路器,智...
    卡卡罗2017阅读 134,869评论 18 139
  • 一.时间的分类 古希腊人认为时间有两个方面:钟表时间和沉浸时间。钟表时间即客观时间,是由钟表和日历来衡量的,比如每...
    晁逸兴阅读 1,346评论 0 2
  • vhjhhuisnwbbjjsjbbdbjsjj
    仇志轩阅读 127评论 0 5
  • 不才!不才!呀! 小学时就被老师当作薛宝钗.....(此处偷笑) 不过是真的。 竟然三十多岁了,才读了一遍少儿漫画...
    十八k阅读 106评论 0 0