JAVA内部类详解2

Java内部类（转）内部类 ———定义在类的内部的类为什么需要内部类？ 典型的情况是，内部类继承⾃某个类或实现某个接⼝，内部类的代码操作创建其的外围类的对象。

所以你可以认为内部类提供了某种进⼊其外围类的窗⼝。

java中的内部类和接⼝加在⼀起，可以实现多继承。

可以使某些编码根简洁。

隐藏你不想让别⼈知道的操作。

使⽤内部类最吸引⼈的原因是： 每个内部类都能独⽴地继承⾃⼀个（接⼝的）实现，所以⽆论外围类是否已经继承了某个（接⼝的）实现，对于内部类都没有影响。

如果没有内部类提供的可以继承多个具体的或抽象的类的能⼒，⼀些设计与编程问题就很难解决。

从这个⾓度看，内部类使得多重继承的解决⽅案变得完整。

接⼝解决了部分问题，⽽内部类有效地实现了“多重继承”。

　内部类分为: 成员内部类、静态嵌套类、⽅法内部类、匿名内部类。

特点：　⼀、内部类仍然是⼀个独⽴的类，在编译之后内部类会被编译成独⽴的.class⽂件，但是前⾯冠以外部类的类命和$符号。

⼆、内部类可以直接或利⽤引⽤访问外部类的属性和⽅法，包括私有属性和⽅法（但静态内部类不能访问外部类的⾮静态成员变量和⽅法）。

内部类所访问的外部属性的值由构造时的外部类对象决定。

三、⽽外部类要访问内部类的成员，则只能通过引⽤的⽅式进⾏，可问内部类所有成员 四、访问机制： System.out.println(this.x);或System.out.println(x);//内部类访问内部类的成员变量或成员⽅法可⽤此⽅法。

System.out.println(OuterClass.this.x);//内部类访问外部类的同名变量时可⽤此⽅法，如果没有同名可⽤System.out.println(x); 五、内部类可以使⽤任意的范围限定：public/private/protected class InnerClass，且严格按照这⼏种访问权限来控制内部类能使⽤的范围。

普通类的范围限定只可以是public或者不加。

java内部类知识点总结概述Java内部类是Java的一种特殊类，它有自己的特殊特性，它可以帮助程序员更好地维护和管理程序的细节，使程序更加可靠。

本文将为大家介绍一些关于java内部类的基本知识，供程序员参考学习。

一、内部类的定义内部类是一种特殊的类，它可以在其他类的内部定义，内部类可以访问它所在的类的所有成员（包括私有变量），而外部类不能够访问内部类的成员。

二、内部类的分类1. 成员内部类：成员内部类是定义在另一个类中的类，它需要使用外部类对象的引用来创建内部类对象。

2. 静态内部类：静态内部类是指在另一个类中定义的静态类，它不能访问外部类的非静态成员，但是可以访问外部类的静态成员，而且静态内部类可以使用外部类的静态变量。

3. 局部内部类：局部内部类是指定义在方法内部的类，它不能使用任何外部类的成员变量，只能使用final类型的局部变量。

4. 匿名内部类：匿名内部类是指没有名字的内部类，它是用匿名类实例化的，不能有构造函数，只能使用一次。

5. 抽象内部类：抽象内部类是一种特殊的内部类，它可以提供抽象方法的包装，让外部类能够使用这些抽象方法，而不需要定义抽象方法，它是抽象类和普通类的中间级别。

三、内部类的使用内部类可以访问外部类的所有成员，这样使得我们能够轻松地定义和管理细节，从而更容易地维护程序。

内部类也可以帮助我们将程序的复杂性融入结构化的代码中，这样可以提高程序的可读性。

此外，内部类可以帮助我们实现封装，可以将类的实现细节隐藏起来，从而保护类的实现细节不被外部访问。

四、小结由以上内容可知，java内部类是java的一种特殊类，它可以帮助程序员更好的维护和管理程序的细节，使程序变得更加可靠，程序员可以根据自己的实际情况选择使用合适的内部类来实现特定的功能。

Java中的内部类（成员内部类、静态内部类、局部内部类、匿名内部类）Java中的内部类（成员内部类、静态内部类、局部内部类、匿名内部类） 我们先看这样⼀段话：⼈是由⼤脑、肢体、器官等⾝体结果组成。

⽽组成我们⼈体的⼼脏它也有⾃⼰的属性和⾏为（⾎液、跳动），显然，此处不能单⽅⾯⽤属性或者⽅法表⽰⼀个⼼脏了，⽽需要⼀个类，但是这个类要依赖于⼈这个类存在（因为⼼脏不能脱离⼈体⽽存活，当然不考虑现今社会的发达科技，只从正常情况下来说），所⼼脏以需要写在⼈类的内部。

内部类就相当于其中的某个器官之⼀。

⾸先看看什么是内部类：在类的内部定义另⼀个类。

没错，定义就这么简单。

如果在类Outer的内部再定义⼀个类Inner，此时Inner就称为内部类，⽽Outer则称为外部类。

内部类的定义格式如下：public class外部类的名称{//外部类的成员public class内部类的名称{//内部类的成员}}使⽤内部类有什么好处；1）实现多重继承;2）内部类可以很好的实现隐藏：⼀般的⾮内部类，是不允许有 private 与protected权限的，但内部类可以3）减少了类⽂件编译后的产⽣的字节码⽂件的⼤⼩使⽤内部类的缺点：使程序结构不清楚。

内部类在编译完成后也会产⽣.class⽂件，但⽂件名称是：外部类名称$内部类名称.class内部类的种类：成员内部类、静态内部类、局部内部类、匿名内部类。

下⾯分别详细学习⼀下这四种内部类的具体使⽤。

⼀、成员内部类1、成员内部类也叫实例内部类。

应⽤场合：每⼀个外部类对象都需要⼀个内部类的实例，内部类离不开外部类存在（相当于⼼脏对⼈体）2、成员内部类的特征：作为外部类的⼀个成员存在，与外部类的属性、⽅法并列成员内部类持有外部类的引⽤成员内部类中不能定义static变量和⽅法3、使⽤格式：Outer outer = new Outer();Outer.Inner inner = outer.new Inner();代码演⽰⼀：/** 成员内部类*/public class Body {String arm;String leg;String blood;public Body(String arm, String leg, String blood) {super();this.arm = arm;this.leg = leg;this.blood = blood;}//内部类Heartclass Heart{String name;void work() {System.out.println("⼼脏正在给"+arm+leg+"输"+blood);}};}public class Test {public static void main(String[] args) {Body body=new Body("两个胳膊","两条腿","⾎");Body.Heart heart=body.new Heart();heart.work();}}运⾏截图：代码演⽰⼆：/** 成员内部类*/public class Outer {private String name="Hello World";public class Inner{public void print(){System.out.println(name);}};public void print(){//定义外部类⽅法new Inner().print();//通过内部类的实例化对象调⽤⽅法}public static void main(String[] args) {Outer outer=new Outer();outer.print();//调⽤外部类的⽅法}}运⾏截图：解释⼀下，上述代码中，new Inner().print();代码相当于Inner inner=new Inner();Inner.print();⼆、静态内部类1、内部类如果使⽤static声明，则此内部类就称为静态内部类。

java内部类（Inner Class）详解简单的说，内部（inner）类指那些类定义代码被置于其它类定义中的类；而对于一般的、类定义代码不嵌套在其它类定义中的类，称为顶层（top-level）类。

对于一个内部类，包含其定义代码的类称为它的外部（outer）类。

1 Static member class（静态成员类）类声明中包含“static”关键字的内部类。

如以下示例代码，Inner1/Inner2/Inner3/Inner4就是Outer的四个静态成员类。

静态成员类的使用方式与一般顶层类的使用方式基本相同。

public class Outer{//just like static method, static member class has public/private/default access privilege levels//access privilege level: publicpublic static class Inner1 {public Inner1() {//Static member inner class can access static method of outer classstaticMethod();//Compile error: static member inner class can not access instance method of outer class//instanceMethod();}}//access privilege level: defaultstatic class Inner2 {}//access privilege level: privateprivate static class Inner3 {//define a nested inner class in another inner classpublic static class Inner4 {}}private static void staticMethod() {//cannot define an inner class in a method/*public static class Inner4() {}*/}private void instanceMethod() {//private static member class can be accessed only in its outer class definition scopeInner3 inner3 = new Inner3();//how to use nested inner classInner3.Inner4 inner4 = new Inner3.Inner4();}}class Test {Outer.Inner1 inner1 = new Outer.Inner1();//Test and Outer are in the same package, so Inner2 can be accessed hereOuter.Inner2 inner2 = new Outer.Inner2();//Compile error: Inner3 cannot be accessed here//Outer.Inner3 inner3 = new Outer.Inner3();}1.1 静态成员类特性静态成员类可访问外部类的任一静态字段或静态方法像静态方法或静态字段一样，静态成员类有public/private/default权限修饰符1.2 静态成员类约束静态成员类不能与外部类重名像外部类的静态方法一样，不能直接访问外部类的实例字段和实例方法静态成员类只能定义于外部类的顶层代码或外部类其它静态成员类的顶层代码中（嵌套定义）；不能定义于外部类的某个函数中。

Inner class 可以声明为static的，但此时就不能再使用外层类的非static的成员变量；成员内部类作为类的角色：可以在内部定义属性、方法、构造器等结构可以继承自己的想要继承的父类，实现自己想要实现的父接口们，和外部类的父类和父接口无关可以声明为abstract类，因此可以被其它的内部类继承可以声明为final的，表示不能被继承编译以后生成OuterClass$InnerClass.class字节码文件（也适用于局部内部类）注意点：2. 外部类访问成员内部类的成员，需要“内部类.成员”或“内部类对象.成员”的方式3. 成员内部类可以直接使用外部类的所有成员，包括私有的数据4. 当想要在外部类的静态成员部分使用内部类时，可以考虑内部类声明为静态的1.2.2 创建成员内部类对象实例化静态内部类外部类名.静态内部类名变量 = 外部类名.静态内部类名();变量.非静态方法();实例化非静态内部类外部类名变量1 = new 外部类();外部类名.非静态内部类名变量2 = 变量1.new 非静态内部类名();变量2.非静态方法();1.2.3 举例public class TestMemberInnerClass {public static void main(String[] args) {//创建静态内部类实例，并调用方法Outer.StaticInner inner=new Outer.StaticInner();inner.inFun();//调用静态内部类静态方法Outer.StaticInner.inMethod();System.out.println("*****************************");//创建非静态内部类实例（方式1），并调用方法Outer outer=new Outer();Outer.NoStaticInner inner1=outer.new NoStaticInner();inner1.inFun();//创建非静态内部类实例（方式2）Outer.NoStaticInner inner2=outer.getNoStaticInner();inner1.inFun();}}class Outer{private static String a="外部类的静态a";private static String b ="外部类的静态b";private String c="外部类对象的非静态c";private String d="外部类对象的非静态d";static class StaticInner{private static String a="静态内部类的静态a";private String c="静态内部类对象的非静态c";public static void inMethod(){System.out.println("Inner.a = "+a);System.out.println("Outer.a = "+Outer.a);System.out.println("b = "+b);}public void inFun(){System.out.println("Inner.inFun");System.out.println("Outer.a = "+Outer.a);System.out.println("Inner.a = "+a);System.out.println("b = "+b);System.out.println("c = "+c);//System.out.println("d = " + d);//不能访问外部类的非静态成员 }}class NoStaticInner{private String a="非静态内部类对象的非静态a";private String c="非静态内部类对象的非静态c";public void inFun(){System.out.println("NoStaticInner.inFun");System.out.println("Outer.a = "+Outer.a);System.out.println("a = "+a);System.out.println("b = "+b);System.out.println("Outer.c = "+Outer.this.c);System.out.println("c = "+c);System.out.println("d = "+d);}}public NoStaticInner getNoStaticInner(){return new NoStaticInner();}}1.3 局部内部类1.3.1 非匿名局部内部类语法格式：[修饰符] class外部类{[修饰符] 返回值类型 方法名(形参列表){[final/abstract] class内部类{}}}编译后有自己的独立的字节码文件，只不过在内部类名前面冠以外部类名、$符号、编号。

内部类构造方法1. 什么是内部类？在Java中，内部类是指定义在其他类内部的类。

与外部类相比，内部类具有更高的封装性和灵活性。

内部类可以访问外部类的所有成员，包括私有成员，而外部类不能直接访问内部类的成员。

2. 内部类的分类Java中的内部类可以分为四种类型：成员内部类、局部内部类、匿名内部类和静态嵌套类。

2.1 成员内部类成员内部类是定义在一个类的内部，并且与外部类的实例相关联的。

成员内部类可以访问外部类的所有成员，包括私有成员。

下面是一个示例代码：public class OuterClass {private int outerField;public class InnerClass {public void innerMethod() {outerField = 10;}}}2.2 局部内部类局部内部类是定义在一个方法或代码块中的内部类。

局部内部类只能在所在方法或代码块中使用，并且不能被其他方法或代码块访问到。

下面是一个示例代码：public class OuterClass {public void outerMethod() {class LocalInnerClass {public void innerMethod() {System.out.println("Hello from local inner class!");}}LocalInnerClass innerClass = new LocalInnerClass();innerClass.innerMethod();}}2.3 匿名内部类匿名内部类是没有名字的内部类，它通常用于创建只需要使用一次的类。

匿名内部类可以继承一个类或实现一个接口，并且可以在创建对象的时候直接定义类的内容。

下面是一个示例代码：public class OuterClass {public void outerMethod() {Runnable runnable = new Runnable() {@Overridepublic void run() {System.out.println("Hello from anonymous inner class!");}};Thread thread = new Thread(runnable);thread.start();}}2.4 静态嵌套类静态嵌套类是定义在一个类的内部，并且被声明为静态的内部类。

java内部类知识点总结Java内部类是Java语言的一个重要特性，它允许在一个类的内部定义另一个类。

本文将从以下几个方面对Java内部类进行总结：1. 内部类的定义和特点内部类是指在一个类的内部定义的另一个类，它可以被看作是一个类的成员。

内部类可以访问外部类的所有成员，包括私有成员，而外部类不能直接访问内部类的成员。

内部类对外部类的访问具有完全访问权，而外部类对内部类的访问则需要通过内部类的实例来进行。

内部类可以被定义为静态或非静态的，静态内部类可以访问外部类的静态成员，而非静态内部类则不能访问外部类的静态成员。

2. 内部类的分类Java内部类分为四种类型：成员内部类、局部内部类、匿名内部类和静态内部类。

成员内部类是指在类的内部定义的非静态类，它可以访问外部类的所有成员，并且可以被外部类的其他成员访问。

成员内部类可以被看作是外部类的一个成员，它可以访问外部类的成员变量和成员方法，而外部类则不能直接访问成员内部类的成员。

局部内部类是定义在方法或作用域内的内部类，它只能在定义它的方法或作用域内使用，局部内部类可以访问外部类的所有成员，但是外部类不能访问局部内部类的成员。

匿名内部类是没有名称的内部类，它通常用于继承一个类或实现一个接口，并且只使用一次。

匿名内部类必须继承一个类或实现一个接口，并且必须在创建对象时实现它的方法，它可以访问外部类的所有成员。

静态内部类是定义在类的内部的静态类，它可以访问外部类的静态成员，但是不能访问外部类的非静态成员。

静态内部类可以被看作是外部类的一个静态成员，它只能访问外部类的静态成员，而不能访问外部类的非静态成员。

3. 内部类的应用场景内部类在Java中有着广泛的应用场景，其中最常见的应用场景包括以下几个方面：3.1 实现多重继承Java中不支持多重继承，但是通过使用内部类可以实现类似于多重继承的功能。

例如，一个类可以继承一个类，并且在内部定义一个实现接口的内部类，从而实现多重继承的效果。

Java的内部类在java语言中，有一种类叫做内部类(inner class)，也称为嵌入类(nested class)，它是定义在其他类的内部。

内部类作为其外部类的一个成员，与其他成员一样，可以直接访问其外部类的数据和方法。

只不过相比较外部类只有public和默认的修饰符不同，内部类作为一个成员，可以被任意修饰符修饰。

编译器在编译时，内部类的名称为OuterClass$InnerClass.class 。

1、内部类访问数据变量当在某些时候，内部类中定义的变量与外部类中变量名称相同时，如何确保正确地访问每一个变量呢？1.1在main中直接从外部类调用内部类的方法class Outer{private int index = 10;class Inner{private int index = 20;void print(){int index = 30;System.out.println(this); // the object created from the InnerSystem.out.println(Outer.this); // the object created from the OuterSystem.out.println(index); // output is 30System.out.println(this.index); // output is 20System.out.println(Outer.this.index); // output is 10}}void print(){Inner inner = new Inner();//得到内部类的引用inner.print();}}class Test{public static void main(String[] args){Outer outer = new Outer();outer.print();}}在这里内部类Inner中关键字this指向内部类Inner的对象，如果要想指向外部类的对象，必须在this指针前加上外部类名称，表示this是指向外部类构造的碎屑，如Outer.this 。