Java内部类典型用法

最新推荐文章于 2024-08-09 06:30:00 发布
最新推荐文章于 2024-08-09 06:30:00 发布
阅读量664 收藏 5
点赞数
分类专栏： Java语言 文章标签： Java 内部类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dkfajsldfsdfsd/article/details/84937161
版权

将一个类的定义嵌套在另一个类内部就是内部类（内部接口也可以），另一个类就是外部类。形式上很简单，关键问题是内部类有什么用，它能解决什么别人解决不了的问题？

在Java编程思想第四版中文版中有如下说法“内部类对我们非常有用，因为利用它可以对那些逻辑上相互联系的类进行分组，并可控制一个类在另一个类里的可见性”。

1、利用内部类实现分组

先看“因为利用它可以对那些逻辑上相联系的类（或者接口）进行分组这句话”。假如我们想定义一个“Tree”类，它要实现“Root”接口与“Leaf”接口。因为"Root"与"Leaf"在逻辑上是相关的，它们都是树的组成部分或者是其它植物的组成部分，因此最好把它们定义在一个文件中，也就是组织在一起，创建一个Interface.java文件，内容如下：

                                                                                            示例一

public interface Interface {
	public interface Root {
		public void show();
	}

	public interface Leaf {
		public void show();
	}
}

注意接口Root与Leaf都是public的，如果不使用内部类或者内部接口，就需要把这两个接口分别定义在各自独立的文件中，显然没有上例中使用的方式好。如果想实现以上接口的话，代码如下：

                                                                                               示例二

public class Tree implements Interface.Root, Interface.Leaf{

	@Override
	public void show() {
		System.out.println("Implement who?Root or Leaf?");
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Interface.Root r = new Tree();
		r.show();
		Interface.Leaf l = new Tree();
		l.show();
		Tree  tree = new Tree();
		tree.show();

	}

}

上例中与不使用内部接口的区别只有一个地方，就是在涉及到Root、Leaf时要在前边加上外部接口的限定符，如Interface.Root与Interface.Leaf。

2、控制内部类的可见性

上述代码中同时暴露了接口的一个问题，就是接口内方法名冲突的问题。show()这个方法同时出现在interface.Root与interface.Leaf中，在Tree中，show()方法同时实现了来自两个不同接口的show()方法，这显然是不能接受的，Root的show()方法与Leaf的show()方法在实现上不可能相同。这个问题本质上是因为继承中的“多重接口”机制引起的，因此，要解决这个问题就不能使用接口的多重实现这种机制。解决的基本思路是定义两个新类，分别实现Root与Leaf，这种方法与内部类没有关系，示例代码如下：

                                                                                              示例三

class MyRoot implements Interface.Root {
	@Override
	public void show() {
		System.out.println("Implement Root");

	}
}

class MyLeaf implements Interface.Leaf {
	@Override
	public void show() {
		System.out.println("Implement Leaf");
	}
}

public class Tree2 {
	private MyRoot r = new MyRoot();
	private MyLeaf l = new MyLeaf();

	void show(String type) {
		if ("root".equals(type)) {
			r.show();
		} else {
			l.show();
		}
	}

	public static void main(String[] args) {
		Tree2 t2 = new Tree2();
		t2.show("tree");
		t2.show("leaf");
        // 错误
        // Interface.Root r = new Tree2();
	}
}

分别定义了MyRoot与MyLeaf实现两个不同接口中的相同方法show。然后定义Tree2将MyRoot与MyLeaf组合进去。Tree2中的show()方法，注意它是独立的方法，与Root中与Leaf中的show()没有关系。它只是根据参数分别调用Root与Leaf中的不同show()。本例中的Tree2确实实现了两个不同版本的show()，但是与示例二的Tree不同，Tree2不能向上转型了。当然可以添加两个成员函数，让它模拟向上转型，示例代码如下：
                                                                                              示例四

public class Tree2 {
	private MyRoot r = new MyRoot();
	private MyLeaf l = new MyLeaf();

	void show(String type) {
		if ("root".equals(type)) {
			r.show();
		} else {
			l.show();
		}
	}
	
	Interface.Root getRoot () {
		return r;
	}
	
	Interface.Leaf getLeaf () {
		return l;
	}

	public static void main(String[] args) {
		Tree2 t2 = new Tree2();
		t2.show("tree");
		t2.show("leaf");
		
		Interface.Root r = t2.getRoot();
		r.show();
	}
}

注意Interface.Root r = t2.getRoot();这句话，它是模拟向上转型，不是真正的向上转型。以上的代码只是铺垫，与内部类没有关系，接下来就有关系了。

我们定义Tree2的目的是向外暴露一棵树的实现，而在上例中MyRoot与MyLeaf也同时暴露出去了，这不符合我们的意图，只所以分别定义MyRoot与MyLeaf是为了解决接口中方法名冲突的问题，这是我们的实现细节，需要对外隐藏。我们知道Java中普通的类只有public访问控制与默认访问控制，但内部类可以有private访问控制。因此把MyRoot与MyLeaf定义在Tree2内部，并把它设置成private型，这样就实现了隐藏，使用我们代码的人看不到MyRoot与MyLeaf了，示例如下：

                                                                                      示例五

public class Tree2 {
	private class MyRoot implements Interface.Root {
		@Override
		public void show() {
			System.out.println("[" + NAME + "]" + "Implement Root");

		}
	}
	
	private class MyLeaf implements Interface.Leaf {
		@Override
		public void show() {
			System.out.println("[" + NAME + "]" + "Implement Leaf");
		}
	}
	
	private final String NAME="Tree2";
	
	private MyRoot r = new MyRoot();
	private MyLeaf l = new MyLeaf();

	void show(String type) {
		if ("root".equals(type)) {
			r.show();
		} else {
			l.show();
		}
	}
	
	Interface.Root getRoot () {
		return r;
	}
	
	Interface.Leaf getLeaf () {
		return l;
	}

	public static void main(String[] args) {
		Tree2 t2 = new Tree2();
		t2.show("tree");
		t2.show("leaf");
		
		Interface.Root r = t2.getRoot();
		r.show();
	}

可以看到，MyRoot与MyLeaf成为Tree2的私有内部类，使用Tree2的人看不到MyRoot、MyLeaf，甚至不知道它们的存在，这也就是通过内部类控制MyRoot与MyLeaf的可见性，从而实现了隐藏实现细节的目的。

另一个非常重要的问题就是，注意Tree2中的NAME属性，它是Tree2中的私有final成员，但是对于内部类MyRoot与MyLeaf而言却是可见的，也就是说内部类可以共享外部类的一切，这一点也很重要。

3、通过方法内部类、语句块内部类、匿名内部类实现更深层次的隐藏

内部类不仅可以嵌套在类内部，还可以嵌套在方法内部、语句块内部，还可以匿名。示例代码如下：

                                                                                            示例六

public class Tree2 {
	private final String NAME = "Tree2";

	private Interface.Root r;
	private Interface.Leaf l;
	
	private void createRoot(int len) {
		class MyLeaf implements Interface.Root {
			@Override
			public void show() {
				System.out.println("[" + NAME + "]" + "[" + len + "]" + "Implement Leaf");
			}
		}
		r = new MyLeaf();
	}

	private void createLeaf(String color) {
		class MyRoot implements Interface.Root {
			@Override
			public void show() {
				System.out.println("[" + NAME + "]" + "[" + color + "]" + "Implement Root");

			}
		}
		r = new MyRoot();
	}
	
	Tree2 (int len, String color) {
		createRoot(len);
		createLeaf(color);
	}

	void show(String type) {
		if ("root".equals(type)) {
			r.show();
		} else {
			l.show();
		}
	}
	
	Interface.Root getRoot () {
		return r;
	}
	
	Interface.Leaf getLeaf () {
		return l;
	}

	public static void main(String[] args) {
		Tree2 t2 = new Tree2(10, "blue");
		t2.show("tree");
		t2.show("leaf");

		Interface.Root r = t2.getRoot();
		r.show();
	}
}

将MyRoot与MyLeaf分别定义在私有方法createRoot与createLeaf中，现在MyRoot与MyLeaf不再是类级别的内部类了，变成方法级别的内部类了。它们分别只在createRoot中createLeaf中可见，对于类中的其它方法它们都不可见，隐藏的更深。另外代码看起来结构更合理，因为相关的部分都被定义在了一起。

利用匿名内部类更进一步隐藏：

                                                                                           示例七 

public class Tree2 {
	private final String NAME = "Tree2";

	private Interface.Root r;
	private Interface.Leaf l;

	Tree2(int len, String color) {
		r = new Interface.Root() {
			@Override
			public void show() {
				System.out.println("[" + NAME + "]" + "[" + len + "]" + "Implement Leaf");
			}
		};
		l = new Interface.Leaf() {
			@Override
			public void show() {
				System.out.println("[" + NAME + "]" + "[" + color + "]" + "Implement Root");

			}
		};
	}

	void show(String type) {
		if ("root".equals(type)) {
			r.show();
		} else {
			l.show();
		}
	}

	Interface.Root getRoot() {
		return r;
	}

	Interface.Leaf getLeaf() {
		return l;
	}

	public static void main(String[] args) {
		Tree2 t2 = new Tree2(10, "blue");
		t2.show("tree");
		t2.show("leaf");

		Interface.Root r = t2.getRoot();
		r.show();
	}
}

createRoot与createLeaf方法都省了，直接在构建函数中使用内部匿名类，无需指定名称。

注意一个问题，匿名类没有名字，那么自然它就不可能有构建器。我们知道，构建器的一个重要作用是接收参数并用不同的逻辑初始化实例。上边的例子中，我们给Tree2类的构造方法传递了参数，而在内部匿名类中可以直接使用这个参数，这样，内部匿名类也就不需要通过构造器传递参数了。如果实在需要用一段逻辑初始化内部类，那么也可以用构造函数的替换方法initializer，就是把构造逻辑用{}扩起来就可以了，因此内部匿名类没有构造函数完全没有问题。 

4、总结

总结一下内部类的典型用法：

  1. 将逻辑上相关的类与接口组织在一起而不是各个定义单独的文件，如示例一。
  2. 更细粒度的控制类的可见性，如示例五。

从内部类的典型用法来看，内部类并非一定要用。它的一个作用是组织代码，使代码看起来更紧凑，组织的更合理。这个的话没有内部类也可以，只不过是代码的组织看起来不那么好而已。

关于细粒度控制类的可见性，没有这个也可以。我们可以把类定义成默认的访问控制，这样包以外的用户，也就是外部的用户就看不见这个类。而对于包内的开发人员，一般都是一个团队的人，自然知道怎么用，当然也就不用刻意隐藏来防止误用了。

只有在解决不同接口的方法名冲突时，内部类是必需的。实际上内部类的真正威力不是在这里，以上的代码里你可能忽略了一个事实，内部类可以访问外部类的一切，包括外部类私有的成员与方法，这个特性才是它的真正威力所在，我打算在下一篇文章中介绍这个特性。

五星上炕
关注
专栏目录
JAVA Stream的collect用法与原理(详解)
weixin_45985053的博客
07-19 1万+
前面我们演示了很多Collectors工具类中提供的收集器的用法，上一节中列出来的Collectors提供的常用收集器，也可以覆盖大部分场景的开发诉求了。但也许在项目中，我们会遇到一些定制化的场景，现有的收集器无法满足我们的诉求，这个时候，我们也可以自己来实现定制化的收集器。我们知道，所谓的收集器，其实就是一个Collector接口的具体实现类。所以如果想要定制自己的收集器，首先要先了解Collector接口到底有哪些方法需要我们去实现，以及各个方法的作用与用途。当我们新建一个5个接口。...
java 动态创建类_Java运行时动态生成类几种方式
weixin_32226023的博客
02-12 2591
最近一个项目中利用规则引擎，提供用户拖拽式的灵活定义规则。这就要求根据数据库数据动态生成对象处理特定规则的逻辑。如果手写不仅每次都要修改代码，还要每次测试发版，而且无法灵活根据用户定义的规则动态处理逻辑。所以想到将公共逻辑写到父类实现，将特定逻辑根据字符串动态生成子类处理。这就可以一劳永逸解决这个问题。那就着手从Java如何根据字符串模板在运行时动态生成对象。Java是一门静态语言，通常，我们需要...
java 内部类使用（内部匿名类）
12-12
java 成员内部类使用 内部匿名类 方法参数匿名类 方法匿名类
浅析总结 Java 内部类的一些使用与梳理
QiuJuer
01-30 6211
在内部类的使用中，这位客官你懂她么？来看看，有哪些是你所知道的，那些是不知道的~~ 有这篇文章，纯属巧合；那天在使用中突然发现 Java 内部类中还分 static ，说实话平时都在用，但是就是没有注意到；感觉有必要总结一下。
Java内部类详解：从基础到高级应用
最新发布
xycxycooo的博客
08-09 961
内部类是定义在另一个类内部的类。内部类可以访问外部类的所有成员（包括私有成员），并且可以实现更好的封装和代码组织。成员内部类是定义在类内部但在方法外的内部类。成员内部类可以访问外部类的所有成员（包括私有成员）。静态内部类是使用static关键字修饰的内部类。静态内部类不能访问外部类的非静态成员，只能访问外部类的静态成员。局部内部类是定义在方法或代码块内部的内部类。局部内部类的作用域仅限于定义它的方法或代码块。匿名内部类是没有名字的内部类，通常用于实现接口或抽象类的实例化。
java内部类的用法
菜鸟一缕清风的博客
05-30 280
内部类共分４种：常规内部类、静态内部类、局部内部类、匿名内部类 １．常规内部类：常规内部类没有用static修饰且定义在在外部类类体中。 - 常规内部类中的方法可以直接使用外部类的实例变量和实例方法。 - 在常规内部类中可以直接用内部类创建对象 public class OuterClass { private int x = 100; ...
kuangshenshuo-面向对象编程-内部类
baidu_38126306的博客
09-10 121
OOP --> 内部类 内部类就是在一个类的内部再定义一个类。 成员内部类 静态内部类 局部内部类 匿名内部类 public class Outer { public static void main(String[] args) { Outer outer = new Outer(); //通过这个外部类来实例化内部类 Outer.Inner inner = outer.new Inner(); inner.i
JAVA中内部类的用法
qq_40922845的博客
09-14 130
非静态内部类 package cn.aynortechnology.oop; /* * 测试非晶态内部类 */ public class TestInnerclass { public static void main(String[] args) { //创建内部类对象 Outer.Inner inner = new Outer().new Inner(); //创建内部类对象的时...
java 中抽象类的继承_java抽象类 继承
weixin_42357256的博客
02-23 5370
关于java抽象类 继承的搜索结果回答抽象类和接口的区别：默认的方法实现抽象类可以有默认的方法实现完全是抽象的。接口根本不存在方法的实现。抽象类中可以有已经实现了的方法，也可以有被abstract修饰的方法(抽象方法)，因为存在抽象方法，所以该类必须是抽象类。但是接口要求只能包含抽象方法，抽象方法是指没有实现的方法。所以就不能像抽象类那么无赖了，接口就根本不能存在方法的实现。实现 抽象类使用ex...
Java内存分配多种情况的用法解析
08-25
关于内存分配的用法，Java中比较典型的例子是对象作为方法的返回值。当对象作为返回值时，实际上是在堆内存中创建的对象，方法调用结束后，其返回的对象引用存储在栈中，通过这个引用可以访问对象。 此外，Java中的...
Java开发典型模块大全源代码
03-26
10. **并发工具类**：如CountDownLatch、CyclicBarrier、Semaphore等，这些工具类在多线程协同工作时起到关键作用，源码分析能帮助我们更好地掌握其用法。 11. **泛型**：Java泛型提高了代码的类型安全性，源代码...
java内部类的使用
mr_mari的博客
01-06 875
Java内部类的使用
java中内部类的使用
qq_45760909的博客
06-10 209
package 内部类; /* 什么是内部类，在一个类中又定义了一个类 ： 内部类的规则： 1，内部类可以直接方法外部类的成员，包括私有。 2，外部类要访问内部类，必须建立内部类对象 在内部类中 内部类可以被私有 什么时候用： 当描述事物时，事物的内部还有事物，该事物用内部类来描述。 因为内部事物在 使用外部事物的内容 */ class A{ private int num = 4; cla
Java 内部类详细用法
qq_36095290的博客
03-06 921
Java内部类详细用法、成员内部类、静态内部类、局部（⽅法）内部类、匿名内部类、内部类分类详解
【Java笔记】内部类的使用
lijibai_的博客
03-27 646
当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么整个内部的完整结构最好使用内部类。 在 Java 中，允许一个类的定义位于另一个类的内部，前者称为内部类，后者称为外部类。 目录 内部类的分类 成员内部类 一方面，作为外部类的成员 另一方面，作为一个类 内部类使用注意事项 内部类代码举例 内部类的分类 成员内部类：静态与非静态 成员内部类 一方面，作为外部类的成员 1. 可以调用外部类的结构 2. 可以被 static
java各内部类的使用
m0_73668562的博客
02-10 215
java内部类使用
Java内部类的使用总结
yygr的博客
01-24 399
https://blog.csdn.net/qq_35995514/article/details/90731394 1 学习内容 为什么使用内部类，内部类在java 源码中的设计； 成员内部类； 静态内部类； 局部内部类； 匿名内部类； 总结 2 具体内容 2.1 为什么使用内部类 为什么要使用内部类？在《Think in java》中有这样一句话：使用内部类最吸引人的原因是：每个内部类都能独立地继承一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。 在我们程
内部类 的使用
weixin_44768962的博客
08-07 723
局部内部类 静态内部类 匿名内部部类 成员内部类
Java中内部类的使用
zjojk的博客
08-29 2482
内部类 一般情况下，类和类之间是相互独立的，内部类的意思是打破这种独立，让一个类成为另外一个类的内部成员，和成员变量、成员方法同等级别。采用内部类可以隐藏细节和内部结构，封装性更好，让程序结构更加合理。基本的内部类还可以在一个方法体内定义。 非静态内部类 package com.dgut.test.demo7; public class OutClass { private String outName; public void display(){ System.ou
Java并发问题详解与synchronized用法深度解析
- **用法3：私有变量锁** - 在类内部，可以使用私有变量作为锁，如`private String a = "test"`，这样`public synchronized void print()`会锁定`a`而不是整个类，允许其他`synchronized`方法不受影响。 为了更...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值