Java中的嵌套类

??Java 面向对象/Java 接口

在java中，可以在另一个类中定义一个类，这些类称为嵌套类。它们使您能够对仅在一个地方使用的类进行逻辑分组，从而增加封装的使用，并创建更具可读性和可维护性的代码。

• 嵌套类的范围受其封闭类的范围限制。因此，在上面的例子中，类NestedClass并不独立类的存在在OuterClass。
• 嵌套类可以访问嵌套类的成员，包括私有成员。然而，反向并不正确，即封闭类不能访问嵌套类的成员。
• 嵌套类也是其封闭类的成员。
• 作为其封闭类的成员，嵌套类可以声明为private，public，protected或package private（默认）。
• 嵌套类分为两类：
  1. 静态嵌套类：被声明为嵌套类的静态被称为静态嵌套类。
  2. 内部类：内部类是非静态嵌套类。

句法：

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

静态嵌套类

与类方法和变量一样，静态嵌套类与其外部类相关联。像静态类方法一样，静态嵌套类不能直接引用其封闭类中定义的实例变量或方法：它只能通过对象引用来使用它们。
他们使用封闭的类名访问。

OuterClass.StaticNestedClass

例如，要为静态嵌套类创建对象，请使用以下语法：

OuterClass.StaticNestedClass nestedObject =
     new OuterClass.StaticNestedClass（）;

// Java program to demonstrate accessing 
// a static nested class

// outer class
class OuterClass
{ 
    // static member
    static int outer_x = 10;
    
    // instance(non-static) member
    int outer_y = 20;
    
    // private member
    private static int outer_private = 30;
    
    // static nested class
    static class StaticNestedClass
    {
        void display()
        {
            // can access static member of outer class
            System.out.println("outer_x = " + outer_x);
            
            // can access display private static member of outer class
            System.out.println("outer_private = " + outer_private);
            
            // The following statement will give compilation error
            // as static nested class cannot directly access non-static membera
            // System.out.println("outer_y = " + outer_y);
        
        }
    }
}

// Driver class
public class StaticNestedClassDemo
{
    public static void main(String[] args)
    {
        // accessing a static nested class
        OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();
        
        nestedObject.display();
        
    }
}

输出：

outer_x = 10
outer_private = 30

内部类

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

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

有两种特殊的内部类：

1. 本地内部类
2. 匿名内部类

// Java program to demonstrate accessing
// a inner class

// outer class
class OuterClass
{ 
    // static member
    static int outer_x = 10;
    
    // instance(non-static) member
    int outer_y = 20;
    
    // private member
    private int outer_private = 30;
    
    // inner class
    class InnerClass
    {
        void display()
        {
            // can access static member of outer class
            System.out.println("outer_x = " + outer_x);
            
            // can also access non-static member of outer class
            System.out.println("outer_y = " + outer_y);
            
            // can also access private member of outer class
            System.out.println("outer_private = " + outer_private);
        
        }
    }
}

// Driver class
public class InnerClassDemo
{
    public static void main(String[] args)
    {
        // accessing an inner class
        OuterClass outerObject = new OuterClass();
        OuterClass.InnerClass innerObject = outerObject.new InnerClass();
        
        innerObject.display();
        
    }
}

输出：

outer_x = 10
outer_y = 20
outer_private = 30

静态和内部（非静态嵌套）类之间的区别

• 静态嵌套类不直接访问封闭类的其他成员（非静态变量和方法），因为它是静态的，它必须通过对象访问封闭类的非静态成员。也就是说，它不能直接引用其封闭类的非静态成员。由于这个限制，很少使用静态嵌套类。
• 非静态嵌套类（内部类）可以访问其外部类的所有成员（静态变量和非静态变量和方法，包括私有变量），并且可以直接以与外部其他非静态成员相同的方式引用它们上课做。

??Java 面向对象/Java 接口