静态内部类详解
静态内部类详解
静态内部类详解什么是静态内部类？有static关键字修饰的内部类。
⽐如：Pattern类中的Node类。
注意：静态内部类访问外部类的静态成员变量或⽅法必须是静态的。
代码：public class Outer {private static String s1 = "this is s1 in Outer";private static String s2 = "this is s2 in Outer";public void method1() {// 外部类可通过内部类的对象调⽤内部类的私有成员变量或⽅法System.out.println(new Inner().s1);System.out.println(new Inner().method2());}private static String method2() {return "this is method2 in Outer";}// 内部静态类public static class Inner {private String s1 = "this is s1 in Inner";private static String s3 = "this is s3 in Inner";public void method1() {// 内部类可直接访问外部类的私有静态成员变量或⽅法System.out.println(s2);// 内部类和外部类有同名变量和⽅法时System.out.println(s1);System.out.println(Outer.s1);System.out.println(method2());System.out.println(Outer.method2());}private String method2() {return "this is method2 in Inner";}}}调⽤：public class MainClass {public static void main(String[] args) {Outer outer = new Outer();System.out.println("------外部类测试--------");outer.method1();System.out.println("------内部类测试--------");Outer.Inner inner = new Outer.Inner();inner.method1();}}打印：------外部类测试--------this is s1 in Innerthis is method2 in Inner------内部类测试--------this is s2 in Outerthis is s1 in Innerthis is s1 in Outerthis is method2 in Innerthis is method2 in Outer分析：反编译后⾃动⽣成⽂件：Outer$Inner.classOuter 反编译代码1：public class jichu.Outer {private static ng.String s1;private static ng.String s2;static {};public jichu.Outer();public void method1();private static ng.String method2();static ng.String access$0();static ng.String access$1();static ng.String access$2();}Outer 反编译代码2：public class Outer{private static String s1 = "this is s1 in Outer"; private static String s2 = "this is s2 in Outer"; public void method1(){System.out.println(new Inner().s1);System.out.println(new Inner().method2());}private static String method2(){return "this is method2 in Outer";}public static class Inner{private String s1 = "this is s1 in Inner";private static String s3 = "this is s3 in Inner"; public void method1(){System.out.println(Outer.s2);System.out.println(this.s1);System.out.println(Outer.s1);System.out.println(method2());System.out.println(Outer.access$2());}private String method2(){return "this is method2 in Inner";}}}Outer$Inner 反编译代码1：public class jichu.Outer$Inner {private ng.String s1;private static ng.String s3;static {};public jichu.Outer$Inner();public void method1();private ng.String method2();static ng.String access$0(jichu.Outer$Inner); static ng.String access$1(jichu.Outer$Inner); }Outer$Inner 反编译代码2：public class Outer$Inner{private String s1 = "this is s1 in Inner";private static String s3 = "this is s3 in Inner"; public void method1(){System.out.println(Outer.access$0());System.out.println(this.s1);System.out.println(Outer.access$1());System.out.println(method2());System.out.println(Outer.access$2());}private String method2(){return "this is method2 in Inner";}}MainClass反编译代码：public class MainClass{public static void main(String[] args){Outer outer = new Outer();System.out.println("------外部类测试--------");outer.method1();System.out.println("------内部类测试--------");Outer.Inner inner = new Outer.Inner();inner.method1();}}1、创建静态内部类⽅式：Outer.Inner inner = new Outer.Inner()；静态内部类不依赖于外部类。
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内部类
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 静态成员类约束静态成员类不能与外部类重名像外部类的静态方法一样，不能直接访问外部类的实例字段和实例方法静态成员类只能定义于外部类的顶层代码或外部类其它静态成员类的顶层代码中（嵌套定义）；不能定义于外部类的某个函数中。
java 静态类定义
java 静态类定义1.引言1.1 概述在Java编程语言中，静态类是一种特殊的类，它具有一些与其他类不同的特点和用途。
静态类可以被认为是一个工具类，它通过提供一组静态方法和静态变量来支持其他类的功能。
与实例类不同，静态类无法实例化，也无法被继承。
静态类通常用于封装一些通用的功能，例如数学计算、日期处理、文件操作等，以便于其他类直接调用这些功能而无需进行实例化。
通过使用静态方法，我们可以在任何地方轻松地调用这些功能，而无需创建类的实例。
另外，静态变量可以在不同的对象之间共享数据，这在一些场景下非常有用。
静态类的定义形式与普通类相似，但需要使用关键字"static"来修饰类名。
静态类中的方法和变量也需要使用"static"关键字来修饰，以区分于实例方法和变量。
静态方法只能调用静态方法或使用静态变量，而不能直接访问实例方法或实例变量。
在本文中，我们将探讨静态类的定义、特点以及其在Java编程中的应用。
通过深入了解静态类的概念，我们可以更好地理解和利用这一特性，提高代码的灵活性和重用性。
接下来的章节将详细介绍静态类的相关内容，并展望其在未来的应用前景。
1.2 文章结构文章结构部分的内容可以按照以下内容进行编写：在这篇文章中，我们将展开讨论关于Java中静态类定义的话题。
为了让读者更好地理解本文的内容，我们将按照以下结构进行论述。
首先，在引言部分，我们会概述本文要讨论的主题，并对文章的结构进行简要介绍，以便读者能够更好地理解本文的内容和组织架构。
接下来，在正文部分，我们将详细讨论静态类的定义以及它的特点。
在2.1节中，我们将对静态类的定义进行深入探讨，包括其语法规则、使用方法等。
在2.2节中，我们将具体阐述静态类的特点，如静态成员、静态方法等，并举例说明其在实际应用中的使用场景。
最后，在结论部分，我们将对静态类的作用进行总结，归纳本文的主要观点和结论。
在3.1节中，我们将对静态类的作用进行简要总结，强调其在代码设计中的重要性。
java静态类
Java基础_内部类、静态内部类、成员内部类、局部内部类、匿名内部类（转）内部类：使用内部类减少了命名冲突。
一个内部类可以定义在一个类中，一个方法中甚至一个表达式中。
内部类分为四种：静态内部类(static inner classes)成员内部类(member inner classes)局部内部类(local inner classes)匿名内部类(anonymous inner classes)1、静态内部类(static inner classes)最简单的内部类。
只能访问外部类的静态成员变量与静态方法。
生成静态内部类对象的方法：OuterClass.InnerClass inner = new OuterClass.InnerClass();1.1、相关使用例子：静态内部类：1 class StaticInner{2 private static int a = 1;34 /**5 * 静态内部类6 * 生成的类名：StaticInner$InnerClass7 */8 public static class InnerClass{9 //静态内部类可以声明静态的成员变量，其他的内部类不可以10 private static int b = 1;11 public void execute(){12 //静态内部类只能访问静态程序13 System.out.println(a + b);14 }15 }16 }main方法中使用：1 public static void main(String[] args) {2 //创建静态内部类3 StaticInner.InnerClassinnerClass = new StaticInner.InnerClass();4 innerClass.execute();5 }2、成员内部类(member inner classes)：成员内部类可以访问外部类的静态与非静态的方法和成员变量。
内部类的定义方法
内部类的定义方法内部类是指在一个类的内部定义另一个类的情况，它是一种嵌套类的表现形式，具有特定的访问权限和作用域。
在Java等多种编程语言中，内部类提供了一种便捷的方式来组织和管理相关的类，同时也能够实现更加灵活的程序设计和模块化开发。
内部类的定义方法通常包括以下几种形式：1. 成员内部类：成员内部类是定义在类内部的非静态类，它能够访问外部类的成员变量和方法，并且可以使用外部类的引用。
成员内部类的定义方式如下：```javapublic class OuterClass {private int outerVar;public class InnerClass {public void innerMethod() {System.out.println("Accessing outer class variable: " + outerVar);}}}```在上述例子中，InnerClass 就是一个成员内部类，可以直接访问 OuterClass 的成员变量 outerVar。
2. 静态内部类：静态内部类是定义在类内部且带有 static 修饰符的类，它与外部类不具有依赖关系，可以直接通过类名进行访问。
静态内部类的定义方式如下：```javapublic class OuterClass {private static int outerVar;public static class InnerClass {public void innerMethod() {System.out.println("Accessing outer class variable: " + outerVar);}}}```在这个例子中，InnerClass 是一个静态内部类，可以直接通过OuterClass.InnerClass 的方式进行访问。
3. 局部内部类：局部内部类是定义在方法内部的类，它只能在定义它的方法中使用，通常用于辅助实现某个特定的功能。
静态内部类定义在类中，任何方法外，用static定义
静态内部类定义在类中，任何⽅法外，⽤static定义静态内部类：（注意：前三种内部类与变量类似，所以可以对照参考变量）静态内部类定义在类中，任何⽅法外，⽤static定义。
静态内部类只能访问外部类的静态成员。
⽣成（new）⼀个静态内部类不需要外部类成员：这是静态内部类和成员内部类的区别。
静态内部类的对象可以直接⽣成：Outer.Inner in=new Outer.Inner()；⽽不需要通过⽣成外部类对象来⽣成。
这样实际上使静态内部类成为了⼀个顶级类。
静态内部类不可⽤private来进⾏定义。
例⼦：对于两个类，拥有相同的⽅法：People{run();}Machine{run();}此时有⼀个robot类：class Robot extends People implement Machine.此时run()不可直接实现。
注意：当类与接⼝（或者是接⼝与接⼝）发⽣⽅法命名冲突的时候，此时必须使⽤内部类来实现。
⽤接⼝不能完全地实现多继承，⽤接⼝配合内部类才能实现真正的多继承。
1package TomText;2//测试对实例成员和类成员的不同访问形式。
3public class TomText_44 {4static int i=1;5int j=1;6static void printStatic( ){7 System.out.println("i="+i);8//System.out.println("j="+j); //⾮法访问9 }10void print(){11 System.out.println("i="+i);12 System.out.println("j="+j);13 }14public static void main(String [ ] args){15 TomText_44.printStatic( );16//StaticTest.print( ); //⾮法访问17 TomText_44.i=2;18//StaticTest.j=2; //⾮法访问19 TomText_44 st=new TomText_44( );20 st.i=3;21 st.j=3;22 st.print( );23 st.printStatic( );24 }2526 }。
内部类和匿名类
[u][/u]学java时我总是觉得理解基本的编码规则不是很困难，困难的是实际操作中如何灵活应用，碰到的第一个难题就是内部类与匿名类的灵活应用，所以我总结了一点我知道的使用方法，希望各位路过的、拍砖的、指教的、补充的、拾遗的大虾们能帮我纠正和往后继续补充：块代码的定义：简单来说就是处于一对{}之间的代码。
内部类的定义：处于另外一个类中的具有类型名称定义块代码。
匿名类的定义：已知父类或者接口标准的内部类，且不具有具体的类型名称的块代码。
匿名类的实例创建必须使用new 父类名|接口名()来创建。
）一、命名内部类——用于临时创建实例或者类型，且该类型或实例需要控制是否允许使用该类的人调用1-1：命名局部内部类public class OutClass{public int f(){private class InnerClass{int i=10;}return new InnerClass().i;public static void main(String[] args){OutClass o=new OutClass();System.out.println(o.f());}}此例中对于使用OutClass的人来说，无需关注于InnerClass类的存在，只关注于f()函数具体的返回值；使用者无法访问InnerClass 类的成员.1-2：命名成员内部类public class OutClass{public class InnerClass{int i=10;}public int f(){return new InnerClass().i;}public static void main(String[] args)OutClass o=new OutClass();System.out.println(o.f());}}此例将简单内部类提升至成员等级，在此等级中，我们可以自由设定该内部类是允许OutClass使用者实例化InnerClass实例，如果为public 类型，则允许实例化，如果为private 类型，则不允许实例化（除开OutClass的成员方法将InnerClass类型的实例作为返回值返回）1-3：命名内部类的实例化方法public class OutClass{public class InnerClass{public InnerClass(){System.out.println("InnerClass construction start");}}//public static void test()//{// InnerClass ic=new InnerClass();//错误的实例化内部类//}//public static InnerClass ic=new InnerClass();//错误的实例化内部类public InnerClass ic=new InnerClass();public InnerClass test(){return new InnerClass();}public static void main (String[] args){OutClass oc=new OutClass();OutClass.InnerClass ic=oc.new InnerClass();}}注意：此处的输出结果为：InnerClass construction startInnerClass construction start原因是外部类实例化时，需要产生一个内部类InnerClass成员，因此会调用内部类的构造函数，所以会有第一条InnerClass construction start而当在主方法中实例化内部类时，也需要调用内部类的构造函数，因此产生了第二条InnerClass construction start内部类实例化的前提条件：内部类实例的存在，必须依赖于外部类实例的存在，也就是说，在没有实例化外部类的情况下，不允许产生内部类实例，同样的，由于静态方法及静态成员的存在必须依赖于包含该静态方法或该静态成员的类型的实例，所以内部类的实例不能存在于外部类的静态方法或静态成员中，同理，非静态的内部类也不能包含静态的成员。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
在开发过程中，内部类中使用的最多的还是非静态地成员内部类。
不过在特定的情况下，静态内部类也能够发挥其独特的作用。
一、静态内部类的使用目的。
在定义内部类的时候，可以在其前面加上一个权限修饰符static。
此时这个内部类就变为了静态内部类。
不过由于种种的原因，如使用上的限制等等因素(具体的使用限制，笔者在下面的内容中会详细阐述)，在实际工作中用的并不是很多。
但是并不是说其没有价值。
在某些特殊的情况下，少了这个静态内部类还真是不行。
如在进行代码程序测试的时候，如果在每一个Java源文件中都设置一个主方法(主方法是某个应用程序的入口，必须具有)，那么会出现很多额外的代码。
而且最主要的时这段主程序的代码对于Java文件来说，只是一个形式，其本身并不需要这种主方法。
但是少了这个主方法又是万万不行的。
在这种情况下，就可以将主方法写入到静态内部类中，从而不用为每个Java源文件都设置一个类似的主方法。
这对于代码测试是非常有用的。
在一些中大型的应用程序开发中，则是一个常用的技术手段。
为此，这个静态内部类虽然不怎么常用，但是程序开发人员还必须要掌握它。
也许在某个关键的时刻，其还可以发挥巨大的作用也说不定。
二、静态内部类的使用限制。
将某个内部类定义为静态类，跟将其他类定义为静态类的方法基本相同，引用规则也基本一致。
不过其细节方面仍然有很大的不同。
具体来说，主要有如下几个地方要引起各位程序开发人员的注意。
来源：考试大
一是静态成员(包括静态变量与静态成员)的定义。
一般情况下，如果一个内部类不是被定义成静态内部类，那么在定义成员变量或者成员方法的时候，是不能够被定义成静态成员变量与静态成员方法的。
也就是说，在非静态内部类中不可以声明静态成员。
如现在在一个student类中定义了一个内部类age，如果没有将这个类利用static关键字修饰，即没有定义为静态类，那么在这个内部类中如果要利用static关键字来修饰某个成员方法或者成员变量是不允许的。
在编译的时候就通不过。
故程序开发人员需要注意，只有将某个内部类修饰为静态类，然后才能够在这个类中定义静态的成员变量与成员方法。
这是静态内部类都有的一个特性。
也正是因为这个原因，有时候少了这个静态的内部类，很多工作就无法完成。
或者说要绕一个大圈才能够实现某个用户的需求。
这也是静态的内部类之所以要存在的一个重要原因。
来源：考试大
二是在成员的引用上，有比较大的限制。
一般的非静态内部类，可以随意的访问外部类中的成员变量与成员方法。
即使这些成员方法被修饰为private(私有的成员变量或者方法)，其非静态内部类都可以随意的访问。
则是非静态内部类的特权。
因为在其他类中是无法访问被定义为私有的成员变量或则方法。
但是如果一个内部类被定义为静态的，那么在银用外部类的成员方法或则成员变量的时候，就会有诸多的限制。
如不能够从静态内部类的对象中访问外部类的非静态成员(包括成员变量与成员方法)。
这是什么意思呢?如果在外部类中定义了两个变量，一个是非静态的变量，一个是静态的变量。
那么在静态内部类中，无论在成员方法内部还是在其他地方，都只能够引用外部类中的静态的变量，而不能够访问非静态的变量。
在静态内部类中，可以定义静态的方法(也只有在静态的内部类中可以定义静态的方法)，在静态方法中引用外部类的成员。
但是无论在内部类的什么地方引用，有一个共同点，即都只能够引用外部类中的静态成员方法或者成员变量。
对于那些非静态的成员变量与成员方法，在静态内部类中是无法访问的。
这就是静态内部类的最大使用限制。
在普通的非静态内部类中是没有这个限制的。
也正是这个原因，决定了静态内部类只应用在一些特定的场合。
其应用范围远远没有像非静态的内部类那样广泛。
三是在创建静态内部类时不需要将静态内部类的实例绑定在外部类的实例上。
来源：考试大的美女编辑们
通常情况下，在一个类中创建成员内部类的时候，有一个强制性的规定，即内部类的实例一定要绑定在外部类的实例中。
也就是说，在创建内部类之前要先在外部类中要利用new关键字来创建这个内部类的对象。
如此的话如果从外部类中初始化一个内部类对象，那么内部类对象就会绑定在外部类对象上。
也就是说，普通非静态内部类的对象是依附在外部类对象之中的。
但是，如果成员开发人员创建的时静态内部类，那么这就又另当别论了。
通常情况下，程序员在定义静态内部类的时候，是不需要定义绑定在外部类的实例上的。
也就是说，要在一个外部类中定义一个静态的内部类，不需要利用关键字new来创建内部类的实例。
即在创建静态类内部对象时，不需要其外部类的对象。
具体为什么会这样，一般程序开发人员不需要了解这么深入，只需要记住有这个规则即可。
在定义静态内部类的时候，千万不要犯画蛇添足的错误。
来源：考试大
从以上的分析中可以看出，静态内部类与非静态的内部类还是有很大的不同的。
一般程序开发人员可以这么理解，非晶态的内部类对象隐式地在外部类中保存了一个引用，指向创建它的外部类对象。
不管这么理解，程序开发人员都需要牢记静态内部类与非静态内部类的差异。
如是否可以创建静态的成员方法与成员变量(静态内部类可以创建静态的成员而非静态的内部类不可以)、对于访问外部类的成员的限制(静态内部类只可以访问外部类中的静态成员变量与成员方法而非静态的内部类即可以访问静态的也可以访问非静态的外部类成员方法与成员变量)。
这两个差异是静态内部类与非静态外部类最大的差异，也是静态内部类之所以存在的原因。
了解了这个差异之后，程序开发人员还需要知道，在什么情况下该使用静态内部类。
如在程序测试的时候，为了避免在各个Java源文件中书写主方法的代码，可以将主方法写入到静态内部类中，以减少代码的书写量，让代码更加的简洁。
总之，静态内部类在Java语言中是一个很特殊的类，跟普通的静态类以及非静态的内部类都有很大的差异。
作为程序开发人员，必须要知道他们之间的差异，并在实际工作中在合适的地方采用合适的类。
不过总的来说，静态内部类的使用频率并不是很高。
但是在有一些场合，如果没有这个内部静态类的话，可能会起到事倍功半的反面效果。