西西软件下载最安全的下载网站、值得信赖的软件下载站！
→ java 嵌套类的分类、为什么使用嵌套类？
java程序语言允许你在一个类里面再声明另一个类，这样的类成为嵌套类，说明如下:class OuterClass {
class NestedClass {
}术语：嵌套类分为两种：静态或非静态。嵌套类声明为static称为静态嵌套类。非静态嵌套类都称为内部类。class OuterClass {&&& ...&&& static class StaticNestedClass {&&&&&&& ...&&& }&&& class InnerClass {&&&&&&& ...&&& }}一个嵌套类是它的封装类的成员。非静态嵌套类可以访问它的封装类的其他成员，即使这些成员声明是private。静态嵌套类不能访问封装类的其他成员。就像外部类的一个成员一样，嵌套类可以声明为private,public,protected,包内私有(回顾外部类只能声明为public或者是包内私有)为什么使用嵌套类使用嵌套类，其中有几个令人信服的理由：它是一个在一个地方使用类的逻辑分组的方法它加强封装嵌套类可以促进更可读性，可维护性的代码。类的逻辑分组―如果一个类只是被其他一个类使用，那么合乎逻辑的是把它嵌套到该类，让这两个类在一起。嵌套这样的帮助类可以让包更加精简。加强封装―考虑两个顶级类，A和B，如果B需要访问A的private成员，通过在A类隐藏B类，那么即使A的成员声明为private，那么B也可以访问它们。更多的是，B本身也可以隐藏于外部。更可读性，可维护性的代码―在顶级类里嵌套小类，让代码更靠近使用的地方。静态嵌套类和类方法，类变量一样，一个静态嵌套类是和它的外部类关联的。就像静态类方法一样，一个静态嵌套类不能直接引用封装类的实例变量或者方法―它只能通过封装类的引用访问它们。注意：一个静态嵌套类访问它的封装类(和其他类)的实例成员，就像访问其他顶级类一样。事实上，一个静态嵌套类就像一个顶级类，只是行为上嵌套在另一个顶级类里而已，达到打包方便的目的。静态嵌套类是使用封装类的名字访问：OuterClass.StaticNestedClass例如，创建一个静态嵌套类的对象，语法是：OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();内部类如实例方法和实例字段一样，一个内部类是和封装类的实例关联的，并且可以直接访问这个对象的成员和方法。正是因为一个内部类是和实例关联的，所以它不能定义任何静态成员。内部类的对象实例存在于外部类的实例，考虑下面的类：class OuterClass {
class InnerClass {
}一个内部类的实例，尽可以存在于外部类的实例中，并且可以直接访问封装实例的方法和字段。下图说明了这个想法：一个内部类的实例存在于外部类的实例实例化内部类之前，你首先要实例化外部类。然后基于外部类的对象创建内部类对象，语法是：还有，有两种特别的内部类，局部类和匿名类(也可以成为匿名内部类)。这两者会在后面讨论。内部类例子为了演示内部类的使用，让我们思考一个数组。接下来的例子，我们会创建一个数组，填充为整数，输出的数组的索引值是升序的。下面的DataStructure类包括：DataStructure外部类，包含了添加整数到内部数组的方法，输出数组里的索引值InnerEvenIterator内部类，类似java的标准迭代器。迭代器用于遍历一个数据结果，典型的是判断是否到了最后一个元素，检索当前元素，移动到下一个元素。在main方法里实例化DataStructure对象，使用它填充数组arrayOfInts为一系列整数(0, 1, 2, 3, etc.),然后调用一个printEven 方法，输出arrayOfInts的索引值。public class DataStructure {&&& // create an array&&& private final static int SIZE = 15;&&& private int[] arrayOfInts = new int[SIZE];&&& &&& public DataStructure() {&&&&&&& // fill the array with ascending integer values&&&&&&& for (int i = 0; i & SIZE; i++) {&&&&&&&&&&& arrayOfInts[i] =&&&&&&& }&&& }&&& &&& public void printEven() {&&&&&&& // print out values of even indices of the array&&&&&&& InnerEvenIterator iterator = this.new InnerEvenIterator();&&&&&&& while (iterator.hasNext()) {&&&&&&&&&&& System.out.println(iterator.getNext() + & &);&&&&&&& }&&& }&&& &&& // inner class implements the Iterator pattern&&& private class InnerEvenIterator {&&&&&&& // start stepping through the array from the beginning&&&&&&& private int next = 0;&&&&&&& &&&&&&& public boolean hasNext() {&&&&&&&&&&& // check if a current element is the last in the array&&&&&&&&&&& return (next &= SIZE - 1);&&&&&&& }&&&&&&& &&&&&&& public int getNext() {&&&&&&&&&&& // record a value of an even index of the array&&&&&&&&&&& int retValue = arrayOfInts[next];&&&&&&&&&&& //get the next even element&&&&&&&&&&& next += 2;&&&&&&&&&&& return retV&&&&&&& }&&& }&&& &&& public static void main(String s[]) {&&&&&&& // fill the array with integer values and print out only&&&&&&& // values of even indices&&&&&&& DataStructure ds = new DataStructure();&&&&&&& ds.printEven();&&& }}输出是:0 2 4 6 8 10 12 14 注意InnerEvenIterator是直接引用DataStructure对象的实例变量arrayOfInts。内部类可用来实现帮助类，就像上面的例子。如果你计划处理用户接口事件，你需要指导如何使用内部类，因为事件处理机制中，内部类是广泛使用的。局部和匿名内部类有两种良性的内部类。你可以在方法体内声明一个内部类。这样的类成为局部内部类。你也可以在方法体内，声明一个没有名字的内部类，这种类就是匿名内部类了。我们将会在java高级编程遇到它。修饰符可以为内部类使用修饰符，就像外部类成员那么使用。例如，可以使用特殊访问―private,public,protected―限制访问内部类的方式，就像和其他类成员的使用方式一样。
12-2002-0501-2901-2901-2901-2901-2501-2301-2201-13
阅读本文后您有什么感想? 已有23人给出评价!
名称大小下载下次自动登录
现在的位置:
& 综合 & 正文
深入理解java嵌套类和内部类
　　可以在一个类的内部定义另一个类，这种类称为嵌套类（nested classes），它有两种类型：静态嵌套类和非静态嵌套类。静态嵌套类使用很少，最重要的是非静态嵌套类，也即是被称作为内部类（inner）。嵌套类从JDK1.1开始引入。其中inner类又可分为三种：
　　其一、在一个类（外部类）中直接定义的内部类；
　　其二、在一个方法（外部类的方法）中定义的内部类；
　　其三、匿名内部类。
　　下面，我将说明这几种嵌套类的使用及注意事项。
　　如下所示代码为定义一个静态嵌套类，
　　public class StaticTest {
private static String name = "javaJohn";　
　　　　private String id = "X001";
　　　　static class Person{
　　　　　　private String address = "swjtu,chenDu,China";
　　　　　　public String mail = "";//内部类公有成员
　　　　　　public void display(){
　　　　　　　　//System.out.println(id);//不能直接访问外部类的非静态成员
　　　　　　　　System.out.println(name);//只能直接访问外部类的静态成员
　　　　　　　　System.out.println("Inner "+address);//访问本内部类成员。
　　　　　　}
　　　　public void printInfo(){
　　　　　　Person person = new Person();
　　　　　　person.display();
　　　　　　//System.out.println(mail);//不可访问
　　　　　　//System.out.println(address);//不可访问
　　　　　　System.out.println(person.address);//可以访问内部类的私有成员
　　　　　　System.out.println(person.mail);//可以访问内部类的公有成员
　　　　public static void main(String[] args) {
　　　　StaticTest staticTest = new StaticTest();
　　　　staticTest.printInfo();
　　在静态嵌套类内部，不能访问外部类的非静态成员，这是由Java语法中"静态方法不能直接访问非静态成员"所限定。若想访问外部类的变量，必须通过其它方法解决，由于这个原因，静态嵌套类使用很少。注意，外部类访问内部类的的成员有些特别，不能直接访问，但可以通过内部类来访问，这是因为静态嵌套内的所有成员和方法默认为静态的了。同时注意，内部静态类Person只在类StaticTest 范围内可见，若在其它类中引用或初始化，均是错误的。
　　如下所示代码为在外部类中定义两个内部类及它们的调用关系：
public class Outer {
　　int outer_x = 100;
　　　　class Inner{
　　　　　　public int y = 10;
　　　　　　private int z = 9;
　　　　　　int m = 5;
　　　　　　public void display(){
　　　　　　　　System.out.println("display outer_x:"+ outer_x);
　　　　　　}
　　　　　　private void display2(){
　　　　　　　　System.out.println("display outer_x:"+ outer_x);
　　　　　　}
　　　　void test(){
　　　　　　Inner inner = new Inner();
　　　　　　inner.display();
　　　　　　inner.display2();
　　　　　　//System.out.println("Inner y:" + y);//不能访问内部内变量
　　　　　　System.out.println("Inner y:" + inner.y);//可以访问
　　　　　　System.out.println("Inner z:" + inner.z);//可以访问
　　　　　　System.out.println("Inner m:" + inner.m);//可以访问
　　　　　　InnerTwo innerTwo = new InnerTwo();
　　　　　　innerTwo.show();
　　　　class InnerTwo{
　　　　　　Inner innerx = new Inner();
　　　　　　public void show(){
　　　　　　　　//System.out.println(y);//不可访问Innter的y成员
　　　　　　　　//System.out.println(Inner.y);//不可直接访问Inner的任何成员和方法
　　　　　　　　innerx.display();//可以访问
　　　　　　　　innerx.display2();//可以访问
　　　　　　　　System.out.println(innerx.y);//可以访问
　　　　　　　　System.out.println(innerx.z);//可以访问
　　　　　　　　System.out.println(innerx.m);//可以访问
　　　　　　}
　　　　public static void main(String args[]){
　　　　　　Outer outer = new Outer();
　　　　　　outer.test();
　　以上代码需要说明有，对于内部类，通常在定义类的class关键字前不加public 或 private等限制符，若加了没有任何影响，同时好像这些限定符对内部类的变量和方法也没有影响（？）。另外，就是要注意，内部类Inner及InnterTwo只在类Outer的作用域内是可知的，如果类Outer外的任何代码尝试初始化类Inner或使用它，编译就不会通过。同时，内部类的变量成员只在内部内内部可见，若外部类或同层次的内部类需要访问，需采用示例程序中的方法，不可直接访问内部类的变量。
&&&&推荐文章:
【上篇】【下篇】相关文章推荐
Java嵌套类的深入理解
为什么Java支持类嵌套？　　Java并非一定要支持类嵌套。实际上，如果你看过内部类规范文档，你将会发现类嵌套的应用在哪里。不过，Java支持类嵌套至少有两个好处：　　.令源代码更加清晰　　.减少命名...
开心一笑【刚在路上遇到一只狗，我蹲下来问它：我2017年的运势，它慎重考虑了下说：旺旺旺，这下我就放心了……】提出问题java中的嵌套接口和嵌套类???解决问题接口嵌套接口/**
* 花（接口嵌套接...
一、什么是嵌套类及内部类
　　可以在一个类的内部定义另一个类，这种类称为嵌套类（nested classes），它有两种类型：静态嵌套类和非静态嵌套类。静态嵌套类使用很少，最重要的是非静态嵌套类...
嵌套类可以分为两种，静态的和非静态的，即静态嵌套类和非静态嵌套类。非静态嵌套类又叫做内部类（Inner Class）。我们通常所说的静态内部类其实是不严格的，严格的说应该叫做静态嵌套类(Static ...
声明1：本篇内容大量参照W3C：http://www.w3.org/TR/CSS2/cascade.html
声明2：英语里继承的单词应该是Inheritance，而Cascade意思是瀑布。文章标...
Java嵌套类的深入理解
深入理解java嵌套类和内部类、匿名类
一、什么是嵌套类及内部类
　　可以在一个类的内部定义另一个类，这种类称为嵌套类（nested classes...
一、什么是嵌套类及内部类
　　可以在一个类的内部定义另一个类，这种类称为嵌套类（nested classes），它有两种类型：静态嵌套类和非静态嵌套类。静态嵌套类使用很少，最重要的是...
java嵌套类和内部类、匿名类
1、嵌套类和内部类定义
可以在一个类的内部定义另一个类，这种类称为嵌套类（nested classes），它有两种类型：静态嵌套类和非静态嵌套类。静态嵌套类使用很少，最...
他的最新文章
他的热门文章
您举报文章：
举报原因：
原文地址：
原因补充：
(最多只允许输入30个字)您所在的位置： &
深入理解JAVA的嵌套类和内部类
深入理解JAVA的嵌套类和内部类
IT专家网论坛
可以在一个类的内部定义另一个类，这种类称为嵌套类（nested classes）,它有两种类型:静态嵌套类和非静态嵌套类。静态嵌套类使用很少，最重要的是非静态嵌套类，也即是被称作为内部类(inner)。
一、什么是嵌套类及内部类?
可以在一个类的内部定义另一个类，这种类称为嵌套类(nested classes),它有两种类型:
静态嵌套类和非静态嵌套类。静态嵌套类使用很少，最重要的是非静态嵌套类，也即是被称作为
内部类(inner)。嵌套类从JDK1.1开始引入。其中inner类又可分为三种：
其一、在一个类(外部类)中直接定义的内部类;
其二、在一个方法(外部类的方法)中定义的内部类;
其三、匿名内部类。
下面，我将说明这几种嵌套类的使用及注意事项。
二、静态嵌套类
如下所示代码为定义一个静态嵌套类，
public class StaticTest {
private static String name = "javaJohn";
private String id = "X001";
static class Person{
private String address = "swjtu,chenDu,China";
public String mail = "";//内部类公有成员
public void display(){
//System.out.println(id);//不能直接访问外部类的非静态成员
System.out.println(name);//只能直接访问外部类的静态成员
System.out.println("Inner "+address);//访问本内部类成员。
public void printInfo(){
Person person = new Person();
person.display();
//System.out.println(mail);//不可访问
//System.out.println(address);//不可访问
System.out.println(person.address);//可以访问内部类的私有成员
System.out.println(person.mail);//可以访问内部类的公有成员
public static void main(String[] args) {
StaticTest staticTest = new StaticTest();
staticTest.printInfo();
在静态嵌套类内部，不能访问外部类的非静态成员，这是由Java语法中"静态方法不能直接访问非静态成员"所限定。
若想访问外部类的变量，必须通过其它方法解决，由于这个原因，静态嵌套类使用很少。注意，外部类访问内
部类的的成员有些特别，不能直接访问，但可以通过内部类来访问，这是因为静态嵌套内的所有成员和方法默认为
静态的了。同时注意，内部静态类Person只在类StaticTest 范围内可见，若在其它类中引用或初始化，均是错误的。
三、在外部类中定义内部类
如下所示代码为在外部类中定义两个内部类及它们的调用关系：
public class Outer{
int outer_x = 100;
class Inner{
public int y = 10;
private int z = 9;
int m = 5;
public void display(){
System.out.println("display outer_x:"+ outer_x);
private void display2(){
System.out.println("display outer_x:"+ outer_x);
void test(){
Inner inner = new Inner();
inner.display();
inner.display2();
//System.out.println("Inner y:" + y);//不能访问内部内变量
System.out.println("Inner y:" + inner.y);//可以访问
System.out.println("Inner z:" + inner.z);//可以访问
System.out.println("Inner m:" + inner.m);//可以访问
InnerTwo innerTwo = new InnerTwo();
innerTwo.show();
class InnerTwo{
Inner innerx = new Inner();
public void show(){
//System.out.println(y);//不可访问Innter的y成员
//System.out.println(Inner.y);//不可直接访问Inner的任何成员和方法
innerx.display();//可以访问
innerx.display2();//可以访问
System.out.println(innerx.y);//可以访问
System.out.println(innerx.z);//可以访问
System.out.println(innerx.m);//可以访问
public static void main(String args[]){
Outer outer = new Outer();
outer.test();
以上代码需要说明有，对于内部类，通常在定义类的class关键字前不加public 或 private等限制符，若加了
没有任何影响，同时好像这些限定符对内部类的变量和方法也没有影响(?)。另外，就是要注意，内部类Inner及
InnterTwo只在类Outer的作用域内是可知的，如果类Outer外的任何代码尝试初始化类Inner或使用它，编译就不
会通过。同时，内部类的变量成员只在内部内内部可见，若外部类或同层次的内部类需要访问，需采用示例程序中的方法，不可直接访问内部类的变量。
四、在方法中定义内部类
如下所示代码为在方法内部定义一个内部类:
public class FunOuter {
int out_x = 100;
public void test(){
class Inner{
String x = "x";
void display(){
System.out.println(out_x);
Inner inner = new Inner();
inner.display();
public void showStr(String str){
//public String str1 = "test Inner";//不可定义，只允许final修饰
//static String str4 = "static Str";//不可定义，只允许final修饰
String str2 = "test Inner";
final String str3 = "final Str";
class InnerTwo{
public void testPrint(){
System.out.println(out_x);//可直接访问外部类的变量
//System.out.println(str);//不可访问本方法内部的非final变量
//System.out.println(str2);//不可访问本方法内部的非final变量
System.out.println(str3);//只可访问本方法的final型变量成员
InnerTwo innerTwo = new InnerTwo();
innerTwo.testPrint();
public void use(){
//Inner innerObj = new Inner();//此时Inner己不可见了。
//System.out.println(Inner.x);//此时Inner己不可见了。
public static void main(String[] args) {
FunOuter outer = new FunOuter();
outer.test();
从上面的例程我们可以看出定义在方法内部的内部类的可见性更小，它只在方法内部
可见，在外部类(及外部类的其它方法中)中都不可见了。同时，它有一个特点，就是方法
内的内部类连本方法的成员变量都不可访问，它只能访问本方法的final型成员。同时另一个
需引起注意的是方法内部定义成员，只允许final修饰或不加修饰符，其它像static等均不可用。
五、匿名内部类
如下所示代码为定义一个匿名内部类:匿名内部类通常用在Java的事件处理上
import java.applet.*;
import java.awt.event.*;
public class AnonymousInnerClassDemo extends Applet{
public void init(){
addMouseListener(new MouseAdapter(){
public void mousePressed(MouseEvent me){
showStatus("Mouse Pressed!");
public void showStatus(String str){
System.out.println(str);
在上面的例子中，方法addMouseListener接受一个对象型的参数表达式，于是，在参数里，我们定义了一个匿名内部类这个类是一个MouseAdapter类型的类，同时在这个类中定义了一个继承的方法mousePressed，整个类做为一个参数。这个类没有名称，但是当执行这个表达式时它被自动实例化。同时因为，这个匿名内部类是定义在AnonymousInnerClassDemo 类内部的，所以它可以访问它的方法showStatus。这同前面的内部类是一致的。
六、内部类使用的其它的问题
通过以上，我们可以清楚地看出内部类的一些使用方法，同时，在许多时候，内部类是在如Java的事件处理、或做为值对象来使用的。同时，我们需注意最后一个问题，那就是，内部类同其它类一样被定义，同样它也可以继承外部其它包的类和实现外部其它地方的接口。同样它也可以继承同一层次的其它的内部类,甚至可以继承外部类本身。下面我们给出最后一个例子做为结束：
public class Layer {
//Layer类的成员变量
private String testStr = "testStr";
//Person类，基类
class Person{
public void setName(String nameStr){
this.name = nameS
public String getName(){
return this.
public void setEmail(Email emailObj){
this.email = emailO
public String getEmail(){
return this.email.getMailStr();
//内部类的内部类，多层内部类
class Email{
String mailID;
String mailNetA
Email(String mailId,String mailNetAddress){
this.mailID = mailId;
this.mailNetAddress = mailNetA
String getMailStr(){
return this.mailID +"@"+this.mailNetA
//另一个内部类继承外部类本身
class ChildLayer extends Layer{
void print(){
System.out.println(super.testStr);//访问父类的成员变量
//另个内部类继承内部类Person
class OfficePerson extends Person{
void show(){
System.out.println(name);
System.out.println(getEmail());
//外部类的测试方法
public void testFunction(){
//测试第一个内部类
ChildLayer childLayer = new ChildLayer();
childLayer.print();
//测试第二个内部类
OfficePerson officePerson = new OfficePerson();
officePerson.setName("abner chai");
//注意此处，必须用 对象.new 出来对象的子类对象
//而不是Person.new Email(...)
//也不是new Person.Email(...)
officePerson.setEmail(officePerson.new Email("josserchai",""));
officePerson.show();
public static void main(String[] args) {
Layer layer = new Layer();
layer.testFunction();
【编辑推荐】
【责任编辑： TEL：（010）】
关于&&&&&&&&的更多文章
TIOBE编程语言排行榜Java以4.5%的差距遥遥领先于第二名，以后使
讲师： 7人学习过讲师： 31人学习过讲师： 19人学习过
如何看将流行的JavaScript MVC框架Ember.js? 这款Java
一周一周的过的很快，2013年已经进入了倒计时。开发频
在脚本语言领域，Lua是最快、最高效的脚本语言之一，
osCommerce是一款免费的、开放源代码的专业电子商务解决方案。本书以通俗易懂的语言向读者展示了该软件强大的功能和简易的操作方
51CTO旗下网站