from:
http://blog.csdn.net/chenssy/article/details/13170015
http://www.cnblogs.com/nerxious/archive/2013/01/25/2876489.html
http://android.blog.51cto.com/268543/384844
ava中的匿名内部类
匿名内部类就是没有名字的内部类
正因为没有名字,所以匿名内部类只能使用一次,它通常用来简化代码编写
但使用匿名内部类还有个前提条件:必须继承一个父类或实现一个接口
格式:
Class/Interface p = new <span style="font-family: 'Helvetica Neue', Helvetica, Arial, sans-serif;">Class/Interface</span>() {// new --
public void override() {
//System.out.println("eat something");
}
};//注意冒号
实例1:不使用匿名内部类来实现抽象方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
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:匿名内部类的基本实现,这里理论上抽象类不可以new----但是使用匿名内部类!!! can!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
abstract
class
Person {
public
abstract
void
eat();
}
public
class
Demo {
public
static
void
main(String[] args) {
Person p =
new
Person() {// new --
public
void
eat() {
System.out.println(
"eat something"
);
}
};
p.eat();
}
}
|
运行结果:eat something
可以看到,我们直接将抽象类Person中的方法在大括号中实现了
这样便可以省略一个类的书写
并且,匿名内部类还能用于接口上
实例3:在接口上使用匿名内部类
interface
Person {
public
void
eat();
}
public
class
Demo {
public
static
void
main(String[] args) {
Person p =
new
Person() {//new interface
public
void
eat() {
System.out.println(
"eat something"
);
}
};
p.eat();
}
}
|
运行结果:eat something
由上面的例子可以看出,只要一个类是抽象的或是一个接口,那么其子类中的方法都可以使用匿名内部类来实现
最常用的情况就是在多线程的实现上,因为要实现多线程必须继承Thread类或是继承Runnable接口
实例4:Thread类的匿名内部类实现
public
class
Demo {
public
static
void
main(String[] args) {
Thread t =
new
Thread() {//--实现多线程必须继承Thread类或是继承Runnable接口原因
public
void
run() {
for
(
int
i =
1
; i <=
5
; i++) {
System.out.print(i +
" "
);
}
}
};
t.start();
}
}
|
运行结果:1 2 3 4 5
实例5:Runnable接口的匿名内部类实现
1
2
3
4
5
6
7
8
9
10
11
12
13
|
public
class
Demo {
public
static
void
main(String[] args) {
Runnable r =
new
Runnable() {
public
void
run() {
for
(
int
i =
1
; i <=
5
; i++) {
System.out.print(i +
" "
);
}
}
};
Thread t =
new
Thread(r);
t.start();
}
}
|
运行结果:1 2 3 4 5
-------------------------------------
深入匿名内部类;
一、使用匿名内部类内部类
匿名内部类由于没有名字,所以它的创建方式有点儿奇怪。创建格式如下:
在这里我们看到使用匿名内部类我们必须要继承一个父类或者实现一个接口,当然也仅能只继承一个父类或者实现一个接口。同时它也是没有class关键字,这是因为匿名内部类是直接使用new来生成一个对象的引用。当然这个引用是隐式的。
在Test类中,test()方法接受一个Bird类型的参数,同时我们知道一个抽象类是没有办法直接new的,我们必须要先有实现类才能new出来它的实现类实例。所以在mian方法中直接使用匿名内部类来创建一个Bird实例。
由于匿名内部类不能是抽象类,所以它必须要实现它的抽象父类或者接口里面所有的抽象方法。
对于这段匿名内部类代码其实是可以拆分为如下形式:
在这里系统会创建一个继承自Bird类的匿名类的对象,该对象转型为对Bird类型的引用。
对于匿名内部类的使用它是存在一个缺陷的,就是它仅能被使用一次,创建匿名内部类时它会立即创建一个该类的实例,该类的定义会立即消失,所以匿名内部类是不能够被重复使用。对于上面的实例,如果我们需要对test()方法里面内部类进行多次使用,建议重新定义类,而不是使用匿名内部类。
二、注意事项
在使用匿名内部类的过程中,我们需要注意如下几点:
1、使用匿名内部类时,我们必须是继承一个类或者实现一个接口,但是两者不可兼得,同时也只能继承一个类或者实现一个接口。
2、匿名内部类中是不能定义构造函数的。
3、匿名内部类中不能存在任何的静态成员变量和静态方法。
4、匿名内部类为局部内部类,所以局部内部类的所有限制同样对匿名内部类生效。
5、匿名内部类不能是抽象的,它必须要实现继承的类或者实现的接口的所有抽象方法。
三、使用的形参为何要为final
参考文件:http://android.blog.51cto.com/268543/384844
我们给匿名内部类传递参数的时候,若该形参在内部类中需要被使用,那么该形参必须要为final。也就是说:当所在的方法的形参需要被内部类里面使用时,该形参必须为final。
为什么必须要为final呢?----防止改变----变量子父不一致
首先我们知道在内部类编译成功后,它会产生一个class文件,该class文件与外部类并不是同一class文件,仅仅只保留对外部类的引用。当外部类传入的参数需要被内部类调用时,从java程序的角度来看是直接被调用:
从上面代码中看好像name参数应该是被内部类直接调用?其实不然,在java编译之后实际的操作如下:
所以从上面代码来看,内部类并不是直接调用方法传递的参数,而是利用自身的构造器对传入的参数进行备份,自己内部方法调用的实际上时自己的属性而不是外部方法传递进来的参数。
直到这里还没有解释为什么是final?在内部类中的属性和外部方法的参数两者从外表上看是同一个东西,但实际上却不是,所以他们两者是可以任意变化的,也就是说在内部类中我对属性的改变并不会影响到外部的形参,而然这从程序员的角度来看这是不可行的,毕竟站在程序的角度来看这两个根本就是同一个,如果内部类该变了,而外部方法的形参却没有改变这是难以理解和不可接受的,所以为了保持参数的一致性,就规定使用final来避免形参的不改变。
简单理解就是,拷贝引用,为了避免引用值发生改变,例如被外部类的方法修改等,而导致内部类得到的值不一致,于是用final来让该引用不可改变。
故如果定义了一个匿名内部类,并且希望它使用一个其外部定义的参数,那么编译器会要求该参数引用是final的。
四、匿名内部类初始化
我们一般都是利用构造器来完成某个实例的初始化工作的,但是匿名内部类是没有构造器的!那怎么来初始化匿名内部类呢?使用构造代码块!利用构造代码块能够达到为匿名内部类创建一个构造器的效果。
1. 成员内部类
- public class Outer {
- public static void main(String[] args) {
- Outer outer = new Outer();
- Outer.Inner inner = outer.new Inner();
- inner.print("Outer.new");
- inner = outer.getInner();
- inner.print("Outer.get");
- }
- // 个人推荐使用getxxx()来获取成员内部类,尤其是该内部类的构造函数无参数时
- public Inner getInner() {
- return new Inner();
- }
- public class Inner {
- public void print(String str) {
- System.out.println(str);
- }
- }
- }
2. 局部内部类
- public class Parcel4 {
- public Destination destination(String s) {
- class PDestination implements Destination {
- private String label;
- private PDestination(String whereTo) {
- label = whereTo;
- }
- public String readLabel() {
- return label;
- }
- }
- return new PDestination(s);
- }
- public static void main(String[] args) {
- Parcel4 p = new Parcel4();
- Destination d = p.destination("Tasmania");
- }
- }
- public class Parcel5 {
- private void internalTracking(boolean b) {
- if (b) {
- class TrackingSlip {
- private String id;
- TrackingSlip(String s) {
- id = s;
- }
- String getSlip() {
- return id;
- }
- }
- TrackingSlip ts = new TrackingSlip("slip");
- String s = ts.getSlip();
- }
- }
- public void track() {
- internalTracking(true);
- }
- public static void main(String[] args) {
- Parcel5 p = new Parcel5();
- p.track();
- }
- }
3. 嵌套内部类,静态内部类
4. 匿名内部类
- ((Button) findViewById(R.id.start)).setOnClickListener(new Button.OnClickListener() {
- @Override
- public void onClick(View v) {
- new Thread() {
- @Override
- public void run() {
- // TODO Auto-generated method stub
- }
- }.start();
- }
- });
- public class Outer {
- public static void main(String[] args) {
- Outer outer = new Outer();
- Inner inner = outer.getInner("Inner", "gz");
- System.out.println(inner.getName());
- }
- public Inner getInner(final String name, String city) {
- return new Inner() {
- private String nameStr = name;
- public String getName() {
- return nameStr;
- }
- };
- }
- }
- //注释后,编译时提示类Inner找不到
- /* interface Inner {
- String getName();
- } */
- public class Outer {
- public static void main(String[] args) {
- Outer outer = new Outer();
- Inner inner = outer.getInner("Inner", "gz");
- System.out.println(inner.getName());
- }
- public Inner getInner(final String name, String city) {
- return new Inner(name, city) {
- private String nameStr = name;
- public String getName() {
- return nameStr;
- }
- };
- }
- }
- abstract class Inner {
- Inner(String name, String city) {
- System.out.println(city);
- }
- abstract String getName();
- }
- public class Outer {
- public static void main(String[] args) {
- Outer outer = new Outer();
- Inner inner = outer.getInner("Inner", "gz");
- System.out.println(inner.getName());
- System.out.println(inner.getProvince());
- }
- public Inner getInner(final String name, final String city) {
- return new Inner() {
- private String nameStr = name;
- private String province;
- // 实例初始化
- {
- if (city.equals("gz")) {
- province = "gd";
- }else {
- province = "";
- }
- }
- public String getName() {
- return nameStr;
- }
- public String getProvince() {
- return province;
- }
- };
- }
- }
- interface Inner {
- String getName();
- String getProvince();
- }
5.内部类的继承
- public class InheritInner extends WithInner.Inner {
- // InheritInner() 是不能通过编译的,一定要加上形参
- InheritInner(WithInner wi) {
- wi.super();
- }
- public static void main(String[] args) {
- WithInner wi = new WithInner();
- InheritInner obj = new InheritInner(wi);
- }
- }
- class WithInner {
- class Inner {
- }
- }
package test;
public class Foo {
public static void main(String[] args) {
class Goo{//内部类
int test(int i){
int j=1;
return j+i;
}
int test(){//方法的重载
String str="1";
return Integer.parseInt(str);
}
}
Goo goo=new Goo();
System.out.println(goo.test());
}
}