静态内部类详解
静态内部类详解
静态内部类详解什么是静态内部类？有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内部类实例化的前提条件：内部类实例的存在，必须依赖于外部类实例的存在，也就是说，在没有实例化外部类的情况下，不允许产生内部类实例，同样的，由于静态方法及静态成员的存在必须依赖于包含该静态方法或该静态成员的类型的实例，所以内部类的实例不能存在于外部类的静态方法或静态成员中，同理，非静态的内部类也不能包含静态的成员。
java内部类的定义
java内部类的定义Java内部类的定义Java是一门面向对象的编程语言，有着很多独特的特性，其中一项就是内部类。
内部类是Java中一个非常有趣的特性，我们可以在一个类中定义另一个类，并且在外部类中访问内部类的变量和方法。
本文将介绍关于Java内部类定义的几个问题。
一、Java内部类的分类Java内部类可以分为四类：1. 成员内部类（Member Inner Class）：作为外部类的成员，可以访问外部类的成员变量和方法。
2. 静态内部类（Static Inner Class）：与成员内部类不同的是，静态内部类只能访问外部类的静态成员变量和方法。
3. 方法内部类（Method Local Inner Class）：定义在方法中的内部类，只能在方法内部被访问，但可以访问方法内的变量。
4. 匿名内部类（Anonymous Inner Class）：没有名字的内部类，通常用来实现接口或继承抽象类。
二、成员内部类的定义成员内部类是定义在外部类中的类。
要想创建一个成员内部类的实例，必须先创建一个外部类的实例，并使用外部类实例创建内部类实例，如下所示：```class Outer {private int x = 10;class Inner {void print() {System.out.println("x = " + x);}}}public class MainClass {public static void main(String[] args) {Outer outer = new Outer();Outer.Inner inner = outer.new Inner();inner.print();}}```在上面的例子中，内部类访问了外部类的成员变量x，这就是成员内部类的特性。
三、静态内部类的定义静态内部类是定义在外部类中的静态类，可以通过外部类直接访问。
因为静态内部类是静态的，所以它不能访问外部类的非静态成员变量和方法。
JAVA内部类的作用方法使用
JAVA内部类的作用方法使用一、内部类的作用1.封装：内部类可以被用来封装和隐藏代码。
通过将一个类定义在另一个类的内部，可以将类的实现细节隐藏起来，只暴露出对外公开的接口。
这样一来，外部类的使用者只需要关心外部类提供的接口，而不需要关注内部类的实现。
2.实现多继承：内部类可以实现多继承的效果。
由于JAVA是单继承的，但是通过内部类，一个类可以实现多个接口或继承多个类。
这样可以灵活地使用多种功能，增强代码的复用性。
3.回调函数：内部类可以用作回调函数的实现。
在一些情况下，我们需要将一个类的方法传递给另一个类，并在一些事件发生时被调用。
内部类可以轻松地实现这种回调机制，使得代码更加简洁易读。
4.访问外部类的成员：内部类可以访问外部类的私有成员，包括私有变量和私有方法。
这样可以实现对外部类的更加灵活的访问，增强了代码的封装性。
5.提供更好的逻辑组织：内部类可以将相关的类组织在一起，使得代码更加清晰和易于管理。
当一个类只在一个类中使用，又不希望被其他类访问到，就可以使用内部类来定义。
6.实例化内存的开销：由于内部类是和外部类绑定在一起的，所以内部类的创建必须依赖外部类的实例对象。
当外部类创建实例时，内部类实例也会被同时创建。
这样就可以实现一些特殊的功能，例如在外部类的构造器中创建内部类实例，从而实现一些初始化的操作。
二、内部类的方法1.成员内部类：成员内部类是定义在外部类中的类，它可以直接访问外部类的成员，并且可以实现多继承的效果。
成员内部类的定义格式如下：```public class OuterClass//外部类的成员变量和方法public class InnerClass//内部类的成员变量和方法}```要创建成员内部类的实例，需要先创建外部类的实例，然后再通过外部类的实例来创建内部类的实例：```OuterClass outer = new OuterClass(;OuterClass.InnerClass inner = outer.new InnerClass(;```2.静态内部类：静态内部类是定义在外部类中的静态类，它不能直接访问外部类的实例成员，只能访问外部类的静态成员。
静态内部类的特点
静态内部类的特点
静态内部类，顾名思义，是定义在另一个类的内部且被 static 修饰的类。
它具有以下特点：
1. 静态内部类可以访问其外部类的静态成员变量和静态方法，但不能直接访问其外部类的非静态成员变量和方法，需要通过创建外部类对象来访问。
2. 静态内部类的创建不依赖于外部类的实例，可以直接通过类名来访问。
因此，它可以作为外部类的静态成员变量或方法中的返回类型。
3. 静态内部类可以拥有自己的静态成员变量和方法，这些成员只在静态内部类的范围内可见。
4. 静态内部类的生命周期与外部类相同，即在外部类加载时被加载，在外部类卸载时被卸载。
5. 静态内部类相对于外部类，具有更低的访问权限，可以被定义为private 或 protected。
总之，静态内部类在 Java 开发中经常被用作辅助功能的实现，例如迭代器、线程池等。
它具有较好的封装性、扩展性和代码简洁性。
下面是静态内部类的特点的列表：
静态内部类的特点：
1. 可以访问外部类的静态成员变量和静态方法。
2. 创建不依赖于外部类的实例，因此可以直接通过类名来访问。
3. 可以拥有自己的静态成员变量和方法，这些成员只在静态内部类的范围内可见。
4. 生命周期与外部类相同，在外部类加载时被加载，在外部类卸载时被卸载。
5. 相对于外部类，具有更低的访问权限，可以被定义为 private 或protected。
Java内部类,内部接口详解
Java内部类，内部接口详解介绍通常情况下，我们创建类或者是接口都是一个类或接口对应一个文件，但是学习java编程语言的朋友时常会见到一个文件中有多个类或者是接口的情形，这就是下面所要介绍的内部类和内部接口。
一. 内部类内部类就是在类中定义类。
我们可以把类中的类看做是类的一个属性，一个属性可以是static也可以是非static的。
而内部类也可以定义在类的方法中，再加上匿名类，总共有5种内部类。
1. 静态内部类静态内部类就是在class内部定义一个static的class，如下代码所示：public class StaticInnerClass {static class Inner {void print() {(“Inner class is: “ + this);}}public static void main(String[] args) {StaticInnerClass.Inner inner = new StaticInnerClass.Inner();inner.print();}}注意：静态内部类中因为static变量可以直接根据类名来存取，所以我们使用new StaticInnerClass.Inner()来实例化内部类。
2. 非静态内部类非静态内部类就是在class中定义的类也可以是非静态的，如下代码所示：public class InnerClass {class Inner {void print() {(“Inner class is: “ + this);}}public static void main(String[] args) {InnerClass.Inner inner = new InnerClass().new Inner();inner.print();}}注意：非静态内部类要访问到类的变量，需要实例化外部内，然后再实例化内部类：new InnerClass().new Inner()。
内部类
内部类的问题：java 内部类分四种：成员内部类、局部内部类、静态内部类和匿名内部类1.成员内部类：即作为外部类的一个成员存在，与外部类的属性、方法并列。
注意：成员内部类中不能定义静态变量，但可以访问外部类的所有成员.成员内部类的优点：1）.内部类作为外部类的成员，可以访问外部类的私有成员或者属性.(即使将外部类声明为private，但是对于处于其内部的内部类还是可见的)。
2）.用内部类定义在外部类中不可访问的属性。
这样就在外部类中实现了比外部类的private还要小的访问权限。
外部类的变量如果和内部类的变量没有同名的,则可以直接用变量名访问外部类的变量访问外部类中与内部类同名的实例变量可用"外部类名.this.变量名"static方法可以直接访问本类static方法，如果要想访问非static方法可以先实例化本类实例，再通过实例访问非static方法。
/*外部类的非静态方法访问成员内部类*/public void outer_f3(){Inner inner = new Inner();inner.inner_f1();}/*外部类的静态方法访问成员内部类,与在外部类外部访问成员内部类一样*/public static void outer_f4(){//step1:建立外部类对象Outer outer = new Outer();//** step2:根据外部类对象建立内部类对象Outer.Inner inner = outer.new Inner();//step3:访问内部类的方法inner.inner_f1();2.局部内部类：即在方法中定义的内部类,与局部变量类似,在局部内部类前不加修饰符public 或private，其范围为定义它的代码块注意：局部内部类中不可定义静态变量,可以访问外部类的局部变量(即方法内的变量),但是变量必须是final的。
不可以定义静态的变量。
java 静态内部类
java 静态内部类
静态内部类是指使用static修饰的内部类，如以下示例：
上述示例中的inner类就是静态内部类。
静态内部类有如下特点：
●在创建静态内部类的实例时，不需要创建外部类的实例。
例如：
●静态内部类中可以定义静态成员和实例成员。
●外部类以外的其他类需要通过完整的类名访问静态内部类中的静态成员，如果要访问静
态内部类中的实例成员，则需要通过静态内部类的实例。
代码如下：
●静态内部类可以直接访问外部类的静态成员，如果要访问外部类的成员，则需要通过外
部类的实例去访问。
代码如下：。
内部类调用外部方法
内部类调用外部方法内部类是指在一个类的内部定义的类。
内部类可以访问外部类的私有成员，包括方法、变量和构造函数。
所以，内部类是可以直接调用外部类的方法的。
在内部类中调用外部类方法的方式有两种：静态内部类和非静态内部类。
1. 静态内部类调用外部方法：静态内部类是指使用static修饰的内部类，它和外部类之间是相互独立的。
在静态内部类中调用外部类的方法，可以直接通过外部类名进行调用，不需要创建外部类的对象。
示例代码如下：javapublic class OuterClass {private static int number = 10;static class StaticInnerClass {public void display() {System.out.println("调用外部类的方法：" + number);}}public static void main(String[] args) {OuterClass.StaticInnerClass inner = newOuterClass.StaticInnerClass();inner.display();}}2. 非静态内部类调用外部方法：非静态内部类是指没有使用static修饰的内部类，它和外部类之间是有关联的。
在非静态内部类中调用外部类的方法，需要先创建外部类的对象，然后通过这个对象来调用外部类的方法。
示例代码如下：javapublic class OuterClass {private int number = 10;class InnerClass {public void display() {System.out.println("调用外部类的方法：" + number);}}public static void main(String[] args) {OuterClass outer = new OuterClass();OuterClass.InnerClass inner = outer.new InnerClass();inner.display();}}总结一下，内部类是可以调用外部类的方法的。
Java内部类详解--成员内部类，局部内部类，匿名内部类，静态内部类
Java内部类详解--成员内部类，局部内部类，匿名内部类，静态内部类说起内部类这个词，想必很多⼈都不陌⽣，但是⼜会觉得不熟悉。
原因是平时编写代码时可能⽤到的场景不多，⽤得最多的是在有事件监听的情况下，并且即使⽤到也很少去总结内部类的⽤法。
今天我们就来⼀探究竟。
下⾯是本⽂的⽬录⼤纲： ⼀.内部类基础 ⼆.深⼊理解内部类 三.内部类的使⽤场景和好处 四.常见的与内部类相关的笔试⾯试题 若有不正之处，请多谅解并欢迎批评指正。
请尊重作者劳动成果，转载请标明原⽂链接：⼀.内部类基础 在Java中，可以将⼀个类定义在另⼀个类⾥⾯或者⼀个⽅法⾥⾯，这样的类称为内部类。
⼴泛意义上的内部类⼀般来说包括这四种：成员内部类、局部内部类、匿名内部类和静态内部类。
下⾯就先来了解⼀下这四种内部类的⽤法。
1.成员内部类 成员内部类是最普通的内部类，它的定义为位于另⼀个类的内部，形如下⾯的形式：1 2 3 4 5 6 7 8 9 10 11 12 13class Circle {double radius = 0;public Circle(double radius) {this.radius = radius;}class Draw { //内部类public void drawSahpe() {System.out.println("drawshape"); }}} 这样看起来，类Draw像是类Circle的⼀个成员，Circle称为外部类。
成员内部类可以⽆条件访问外部类的所有成员属性和成员⽅法（包括private成员和静态成员）。
1 2 3 4 5 6 7 8 9 10 11 12 13 14class Circle {private double radius = 0;public static int count =1;public Circle(double radius) {this.radius = radius;}class Draw { //内部类public void drawSahpe() {System.out.println(radius); //外部类的private成员 System.out.println(count); //外部类的静态成员 }}} 不过要注意的是，当成员内部类拥有和外部类同名的成员变量或者⽅法时，会发⽣隐藏现象，即默认情况下访问的是成员内部类的成员。
单例模式-静态内部类实现及原理剖析
单例模式-静态内部类实现及原理剖析 以我的经验为例（如有不对欢迎指正），在⽣产过程中，经常会遇到下⾯两种情况： 1.封装的某个类不包含具有具体业务含义的类成员变量，是对业务动作的封装，如MVC中的各层（HTTPRequest对象以Threadlocal⽅式传递进来的）。
2.某个类具有全局意义，⼀旦实例化为对象则对象可被全局使⽤。
如某个类封装了全球的地理位置信息及获取某位置信息的⽅法（不考虑地球爆炸，板块移动），信息不会变动且可被全局使⽤。
3.许多时候整个系统只需要拥有⼀个的全局对象，这样有利于我们协调系统整体的⾏为。
如⽤来封装全局配置信息的类。
上述三种情况下如果每次使⽤都创建⼀个新的对象，且使⽤频率较⾼或类对象体积较⼤时，对象频繁的创建和GC会造成极⼤的资源浪费，同时不利于对系统整体⾏为的协调。
此时便需要考虑使⽤单例模式来达到对象复⽤的⽬的。
在看单例模式的实现前我们先来看⼀下使⽤单例模式需要注意的四⼤原则： 1.构造私有。
（阻⽌类被通过常规⽅法实例化） 2.以静态⽅法或者枚举返回实例。
（保证实例的唯⼀性） 3.确保实例只有⼀个，尤其是多线程环境。
（确保在创建实例时的线程安全） 4.确保反序列化时不会重新构建对象。
（在有序列化反序列化的场景下防⽌单例被莫名破坏，造成未考虑到的后果） ⽬前单例模式的实现⽅式有很多种，我们仅讨论接受度最为⼴泛的DCL⽅式与静态内部类⽅式（本篇讨论静态内部类⽅式）。
静态内部类⽅式 要理解静态内部类⽅式，⾸先要理解类加载机制。
虚拟机把Class⽂件加载到内存，然后进⾏校验，解析和初始化，最终形成java类型，这就是虚拟机的类加载机制。
加载，验证，准备，解析、初始化这5个阶段的顺序是确定的，类的加载过程，必须按照这种顺序开始。
这些阶段通常是相互交叉和混合进⾏的。
解析阶段在某些情况下，可以在初始化阶段之后再开始---为了⽀持java语⾔的运⾏时绑定（动态绑定，多态的原理）。
Java内部类之静态内部类（附详细代码示例）
Java内部类之静态内部类（附详细代码⽰例） /** 先上概况：关于静态内部类的总结：* 1、静态内部类具有正常类的结构。
* 2、静态内部类的⽅法只能访问外部类的static相关的信息，不能访问实例相关的信息。
* 3、外部类只能访问内部类的static相关的信息，不能访问实例相关的信息。
* 4、使⽤：外部类.内部类引⽤=new 外部类.内部类(); 来⽣成内部类对象；* 5、利⽤引⽤.成员信息(属性、⽅法)调⽤(和正常⼀样的使⽤)。
* 6、访问静态内部类的静态信息，直接外部类.内部类.静态信息的⽅式。
* 7、静态内部类可以独⽴存在，不依赖于其他外部类，类加载的时候同时加载内部类。
*/1package cn.goktech.staticinner;23public class OutClass {4public static String outStaticField = "外部类static属性";5public int outInstanceField = 1;678static {9 System.out.println("外部类OutClass的静态代码块");10 }1112/**13 * 外部类的实例⽅法和static⽅法中：14 * 1、只能访问内部类的static相关的信息15 * 2、不可以访问内部类实例信息16 * (理解：整个内部类已经是static,就是静态成员，和其他静态成员的访问规则⼀样)17*/18public void outInstanceMethod() {19// System.out.println(innerInstanceField); //报错20// innerInstanceMethod(); //报错21 System.out.println(StaticInnerClass.innerStaticField); // 使⽤外部类名访问static属性22 StaticInnerClass.innerStaticMethod();23 }2425public static void outStaticMethod() {26// System.out.println(innerInstanceField);27// innerInstanceMethod();28 System.out.println("在外部类的静态⽅法中访问内部类静态信息：" + StaticInnerClass.innerStaticField); // 使⽤外部类名访问static属性29 StaticInnerClass.innerStaticMethod();30 }3132static class StaticInnerClass { // 声明⼀个静态内部类33public static String innerStaticField = "内部类static属性";34public int innerInstanceField = 1;3536static {37 System.out.println("内部类StaticInnerClass的静态代码块");38 }3940/**41 * 内部类的实例⽅法和static⽅法中：42 * 1、只能访问外部类的static相关的信息43 * 2、不可以访问外部类实例信息44 * (理解：整个内部类已经是static,就是静态成员，和其他静态成员的访问规则⼀样)45*/46public void innerInstanceMethod() {47 System.out.println("在内部类中的实例⽅法中访问外部类static属性：" + outStaticField); // 可以访问外部static属性48 OutClass.outStaticMethod(); // 可以访问外部static⽅法49// System.out.println(outInstanceField); //报错，不可以访问外部⾮静态成员50 }5152public static void innerStaticMethod() {53 System.out.println("在内部类中的静态⽅法中访问外部类static属性：" + outStaticField); // 可以访问外部static属性54//OutClass.outStaticMethod(); // 可以访问外部static⽅法,对重复调⽤所以暂时注释55// System.out.println(outInstanceField); //报错，不可以访问外部⾮静态成员56 }57 }5859 }编写⼀个测试类1public class Test {2public static void main(String[] args) {3// ⽣成外部类对象,⽆法访问任何内部类信息4 OutClass out = new OutClass();56// 外部类.内部类.内部静态⽅法7 OutClass.StaticInnerClass.innerStaticMethod();8// 外部类.内部类.内部静态属性9 System.out.println(OutClass.StaticInnerClass.innerStaticField);1011// 外部类.内部类引⽤ = new 外部类.内部类();12 OutClass.StaticInnerClass inner = new OutClass.StaticInnerClass();13 System.out.println("通过内部类的实例访问“内部类的实例属性”：" + inner.innerInstanceField);14 }1516 }输出结果简单展⽰：各路⼤神多多指教！欢迎评论！。
Java中的内部类（一）静态内部类
Java中的内部类（⼀）静态内部类Java中的静态内部类：在定义的内部类前加static修饰符，此时的内部类就是静态内部类。
通过⼀个例⼦来了解静态内部类都有哪些特点。
1public class Outer {2//定义⼀个实例变量和⼀个静态变量3private int a;4private static int b;5//定义⼀个静态⽅法和⼀个⾮静态⽅法6public static void say(){}7public void test(){8//在外部类中调⽤内部类的属性和⽅法9 Outer.Inner.c = 1; //可以通过静态内部类的全类名来调⽤静态内部类的静态属性（外部类名.静态内部类名.属性）10 Outer.Inner.go(); //可以通过静态内部类的全类名来调⽤静态内部类的静态⽅法（外部类名.静态内部类名.⽅法）11//Outer.Inner.walk(); //不能通过类静态内部类的全类名来调⽤内部类的⾮静态属性和⽅法12 Inner inner = new Inner();13 inner.d = 1;14 inner.walk(); //可以通过创建内部类实例来调⽤静态内部类的⾮静态属性和⽅法15 }16//静态内部类17public static class Inner{18//在静态内部类中定义⼀个静态变量和⼀个实例变量19static int c;20int d;21//定义⼀个匿名代码块和⼀个静态代码块22 {}23static{}24//定义⼀个静态⽅法和⼀个普通⽅法25public static void go(){}26public void walk(){27//在静态内部类中调⽤外部类的属性和⽅法28int f = b; //可以直接调⽤外部类的静态属性29 say(); //可以直接调⽤外部类的静态⽅法30//int e = a; 直接调⽤外部类的⾮静态属性出错编译出错31//test(); 直接调⽤外部类的⾮静态⽅法时编译出错32 Outer outer = new Outer();33int e = outer.a; //可以通过创建外部类实例来调⽤外部类的⾮静态属性34 outer.test(); //可以通过创建外部类实例来调⽤外部类的⾮静态⽅法35 }36 }37 }总结：1、静态内部类中可以写哪些内容 1）匿名代码块 2）静态代码块 3）静态变量和⾮静态变量 4）静态⽅法和⾮静态⽅法注意：不能在静态内部类中写抽象⽅法 2、外部类如何调⽤静态内部类中的属性和⽅法 1）外部类可以通过创建静态内部类实例的⽅法来调⽤静态内部类的⾮静态属性和⽅法 2）外部类可以直接通过“ 外部类.内部类.属性（⽅法）” 的⽅式直接调⽤静态内部类中的静态属性和⽅法 3、静态内部类如何调⽤外部类的属性和⽅法 1）静态内部类可以直接调⽤外部类的静态属性和⽅法 2）静态内部类可以通过创建外部类实例的⽅法调⽤外部类的⾮静态属性和⽅法 4、如何创建静态内部类实例 1）在⾮外部类中：外部类名.内部类名 name = new 外部类名.内部类名(); 2）在外部类中：内部类名 name = new 内部类名();。
静态方法 内部类
静态方法内部类
静态方法是指在类中使用static修饰的方法，静态方法不依赖于对象的实例，可以直接通过类名调用。
静态方法可以在类加载时直接使用，不需要创建对象实例。
内部类是在一个类的内部定义的类，可以访问外部类的私有成员，包括私有变量和私有方法。
内部类可以分为四种类型：成员内部类、局部内部类、匿名内部类和静态内部类。
其中，静态内部类使用static修饰，与普通静态方法类似，可以直接通过类名调用，不依赖于外部类的实例。
静态内部类和普通内部类最大的区别是静态内部类不持有外部类的引用，可以直接访问外部类的静态成员，但不能访问外部类的非静态成员。
因此，静态内部类可以看作是与外部类相互独立的类。
使用静态内部类的主要好处是可以用于实现逻辑上相关的类的组织和管理，并且可以隐藏实现细节，并提高代码的可读性和可维护性。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
在开发过程中，内部类中使用的最多的还是非静态地成员内部类。
不过在特定的情况下，静态内部类也能够发挥其独特的作用。
一、静态内部类的使用目的。
在定义内部类的时候，可以在其前面加上一个权限修饰符static。
此时这个内部类就变为了静态内部类。
不过由于种种的原因，如使用上的限制等等因素(具体的使用限制，笔者在下面的内容中会详细阐述)，在实际工作中用的并不是很多。
但是并不是说其没有价值。
在某些特殊的情况下，少了这个静态内部类还真是不行。
如在进行代码程序测试的时候，如果在每一个Java源文件中都设置一个主方法(主方法是某个应用程序的入口，必须具有)，那么会出现很多额外的代码。
而且最主要的时这段主程序的代码对于Java文件来说，只是一个形式，其本身并不需要这种主方法。
但是少了这个主方法又是万万不行的。
在这种情况下，就可以将主方法写入到静态内部类中，从而不用为每个Java源文件都设置一个类似的主方法。
这对于代码测试是非常有用的。
在一些中大型的应用程序开发中，则是一个常用的技术手段。
为此，这个静态内部类虽然不怎么常用，但是程序开发人员还必须要掌握它。
也许在某个关键的时刻，其还可以发挥巨大的作用也说不定。
二、静态内部类的使用限制。
将某个内部类定义为静态类，跟将其他类定义为静态类的方法基本相同，引用规则也基本一致。
不过其细节方面仍然有很大的不同。
具体来说，主要有如下几个地方要引起各位程序开发人员的注意。
来源：考试大
一是静态成员(包括静态变量与静态成员)的定义。
一般情况下，如果一个内部类不是被定义成静态内部类，那么在定义成员变量或者成员方法的时候，是不能够被定义成静态成员变量与静态成员方法的。
也就是说，在非静态内部类中不可以声明静态成员。
如现在在一个student类中定义了一个内部类age，如果没有将这个类利用static关键字修饰，即没有定义为静态类，那么在这个内部类中如果要利用static关键字来修饰某个成员方法或者成员变量是不允许的。
在编译的时候就通不过。
故程序开发人员需要注意，只有将某个内部类修饰为静态类，然后才能够在这个类中定义静态的成员变量与成员方法。
这是静态内部类都有的一个特性。
也正是因为这个原因，有时候少了这个静态的内部类，很多工作就无法完成。
或者说要绕一个大圈才能够实现某个用户的需求。
这也是静态的内部类之所以要存在的一个重要原因。
来源：考试大
二是在成员的引用上，有比较大的限制。
一般的非静态内部类，可以随意的访问外部类中的成员变量与成员方法。
即使这些成员方法被修饰为private(私有的成员变量或者方法)，其非静态内部类都可以随意的访问。
则是非静态内部类的特权。
因为在其他类中是无法访问被定义为私有的成员变量或则方法。
但是如果一个内部类被定义为静态的，那么在银用外部类的成员方法或则成员变量的时候，就会有诸多的限制。
如不能够从静态内部类的对象中访问外部类的非静态成员(包括成员变量与成员方法)。
这是什么意思呢?如果在外部类中定义了两个变量，一个是非静态的变量，一个是静态的变量。
那么在静态内部类中，无论在成员方法内部还是在其他地方，都只能够引用外部类中的静态的变量，而不能够访问非静态的变量。
在静态内部类中，可以定义静态的方法(也只有在静态的内部类中可以定义静态的方法)，在静态方法中引用外部类的成员。
但是无论在内部类的什么地方引用，有一个共同点，即都只能够引用外部类中的静态成员方法或者成员变量。
对于那些非静态的成员变量与成员方法，在静态内部类中是无法访问的。
这就是静态内部类的最大使用限制。
在普通的非静态内部类中是没有这个限制的。
也正是这个原因，决定了静态内部类只应用在一些特定的场合。
其应用范围远远没有像非静态的内部类那样广泛。
三是在创建静态内部类时不需要将静态内部类的实例绑定在外部类的实例上。
来源：考试大的美女编辑们
通常情况下，在一个类中创建成员内部类的时候，有一个强制性的规定，即内部类的实例一定要绑定在外部类的实例中。
也就是说，在创建内部类之前要先在外部类中要利用new关键字来创建这个内部类的对象。
如此的话如果从外部类中初始化一个内部类对象，那么内部类对象就会绑定在外部类对象上。
也就是说，普通非静态内部类的对象是依附在外部类对象之中的。
但是，如果成员开发人员创建的时静态内部类，那么这就又另当别论了。
通常情况下，程序员在定义静态内部类的时候，是不需要定义绑定在外部类的实例上的。
也就是说，要在一个外部类中定义一个静态的内部类，不需要利用关键字new来创建内部类的实例。
即在创建静态类内部对象时，不需要其外部类的对象。
具体为什么会这样，一般程序开发人员不需要了解这么深入，只需要记住有这个规则即可。
在定义静态内部类的时候，千万不要犯画蛇添足的错误。
来源：考试大
从以上的分析中可以看出，静态内部类与非静态的内部类还是有很大的不同的。
一般程序开发人员可以这么理解，非晶态的内部类对象隐式地在外部类中保存了一个引用，指向创建它的外部类对象。
不管这么理解，程序开发人员都需要牢记静态内部类与非静态内部类的差异。
如是否可以创建静态的成员方法与成员变量(静态内部类可以创建静态的成员而非静态的内部类不可以)、对于访问外部类的成员的限制(静态内部类只可以访问外部类中的静态成员变量与成员方法而非静态的内部类即可以访问静态的也可以访问非静态的外部类成员方法与成员变量)。
这两个差异是静态内部类与非静态外部类最大的差异，也是静态内部类之所以存在的原因。
了解了这个差异之后，程序开发人员还需要知道，在什么情况下该使用静态内部类。
如在程序测试的时候，为了避免在各个Java源文件中书写主方法的代码，可以将主方法写入到静态内部类中，以减少代码的书写量，让代码更加的简洁。
总之，静态内部类在Java语言中是一个很特殊的类，跟普通的静态类以及非静态的内部类都有很大的差异。
作为程序开发人员，必须要知道他们之间的差异，并在实际工作中在合适的地方采用合适的类。
不过总的来说，静态内部类的使用频率并不是很高。
但是在有一些场合，如果没有这个内部静态类的话，可能会起到事倍功半的反面效果。