浅析总结 Java 内部类的一些使用与梳理

Love The Way You Lie 2022-08-06 14:06 215阅读 0赞

========================================================  
作者：qiujuer  
博客：[blog.csdn.net/qiujuer][blog.csdn.net_qiujuer]  
网站：[www.qiujuer.net][]  
开源库：[Genius-Android][]  
转载请注明出处：[http://blog.csdn.net/qiujuer/article/details/43282699][http_blog.csdn.net_qiujuer_article_details_43282699]

*——学之开源，用于开源；初学者的心态，与君共勉！*  
========================================================

## 序 ##

有这篇文章，纯属巧合；那天在使用中突然发现 **Java** 内部类中还分 **static** ，说实话平时都在用，但是就是没有注意到；感觉有必要总结一下。

有必要说一下的是本文纯属浅析，如有补充还请在评论中指出，欢迎总结。

## 内部类的位置 ##

public class A {
    	class B {
    
    	}
    
    	public void pint() {
    		class C {
    		}
    		new C();
    	}
    
    	public void pint(boolean b) {
    		if (b) {
    			class D {
    			}
    			new D();
    		}
    	}
    }

从代码中可以看出，内部类可以定义到很多地方，常用的是成员变量中 **（B）**，方法中也叫局部内部类 **（C）**，作用域中 **（D）**

从上面来看似乎没有用到过在方法中和作用域中的情况啊，这就错了；再来看看这个：

public interface AInterface {
    	void show();
    }
    public class B {
    
    	public void show() {
    		class Man implements AInterface {
    			@Override
    			public void show() {
    
    			}
    
    		}
    		Man man = new Man();
    		man.show();
    	}
    
    }

其中我们定义了两个文件，一个文件是一个接口类，一个是 **B**文件；在 **B**类中，的  **show()**方法中我们使用了局部内部类的方式创建了类  **Man** ， **Man class**继承接口并实现方法，随后使用该类。

## 内部类的权限 ##

### 为什么要有内部类的存在？ ###

在我看来类主要的就是封装、继承、多态；当然其中的回调思想我认为是很重要的；而内部类的出现就是为了简化多重继承的问题；一个**A**类，并不能继承多个其他类，但是在使用中又需要使用到其他类的方法，这个时候内部类就发挥作用了；典型的就是事件点击的回调实现。

### 那么内部类的权限究竟有多大？ ###

至于答案是什么，代码上看看就知道了。

public class C {
    	int a = 1;
    	private int b = 2;
    	protected int c = 3;
    	public int d = 4;
    
    	void a() {
    		System.out.println("A:" + a);
    	}
    
    	private void b() {
    		System.out.println("B:" + b);
    	}
    
    	protected void c() {
    		System.out.println("C:" + c);
    	}
    
    	public void d() {
    		System.out.println("D:" + d);
    	}
    
    	class D {
    
    		void show() {
    			int max = a + b + c + d;
    			a();
    			b();
    			c();
    			d();
    			System.out.println("Max:" + max);
    		}
    	}
    
    	public static void main(String[] args) {
    		D d = new C().new D();
    		d.show();
    	}
    }

运行结果：

![20150129174923276][]  
可以看出，内部类 D 对类 C 具有完整的访问权限，等于全身脱光了给你看。

### 那要是反过来呢？ ###

public class C {
    	class D {
    		private int a = 20;
    		private void a(){
    			System.out.println("D.A:" + a);
    		}
    	}
    	
    	void show(){
    		D d = new D();
    		d.a();
    		
    		System.out.println("D.A:" + d.a);
    	}
    
    	public static void main(String[] args) {
    		new C().show();
    	}
    }

运行结果：

![20150129175626271][]  
可见也是完全可行的，也能直接访问私有属性 私有方法，在这里似乎私有的限制已经失效了一般，这个让我想起了以前看见过一个面试：在 Java 中 private 修饰何时会失效。

这完全是两个人互相脱光光了啊~

## 匿名内部类 ##

这个非常常见，特别是在按钮点击事件绑定中。

public class D {
    	void initButton() {
    		Button b1 = new Button();
    		b1.setOnClickListener(new OnClickListener() {
    
    			@Override
    			public void onClick(Button v) {
    
    			}
    		});
    
    		Button b2 = new Button();
    		b2.setOnClickListener(new OnClickListener() {
    
    			@Override
    			public void onClick(Button v) {
    
    			}
    		});
    	}
    
    }

其中的：

new OnClickListener() {
    
    			@Override
    			public void onClick(Button v) {
    
    			}
    		}

就是匿名内部类的使用方式，**OnClickListener** 是一个接口类，接口类是无法直接**new** 一个实例的；这里也并不是那样，而是**new** 了一个其他的类，该类是匿名的，也就是没有名字，只不过该类实现了 **OnClickListener**接口类中的方法。

### 上面的添加回调部分可等同于： ###

public class D {
    	void initButton1() {
    		Button b1 = new Button();
    		b1.setOnClickListener(new Listener1());
    
    		Button b2 = new Button();
    		b2.setOnClickListener(new Listener2());
    	}
    
    	class Listener1 implements OnClickListener {
    
    		@Override
    		public void onClick(Button v) {
    
    		}
    	}
    
    	class Listener2 implements OnClickListener {
    
    		@Override
    		public void onClick(Button v) {
    
    		}
    	}
    
    }

这里就是先建立类，继承自接口；而后赋值到  **Button** 中。

要说两者的区别与好处，这个其实看具体的使用情况吧；如果你的按钮很多，但是为了避免建立太多类；那么可以建立一个回调类，然后都赋值给所有的按钮，不过最后就是需要在 **onClick**方法中进行判断是那个按钮进行的点击。  
  
匿名内部类的使用地方很多；具体的使用应视使用情况而定~

## 静态内部类/静态嵌套类 ##

这个其实并不应该叫做内部类了，因为其并不具备内部类的完全权限，在使用上与一般的类基本一样；那为什么会有这个的存在？

在我看来这个类的存在是为其包括类服务；意思是可以单独服务，不被外面的类所知晓；如这样：

public class E {
    	private void show(){
    		new A();
    	}
    	
    	private static class A{
    		
    	}
    }

其中类  **A** 使用了 **static** ，所以是 **静态嵌套类**，在这里使用 **private** 修饰；那么该类只能在  **E** 类中进行实例化；无法在 其他文件中实例化。

这样的情况使用外面的类能行么？不行吧？也许你会说在 **E.java** 文件夹中建立 **A.java** ，并使用**protected**修饰；但是在同样的包下，或者继承的类中同样能访问了；这也只是其中一个较为特殊的情况。

### 我们来看看权限 ###

在这个中的结果是怎样？

![20150129213252311][]  
从图片中可以看出，其权限级别是单方向的；静态嵌套类 A 对其包含类 E 完全透明；但 E 并不对 A 透明。

### 再来看看方法： ###

![20150129213725499][]  
可以看出同样的情况；这个是为什么呢？为什么就是多一个 **static** 的修饰就这么完全不同？其是很好理解，两个独立的类；本来就无法直接使用，必须有引用才能调用其属性与方法。

我们或许可以这么调整一下就**OK**：

public class E {
    	int a1 = 0;
    	private int a2 = 0;
    	protected int a3 = 0;
    	public int a4 = 0;
    
    	private void show() {
    		A a = new A();
    		System.out.print("b1:" + a.b1);
    		System.out.print("b2:" + a.b2);
    		System.out.print("b3:" + a.b3);
    		System.out.print("b4:" + a.b4);
    
    		a.b1();
    		a.b2();
    		a.b3();
    		a.b4();
    	}
    
    	void a1() {
    
    	}
    
    	private void a2() {
    
    	}
    
    	protected void a3() {
    
    	}
    
    	public void a4() {
    
    	}
    
    	private static class A {
    		int b1 = 0;
    		private int b2 = 0;
    		protected int b3 = 0;
    		public int b4 = 0;
    
    		void b1() {
    
    		}
    
    		private void b2() {
    
    		}
    
    		protected void b3() {
    
    		}
    
    		public void b4() {
    
    		}
    
    		private void print(E e) {
    			System.out.print("a1:" + e.a1);
    			System.out.print("a2:" + e.a2);
    			System.out.print("a3:" + e.a3);
    			System.out.print("a4:" + e.a4);
    
    			e.a1();
    			e.a2();
    			e.a3();
    			e.a4();
    		}
    	}
    }

在其静态类中传递一个  **E** 的引用进去就能解决问题了：

![20150129214652544][]  
可以看出其中现在并没有报错了；能正常运行。

## 两者之间的隐藏区别 ##

但是最开始上面的内部类是怎么回事？难道是闹鬼了？上面的内部类没有传递引用的啊；为啥加上一个 **static** 就不行了？

在这里我们需要看看字节码，我们先建立一个简单的内部类：

public class F {
    	
    	class A{
    		
    	}
    }

这个够简单吧？别说这个都难了；汗~

然后我们找到 class 文件，然后查看字节码：

![20150129215105783][]

在这里分别查看了 F 类的字节码和 **F$A** 类的字节码。

其中有这样的一句：**final F this$0;** 这句是很重要的一句，这句出现的地方在其内部类中，意思是当你 new 一个内部类的时候就同时传递了当前类进去；所以在内部类中能具有当前类的完全权限，能直接使用所有的东西；就是因为在隐藏情况下已经传递了当前类进去。

那么我们再看看一个简单的静态内部类：

public class G {
    	static class A {
    
    	}
    }

与上面的区别唯一就是在于添加了一个  **static** 。此时我们看看字节码：

![20150129215728947][]  
  
可以看出其中无论是 **G** 类，还是 **G$A** 类的初始化中都没有其他多余的部分，也没有进行隐藏的传递进去当前类；所以这样的情况下并不具备访问权限，需要我们传递引用进去，可以通过接口也可以完全传递进去，具体取决于个人。所以加了**static**类的内部类除了在权限上比一般的类更加开放（与其包含类）外，与一般的类在使用上是一样的；所以准确的说应该叫做静态嵌套类。

## 初始化的区别 ##

一个类中，同时包含了内部类与静态内部类，那么其初始化应该是怎么样的呢？

都是直接 **new** ？还是看看代码：

public class H {
    	int a = 1;
    
    	public class A {
    		public void Show() {
    			System.out.print("a:" + a);
    		}
    	}
    
    	public static class B {
    		public void Show(H h) {
    			System.out.print("a:" + h.a);
    		}
    	}
    
    	public static void main(String[] args) {
    		H h = new H();
    		//A a = new A();
    		A a1 = h.new A();
    		B b = new B();
    		//B b1 = h.new B();
    		B b3 = new H.B();
    	}
    }

其中注释了的两种方式是不允许的方式，也就是无法正常运行。

**A** 因为有一个隐藏的引用，所以必须是**H** 的实例才能进行初始化出**A** 类；而**B** 类则是因为是在**H** 类中以静态方式存在的类，所以需要 **new H.B()**；之所以能直接使用**new B()**，与该 **main** 方法在 **H** 类中有关，因为本来就在 **H**类中，所以直接使用 **H**类的静态属性或者方法可以不加上：“**H.**” 在前面。

## 内部类的继承 ##

直接继承的情况：

![20150129221928916][]

可以看出报错了，为什么？因为需要传递一个 H 类进去，所以我们在继承的时候需要显示的指明：

public class I extends H.A{
    	public I(H h){
    		h.super();
    	}
    }

也就是在构造方法中，传递一个 H 的引用进去，并调用 H 实例的 super() 方法，才能进行实例化。  
使用的话应该这样：

public static void main(String[] args) {
            H h = new H();
            I i = new I(h);
        }

而，如果是继承其静态嵌套类，则不需要这样：

public class J extends H.B{
    
    }

就这样就OK。

哎，差不多了~~整个内部类的东西差不多就是这些了，写了我3个小时42分钟~汗！！！！

如果有没有写到的地方，还请补充~~

不对的地方还请指正~~

*——学之开源，用于开源；初学者的心态，与君共勉！*  
========================================================

[blog.csdn.net_qiujuer]: http://blog.csdn.net/qiujuer
[www.qiujuer.net]: http://www.qiujuer.net/
[Genius-Android]: https://github.com/qiujuer/Genius-Android
[http_blog.csdn.net_qiujuer_article_details_43282699]: http://blog.csdn.net/qiujuer/article/details/43282699
[20150129174923276]: /images/20220806/9954ec20c09e44d395102044d5f72473.png
[20150129175626271]: /images/20220806/1e0804b123b84c268654ce2121c121cb.png
[20150129213252311]: /images/20220806/a703e79cc037490e9fe8cf0841023bb6.png
[20150129213725499]: /images/20220806/3960c64a6b1e4e76a1106d8f4123c932.png
[20150129214652544]: /images/20220806/743f8423812246d1ac9bf9b2681892aa.png
[20150129215105783]: /images/20220806/ef9b0c6620b8451ba0715105e01d7c9f.png
[20150129215728947]: /images/20220806/27f98c6bcf414ec4b7b4d2874b380c3c.png
[20150129221928916]: /images/20220806/5b86328285204d1a846bb6ece64dbebe.png