Was verursacht den Fehler „Keine einschließende Instanz vom Typ Foo ist zugänglich“ und wie behebe ich ihn?

Ich habe folgenden Code:

class Hello {
    class Thing {
        public int size;

        Thing() {
            size = 0;
        }
    }

    public static void main(String[] args) {
        Thing thing1 = new Thing();
        System.out.println("Hello, World!");
    }
}

Ich kenne Thing tut nichts, aber mein Hello, World-Programm kompiliert problemlos ohne es. Es sind nur meine definierten Klassen, die bei mir versagen.

Und es weigert sich zu kompilieren. Ich bekomme No enclosing instance of type Hello is accessible." an der Linie, die ein neues Ding erschafft. Ich vermute entweder:

1. Ich habe Probleme auf Systemebene (entweder in DrJava oder meiner Java-Installation) oder
2. Ich habe ein grundlegendes Missverständnis darüber, wie man ein funktionierendes Programm in Java erstellt.

Irgendwelche Ideen?

static class Thing wird Ihr Programm zum Laufen bringen.

So wie es ist, hast du Thing als innere Klasse, die (per Definition) einer bestimmten Instanz von zugeordnet ist Hello (auch wenn es nie verwendet oder darauf verwiesen wird), was bedeutet, dass es ein Fehler ist, dies zu sagen new Thing(); ohne ein bestimmtes zu haben Hello Beispiel im Geltungsbereich.

Wenn Sie es stattdessen als statische Klasse deklarieren, handelt es sich um eine “verschachtelte” Klasse, die keine besondere Klasse benötigt Hello Beispiel.

Sie haben die Klasse deklariert Thing als nichtstatische innere Klasse. Das bedeutet, dass es mit einer Instanz von verknüpft sein muss Hello Klasse.

In Ihrem Code versuchen Sie, eine Instanz von zu erstellen Thing aus einem statischen Kontext. Darüber beschwert sich der Compiler.

Es gibt einige mögliche Lösungen. Welche Lösung Sie verwenden, hängt davon ab, was Sie erreichen möchten.

• Umzug Thing aus dem Hello Klasse.

• Ändern Thing ein … zu sein static verschachtelte Klasse.

  static class Thing
  

• Schaffen eine Instanz von Hello bevor Sie eine Instanz von erstellen Thing.

  public static void main(String[] args)
  {
      Hello h = new Hello();
      Thing thing1 = h.new Thing(); // hope this syntax is right, typing on the fly :P
  }
  

Die letzte Lösung (a nicht statisch verschachtelte Klasse) wäre obligatorisch, wenn eine Instanz von Thing hing von einer Instanz von ab Hello aussagekräftig sein. Wenn wir zum Beispiel hätten:

public class Hello {
    public int enormous;

    public Hello(int n) {
        enormous = n;
    }

    public class Thing {
        public int size;

        public Thing(int m) {
            if (m > enormous)
                size = enormous;
            else
                size = m;
        }
    }
    ...
}

jeder rohe Versuch, ein Objekt der Klasse zu schaffen Thingwie in:

Thing t = new Thing(31);

wäre problematisch, da es kein offensichtliches gäbe enormous Wert, um 31 dagegen zu testen. Eine Instanz h des Hello äußere Klasse ist notwendig, um dies zu gewährleisten h.enormous Wert:

...
Hello h = new Hello(30);
...
Thing t = h.new Thing(31);
...

Denn es bedeutet nicht a Thing wenn es keine hat Hello.

Weitere Informationen zu verschachtelten/inneren Klassen:
Verschachtelte Klassen (Die Java-Tutorials)

Nun … so viele gute Antworten, aber ich möchte mehr hinzufügen. Ein kurzer Blick auf die innere Klasse in Java – Java ermöglicht es uns, eine Klasse innerhalb einer anderen Klasse zu definieren, und die Möglichkeit, Klassen auf diese Weise zu verschachteln, hat bestimmte Vorteile:

1. Es kann verstecken (Erhöht die Kapselung) die Klasse aus anderen Klassen – besonders relevant, wenn die Klasse nur von der Klasse verwendet wird, in der sie enthalten ist. In diesem Fall ist es nicht erforderlich, dass die Außenwelt davon erfährt.

2. Es kann machen Code wartbarer da die Klassen logisch dort gruppiert sind, wo sie benötigt werden.

3. Die innere Klasse hat betreten zu den Instanzvariablen und Methoden seiner enthaltenden Klasse.

Wir haben hauptsächlich drei Arten von Inner Classes

1. Lokales Inneres
2. Statische innere Klasse
3. Anonyme innere Klasse

Einige der wichtigen Punkte, an die Sie sich erinnern sollten

• Wir benötigen ein Klassenobjekt, um auf die lokale innere Klasse zuzugreifen, in der es existiert.
• Auf die statische innere Klasse wird direkt zugegriffen wie auf jede andere statische Methode derselben Klasse, in der sie vorhanden ist.
• Anonyme innere Klassen sind weder für die Außenwelt noch für die anderen Methoden oder Klassen derselben Klasse (in denen sie vorhanden ist) sichtbar und werden an dem Punkt verwendet, an dem sie deklariert sind.

Versuchen wir, die obigen Konzepte praktisch zu sehen_

public class MyInnerClass {

public static void main(String args[]) throws InterruptedException {
    // direct access to inner class method
    new MyInnerClass.StaticInnerClass().staticInnerClassMethod();

    // static inner class reference object
    StaticInnerClass staticInnerclass = new StaticInnerClass();
    staticInnerclass.staticInnerClassMethod();

    // access local inner class
    LocalInnerClass localInnerClass = new MyInnerClass().new LocalInnerClass();
    localInnerClass.localInnerClassMethod();

    /*
     * Pay attention to the opening curly braces and the fact that there's a
     * semicolon at the very end, once the anonymous class is created:
     */
    /*
     AnonymousClass anonymousClass = new AnonymousClass() {
         // your code goes here...

     };*/
 }

// static inner class
static class StaticInnerClass {
    public void staticInnerClassMethod() {
        System.out.println("Hay... from Static Inner class!");
    }
}

// local inner class
class LocalInnerClass {
    public void localInnerClassMethod() {
        System.out.println("Hay... from local Inner class!");
    }
 }

}

Ich hoffe, das wird allen helfen. Bitte siehe mehr

Thing ist ein innere Klasse mit einer automatischen Verbindung zu einer Instanz von Hello. Sie erhalten einen Kompilierungsfehler, weil es keine Instanz von gibt Hello damit es sich anheften kann. Sie können es am einfachsten beheben, indem Sie es in eine statische verschachtelte Klasse ändern, die keine Verbindung hat:

static class Thing

Lassen Sie uns es mit dem folgenden einfachen Beispiel verstehen. Dies geschieht, weil dies eine NON-STATIC INNER CLASS ist. Sie sollten die Instanz der äußeren Klasse benötigen.

 public class PQ {

    public static void main(String[] args) {

        // create dog object here
        Dog dog = new PQ().new Dog();
        //OR
        PQ pq = new PQ();
        Dog dog1 = pq.new Dog();
    }

    abstract class Animal {
        abstract void checkup();
    }

    class Dog extends Animal {
        @Override
        void checkup() {
            System.out.println("Dog checkup");

        }
    }

    class Cat extends Animal {
        @Override
        void checkup() {
            System.out.println("Cat Checkup");

        }
    }
}

Vor Java 14
Sie müssen der Zugriffsklasse ein statisches Schlüsselwort hinzufügen Thing aus dem statischen Kontext.

class Hello {
    static class Thing {
        public int size;

        Thing() {
            size = 0;
        }
    }

    public static void main(String[] args) {
        Thing thing1 = new Thing();
        System.out.println("Hello, World!");
    }
}

Java 14+
Ab Java 14 können Sie innere Datensatzklassen verwenden, die implizit statisch sind. Du hättest also:

class Hello {
    record Thing(int size) { }

    public static void main(String[] args) {
        Thing thing1 = new Thing(0);
        System.out.println("Hello, World!");
    }
}

Deklarieren Sie die INNERE Klasse Ding als statisch und es wird ohne Probleme funktionieren.

Ich erinnere mich, dass ich das gleiche Problem mit der inneren Klasse Dog hatte, als ich sie als Klasse deklarierte Hund { nur. Ich habe das gleiche Problem wie du. Es gab zwei Lösungen:

1- Um die innere Klasse Dog als statisch zu deklarieren. Oder

2- Den Hund der inneren Klasse selbst in eine neue Klasse zu verschieben.

Hier ist das Beispiel:

öffentliche Klasse ReturnDemo {

public static void main(String[] args) {
    
    int z = ReturnDemo.calculate(10, 12);
    System.out.println("z = " + z);
    
    ReturnDemo.Dog dog = new Dog("Bosh", " Doggy");
    System.out.println( dog.getDog());
}


public static int calculate (int x, int y) {
    return x + y;
}

public void print( ) {
    System.out.println("void method");
    return;
}

public String getString() {
    return "Retrun String type value";
}


static class Dog {
    
private String breed;
private String name;

public Dog(String breed, String name) {
    super();
    this.breed = breed;
    this.name = name;
}

public Dog getDog() {
    // return Dog type;
    return this;
    
}

public String toString() {
    return "breed" + breed.concat("name: " + name);
}
}

}