Java内部类介绍

Java内部类是一种定义在其他类（外部类）内部的类。它的特点是可以访问外部类的私有变量和方法，并且可以隐藏实现细节，提高代码的可读性和可维护性。本文将介绍Java内部类的概念、分类、语法和使用场景。

分类

Java内部类可以分为四类：

1. 成员内部类：在外部类的成员位置定义的类，它可以访问外部类的所有成员变量和方法，可以被外部类或其他类使用。
2. 局部内部类：定义在方法或作用域内部的类，它只能在定义它的方法或作用域内部使用。
3. 匿名内部类：没有类名的内部类，通常用作接口的实现类或线程的实现类。
4. 静态内部类：在外部类的成员位置定义的静态类，它不依赖于外部类的实例，可以直接访问外部类的静态成员，可以被外部类或其他类使用。

语法

成员内部类

public class OuterClass {
    private int outerField;
    public class InnerClass {
        public void innerMethod() {
            //可以访问外部类的私有变量
            System.out.println("Outer field value: " + outerField);
        }
    }
}

局部内部类

public class OuterClass {
    public void someMethod() {
        class InnerClass {
            public void innerMethod() {
                System.out.println("This is a local inner class.");
            }
        }
        InnerClass inner = new InnerClass();
        inner.innerMethod();
    }
}

匿名内部类

public interface MyInterface {
    void myMethod();
}
public class OuterClass {
    public void someMethod() {
        MyInterface inner = new MyInterface() {
            public void myMethod() {
                System.out.println("This is an anonymous inner class.");
            }
        };
        inner.myMethod();
    }
}

静态内部类

public class OuterClass {
    private static int outerField;
    public static class InnerClass {
        public void innerMethod() {
            //可以访问外部类的静态变量
            System.out.println("Outer field value: " + outerField);
        }
    }
}

使用场景

1. 封装实现细节

public class Queue {
    private Node head;
    private Node tail;
    private class Node {
        private Object item;
        private Node next;
    }
    public void enqueue(Object item) {
        Node node = new Node();
        node.item = item;
        if (head == null) {
            head = node;
            tail = node;
        } else {
            tail.next = node;
            tail = node;
        }
    }
}

在上面的Queue类中，Node类用于封装节点的实现细节，而不必暴露给外部类的用户。

2. 接口回调

public interface OnClickListener {
    void onClick();
}
public class Button {
    public void setOnClickListener(OnClickListener listener) {
        //省略代码
    }
}
public class MainActivity {
    private Button button;
    protected void onCreate(Bundle savedInstanceState) {
        button = findViewById(R.id.button);
        button.setOnClickListener(new OnClickListener() {
            public void onClick() {
                Toast.makeText(MainActivity.this, "Button is clicked.", Toast.LENGTH_SHORT).show();
            }
        });
    }
}

在上述代码中，MainActivity类实现了OnClickListener接口的方法，将其作为匿名内部类传递给Button类的setOnClickListener()方法，从而实现了事件回调的功能。

结论

Java内部类是一种非常有用的语言特性，可以帮助我们封装实现细节、实现接口回调等功能，在代码中广泛应用。可以根据实际需要选择合适的类型，并注意其作用域和访问权限，以便发挥出最大的效益。