【java】浅谈java内部类

前言

说到java内部类,想必大家首先会想到比较常用的“匿名内部类”,但实际上,这只是内部类的其中一种使用方式而已内部类的使用方式实际上总共包括:成员内部类, 方法局部类,匿名内部类,下面,我就给大家来一一介绍:

为什么要使用内部类

有的时候你可能有这样一种需求:对一个类(假设它为MyClass.java)创建一个和它相关的类(假设它是Part.java),但因为Part.java和MyClass之间的联系“紧密”且“单一”,导致我们在这种情况下,不希望像下面这样增加一个额外的兄弟类

├─MyClass      
└─Part

而希望能将Part.java的数据隐藏在MyClass.java内部,于是这个时候内部类就堂而皇之地出现了

那么,这个不请自来的内部类到底给我们上述的局面造成了怎样的改变呢? 让我们来看看:

增加一个额外的兄弟类Part:

1. 对一些没有关联的类可见(如果protected则对同一包内类可见,如果public则对所有类可见)

2. 不能完全自由的访问MyClass中的私有数据(必须经过访问器方法)

3. 新增了一个java文件

使用内部类,将Part类的定义写入MyClass内部

1. 可以减少多余的可见性,例如可把Part在MyClass内部定义为私有,这样对同一包内其他类也不可见了

2. 内部类(Part)可以自由访问外围类的所有数据(MyClass),包括私有数据

3. 减少了一个java文件,使得类结构更简洁

成员内部类

故名思议,成员内部类嘛~  使用当然和成员变量很相似咯

你可以像

private String data

这样定义一个“平行的”成员内部类:

private class Inner

具体看下面的例子:

Outter.java:

public class Outter {
  // 成员变量data
  private String data = "外部数据";
 
  //定义一个内部类
  private class Inner {
    public void innerPrint () {
      System.out.println(data);
    }
   } 
     
  // 外部类的方法, new一个内部类的实例并调用其innerPrint方法
  public void outterPrint () {
    Inner i = new Inner();
    i.innerPrint();
  }}

Test.java:

public class Test {
  public static void main (String [] args) {
    Outter o = new Outter();
    o.outterPrint();
  }
}

结果输出:

外部数据

看来这还是能达到我们预期的效果的:由于将Inner内部类设为private,它变得只对我们当前的外部类Outter类可见,我们成功地把它"隐藏"在了Outter类内部与此同时,它还自由地访问到了Outter类的私有成员变量data

两个this

虽然上面的例子看起来挺简单的,但实际上内部类的作用机制还是比较复杂的。

首先要考虑的是“this”的问题,外部类和内部类各有一个this,关键在于内部类中我们如何对这两个this作出区分:

我们假设上面的例子中的Inner类内部有一个方法fn:

private class Inner {
  public  void fn () {
    Outter.this // 指向Outter实例对象的this引用
    this  // 指向Inner实例对象的this引用
  }
} 

在这个方法fn里,Outter.this是指向Outter实例对象的this的引用, 而this是指向Inner实例对象的this的引用

我们访问类中成员变量有两种方式: 隐式访问(不加this)和显式访问(加this)

隐式访问类中成员变量

让我们对上面的Outter.java做一些改动,增加一行代码:

public class Outter {
  // 成员变量data
  private String data = "外部数据"; 
  //定义一个内部类
  private class Inner {
    // 增加Inner类对data成员变量的声明
    private String data = "内部数据"     public void innerPrint () {
      System.out.println(data);
    }
  } 
     
  // 外部类的方法, new一个内部类的实例并调用其innerPrint方法
  public void outterPrint () {
    Inner i = new Inner();
    i.innerPrint();
  }
}

结果输出:

内部数据

如此可见,内部类内声明的数据会覆盖外部类的同名数据。或者说, 在上述例子中,对于data成员变量,它会首先在Inner的this中查找有无这个成员变量,然后没有,那么就再在Outter.this中查找

显式访问类中成员变量

但有的时候我们希望既能访问外部类的成员变量,同时也能访问内部类的成员变量,这个时候我们就要使用到this了,但是如何区分内部类和外部类的this呢?你可以这样:

以上述例子为例:

访问外部类定义的成员变量:Outter.this.data

访问内部类定义的成员变量:this.data

如下图所示

public class Outter {
  // 外部类的成员变量data
  private String data = "外部数据"; 
  //定义一个内部类
  private class Inner {
    // 内部类的成员变量data
    private String data = "内部数据";
    public void innerPrint () {
      System.out.println(Outter.this.data);
      System.out.println(this.data);
    }
  } 
     
  // 外部类的方法, new一个内部类的实例并调用其innerPrint方法
  public void outterPrint () {
    Inner i = new Inner();
    i.innerPrint();
  }
}

局部内部类

局部内部类是内部类的第二种形式,它让内部类的“隐藏”得更深一层——写在外部类的方法内部,而不是处于和外部类方法平行的位置。

让我们对上面成员内部类处理的场景做些思考:我们的Inner内部类仅仅只在outterPrint方法中使用了一次:

public void outterPrint () {
  Inner i = new Inner();
  i.innerPrint();
}

那么我们能不能把Inner内部类直接定义在outterPrint的内部呢?这样的话,它就能更好地隐藏起来即使是类Outter中除outterPrint外的方法,也不能访问到它:

现在的Outter的类看起来像这样:

public class Outter {
  public void outterPrint () {// 外部类方法
    class LocalInner { // 局部内部类
      public void innerPrint () {   }
    } 
    LocalInner i = new LocalInner(); // 实例化局部内部类
    i.innerPrint();
  }
}

相比于成员内部类,局部内部类多了一项能访问的数据,那就是局部变量(由外部类方法提供)

成员内部类:外部类数据,内部类数据

局部内部类: 外部类数据,内部类数据, 局部数据

具体示例如下:

Outter.java

public class Outter {
  private String data = "外部数据";  // 外部类数据
  public void outterPrint (final String localData) { // 局部数据
    class LocalInner {
      private String data = "内部数据";  // 内部类数据
      public void innerPrint () {
        System.out.println(Outter.this.data);  // 打印外部类数据
        System.out.println(this.data);   //  打印内部类数据
        System.out.println(localData);  // 打印局部数据
      }
    } 
    LocalInner i = new LocalInner();
    i.innerPrint();
  }
}

Test.java:

public class Test {
  public static void main (String [] args) {
    Outter o = new Outter();
    o.outterPrint("局部数据");
  }
}

结果输出:

外部数据
内部数据
局部数据

局部类所使用的外部类方法的形参必须用final修饰

这里要注意一点, 局部类所使用的外部类方法的形参必须用final修饰,否则会编译不通过,也就是说传入后不许改变

为什么这个方法形参一定要用final修饰?

 (仅个人理解,如有不同的意见或者更好的理解欢迎在评论区讨论)

如果不用final修饰会怎样? 且听我慢慢道来:

首先要说一下:

1.内部类和外部类在编译之后形式上是一样的,不会有内外之分

2.局部内部类对于使用的外部方法的值会用构造函数做一个拷贝(编译后)

例如对于下面outterPrint方法中的LocalInner

public void outterPrint (final String data) {
  class LocalInner {
    public void innerPrint () {
    // 使用 data
    }
  }
}

编译之后大概长这样:

public class Outter$LocalInner{ 
  public LocalInner(String data){
    this.LocalInner$data = data; // 对于使用的data做了一次拷贝
  }
  public void innerPrint (){ /* 使用 data */ }
}

这里要注意的是:

1. 编译后,LocalInner并非直接使用data,而是用构造器拷贝一份后再使用

2. java是值传递的,所以包裹 LocalInner的外部方法outterPrint也会对传入的data参数做一次拷贝(基本类型数据拷贝副本,对象等则拷贝引用)

OK,现在的情况是:

方法内的局部类对data拷贝了两次:外部方法outterPrint值传递时的拷贝,和LocalInner构造函数的拷贝

方法内除了局部类外的作用域只拷贝了data一次: 外部方法outterPrint值传递时的拷贝

拷贝两次和拷贝一次,导致在outterPrint方法内部, 局部类内部的data和局部类外部的data是不同步的! 也即你在局部类内部改了data不影响局部类外部的data,在局部类外部改了data也不影响局部类内部的data(注意一个前提,值是基本类型的,如果是对象的话因为拷贝的是引用仍然可以“同步”)

图示一:

 图示二:

于是java说: 哎呀妈呀, 这都data都不同步了, 要是让你修改这还了得!!! 于是就强行要求我们加上final

【注意】所谓的不同步主要是针对基本类型来说的,如果是对象之类的话因为拷贝的是引用所以仍然可以“同步”

如何突破必须用final的限制

我们上面说到,局部内部类所使用的方法形参必须用final修饰的限制。

例如

public void outterPrint (String data) {// 没加上final
  class LocalInner { 
    public void changeData () {
      data = "我想修改data的值";  // 在这一行编译报错
    }
   } 
}

提示:

Cannot refer to a non-final variable data inside an inner class defined in a different method

那么,如果我们有对该形参必须能修改的硬性需求怎么办?

你可以通过一种有趣的方式绕开它:使用一个单元素数组。因为用final修饰的基本类型的变量不允许修改值,但是却允许修改final修饰的单元素数组里的数组元素, 因为存放数组的变量的值只是一个引用,我们修改数组元素的时候是不会修改引用指向的地址的,在这点上final并不会妨碍我们:

Outter.java

public class Outter {
  public void outterPrint (final String []  data) { 
    class LocalInner { 
      public void innerPrint () {
        data[0] = "堂而皇之地修改它!!";   // 修改数据
        System.out.print(data[0]);  // 输出修改后的数据
      }
    } 
    LocalInner i = new LocalInner();
    i.innerPrint();
  }
}

Test.java:

public class Test {
  public static void main (String [] args) {
    Outter o = new Outter();
    String [] data = new String [1];
    data[0] = "我是数据";
    o.outterPrint(data);  // 修改数据并且输出
  }
}

结果输出:

堂而皇之地修改它!!

【注意】局部类不能用public或private访问符进行声明!!

匿名内部类

倘若我们再把局部内部类再深化一下, 那就是匿名内部类

匿名内部类的使用方式

new [超类/接口] {   /* 类体 */   }

让我们看看下面这个例子:

Other.java:

public class Other {    }

Outter.java:

public class Outter {
  public void outterPrint (String data) { 
    Other o = new Other() {  }; // 匿名内部类
  }
}

何谓之匿名?

诶,不是说好的匿名吗? 那么为什么还有个Other的类名呢?”

Other o = new Other() {  /* 匿名内部类的类体 */   };

实际上,这里的Other并不是我们的匿名内部类,而是我们匿名内部类的超类,上面一行代码其实相当于(用成员内部类来表示的话)

// annoymous翻译为匿名
public class Outter {
  private class annoymous extends Other{  }  
  public void outterPrint () { 
    Other a = new annoymous();
  }
}

同时要注意,我们在使用匿名内部类的方式,是在定义一个内部类的同时实例化该内部类:

new Other() {  /* 匿名内部类的类体 */  };  // new操作和定义类的代码是紧紧结合在一起的

匿名函数的作用

用匿名函数的作用在于在一些特定的场景下写起来很简单,例如事件监听器:

ActionListener listener = new ActionListener() { 
  public void actionPerformed(ActionEvent e) {   }
};

避免了再创建另外一个类文件

讲的有点乱, 对匿名内部类做个总结:

1. 省略被定义的类的类名

2. 必须结合超类或者接口使用,即 new [超类/接口] {   /* 类体 */   }

3. 在定义该匿名类的同时实例化该匿名类

4. 在一些场景下能简化代码

【注意】匿名类不能有构造器, 因为构造器和类同名,而匿名类没有类名,所以匿名类不能有构造器

文章总结

我们使用内部类的原因主要有三点:

1.实现数据隐藏, 避免多余的可见性

2.自由访问外部类的变量

3. 在使用监听器等场景的时候使用匿名内部类,避免增加的大量代码

关于成员内部类, 方法局部类,匿名内部类的关系

从成员内部类,方法局部类到匿名内部类是一个不断深入的关系, 成员内部类进一步隐藏可见性就成为了方法局部类, 方法局部类省去类名,并将类的定义和实例化操作合并到一起,就是匿名内部类。因此,匿名内部类沿袭了成员内部类和方法局部类的基本特特性

内部类的一些特殊的要求

1.局部类不能用public或private访问符进行声明

2.局部类所使用的外部类方法的形参必须用final修饰

3. 匿名内部类不能有构造器

参考资料:

《java核心技术 卷1》—— Cay S. Horstmann, Gary Cornell

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏weixuqin 的专栏

Scrapy选择器的用法

34212
来自专栏老马寒门IT

03-老马jQuery教程-DOM操作

jQuery DOM操作 在没有jQuery之前,DOM的操作相对来说有点麻烦,尤其是DOM节点的搜索。目前我们已经学习了jQuery的选择器,接下带大家一块学...

1765
来自专栏java达人

jquery常用选择器

在Dom 编程中我们只能使用有限的函数根据id 或者TagName 获取Dom 对象. 然而在jQuery 中则完全不同,jQuery 提供了异常强大的选择器用...

1936
来自专栏mySoul

通过css类/选择器选取元素 文档结构和遍历 元素树的文档

尽管如此,js还定义了一个方法,即一个getElementsByClassName(),是基于class属性值中的标识符来选取成组的文档元素

562
来自专栏听雨堂

用多个类别来进行微调

          有时css的类基本设计好了,对于大多数的标签都能够实用,但却又个别的不行。如,菜单项,绝大多数都是2个字的,总体上按照这个宽度来设计,但还有...

1888
来自专栏我的博客

DOM基础知识

1.DOM介绍 DOM= Document Object Model,文档对象模型,DOM可以以一种独立于平台和语言的方式访问和修改一个文档的内容和结构。换句话...

2694
来自专栏瓜大三哥

matlab GUI基础1

GUI编程开发 1.句柄图形 是一种面向对象的绘图系统。这些细节一般隐藏在图形M文件的内部,用户通过句柄图形可以定制图形的许多特性,这是使用高级绘图函数无法实现...

2378
来自专栏彭湖湾的编程世界

【CSS/JS】如何实现单行/多行文本溢出的省略(...)--老司机绕过坑道的正确姿势

写前端UI的朋友们也许都遇到过这样的问题:我们需要实现这样一个需求,在一个父级元素中隐藏一个可能过长的文本: 这个文本可能是单行的: ? 也可能是多行的: ? ...

2098
来自专栏性能与架构

浏览器如何完成网页渲染?

image.png 渲染流程 (1)把HTML代码形成文档对象模型DOM (2)加载并解析样式文件,形成CSS对象模型 (3)在DOM和CSS对象模型基础上,把...

2566
来自专栏九彩拼盘的叨叨叨

初级 Web 前端核心技能点

703

扫码关注云+社区