Java成员内部类实现及应用

Java中成员内部类是指定义在类中的类，它可以访问外部类的所有成员变量和方法，并且可以被外部类的方法调用。在实际开发中，成员内部类可以用于实现一些特定的操作和实现一些复杂的业务场景。

一、成员内部类的定义与实现

成员内部类的定义格式如下：

public class OuterClass {
    // 外部类成员变量
    private int num = 10;

    // 内部类
    public class InnerClass {
        // 内部类成员变量
        private int innerNum = 20;

        // 内部类方法
        public void innerMethod() {
            System.out.println("访问外部类成员变量num：" + num);
            System.out.println("访问内部类成员变量innerNum：" + innerNum);
        }
    }
}

在上述代码中，内部类InnerClass是定义在外部类OuterClass中的，可以直接访问外部类的成员变量num。也可以定义自己的成员变量innerNum和方法innerMethod。

在外部类中创建内部类对象的方式如下：

public class Test {
    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        OuterClass.InnerClass inner = outer.new InnerClass();
        inner.innerMethod();
    }
}

在上述代码中，首先创建外部类OuterClass对象outer，然后通过outer.new InnerClass()的方式创建内部类InnerClass对象inner，并调用inner的innerMethod()方法。

二、成员内部类的应用

1、实现特定的操作

成员内部类可以实现一些特定的操作，例如在集合类中定义遍历器Iterator的时候就可以使用内部类来实现。例如：

import java.util.ArrayList;
import java.util.Iterator;

public class MyList {
    private ArrayList list = new ArrayList();

    public void add(String str) {
        list.add(str);
    }

    public void remove(String str) {
        list.remove(str);
    }

    // 定义遍历器
    public Iterator iterator() {
        return new MyIterator();
    }

    // 内部类
    private class MyIterator implements Iterator {
        private int currentIndex = 0;

        @Override
        public boolean hasNext() {
            return currentIndex < list.size();
        }

        @Override
        public String next() {
            return list.get(currentIndex++);
        }

        @Override
        public void remove() {
            list.remove(currentIndex);
        }
    }
}

在上述代码中，定义了一个集合类MyList，其中定义了一个内部类MyIterator来实现遍历器Iterator的接口。通过内部类MyIterator的实现，可以轻松的对集合对象进行遍历操作。

2、实现复杂的业务场景

成员内部类可以用于实现一些复杂的业务场景，例如在网络编程中可以使用成员内部类来实现客户端和服务端之间的通信。下面是一个简单的例子：

import java.net.Socket;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Client {
    // 内部类SocketThread
    private class SocketThread extends Thread {
        private Socket socket;

        public SocketThread(Socket socket) {
            this.socket = socket;
        }

        @Override
        public void run() {
            try {
                // 获取输出流
                BufferedOutputStream out = new BufferedOutputStream(socket.getOutputStream());

                // 发送消息
                String message = "Hello Server!";
                out.write(message.getBytes());
                out.flush();

                // 获取输入流
                BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));

                // 接收消息
                String response = in.readLine();
                System.out.println("服务器返回消息：" + response);

                // 关闭资源
                out.close();
                in.close();
                socket.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        try {
            // 创建Socket对象
            Socket socket = new Socket("127.0.0.1", 8888);

            // 创建内部类SocketThread对象，启动线程
            Client client = new Client();
            SocketThread socketThread = client.new SocketThread(socket);
            socketThread.start();

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

在上述代码中，定义了一个客户端类Client，在客户端类中定义了一个内部类SocketThread来实现客户端和服务端之间的通信。通过成员内部类的方式，可以实现客户端和服务端之间的高效通信。

总结

成员内部类可以访问外部类的所有成员变量和方法，并且可以被外部类的方法调用。在实际开发中，成员内部类可以用于实现特定的操作和实现复杂的业务场景。通过内部类的方式，可以有效的提高程序的可读性和可维护性。