李兴华Java8笔记19：内部类详解
1.基本概念
内部类就是指，在已经定义了一个类的基础之上，再其内部又定义了一个或多个类。从开发的角度，内部类，能少用就少用，优先考虑普通类。下面是一个内部类的代码实例：
class Outer{
private String msg = "hello world";
class Inner{
public void fun(){
System.out.println(msg);
}
}
public void fun(){
new Inner().fun();
}
}
public class Hello{
public static void main(String[] args){
Outer out = new Outer();
out.fun(); //输出hello world
}
}
使用内部类虽然牺牲了结构的简洁性，但是达到了一个很好的目的。为了凸显内部类的特点，我们将内部类拿到外面来，并实现与之前一样的功能。
class Outer{
private String msg = "hello world";
public String getMsg(){
return this.msg;
}
public void fun(){
new Inner().fun();
}
}
class Inner{
public void fun(){
System.out.println(new Outer().getMsg());
}
}
public class Hello{
public static void main(String[] args){
Outer out = new Outer();
out.fun(); //输出hello world
}
}
将内部类拿出来之后，为了能够使得内部类能够访问外部类的属性，我们做了如下两个改变：
- 在外部类定义一个getter方法
- 内部类使用外部类的属性的时候，先实例化一个外部类对象
虽然说结果上达到了将内部类放在外部类里面的一样的效果，但是我们发现，程序中实例化了两个outer对象，这是我们不想看到的结果。
因此，内部类的一大优势就是能够轻松访问外部类中的私有操作。当然，内部类的好处不止这一个：虽然内部类可以轻松访问外部类的私有操作，反之，外部类也可以访问内部类的私有操作。
class Outer{
private String msg = "hello world";
public String getMsg(){
return this.msg;
}
class Inner{
private String info = "世界,你好！";
}
public void fun(){
Inner in = new Inner();
System.out.println(in.info);
}
}
public class Hello{
public static void main(String[] args){
Outer out = new Outer();
out.fun(); //输出世界你好
}
}
内部类的使用，使得私有属性的操作变得很方便，但是新的问题出现了，在内部类之中访问外部类属性的时候，直接写了属性的名，但是之前我们说的，只要类中访问属性，就应该用this关键字，但是如果再内部类中使用this调用外部类的属性，就会报错，因为this指的是当前对象，此时的当前对象就是内部类，但是内部类中没有外部类的属性，所以就会报错，但是解决办法也很简单：Outer.this.mag。
class Outer{
private String msg = "hello world";
class Inner{
public void fun(){
System.out.println(Outer.this.msg);
}
}
public void fun(){
new Inner().fun();
}
}
public class Hello{
public static void main(String[] args){
Outer out = new Outer();
out.fun(); //输出hello world
}
}
上面代码编译后，我们文件目录查看*.class的文件，会发现除了Hello.class、Outer.class之外，还有一个Outer$Inner.class，也就是说，内部类也会被编译成一个class文件，并且这里的$在程序中就是.的意思。那我们能不能像实例化一个没有内部类的对象一样，仅仅实例化一个内部类对象呢？当然可以，语法如下：
外部类.内部类 对象名 = new 外部类().new 内部类()
class Outer{
private String msg = "hello world";
class Inner{
public void fun(){
System.out.println(Outer.this.msg);
}
}
public void fun(){
new Inner().fun();
}
}
public class Hello{
public static void main(String[] args){
Outer.Inner in = new Outer().new Inner();
in.fun();
}
}
内部类不可能离开外部类的实例化对象，所以应该首先实例化外部类。
如果希望一个内部类只允许外部类调用，而不允许外面调用，那么可以用private关键词对内部类进行修饰。那么此时内部类就不可能在外部进行直接实例化对象，下面的程序就会出错。
class Outer{
private String msg = "hello world";
private class Inner{
public void fun(){
System.out.println(Outer.this.msg);
}
}
public void fun(){
new Inner().fun();
}
}
public class Hello{
public static void main(String[] args){
Outer.Inner in = new Outer().new Inner();
in.fun();
}
}
错误信息如下:
Hello.java:14: 错误: Outer.Inner 在 Outer 中是 private 访问控制
Outer.Inner in = new Outer().new Inner();
^
2. 使用static定义内部类
使用static定义的属性或方法，不受类的实例化对象的控制。所以如果用static定义了一个内部类，那么它就不会受到外部类的实例化对象的控制。
如果一个内部类由static定义，那么这个类就变成了一个外部类。并且只能够访问外部类中用static方法或者属性。这就相当于static定义的方法不能调用非static定义的属性和方法。
class Outer{
private static String msg = "hello world";
//static修饰的内部类
static class Inner{
public void fun(){
//这里会报错，因为static定义的类不能访问，非static属性
System.out.println(msg);
}
}
public void fun(){
new Inner().fun();
}
}
public class Hello{
public static void main(String[] args){
}
}
要想修复这个bug，只需要用static修饰外部类中的msg变量。
此时，如果想实例化一个内部类的对象该如何做？下面是语法
外部类.内部类 对象名 = new 外部类.内部类()
class Outer{
private static String msg = "hello world";
//static修饰的内部类
static class Inner{
public void fun(){
//这里会报错，因为static定义的类不能访问，非static属性
System.out.println(msg);
}
}
public void fun(){
new Inner().fun();
}
}
public class Hello{
public static void main(String[] args){
Outer.Inner in = new Outer.Inner();
in.fun();
}
}
以后看到可以直接之力华“类.类.类”的形式，知道这是在实例化有static定义的内部类就行了
3.在方法中定义内部类
内部类可以再类中、代码块中、方法中定义，其中在方法内定义内部类是最常用形式。
class Outer{
private String msg = "hello world";
public void fun(){
//方法内定义的内部类
class Inner{
public void fun(){
//这里会报错，因为static定义的类不能访问，非static属性
System.out.println(msg);
}
}
new Inner().fun();
}
}
public class Hello{
public static void main(String[] args){
Outer out = new Outer();
out.fun(); //输出hello world
}
}
除了可以访问外部类的属性，在方法中定义的内部类还可以访问方法中的参数和变量
class Outer{
private String msg = "hello world";
public void fun(int num){
Double score = 99.9;
//方法内定义的内部类
class Inner{
public void fun(){
//这里会报错，因为static定义的类不能访问，非static属性
System.out.println("外部类属性是："+Outer.this.msg);
System.out.println("方法参数是："+num);
System.out.println("方法属性是："+score);
}
}
new Inner().fun();
}
}
public class Hello{
public static void main(String[] args){
Outer out = new Outer();
out.fun(100);
}
}
但这种操作只支持jdk1.8以后，1.8之前要想访问的话，需要在参数或变量前加上final：
class Outer{
private String msg = "hello world";
public void fun(final int num){
final Double score = 99.9;
//方法内定义的内部类
class Inner{
public void fun(){
//这里会报错，因为static定义的类不能访问，非static属性
System.out.println("外部类属性是："+Outer.this.msg);
System.out.println("方法参数是："+num);
System.out.println("方法属性是："+score);
}
}
new Inner().fun();
}
}
public class Hello{
public static void main(String[] args){
Outer out = new Outer();
out.fun(100);
}
}
4.总结
- 内部类可以与外部类互相进行私有属性的访问。
- 内部类可以使用private关键字进行修饰，而后无法在外部实例化内部类的实例化对象，要想定义使用下面的语法结构：
- 外部类.内部类 实例化对象 = new 外部类().new 内部类()
- 内部类可以使用static关键字进行修饰，而后可以脱离外部实例化对象的限制。此时直接实例化内部类对象的形式为
- 外部类.内部类 实例化对象 = new 外部类.内部类()
- 内部类可以在方法中定义，这是在开发中用的比较多的。