《Java编程思想》学习笔记3——内部类
2013-02-22 14:46
211 查看
1.java中,可以将一个类的定义放在另一个类的内部,这种叫做内部类。
内部类允许编程人员将逻辑上相关的类组织在一起,并且控制内部类对其他类的可见性。
2.在外部类的非静态方法中创建内部类的对象语法:
外部类类名.内部类类名 对象名 = 外部类对象.new 内部类类名();
如:
[java] view plaincopyprint?
public class Outter{ class inner{ } } Outter out = new Outter(); Outter.Inner inner = out.new Inner();
注意:非静态的内部类必须要有外部类对象之后才能创建,因为外部类对象持有内部类的引用,如果内部类是静态的,则不需要外部类对象引用内部类对象。
3.内部类对外部类对象的引用:
外部类中所有的元素对内部类都是可见的,内部类持有对外部类对象引用的语法:外部类名称.this。如:
[java] view plaincopyprint?
public class Outter{ void f(){ System.out.println(“Outter f() method”); } class Inner{ public Outter outer(){ return Outter.this; } } public Inner inner(){ return new Inner(); } }
4.方法内部类:
除了最常见的最为成员变量的内部类以外,内部类还可以定义在方法中,如:
[java] view plaincopyprint?
public class Outter{ public Inner getInner(){ class Inner{ public void f(){ System.out.println(“Method inner class”); } } return new Inner(); } public void fout(){ Inner inner = getInner(); inner.f(); } }
5.匿名内部类:
Java中匿名内部类的应用十分广泛,所谓的匿名内部类就是指所创建的内部类没有类名称,也就是不知道内部类的具体类型,如:
[java] view plaincopyprint?
public class Outter{ public Inner getInner(){ return new Inner(){ private String name = “inner”; public String getName(){ return name; } }; } }
上面的return newInner{……};就是一个匿名内部类,这个匿名内部类继承了Inner类,即其基类是Inner,但是其具体类型不清楚,该匿名内部类等效于下面的内部类写法:
[java] view plaincopyprint?
public class Outter{ class MyInner implement Inner{ private String name = “Inner class”; public String getName(){ return name; } } public Inner getInner(){ return new MyInner(); } }
注意:匿名内部类是实现了new关键字之后的接口或继承了类,只是没有具体的类名称。
6.匿名内部类传递final参数:
如果在创建匿名内部类,需要外部类传递参数时,参数必须是final类型的,否则,编译时会报错。如:
[java] view plaincopyprint?
public class Outter{ public Inner getInner(final String name){ return new Inner(){ public name getName(){ return name; } }; } }
注意:如果外部类传递的参数在内部类中使用,则必须是final类型,如果没有在内部类中使用(如,仅在基类中使用),则可以不用是final类型的。
7.静态内部类:
静态内部类又称为嵌套类,静态内部类和普通内部类的区别:
(1).对于非静态的内部类来说,内部类和外部类必须保持对象引用,内部类可以访问外部类的任何元素.
(2).静态内部类不需要和外部类保持对象引用,静态内部类只能访问外部类的静态元素。
8.为什么要使用内部类:
使用内部类主要有以下两个原因:
(1).解决java中类不能多继承的问题:
Java中的继承是单继承,在某些情况下接口的多继承可以解决大部分类似C++中多继承的问题,但是如果一个类需要继承两个父类而不是接口,在java中是没法实现这种功能的,内部类可以帮助我们部分解决这种问题,如:
[java] view plaincopyprint?
abrstact class A{ abstract public void f(); } abstract class B{ abstract public void g(); } public class D extends A{ public void f(){} public B makeB(){ return new B(){ public void g(){}; } } }
这样既继承了A类,有在makeB方法中使用匿名内部类继承了B类。
(2).闭包方法问题:
在面向对象中有个术语叫闭包,所谓闭包是指一个可调用的对象,它记录了一些信息,这些信息来自于创建它的作用域。Java中不支持闭包,但是java的内部类可以看作是对闭包的一种解决方案,因为外部类的所有元素对于普通的内部类来说都是可见的,并且内部类还包含一个指向外部类的对象引用,因此在作用域内,内部类有权操作外部类的所有成员包括private成员。如:
[java] view plaincopyprint?
interface Incrementable {
void increment();
}
class Callee1 implements Incrementable {
private int i=0;
public void increment() {
i++;
System.out.println(i);
}
}
class MyIncrement {
void increment() {
System.out.println("other increment");
}
static void f(MyIncrement mi) {
mi.increment();
}
}
class Callee2 extends MyIncrement {
private int i=0;
private void incr() {
i++;
System.out.println(i);
}
//闭包内部类
private class Closure implements Incrementable {
public void increment() {
incr();
}
}
//回调函数
Incrementable getCallbackReference() {
//新建内部类
return new Closure();
}
}
class Caller {
private Incrementable callbackRefference;
Caller(Incrementable cbh) {
callbackRefference = cbh;
}
void go() {
//调用increment()方法
callbackRefference.increment();
}
}
public class Callbacks {
public static void main(String [] args) {
Callee1 c1=new Callee1();
Callee2 c2=new Callee2();
MyIncrement.f(c2);
Caller caller1 =new Caller(c1);
//将内部类中的Closure赋给Caller
Caller caller2=new Caller(c2.getCallbackReference());
caller1.go();
caller1.go();
caller2.go();
caller2.go();
}
}
输出:
other increment
1
2
1
2
Callee2 通过使用内名内部类提供了一个访问自身increment方法的钩子,
通过getCallbackReference()方法获取内部类对象的引用,进而通过内部类的increment方法调用外部类的回调方法,这就是java中用于实现回调方法的闭包。
内部类允许编程人员将逻辑上相关的类组织在一起,并且控制内部类对其他类的可见性。
2.在外部类的非静态方法中创建内部类的对象语法:
外部类类名.内部类类名 对象名 = 外部类对象.new 内部类类名();
如:
[java] view plaincopyprint?
public class Outter{ class inner{ } } Outter out = new Outter(); Outter.Inner inner = out.new Inner();
public class Outter{ class inner{ } } Outter out = new Outter(); Outter.Inner inner = out.new Inner();
注意:非静态的内部类必须要有外部类对象之后才能创建,因为外部类对象持有内部类的引用,如果内部类是静态的,则不需要外部类对象引用内部类对象。
3.内部类对外部类对象的引用:
外部类中所有的元素对内部类都是可见的,内部类持有对外部类对象引用的语法:外部类名称.this。如:
[java] view plaincopyprint?
public class Outter{ void f(){ System.out.println(“Outter f() method”); } class Inner{ public Outter outer(){ return Outter.this; } } public Inner inner(){ return new Inner(); } }
public class Outter{ void f(){ System.out.println(“Outter f() method”); } class Inner{ public Outter outer(){ return Outter.this; } } public Inner inner(){ return new Inner(); } }
4.方法内部类:
除了最常见的最为成员变量的内部类以外,内部类还可以定义在方法中,如:
[java] view plaincopyprint?
public class Outter{ public Inner getInner(){ class Inner{ public void f(){ System.out.println(“Method inner class”); } } return new Inner(); } public void fout(){ Inner inner = getInner(); inner.f(); } }
public class Outter{ public Inner getInner(){ class Inner{ public void f(){ System.out.println(“Method inner class”); } } return new Inner(); } public void fout(){ Inner inner = getInner(); inner.f(); } }
5.匿名内部类:
Java中匿名内部类的应用十分广泛,所谓的匿名内部类就是指所创建的内部类没有类名称,也就是不知道内部类的具体类型,如:
[java] view plaincopyprint?
public class Outter{ public Inner getInner(){ return new Inner(){ private String name = “inner”; public String getName(){ return name; } }; } }
public class Outter{ public Inner getInner(){ return new Inner(){ private String name = “inner”; public String getName(){ return name; } }; } }
上面的return newInner{……};就是一个匿名内部类,这个匿名内部类继承了Inner类,即其基类是Inner,但是其具体类型不清楚,该匿名内部类等效于下面的内部类写法:
[java] view plaincopyprint?
public class Outter{ class MyInner implement Inner{ private String name = “Inner class”; public String getName(){ return name; } } public Inner getInner(){ return new MyInner(); } }
public class Outter{ class MyInner implement Inner{ private String name = “Inner class”; public String getName(){ return name; } } public Inner getInner(){ return new MyInner(); } }
注意:匿名内部类是实现了new关键字之后的接口或继承了类,只是没有具体的类名称。
6.匿名内部类传递final参数:
如果在创建匿名内部类,需要外部类传递参数时,参数必须是final类型的,否则,编译时会报错。如:
[java] view plaincopyprint?
public class Outter{ public Inner getInner(final String name){ return new Inner(){ public name getName(){ return name; } }; } }
public class Outter{ public Inner getInner(final String name){ return new Inner(){ public name getName(){ return name; } }; } }
注意:如果外部类传递的参数在内部类中使用,则必须是final类型,如果没有在内部类中使用(如,仅在基类中使用),则可以不用是final类型的。
7.静态内部类:
静态内部类又称为嵌套类,静态内部类和普通内部类的区别:
(1).对于非静态的内部类来说,内部类和外部类必须保持对象引用,内部类可以访问外部类的任何元素.
(2).静态内部类不需要和外部类保持对象引用,静态内部类只能访问外部类的静态元素。
8.为什么要使用内部类:
使用内部类主要有以下两个原因:
(1).解决java中类不能多继承的问题:
Java中的继承是单继承,在某些情况下接口的多继承可以解决大部分类似C++中多继承的问题,但是如果一个类需要继承两个父类而不是接口,在java中是没法实现这种功能的,内部类可以帮助我们部分解决这种问题,如:
[java] view plaincopyprint?
abrstact class A{ abstract public void f(); } abstract class B{ abstract public void g(); } public class D extends A{ public void f(){} public B makeB(){ return new B(){ public void g(){}; } } }
abrstact class A{ abstract public void f(); } abstract class B{ abstract public void g(); } public class D extends A{ public void f(){} public B makeB(){ return new B(){ public void g(){}; } } }
这样既继承了A类,有在makeB方法中使用匿名内部类继承了B类。
(2).闭包方法问题:
在面向对象中有个术语叫闭包,所谓闭包是指一个可调用的对象,它记录了一些信息,这些信息来自于创建它的作用域。Java中不支持闭包,但是java的内部类可以看作是对闭包的一种解决方案,因为外部类的所有元素对于普通的内部类来说都是可见的,并且内部类还包含一个指向外部类的对象引用,因此在作用域内,内部类有权操作外部类的所有成员包括private成员。如:
[java] view plaincopyprint?
interface Incrementable {
void increment();
}
class Callee1 implements Incrementable {
private int i=0;
public void increment() {
i++;
System.out.println(i);
}
}
class MyIncrement {
void increment() {
System.out.println("other increment");
}
static void f(MyIncrement mi) {
mi.increment();
}
}
class Callee2 extends MyIncrement {
private int i=0;
private void incr() {
i++;
System.out.println(i);
}
//闭包内部类
private class Closure implements Incrementable {
public void increment() {
incr();
}
}
//回调函数
Incrementable getCallbackReference() {
//新建内部类
return new Closure();
}
}
class Caller {
private Incrementable callbackRefference;
Caller(Incrementable cbh) {
callbackRefference = cbh;
}
void go() {
//调用increment()方法
callbackRefference.increment();
}
}
public class Callbacks {
public static void main(String [] args) {
Callee1 c1=new Callee1();
Callee2 c2=new Callee2();
MyIncrement.f(c2);
Caller caller1 =new Caller(c1);
//将内部类中的Closure赋给Caller
Caller caller2=new Caller(c2.getCallbackReference());
caller1.go();
caller1.go();
caller2.go();
caller2.go();
}
}
输出:
other increment
1
2
1
2
Callee2 通过使用内名内部类提供了一个访问自身increment方法的钩子,
通过getCallbackReference()方法获取内部类对象的引用,进而通过内部类的increment方法调用外部类的回调方法,这就是java中用于实现回调方法的闭包。
相关文章推荐
- 《java编程思想》学习笔记——内部类四
- 《Java编程思想》学习笔记3——内部类
- 《java编程思想》学习笔记——内部类三
- 《Java编程思想》学习笔记:内部类
- 《java编程思想》学习笔记——内部类二
- 《java编程思想》学习笔记——内部类一
- 《Java编程思想》学习笔记3——内部类
- 《Java编程思想》学习笔记3——内部类
- 《Java编程思想》学习笔记3——内部类
- 《JAVA编程思想》学习笔记——第十章 内部类
- 《java编程思想》学习笔记——内部类五
- 《Java编程思想》学习笔记3——内部类
- 《Java编程思想》学习笔记13——Java new I/O(二)
- 《java编程思想》学习笔记—对象导论
- 《Java编程思想》学习笔记11——Java I/O
- 《Java编程思想》学习笔记15——对象序列化
- 《Java编程思想》学习笔记17——注解Annotation
- 《Java编程思想》学习笔记(二)——构建Java类和Java程序
- 《Java编程思想》之更好了解内部类的价值(一个简单的例子)
- 《Java编程思想》学习笔记4——集合容器