前言
闭包(closure)是一个可调用的对象,它记录了一些信息,这些信息来自于创建它的作用域。通过这个定义,可以看出内部类是面向对象的闭包,因为它不仅包含外围类对象(创建内部类的作用域)的信息,还自动拥有一个指向此外围类对象的引用,在此作用城内,内部类有权操作所有的成员,包括private成员。
Java最引人争议的问题之一就是,人们认为Java应该包含某种类似指针的机制,以允许回调(callback)。通过回调,对象能够携带一些信息,这些信息允许它在稍后的某个时刻调用初始的对象。如果回调是通过指针实现的,那么就只能寄希望于程序员不会误用该指针。
一、成员内部类
可以把一个内部类看做一个成员。成员内部类可以无条件访问外部类的所有成员属性和成员方法。
1
2
3
4
5
6
7
8
9
10
11
12
13
|
class OutterClass { //外部类
private int in = 0 ;
static int inn= 4 ;
public OutterClass( int in) {
this .in = in;
}
class InnerClass { //内部类
public void output() {
System.out.println(in);
System.out.println(inn);
}
}
}
|
当成员内部类拥有和外部类同名的成员变量或者方法时,默认情况下访问的是成员内部类的成员。如果要访问外部类的同名成员,需要以下面的形式进行访问:
1
|
OutterClass(外部类). this .成员
|
外部类访问内部类,必须先创建一个成员内部类的对象,再通过指向这个对象的引用来访问。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
class OutterClass {
private int in = 0 ;
static int inn= 4 ;
public OutterClass( int in) {
InnerClass inner= new InnerClass();
this .in=inner.innerNum;
}
class InnerClass { //内部类
public int innerNum= 1 ;
public void output() {
System.out.println(in);
System.out.println(inn);
int a=OutterClass. this .inn;
}
}
}
|
成员内部类是依附外部类而存在的,也就是说,如果要创建成员内部类的对象,前提是必须存在一个外部类的对象。创建成员内部类对象的一般方式如下:
1
2
3
4
5
6
|
public class classa {
public static void main(){
OutterClass oc= new OutterClass( 3 );
OutterClass.InnerClass in=oc. new InnerClass();
}
}
|
二、局部内部类
局部内部类就像是方法里面的一个局部变量一样,是不能有public
、protected
、private
以及static
修饰符的。
1
2
3
4
5
6
7
|
class OutterClass {
public OutterClass( int in) {
class InnerClass { //局部内部类
int innerNum= 1 ;
}
}
}
|
三、嵌套内部类
嵌套内部类,就是修饰为static
的内部类。声明为static
的内部类,不需要内部类对象和外部类对象之间的联系,就是说我们可以直接引用outer.inner
,即不需要创建外部类,也不需要创建内部类。
1
2
3
4
5
6
7
8
9
10
11
12
|
class OutterClass {
public OutterClass( int in) {
}
static class InnerClass { //局部内部类
int innerNum= 1 ;
}
}
public class classa {
public static void main(){
OutterClass.InnerClass in= new OutterClass.InnerClass();
}
}
|
四、匿名内部类
匿名内部类是我们使用最多的,因为我们并不想给它赋予名字,于是就有了匿名。匿名内部类需要提前定义的。
1
2
3
4
5
|
btnSan.setOnClickListener(newOnClickListener() {
@Override
publicvoidonClick(View v) {
}
});
|
五、闭包和回调
闭包(Closure)是一种能被调用的对象,它保存了创建它的作用域的信息。JAVA并不能显式地支持闭包,但是在JAVA中,闭包可以通过“接口+内部类”来实现。
例如:一个接口程序员和一个基类作家都有一个相同的方法work
,相同的方法名,但是其含义完全不同,这时候就需要闭包。
1
2
3
4
5
6
|
class Writer { //作家基类
void work(){};
}
interface programmer{ //程序员接口
void work();
}
|
闭包实现代码如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
public class WriterProgrammer extends Writer {
@Override
public void work(){
//写作
}
public void code(){
//写代码
}
class ProgrammerInner implements programmer{
@Override
public void work(){
code();
}
}
}
|
在子类中定义了遵循程序员接口规则的内部类,然后使用内部类实现程序员的work()
方法回调code()
方法,在子类中直接实现父类作家的work()
方法。
六、内部类的作用
内部类可以很好的实现隐藏。
一般的非内部类,是不允许有 private
与protected
权限的,但内部类可以
内部类拥有外围类的所有元素的访问权限
可是实现多重继承
可以避免修改接口而实现同一个类中两种同名方法的调用。
七、总结
以上就是这篇文章的全部内容,希望对大家学习或使用Java能有一定的帮助,如果有疑问大家可以留言交流。