文档章节

内部类

小兽
 小兽
发布于 2017/03/26 22:58
字数 3020
阅读 2
收藏 0

 匿名内部类不能访问外部类方法中的局部变量,除非变量被声明为final类型

  1. 这里所说的“匿名内部类”主要是指在其外部类的成员方法内定义,同时完成实例化的类,若其访问该成员方法中的局部变量,局部变量必须要被final修饰。
  2. 原因是编译程序实现上的困难:内部类对象的生命周期会超过局部变量的生命周期。局部变量的生命周期:当该方法被调用时,该方法中的局部变量在栈中被创建,当方法调用结束时,退栈,这些局部变量全部死亡。而内部类对象生命周期与其它类一样:自创建一个匿名内部类对象,系统为该对象分配内存,直到没有引用变量指向分配给该对象的内存,它才会死亡(被JVM垃圾回收)。所以完全可能出现的一种情况是:成员方法已调用结束,局部变量已死亡,但匿名内部类的对象仍然活着。
  3. 如果匿名内部类的对象访问了同一个方法中的局部变量,就要求只要匿名内部类对象还活着,那么栈中的那些它要所访问的局部变量就不能“死亡”。
  4. 解决方法:匿名内部类对象可以访问同一个方法中被定义为final类型的局部变量。定义为final后,编译程序的实现方法:对于匿名内部类对象要访问的所有final类型局部变量,都拷贝成为该对象中的一个数据成员。这样,即使栈中局部变量已死亡,但被定义为final类型的局部变量的值永远不变,因而匿名内部类对象在局部变量死亡后,照样可以访问final类型的局部变量,因为它自己拷贝了一份,且与原局部变量的值始终一致。
-----------------------------

1.内部类        

首先举一个简单的例子,如果你想实现一个接口,但是这个接口中的一个方法和你构想的这个类中的一个 方法的名称,参数相同,你应该怎么办?这时候,你可以建一个内部类实现这个接口。由于内部类对外部类的所有内容都是可访问的,所以这样做可以完成所有你直 接实现这个接口的功能。
         不过你可能要质疑,更改一下方法的不就行了吗?
        的确,以此作为设计内部类的理由,实在没有说服 力。
        真正的原因是这样的,java中的内部类和接口加在一起,可以的解决常被C++程序员抱怨java中存在的一个问题——没有多继承。实际上,C++的多继承设计起来很复杂,而java通过内部类加上接口,可以很好的实现多继承的效果。
        内部类:一个内部类的定义是定义在另一个内部的类。
原因是:
1.一个内部类的对象能够访问创建它的对象的实现,包括私有数据。
2. 对于同一个包中的其他类来说,内部类能够隐藏起来。
3.匿名内部类可以很方便的定义回调。
4.使用内部类可以非常方便的编写事件驱动程序

       内部类可以让你更优雅地设计你的程序结构。下面从以下几个方面来介绍:

 第一次见面

[java] view plain copy

  1. public interface Contents {  
  2.  int value();  
  3. }  
  4.   
  5. public interface Destination {  
  6.  String readLabel();  
  7. }  


 

[java] view plain copy

  1. public class Goods {  
  2.  private class Content implements Contents {  
  3.    private int i = 11;  
  4.   public int value() {  
  5.    return i;  
  6.   }  
  7.   }  
  8.   
  9.  protected class GDestination implements Destination {  
  10.    private String label;  
  11.   private GDestination(String whereTo) {  
  12.     label = whereTo;  
  13.   }  
  14.   public String readLabel() {  
  15.    return label;  
  16.   }  
  17.  }  
  18.   
  19.  public Destination dest(String s) {  
  20.    return new GDestination(s);  
  21.  }  
  22.   
  23.  public Contents cont() {  
  24.    return new Content();  
  25.  }  
  26. }  
  27.   
  28. class TestGoods {  
  29.  public static void main(String[] args) {  
  30.   Goods p = new Goods();  
  31.    Contents c = p.cont();  
  32.   Destination d = p.dest("Beijing");  
  33.     }  
  34. }  


        在这个例子里类 Content 和 GDestination 被定义在了类 Goods 内部,并且分别有着 protected 和 private 修饰符来控制访问级别。Content 代表着 Goods 的内容,而 GDestination 代表着 Goods 的目的地。它们分别实现了两个接口Content和Destination。在后面的main方法里,直接用 Contents c 和 Destination d进行操作,你甚至连这两个内部类的名字都没有看见!这样,内部类的第一个好处就体现出来了——隐藏你不想让别人知道的操作,也即封装性。

       同时,我们也发现了在外部类作用范围之外得到内部类对象的第一个方法,那就是利用其外部类的方法创建并返回。上例中的cont()和 dest() 方法就是这么做的。那么还有没有别的方法呢?当然有,其语法格式如下:

[java] view plain copy

  1. outerObject=new outerClass(Constructor Parameters);  
  2. outerClass.innerClass innerObject=outerObject.new InnerClass(Constructor Parameters);  

       注意在创建非静态内部类对象时,一定要先创建起相应的外部类对象。至于原因,也就引出了我们下一个话题——

 

 非静态内部类对象有着指向其外部类对象的引用

 修改上面的例子

[java] view plain copy

  1. public class Goods {  
  2.   private valueRate=2;  
  3.   
  4.  private class Content implements Contents {  
  5.    private int i = 11 * valueRate;  
  6.   public int value() {  
  7.    return i;  
  8.   }  
  9.  }  
  10.   
  11.  protected class GDestination implements Destination {  
  12.   private String label;  
  13.   private GDestination(String whereTo) {  
  14.    label = whereTo;  
  15.   }  
  16.   public String readLabel() {  
  17.    return label;  
  18.   }  
  19.  }  
  20.   
  21.  public Destination dest(String s) {  
  22.   return new GDestination(s);  
  23.  }  
  24.   
  25.   public Contents cont() {  
  26.   return new Content();  
  27.  }  
  28. }  


        在这里我们给 Goods 类增加了一个 private 成员变量 valueRate,意义是货物的价值系数,在内部类 Content 的方法 value() 计算价值时把它乘上。我们发现,value() 可以访问 valueRate,这也是内部类的第二个好处——一个内部类对象可以访问创建它的外部类对象的内容,甚至包括私有变量!这是一个非常有用的特性,为我们在设计时提供了更多的思路和捷径。要想实现这个功能,内部类对象就必须有指向外部类对象的引用。Java 编译器在创建内部类对象时,隐式的把其外部类对象的引用也传了进去并一直保存着。这样就使得内部类对象始终可以访问其外部类对象,同时这也是为什么在外部 类作用范围之外向要创建内部类对象必须先创建其外部类对象的原因。(具体原因见:http://blog.csdn.net/yu422560654/article/details/6978981

        有人会问,如果内部类里的一个成员变量与外部类的一个成员变量同名,也即外部类 的同名成员变量被屏蔽了,怎么办?没事,Java里用如下格式表达外部类的引用:
        outerClass.this
        有了它,我们就不怕这种屏蔽的情况了。

 

静态内部类(嵌套类)

        和普通的类一样,内部类也可以有静态的。不过和非静态内部类相比,区别就在于静态内部类没有了指向外部的引用。这实际上和 C++ 中的嵌套类很相像了,Java 内部类与 C++ 嵌套类最大的不同就在于是否有指向外部的引用这一点上,当然从设计的角度以及以它一些细节来讲还有区别。
        除此之外,在任何非静态内部类中,都不能有静态数据,静态方法或者又一个静态内部类(内部类的嵌套可以不止一层)。不过静态内部类中却可以拥有这一切。这也算是两者的第二个区别吧。

 

局部内部类

        是的,Java 内部类也可以是局部的,它可以定义在一个方法甚至一个代码块之内。

[java] view plain copy

  1. public class Goods1 {  
  2.  public Destination dest(String s) {  
  3.   class GDestination implements Destination {  
  4.    private String label;  
  5.    private GDestination(String whereTo) {  
  6.     label = whereTo;  
  7.    }  
  8.     public String readLabel() { return label; }  
  9.   }  
  10.   
  11.   return new GDestination(s);  
  12.  }  
  13.   
  14.  public static void main(String[] args) {  
  15.    Goods1 g= new Goods1();  
  16.   Destination d = g.dest("Beijing");  
  17.  }  
  18. }  

        上面就是这样一个例子。在方法dest中我们定义了一个内部类,最后由这个方法返回这个内部类的对象。如果我们在用一个内部类的时候仅需要创建它的一个对象并传给外部,就可以这样做。当然,定义在方法中的内部类可以使设计多样化,用途绝不仅仅在这一点。

        下面有一个更怪的例子:

[java] view plain copy

  1. public class Goods2{  
  2.  private void internalTracking(boolean b) {  
  3.   if(b) {  
  4.    class TrackingSlip {  
  5.     private String id;  
  6.      TrackingSlip(String s) {  
  7.      id = s;  
  8.     }  
  9.     String getSlip() { return id; }  
  10.    }  
  11.    TrackingSlip ts = new TrackingSlip("slip");  
  12.    String s = ts.getSlip();  
  13.   }  
  14.  }  
  15.   
  16.   public void track() { internalTracking(true); }  
  17.   
  18.  public static void main(String[] args) {  
  19.   Goods2 g= new Goods2();  
  20.   g.track();  
  21.   }  
  22. }  

        你不能在 if 之外创建这个内部类的对象,因为这已经超出了它的作用域。不过在编译的时候,内部类 TrackingSlip 和其他类一样同时被编译,只不过它由它自己的作用域,超出了这个范围就无效,除此之外它和其他内部类并没有区别。

 

2. 匿名类

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

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

        这种形式的new语句声明一个 新的匿名类,他对一个给定的类进行扩展,或实现一个给定的接口。他还创建那个类的一个新实例,并把他作为语句的结果而返回。要扩展的类和要实现的接口是 new语句的操作数,后跟匿名类的主体。 
假如匿名类对另一个类进行扩展,他的主体能够访问类的成员、覆盖他的方法等等,这和其他任何标准的类都 是相同的。假如匿名类实现了一个接口,他的主体必须实现接口的方法。

        注意匿名类的声明是在编译时进行的,实例化在运行时进行。这意味着 for循环中的一个new语句会创建相同匿名类的几个实例,而不是创建几个不同匿名类的一个实例。

        从技术上说,匿名类可被视为非静态的内 部类,所以他们具备和方法内部声明的非静态内部类相同的权限和限制。

        假如要执行的任务需要一个对象,但却不值得创建全新的对象(原因可能 是所需的类过于简单,或是由于他只在一个方法内部使用),匿名类就显得很有用。匿名类尤其适合在Swing应用程式中快速创建事件处理程式。

[java] view plain copy

  1. interface pr {   
  2.  void print1();   
  3. }  
  4.   
  5. public class noNameClass {   
  6.  public pr dest() {   
  7.   return new pr() {   
  8.     public void print1() {   
  9.     System.out.println("Hello world!!");   
  10.     }   
  11.   };  
  12.  }  
  13. }  
  14.   
  15. public static void main(String args[]) {   
  16.   noNameClass c = new noNameClass();  
  17.  pr hw = c.dest();  
  18.   hw.print1();  
  19. }  


        有一点需要注意的 是,匿名内部类由于没有名字,所以它没有构造函数(但是如果这个匿名内部类继承了一个只含有带参数构造函数的父类,创建它的时候必须带上这些参数,并在实 现的过程中使用super 关键字调用相应的内容)。如果你想要初始化它的成员变量,有下面几种方法:
        1. 如果是在一个方法的匿名内部类,可以利用这个方法传进你想要的参数,不过记住,这些参数必须被声明为 final 。
        2. 将匿名内部类改造成有名字的局部内部类,这样它就可以拥有构造函数了。
        3. 在这个匿名内部类中使用初始化代码块

 

  最后,Java 8更加智能:如果局部变量被匿名内部类访问,那么该局部变量相当于自动使用了final修饰

© 著作权归作者所有

上一篇: URL
小兽
粉丝 2
博文 28
码字总数 29947
作品 0
上海
项目经理
私信 提问

暂无文章

基础工具类

package com.atguigu.util;import java.sql.Connection;import java.sql.SQLException;import java.util.Properties;import javax.sql.DataSource;import com.alibaba.druid......

architect刘源源
今天
43
0
P30 Pro劲敌!DxO官宣新机:排行榜又要变

5月26日晚间,DxOMark官方推特预告,将在5月27日公布一款新机型的DxOMark评分,猜猜是哪款? 网友猜想的机型有:红米K20、谷歌Pixel 3a、索尼Xperia 1、诺基亚9 PureView等。 DxOMark即将公布...

linux-tao
昨天
15
0
Ubuntu18.04.2窗口过小不能自适应(二次转载)

解决Ubuntu在虚拟机窗口不能自适应 2018年09月06日 16:20:08 起不了名儿 阅读数 855 此博文转载:https://blog.csdn.net/nuddlle/article/details/77994080(原地址) 试了很多办法这个好用 ...

tahiti_aa
昨天
2
0
死磕 java同步系列之CountDownLatch源码解析

问题 (1)CountDownLatch是什么? (2)CountDownLatch具有哪些特性? (3)CountDownLatch通常运用在什么场景中? (4)CountDownLatch的初始次数是否可以调整? 简介 CountDownLatch,可以...

彤哥读源码
昨天
6
0
Nginx提供下载apk服务

有时候我们可能需要提供文件或者其他apk下载链接,通过 nginx 配置可以很简单地实现。 server {    listen 80;    server_name download.xxx.com;    root app;    locati...

Jack088
昨天
4
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部