不能访问类型为Server的封闭实例 [英] No enclosing instance of type Server is accessible

问题描述

我在Java中遇到了一个奇怪的问题，这是我以前从未见过的。

I'm encountering a weird issue in Java at the moment that I've never seen before.

错误是无法访问类型为Server的封闭实例必须使用类型为Server的封闭实例限定分配（egxnew A（），其中x是Server的实例）。

The error is "No enclosing instance of type Server is accessible. Must qualify the allocation with an enclosing instance of type Server (e.g. x.new A() where x is an instance of Server)."

我评论过的行是发生错误的地方。

The line I've commented on is where the error occurs.

package game;

import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.StringTokenizer;

public class Server {

    private static List<ThreadModtagClient> clients;

    class ReceiveDataListener implements SocketListener {

        @Override
        public void dataReceived(ThreadModtagClient client, String data) {

        }   
    }

    /**
     * @param args
     * @throws IOException
     */
    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub

        clients = new ArrayList<ThreadModtagClient>();

        ServerSocket welcomeSocket = new ServerSocket(16567);

        while (true) {
            Socket connectionSocket = welcomeSocket.accept();

            ThreadModtagClient client = new ThreadModtagClient(connectionSocket);
            ReceiveDataListener listener = new ReceiveDataListener(); // <--- this is where the error occurs
            client.addSocketListener(listener);
            clients.add(client);
        }

    }
}

class ThreadModtagClient extends Thread implements SocketThread {

    private BufferedReader inFromClient;
    private DataOutputStream outToClient;

    private Player player;

    private List<SocketListener> listeners;


    public ThreadModtagClient(Socket connection) throws IOException {
        inFromClient = new BufferedReader(new InputStreamReader(connection.getInputStream()));
        outToClient = new DataOutputStream(connection.getOutputStream());
        listeners = new ArrayList<SocketListener>();

    }

    public void addSocketListener(SocketListener listener) {
        listeners.add(listener);
    }

    public void removeSocketListener(SocketListener listener) {
        listeners.remove(listener);
    }

    public Player getPlayer() {
        return player;
    }

    public void setPlayer(Player player) {
        this.player = player;
    }


    public void sendData(String data) throws IOException {
        outToClient.writeChars(data);
    }

    public void run() {

        while (true) {
            try {

                String data = inFromClient.readLine();

                for(SocketListener listener : listeners) {
                    listener.dataReceived(this, data);
                }

            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch(NoSuchElementException e1) {
                e1.printStackTrace();
            }
        }
    }
}

推荐答案

Server.ReceiveDataListener 是一个（非静态）内部类。您是从静态上下文创建它。您需要提供 Server 的实例作为外部实例。但是，几乎可以肯定，您希望 ReceiveDataListener 成为静态嵌套类，或者可能是外部类。

Server.ReceiveDataListener is a (non-static) inner class. You are creating it from a static context. You need to supply an instance of Server to be the outer instance. However, almost certainly you want ReceiveDataListener to be a static nested class, or probably an outer class.

这篇关于不能访问类型为Server的封闭实例的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！