Java - Ningún caso encerrando de tipo Foo es accesible

Question

tengo el siguiente código:

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!"); 
    } 
} 

sé Thing no hace nada, pero mi Hola, el programa Mundial compila muy bien sin él. Solo son mis clases definidas las que me fallan.

Y se niega a compilar. Obtengo No enclosing instance of type Hello is accessible." en la línea que crea una nueva cosa. Estoy adivinando ya sea:

1. tengo problemas a nivel de sistema (ya sea en DrJava o de mi instalación de Java) o
2. Tengo un malentendido básico de cómo construir un programa de trabajo en Java.

¿Alguna idea?

Answer 1

static class Thing hará que su programa funcione.

Como es, usted tiene Thing como una clase interna, que (por definición) se asocia con una instancia particular de Hello (aunque nunca usa o se refiere a ella), lo que significa que es un error decir new Thing(); sin tener una instancia en particular Hello en el alcance.

Si lo declaras como una clase estática en su lugar, entonces es una clase "anidada", que no necesita una instancia en particular Hello.

Answer 2

Thing es un inner class con una conexión automática a una instancia de Hello. Obtiene un error de compilación porque no hay ninguna instancia de Hello para que se pueda conectar. Se puede fijar más fácilmente cambiando a un static nested class que no tiene relación:

static class Thing 

Answer 3

Has declarado la clase Thing como una clase interna no estática. Eso significa que debe estar asociado con una instancia de la clase Hello.

En su código, intenta crear una instancia de Thing desde un contexto estático. De eso es de lo que el compilador se queja.

Existen algunas posibles soluciones. Qué solución usar depende de lo que quiere lograr.

• Cambiar la cosa por ser una clase anidada estática.

  static class Thing 
  

• crear una instancia de Hola, a continuación, crear una instancia de cosas.

  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 
  } 
  

• Move Thing fuera de la clase Hello.

Para obtener más información sobre las clases anidadas/interior: Nested Classes (The Java Tutorials)

Answer 4

Lets entiende con el siguiente ejemplo sencillo. Esto sucede porque esto es CLASE INTERNA NO ESTÁTICA.Deberías necesitar la instancia de la clase externa.

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"); 

     } 
    } 
} 

Answer 5

Bueno ... muchas buenas respuestas, pero quiero añadir más. Una breve mirada en clase interna en Java Java nos permite definir una clase dentro de otra clase y Ser capaz de clases nido de esta manera tiene ciertas ventajas:

1. Puede ocultar (aumenta) la encapsulación la clase de otras clases, especialmente relevante si la clase solo está siendo utilizada por la clase en la que está contenida. En este caso, no es necesario que el mundo exterior lo sepa.

2. Puede hacer que el código sea más fácil de mantener ya que las clases están lógicamente agrupadas en torno a donde se necesitan.

3. La clase interna tiene acceso a las variables y métodos de su clase que contiene de instancia.

Nos tienen principalmente tres tipos de Inner Classes

1. local interno
2. estático interior Clase Clase
3. Anónimo interior

Algunos de los puntos importantes a segundo e recuerda

• Necesitamos objeto de clase para acceder a la clase interna local en la que existe.
• La clase interna estática obtiene acceso directo igual que cualquier otro método estático de la misma clase en la que existe.
• La clase interna anónima no está visible para el mundo exterior, así como para los otros métodos o clases de la misma clase (en la que existe) y se usa en el punto donde se declara.

Let `tratar de ver los conceptos anteriores practically_

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!"); 
    } 
} 

} 

espero que esto ayuda a todos. Por favor refer for more