Java内部类以及内部类与静态内部类的区别

在Java编程中，内部类是将一个类定义在另一个类的内部，形成类的嵌套结构。内部类可以访问其所在外部类的成员，包括私有成员，并且可以对外部类对象拥有控制权，从而提供更加灵活和封装的设计方式。

Java中主要有四种内部类：成员内部类、局部内部类、匿名内部类和静态内部类。

成员内部类：

成员内部类指的是定义在外部类的成员位置上的类，可以访问外部类的所有成员变量和方法，示例代码如下：

public class Outer {
    private int count = 1;
    public class Inner {
        public void print() {
            System.out.println("count: " + count);
        }
    }
}

局部内部类：

局部内部类指的是定义在方法或块内部的内部类，只能在方法或块内使用，示例代码如下：

public class Outer {
    public void test() {
        int num = 10;
        class Inner {
            public void print() {
                System.out.println("num: " + num);
            }
        }
        new Inner().print();
    }
}

匿名内部类：

匿名内部类指的是没有类名的内部类，通常用于实现某个接口或类的子类，示例代码如下：

public interface OnClickListener {
    void onClick();
}

public class Button {
    public void setOnClickListener(OnClickListener listener) {
        //...
    }
}

public class Demo {
    public void test() {
        Button button = new Button();
        button.setOnClickListener(new OnClickListener() {
            @Override
            public void onClick() {
                System.out.println("button clicked.");
            }
        });
    }
}

静态内部类：

静态内部类指的是定义在外部类中的静态成员位置上的类，使用static修饰，可以直接通过外部类名访问其静态成员，示例代码如下：

public class Outer {
    private static int count = 1;
    public static class Inner {
        public void print() {
            System.out.println("count: " + count);
        }
    }
}

内部类与静态内部类的区别：

内部类与静态内部类的最大区别就在于是否具有静态特性。静态内部类是独立于外部类的，可以看作是与外部类并列的一种新型数据类型，因此它不能直接访问外部类的非静态成员，而只能访问静态成员。此外，静态内部类与其他类一样，可以拥有静态成员和方法，并且可以通过类名直接调用。

以下是内部类和静态内部类的代码示例：

public class Outer {
    private int outerVar = 10;
    private static int staticOuterVar = 20;

    // 成员内部类
    class Inner {
        private int innerVar = 30;

        public void print() {
            System.out.println("outerVar: " + outerVar);
            System.out.println("staticOuterVar: " + staticOuterVar);
            System.out.println("innerVar: " + innerVar);
        }
    }

    // 静态内部类
    static class StaticInner {
        private int staticInnerVar = 40;

        public void print() {
            // 静态内部类只能访问外部类的静态成员
            System.out.println("staticOuterVar: " + staticOuterVar);
            System.out.println("staticInnerVar: " + staticInnerVar);
        }
    }

    // 测试方法
    public static void main(String[] args) {
        // 测试成员内部类
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner();
        inner.print();

        // 测试静态内部类
        Outer.StaticInner staticInner = new Outer.StaticInner();
        staticInner.print();
    }
}

在上述代码示例中，我们定义了一个名为Outer的外部类，并分别在其中定义了一个Inner成员内部类和一个StaticInner静态内部类。在Inner类中，可以直接访问外部类的非静态成员变量outerVar和非静态方法print()，并通过使用外部类名Outer来访问外部类的静态成员变量staticOuterVar，从而证明了成员内部类对外部类对象具有控制权。而在StaticInner类中，虽然也可以通过使用外部类名来访问静态成员变量staticOuterVar，但却不能直接访问外部类的非静态成员变量outerVar和非静态方法print()，从而证明了静态内部类是独立于外部类的新型数据类型。