浅谈java内部类

时间 2020-12-27

标签 java mysql 面试算法 spring sql 数组 jvm ide 函数栏目 Java 繁體版

原文原文链接

前言java

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

为何要使用内部类面试

有的时候你可能有这样一种需求：对一个类（假设它为MyClass.java）建立一个和它相关的类（假设它是Part.java），但由于Part.java和MyClass之间的联系“紧密”且“单一”，致使咱们在这种状况下，不但愿像下面这样增长一个额外的兄弟类算法

├─MyClass      
└─Part

而但愿能将Part.java的数据隐藏在MyClass.java内部，因而这个时候内部类就冠冕堂皇地出现了spring

那么，这个不请自来的内部类到底给咱们上述的局面形成了怎样的改变呢？让咱们来看看：sql

增长一个额外的兄弟类Part:数组

对一些没有关联的类可见（若是protected则对同一包内类可见，若是public则对全部类可见）
不能彻底自由的访问MyClass中的私有数据（必须通过访问器方法）
新增了一个java文件

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

能够减小多余的可见性，例如可把Part在MyClass内部定义为私有，这样对同一包内其余类也不可见了
内部类（Part）能够自由访问外围类的全部数据（MyClass），包括私有数据
减小了一个java文件，使得类结构更简洁

成员内部类ide

故名思议，成员内部类嘛~ 使用固然和成员变量很类似咯函数

你能够像

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
    }
  }
}/./*欢迎加入java交流Q君样：909038429一块儿吹水聊天

编译以后大概长这样：

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

这里要注意的是：

编译后，LocalInner并不是直接使用data，而是用构造器拷贝一份后再使用
java是值传递的，因此包裹 LocalInner的外部方法outterPrint也会对传入的data参数作一次拷贝（基本类型数据拷贝副本，对象等则拷贝引用）

ＯＫ，如今的状况是：

方法内的局部类对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) {   }
};

避免了再建立另一个类文件

讲的有点乱，对匿名内部类作个总结：

省略被定义的类的类名
必须结合超类或者接口使用，即 new [超类/接口] { / 类体 / }
在定义该匿名类的同时实例化该匿名类
在一些场景下能简化代码

【注意】匿名类不能有构造器，由于构造器和类同名，而匿名类没有类名，因此匿名类不能有构造器

文章总结
咱们使用内部类的缘由主要有三点：
1.实现数据隐藏，避免多余的可见性
2.自由访问外部类的变量

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

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

从成员内部类，方法局部类到匿名内部类是一个不断深刻的关系，成员内部类进一步隐藏可见性就成为了方法局部类，方法局部类省去类名，并将类的定义和实例化操做合并到一块儿，就是匿名内部类。所以，匿名内部类沿袭了成员内部类和方法局部类的基本特特性

内部类的一些特殊的要求
1.局部类不能用public或private访问符进行声明
2.局部类所使用的外部类方法的形参必须用final修饰

匿名内部类不能有构造器