《Java编程思想》学习笔记3——内部类

1.java中,可以将一个类的定义放在另一个类的内部,这种叫做内部类。

内部类允许编程人员将逻辑上相关的类组织在一起,并且控制内部类对其他类的可见性。

2.在外部类的非静态方法中创建内部类的对象语法:

外部类类名.内部类类名 对象名 = 外部类对象.new 内部类类名();

如:

[java]  view plain copy
  1. public class Outter{  
  2.     class inner{  
  3. }  
  4. }  
  5. Outter out = new Outter();  
  6. Outter.Inner inner = out.new Inner();  

注意:非静态的内部类必须要有外部类对象之后才能创建,因为外部类对象持有内部类的引用,如果内部类是静态的,则不需要外部类对象引用内部类对象。

3.内部类对外部类对象的引用:

外部类中所有的元素对内部类都是可见的,内部类持有对外部类对象引用的语法:外部类名称.this。如:

[java]  view plain copy
  1. public class Outter{  
  2.     void f(){  
  3. System.out.println(“Outter f() method”);  
  4. }  
  5.     class Inner{  
  6.     public Outter outer(){  
  7.         return Outter.this;  
  8. }  
  9. }  
  10.     public Inner inner(){  
  11.         return new Inner();  
  12. }  
  13. }  

4.方法内部类:

除了最常见的最为成员变量的内部类以外,内部类还可以定义在方法中,如:

[java]  view plain copy
  1. public class Outter{  
  2.     public Inner getInner(){  
  3.         class Inner{  
  4.             public void f(){  
  5.     System.out.println(“Method inner class”);  
  6. }  
  7. }  
  8. return new Inner();  
  9. }  
  10. public void fout(){  
  11.     Inner inner = getInner();  
  12.     inner.f();  
  13. }  
  14. }  

5.匿名内部类:

Java中匿名内部类的应用十分广泛,所谓的匿名内部类就是指所创建的内部类没有类名称,也就是不知道内部类的具体类型,如:

[java]  view plain copy
  1. public class Outter{  
  2.     public Inner getInner(){  
  3.         return new Inner(){  
  4.             private String name = “inner”;  
  5.             public String getName(){  
  6.     return name;  
  7. }  
  8. };  
  9. }  
  10. }  

上面的return newInner{……};就是一个匿名内部类,这个匿名内部类继承了Inner类,即其基类是Inner,但是其具体类型不清楚,该匿名内部类等效于下面的内部类写法:

[java]  view plain copy
  1. public class Outter{  
  2.     class MyInner implement Inner{  
  3.         private String name = “Inner class”;  
  4.         public String getName(){  
  5.             return name;  
  6. }  
  7. }  
  8. public Inner getInner(){  
  9.     return new MyInner();  
  10. }  
  11. }  

注意:匿名内部类是实现了new关键字之后的接口或继承了类,只是没有具体的类名称。

6.匿名内部类传递final参数:

如果在创建匿名内部类,需要外部类传递参数时,参数必须是final类型的,否则,编译时会报错。如:

[java]  view plain copy
  1. public class Outter{  
  2.     public Inner getInner(final String name){  
  3.         return new Inner(){  
  4.             public name getName(){  
  5.                 return name;  
  6. }  
  7. };  
  8. }  
  9. }  

注意:如果外部类传递的参数在内部类中使用,则必须是final类型,如果没有在内部类中使用(如,仅在基类中使用),则可以不用是final类型的。

7.静态内部类:

静态内部类又称为嵌套类,静态内部类和普通内部类的区别:

(1).对于非静态的内部类来说,内部类和外部类必须保持对象引用,内部类可以访问外部类的任何元素.

(2).静态内部类不需要和外部类保持对象引用,静态内部类只能访问外部类的静态元素。

8.为什么要使用内部类:

使用内部类主要有以下两个原因:

(1).解决java中类不能多继承的问题:

Java中的继承是单继承,在某些情况下接口的多继承可以解决大部分类似C++中多继承的问题,但是如果一个类需要继承两个父类而不是接口,在java中是没法实现这种功能的,内部类可以帮助我们部分解决这种问题,如:

[java]  view plain copy
  1. abrstact class A{  
  2.     abstract public void f();  
  3. }  
  4. abstract class B{  
  5. abstract public void g();  
  6. }  
  7. public class D extends A{  
  8.     public void f(){}  
  9.     public B makeB(){  
  10.         return new B(){  
  11.             public void g(){};  
  12. }  
  13. }  
  14. }  

这样既继承了A类,有在makeB方法中使用匿名内部类继承了B类。

(2).闭包方法问题:

在面向对象中有个术语叫闭包,所谓闭包是指一个可调用的对象,它记录了一些信息,这些信息来自于创建它的作用域。Java中不支持闭包,但是java的内部类可以看作是对闭包的一种解决方案,因为外部类的所有元素对于普通的内部类来说都是可见的,并且内部类还包含一个指向外部类的对象引用,因此在作用域内,内部类有权操作外部类的所有成员包括private成员。如:

[java]  view plain copy
  1. interface Incrementable  {    
  2.     void increment();    
  3. }    
  4.   
  5. class Callee1 implements Incrementable  {    
  6. private int i=0;    
  7. public void increment()  {    
  8. i++;    
  9. System.out.println(i);    
  10. }    
  11. }    
  12.   
  13. class MyIncrement  {    
  14. void increment()  {    
  15. System.out.println("other increment");    
  16. }    
  17. static void f(MyIncrement mi)  {    
  18.         mi.increment();    
  19. }    
  20. }    
  21.   
  22. class Callee2 extends MyIncrement  {    
  23. private int i=0;    
  24. private void incr()  {    
  25. i++;    
  26. System.out.println(i);    
  27. }    
  28. //闭包内部类  
  29. private class Closure implements Incrementable {    
  30. public void increment() {    
  31. incr();    
  32. }    
  33. }    
  34. //回调函数  
  35. Incrementable getCallbackReference()  {   
  36. //新建内部类     
  37. return new Closure();   
  38. }    
  39. }    
  40.   
  41. class Caller {    
  42. private Incrementable callbackRefference;    
  43. Caller(Incrementable cbh)  {    
  44. callbackRefference = cbh;    
  45. }    
  46. void go() {    
  47. //调用increment()方法  
  48. callbackRefference.increment();   
  49. }    
  50. }    
  51.   
  52. public class Callbacks  {    
  53. public static void main(String [] args) {    
  54. Callee1 c1=new Callee1();    
  55. Callee2 c2=new Callee2();    
  56. MyIncrement.f(c2);    
  57. Caller caller1 =new Caller(c1);    
  58. //将内部类中的Closure赋给Caller    
  59. Caller caller2=new Caller(c2.getCallbackReference());  
  60. caller1.go();    
  61. caller1.go();    
  62. caller2.go();    
  63. caller2.go();    
  64. }    
  65. }  
输出:
other increment
1
2
1
2
Callee2 通过使用内名内部类提供了一个访问自身increment方法的钩子,
通过getCallbackReference()方法获取内部类对象的引用,进而通过内部类的increment方法调用外部类的回调方法,这就是java中用于实现回调方法的闭包。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值