ITPub博客

首页 > 应用开发 > Java > 内部类一

内部类一

原创 Java 作者:Diy_os 时间:2015-10-24 19:59:04 0 删除 编辑
关于java的内部类,尤其匿名类,会感到无法理解,下文简单实验总结一下。由于内部类涉及很多知识,其中很多没有涉及到。如有表述代码错误,欢迎读者指正!
那为什么使用内部类呢?《thinking in java》第十章中,指出:一般来说,内部类继承自某个类或实现某个接口,内部类的代码操作创建它的外围类的对象,所以可以认为内部类提供了某些进入其外围类的窗口。其最吸引之处,每个内部类都能独立的继承自一个(接口的)实现,所以无论外围类是否已经继承了某个(接口的)实现,对于内部类都没有影响。
内部类和接口可以实现c++中的多继承的作用效果。

简单内部类

点击(此处)折叠或打开

  1. public class Parcell1 {

  2. private int i = 5;
  3.  
  4. class Contents{

  5. private int i = 1;
  6. public int value(){ return Parcell1.this.i;}

  7. }
  8. class Destination{

  9. private String label;
  10. private int i = 6;

  11. Destination(String whereTo){

  12. label = whereTo;
  13. }

  14. String readLabel(){ return label;}


  15. public void ship(String dest){

  16. Contents c = new Contents();
  17. System.out.println(value());
  18. Destination d = new Destination(dest);
  19. System.out.println(d.readLabel());

  20. }
  21. public static void main(String[] args){

  22. Parcell1 p = new Parcell1();
  23. p.ship("wang");

  24. }
  25. }
上面Contents,Destination类在Parcell1内部,Parcell1对象通过调用函数ship,创建了两内部类的对象,然后通过调用内部类的函数,打印出私有域的值。上述看以看出这两个内部类就如外部类的成员一样,逻辑结构比较简单,我把这种内部类称之为简单内部类,当然也可称成员内部类,同理它可以被权限修饰词修饰,如果是private,则只能在外部类内部被访问,若是public,则可以在任意地方被访问,若是protected,则只能在包内和其子类访问,和普通的类成员没有区别。
要注意的是,在内部类Contents中,打印的是外围类的私有域值,由于内部类可以引用外围类的成员变量及方法,引用格式:

外部类.this.成员变量
外部类.this.成员方法


局部内部类:
顾名思义,这种类定义在方法内或者域内,而且它的作用域也局限于方法和域内,不能被访问权限修饰词所修饰。

点击(此处)折叠或打开

  1. interface pr {
  2.     
  3.     void print1();
  4.     
  5.     }

点击(此处)折叠或打开

  1. public class Parcell2 {
  2.     
  3.     private int i = 5;

  4.     public pr ship(String wang){
  5.     class Destination implements pr {
  6.         
  7.         private String label;
  8.         private int i = 6;
  9.         
  10.         Destination(String whereTo){
  11.             
  12.          label = whereTo;
  13.          RetrunLabel();
  14.         }
  15.         public void print1() {
  16.             
  17.             System.out.println(label);
  18.         }
  19.     
  20.         public void RetrunLabel(){
  21.             
  22.             System.out.println(label);
  23.         }
  24.     }
  25.     return new Destination(wang);
  26. }
  27.         
  28.         
  29.     public static void main(String[] args){
  30.         
  31.         Parcell2 p = new Parcell2();
  32.         pr wang = p.ship("wang");
  33.     }
  34. }
上面局部类放在返回值是接口对象类型的函数中,该类继承了该接口,该题只是简单的打印出了内部类的私有域,其中可以自定义很多内容,读者感兴趣可以尝试。


静态内部类:
如果我们把内部类看成是外部类的成员,则并不矛盾。静态内部类不能只想外部类的引用,而且在任何非静态内部类中,都不能有静态数据,静态方法或者又一个静态内部类(内部类的嵌套可以不止一层)。不过静态内部类中却可以拥有这一切。

点击(此处)折叠或打开

  1. public class Parcell3 {
  2.     
  3.     private int i = 5;
  4.    static class Destination{
  5.         
  6.         private String label;
  7.         private static int i = 5;
  8.         //private static int j = 6; //error if the class is not static
  9.         Destination(String whereTo){
  10.             
  11.             label = whereTo;
  12.         }
  13.         
  14.         int readi(){ return i;} //Parcell3.this.i; error
  15.         
  16.     }
  17.     
  18.     public void ship(String dest){
  19.         
  20.         Destination d = new Destination(dest);
  21.         System.out.println(d.readi());
  22.     
  23.     }
  24.     public static void main(String[] args){
  25.         
  26.         Parcell3 p = new Parcell3();
  27.         p.ship("wang");
  28.         
  29.     }
  30. }

匿名类:
匿名类是不能有名称的类,所以没办法引用他们。必须在创建时,作为new语句的一部分来声明他们。 
这就要采用另一种形式 的new语句,如下所示: 

        new <类或接口> <匿名类的主体>

        这种形式的new语句声明一个 新的匿名类,他对一个给定的类进行扩展,或实现一个给定的接口。他还创建那个类的一个新实例,并把他作为语句的结果而返回。要扩展的类和要实现的接口是 new语句的操作数,后跟匿名类的主体。

点击(此处)折叠或打开

  1. public interface prr {
  2.    
  3.     String print1();
  4.     String geti();
  5. }

点击(此处)折叠或打开

  1. public class Parcell4 {
  2.     
  3.     private int i = 5;
  4.     private String ss;
  5.     
  6.      Parcell4(String ss){
  7.          
  8.          this.ss = ss;
  9.      }
  10.     
  11.     public prr ship(String qq){
  12.         
  13.     return new prr(){
  14.         
  15.         public String print1() {
  16.             
  17.             return ss + qq;
  18.         }
  19.     
  20.         public String geti(){
  21.             
  22.             return "Lios" + "\n" +i;
  23.         }
  24.     };
  25.     
  26. }
  27.         
  28.     public static void main(String[] args){
  29.         
  30.         Parcell4 p = new Parcell4("diy_");
  31.         prr c = p.ship("os");
  32.         String s = p.ship("os").print1();
  33.         System.out.println(s);
  34.         System.out.println(c.geti());
  35.         
  36.     }
  37. }

上面我们不知道一个匿名类的名字,而return new prr()这一句很让人寻味,好像在实例化一个prr对象(接口是高级抽象类,当然不能被实例化),但是此时又恰好创建一个类,但是我们无法知道它的名字。
我们把上面的匿名内部类改成一般形式:

点击(此处)折叠或打开

  1. package 第十章内部类;

  2. public interface prr {
  3.    
  4.     String print1(String bb);
  5.     String geti();
  6. }

点击(此处)折叠或打开

  1. public class Parcell5 {
  2.     
  3.     private int i = 5;
  4.     private String ss;
  5.     
  6.      Parcell5(String ss){
  7.          
  8.          this.ss = ss;
  9.      }
  10.     
  11.     class WANG implements prr{
  12.         
  13.         public String print1(String bb) {
  14.             
  15.             return ss + bb;
  16.         }
  17.     
  18.         public String geti(){
  19.             
  20.             return "Lios" + "\n" +i;
  21.         }
  22.     }
  23.         
  24.     public prr ship(){
  25.         
  26.         return new WANG();
  27.     }
  28.     
  29.     public static void main(String[] args){
  30.         
  31.         Parcell5 p = new Parcell5("diy_");
  32.         prr c = p.ship();
  33.         String s = p.ship().print1("os");
  34.         System.out.println(s);
  35.         System.out.println(c.geti());
  36.         
  37.     }
  38. }

我们发现使用抽象类很简洁,但是要注意几点:
1.匿名内部类是没有访问修饰符的。
2.new 匿名内部类,这个类(接口)首先是要存在的。
3.匿名内部类是没有构造方法。

文章参考:
http://www.cnblogs.com/dolphin0520/p/3811445.htmlhttp://blog.csdn.net/yu422560654/article/details/7466260

来自 “ ITPUB博客 ” ,链接:http://blog.itpub.net/29876893/viewspace-1816069/,如需转载,请注明出处,否则将追究法律责任。

下一篇: Java内存分析一
请登录后发表评论 登录
全部评论

注册时间:2014-12-11

  • 博文量
    159
  • 访问量
    983443