Android什么是匿名内部类,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();*/

}

}