java 内部类和静态内部类的区别

最新推荐文章于 2023-04-14 14:15:23 发布

zhifeng687

最新推荐文章于 2023-04-14 14:15:23 发布

阅读量456

点赞数

分类专栏： Java

Java 专栏收录该内容

57 篇文章 6 订阅

订阅专栏

翻译自oracle官网：Nested Classes

Java编程语言允许您在另外一个类中定义一个类。这个类被称为嵌套类，并在此处进行说明：

class OuterClass {
...
class NestedClass {
...
}

}

嵌套类分为两类：静态和非静态。被声明为静态的嵌套类称为静态嵌套类。非静态嵌套类称为内部类。

class OuterClass {
...
static class StaticNestedClass {
...
}
class InnerClass {
...
}
}

嵌套类是其封闭类的成员。非静态嵌套类（内部类）可以访问封闭类的所有其他成员，即使它们被声明为私有。静态嵌套类不能访问封闭类的非静态成员。作为OuterClass的成员，可以将嵌套类声明为private，public，protected或package private。（回想一下，只能将外部类声明为public或package private。）

Why Use Nested Classes?

使用嵌套类的强大原因包括：

这是一种逻辑分组的方法，它只在一个地方使用：如果一个类只对另一个类有用，那么将它嵌入该类并将它们保持在一起是合乎逻辑的。嵌套这样的“帮助类”使得它们的包更加简化。

它增加了封装：考虑两个顶级类A和B，其中B需要访问A的成员，否则这些成员将被声明为私有。通过在类A中隐藏类B，可以将A的成员声明为私有，并且B可以访问它们。另外，B本身可以被外界隐藏起来。

它可以导致更易读和可维护的代码：在顶级类中嵌套小类会使代码更接近它的使用位置。

Static Nested Classes

与类方法和变量一样，静态嵌套类与其外部类相关联。像静态类方法一样，静态嵌套类不能直接引用其封闭类中的非静态成员。
静态嵌套类与其外部类（和其他类）的实例成员交互，就像任何其他顶级类一样。实际上，为了方便打包，静态嵌套类在行为上是嵌套在另一个顶级类中的顶级类。
静态类可以通过以下方法访问

OuterClass.StaticNestedClass

例如，获取静态内部类的实例
OuterClass.StaticNestedClass nestedObject =
new OuterClass.StaticNestedClass();

Inner Classes

与实例方法和变量一样，内部类与其包含类的实例关联，并可直接访问该对象的方法和字段。另外，因为内部类与一个实例相关联，所以它不能自己定义任何静态成员。

作为内部类实例的对象存在于外部类的实例中。考虑以下类：
InnerClass的一个实例只能存在于OuterClass的一个实例中，并且可以直接访问其封闭实例的方法和字段。

要实例化一个内部类，你必须首先实例化外部类。然后，使用以下语法在外部对象内创建内部对象：

OuterClass.InnerClass innerObject = outerObject.new InnerClass（）;

有两种特殊的内部类：本地类和匿名类。

Shadowing
如果特定作用域（如内部类或方法定义）中的类型声明（例如成员变量或参数名称）与封闭作用域中的另一个声明具有相同的名称，则该声明会隐藏该声明封闭的范围。您无法单独通过名称来引用阴影声明。以下示例ShadowTest演示了这一点：
public class ShadowTest {

public int x = 0;

class FirstLevel {

public int x = 1;

void methodInFirstLevel(int x) {
System.out.println("x = " + x);
System.out.println("this.x = " + this.x);
System.out.println("ShadowTest.this.x = " + ShadowTest.this.x);
}
}

public static void main(String... args) {
ShadowTest st = new ShadowTest();
ShadowTest.FirstLevel fl = st.new FirstLevel();
fl.methodInFirstLevel(23);
}
}
输出如下：

x = 23
this.x = 1
ShadowTest.this.x = 0
此示例定义了三个名为x的变量：类ShadowTest的成员变量，内部类FirstLevel的成员变量以及methodInFirstLevel方法中的参数。定义为方法methodInFirstLevel的参数的变量x会影响内部类FirstLevel的变量。因此，当您在methodInFirstLevel方法中使用变量x时，它会引用方法参数。要引用内部类FirstLevel的成员变量，请使用关键字this来表示封闭范围：
System.out.println("this.x = " + this.x);

通过它们所属的外部类类名引用包含较大范围的成员变量。例如，以下语句在内部类中访问类ShadowTest的成员变量：
System.out.println("ShadowTest.this.x = " + ShadowTest.this.x);

Serialization
内部类的序列化，包括本地和匿名类，强烈不鼓励。当Java编译器编译某些结构（如内部类）时，它会创建合成结构; 这些是在源代码中没有相应构造的类，方法，字段和其他构造。合成结构使Java编译器能够在不改变JVM的情况下实现新的Java语言功能。但是，合成结构在不同的Java编译器实现中可能会有所不同，这意味着.class文件在不同的实现中也会有所不同。因此，如果序列化内部类，然后使用不同的JRE实现对其进行反序列化，则可能会遇到兼容性问题。有关在编译内部类时生成的合成结构的更多信息，请参阅“获取方法参数的名称”一节中的隐式和合成参数部分。

----------------

译文结束，以下通过实例说明内部类和静态内部类的区别：

package com.test.xml;  
  
/** 
 * @author <a href="mailto:dq201@126.com">du.qiang</a> 
 * @version $Revision 1.1 $ 2010-6-23 上午06:48:28 
 */  
public class OutClassTest {  
    static int a;  
  
    int b;  
  
    public static void test() {  
        System.out.println("outer class static function");  
    }  
  
    public static void main(String[] args) {  
        OutClassTest oc = new OutClassTest();  
        // new一个外部类  
        OutClassTest oc1 = new OutClassTest();  
        // 通过外部类的对象new一个非静态的内部类  
        OutClassTest.InnerClass no_static_inner = oc1.new InnerClass();  
        // 调用非静态内部类的方法  
        System.out.println(no_static_inner.getKey());  
  
        // 调用静态内部类的静态变量  
        System.out.println(OutClassTest.InnerStaticClass.static_value);  
        // 不依赖于外部类实例,直接实例化内部静态类  
        OutClassTest.InnerStaticClass inner = new OutClassTest.InnerStaticClass();  
        // 调用静态内部类的非静态方法  
        System.out.println(inner.getValue());  
        // 调用内部静态类的静态方法  
        System.out.println(OutClassTest.InnerStaticClass.getMessage());  
    }  
  
    private class InnerClass {  
        // 非静态内部类不能声明或定义静态成员 ，所以不能声明为 private static String tt = "0";        
        private int flag = 0;  
  
        public InnerClass() {  
            // 三.非静态内部类的非静态成员可以访问外部类的非静态变量和静态变量  
            System.out.println("InnerClass create a:" + a);  
            System.out.println("InnerClass create b:" + b);  
            System.out.println("InnerClass create flag:" + flag);  
            //  
            System.out.println("InnerClass call outer static function");  
            // 调用外部类的静态方法  
            test();  
        }  
  
        public  String getKey() {  
            return "no-static-inner";  
        }  
    }  
  
    private static class InnerStaticClass {  
        // 静态内部类可以有静态成员，而非静态内部类则不能有静态成员。  
        private static String static_value = "0";  
  
        private int flag = 0;  
  
        public InnerStaticClass() {  
            System.out.println("InnerClass create a:" + a);  
            // 静态内部类不能够访问外部类的非静态成员  
            // System.out.println("InnerClass create b:" + b);  
            System.out.println("InnerStaticClass flag is " + flag);  
            System.out.println("InnerStaticClass tt is " + static_value);  
        }  
  
        public int getValue() {  
            // 静态内部类访问外部类的静态方法  
            test();  
            return 1;  
        }  
  
        public static String getMessage() {  
            return "static-inner";  
        }  
    }  
  
    public OutClassTest() {  
        // new一个非静态的内部类  
        InnerClass ic = new InnerClass();  
        System.out.println("OuterClass create");  
    }  
  
}

/**
* 总结：
* 1.静态内部类可以有静态成员(方法，属性)，而非静态内部类则不能有静态成员(方法，属性)。
* 2.静态内部类只能够访问外部类的静态成员,而非静态内部类则可以访问外部类的所有成员(方法，属性)。
* 3.实例化一个非静态的内部类的方法：
* a.先生成一个外部类对象实例
* OutClassTest oc1 = new OutClassTest();
* b.通过外部类的对象实例生成内部类对象
* OutClassTest.InnerClass no_static_inner = oc1.new InnerClass();
* 4.实例化一个静态内部类的方法：
* a.不依赖于外部类的实例,直接实例化内部类对象
* OutClassTest.InnerStaticClass inner = new OutClassTest.InnerStaticClass();
* b.调用内部静态类的方法或静态变量,通过类名直接调用
* OutClassTest.InnerStaticClass.static_value
* OutClassTest.InnerStaticClass.getMessage()
*/