Ich erhalte diesen Fehler als-

Auf keine einschließende Instanz vom Typ GeoLocation kann zugegriffen werden. Die Zuordnung muss mit einer einschließenden Instanz vom Typ GeoLocation (z. B. neu A (), wobei x eine Instanz von GeoLocation ist) qualifiziert werden. Dieser Fehler tritt bei der neuen ThreadTask (i) auf . Ich weiß nicht, warum es passiert. Anregungen werden geschätzt.

public class GeoLocation {
    public static void main(String[] args) throws InterruptedException {
        int size = 10;

        // create thread pool with given size
        ExecutorService service = Executors.newFixedThreadPool(size); 

        // queue some tasks
        for(int i = 0; i < 3 * size; i++) {
            service.submit(new ThreadTask(i));
        }

        // wait for termination        
        service.shutdown();
        service.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS); 
    }

    class ThreadTask implements Runnable {
        private int id;

        public ThreadTask(int id) {
            this.id = id;
        }

        public void run() {
            System.out.println("I am task " + id);
        }
    }

}

Hallo ich habe eine Lösung dafür gefunden ;-)

Dieser Fehler tritt auf, weil Sie versuchen, eine Instanz einer inneren Klasse service.submit(new ThreadTask(i)); zu erstellen, ohne eine Instanz der Hauptklasse zu erstellen .

Um dieses Problem zu beheben, erstellen Sie bitte zuerst eine Instanz der Hauptklasse:

GeoLocation outer = new GeoLocation();

Erstellen Sie dann die Instanz der Klasse, die Sie aufrufen möchten, wie folgt:

service.submit(outer.new ThreadTask(i));

Ich hoffe das wird dein Problem lösen ;-)

Eine andere Option, und die, die ich bevorzuge, wäre, die innere Klasse auf statisch zu setzen.

public static class ThreadTask implements Runnable { ... }

Machen Sie die Inline-Klasse static.

public class OuterClass {

    static class InnerClass {
    }

    public InnerClass instance = new OuterClass.InnerClass();
}

Dann können Sie die innere Klasse wie folgt instanziieren:

new OuterClass.InnerClass();

Führen Sie diese Struktur aus:

DATEI GeoLocation.java

public class GeoLocation {

    public static void main(String[] args) throws InterruptedException {

        int size = 10;

        // create thread pool with given size
        ExecutorService service = Executors.newFixedThreadPool(size); 

        // queue some tasks
        for(int i = 0; i < 3 * size; i++) {
            service.submit(new ThreadTask(i));
        }

        // wait for termination        
        service.shutdown();
        service.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS); 
    }

}}

Datei ThreadTask.java

public class ThreadTask implements Runnable {
    private int id;

    public ThreadTask(int id) {
        this.id = id;
    }

    public void run() {
        System.out.println("I am task " + id);
    }
}

Sie müssen eine Instanz der übergeordneten Klasse erstellen, um Instanzen Ihrer inneren Klassen zu erstellen. Hier ist ein Beispiel:

package RandomTests;

public class FinalConstructorTest {


    public static void main (String [] arg){
        FinalConstructorTest fct= new FinalConstructorTest();
        InnerClass1 f1= fct.new InnerClass1(99);
        InnerClass2 f2= fct.new InnerClass2();
    }

    class InnerClass1{
        private final int num2;

        protected InnerClass1(int num){
            num2= num;
            System.out.println("num2= "+ num2);
        }
    }
    class InnerClass2{
        //private static final int x; //Doesn't work
        private final int y; 

        {
            y= 5;
            System.out.println("y= "+ y);
        }
    }
}

Dies kann auch passieren, wenn Sie über die statischen Methoden oder auf ähnliche Weise auf nicht statische Elemente zugreifen. Es folgen zwei verschiedene Aspekte, einer, der den Fehler verursacht, und ein anderer gelöster Code. Es geht nur darum, andere als Klasse "statisch" zu machen.

package Stack;

import java.util.Stack;
import java.util.*;

public class StackArrList {

    public static void main(String[] args) {


        Scanner in = new Scanner(System.in);

        Stack S = new Stack();
        System.out.println("Enter some integers and keep 0 at last:\n");
        int n = in.nextInt();

        while (n != 0) {
            S.push(n);
            n = in.nextInt();
        }
        System.out.println("Numbers in reverse order:\n");

        while (!S.empty()) {

            System.out.printf("%d", S.pop());
            System.out.println("\n");

        }

    }

    public class Stack {
        final static int MaxStack = 100;
        final static int Value = -999999;
        int top = -1;
        int[] ST = new int[MaxStack];

        public boolean empty() {
            return top == -1;
        }

        public int pop() {

            if (this.empty()) {
                return Value;
            }
            int hold = ST[top];
            top--;
            return hold;
        }

        public void push(int n) {
            if (top == MaxStack - 1) {
                System.out.println("\n Stack Overflow\n");
                System.exit(1);
            }
            top++;
            ST[top] = n;

        }

    }

}

Dies löst den Fehler aus. Auf keine einschließende Instanz vom Typ StackArrList kann zugegriffen werden. Die Zuordnung muss mit einer einschließenden Instanz vom Typ StackArrList (egxnew A (), wobei x eine Instanz von StackArrList ist) qualifiziert werden. und erlaubt nicht, eine Instanz der Stapelklasse zu erstellen

Wenn Sie den Klassenstapel zur statischen Klasse machen , funktioniert der Stapel einwandfrei und es tritt kein Fehler auf.

package Stack;

import java.util.Stack;
import java.util.*;

public class StackArrList {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        Stack S = new Stack();
        System.out.println("Enter some integers and keep 0 at last:\n");
        int n = in.nextInt();

        while (n != 0) {
            S.push(n);
            n = in.nextInt();
        }
        System.out.println("Numbers in reverse order:\n");

        while (!S.empty()) {

            System.out.printf("%d", S.pop());
            System.out.println("\n");

        }

    }

    static class Stack {
        final static int MaxStack = 100;
        final static int Value = -999999;
        int top = -1;
        int[] ST = new int[MaxStack];

        public boolean empty() {
            return top == -1;
        }

        public int pop() {

            if (this.empty()) {
                return Value;
            }
            int hold = ST[top];
            top--;
            return hold;
        }

        public void push(int n) {
            if (top == MaxStack - 1) {
                System.out.println("\n Stack Overflow\n");
                System.exit(1);
            }
            top++;
            ST[top] = n;

        }

    }

}