static class Thing hará que su programa funcione.

Tal como está, tienes Thing como una clase interna, que (por definición) está asociada con una instancia particular de Hello (incluso si nunca la usa o hace referencia a ella), lo que significa que es un error decir new Thing(); sin tener una instancia particular de Hello en el alcance.

Si la declara como una clase estática, entonces es una clase "anidada", que no necesita una instancia de Hello en particular.

Ha 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, está tratando de crear una instancia de Thing desde un contexto estático. De eso se queja el compilador.

Hay algunas soluciones posibles. La solución a utilizar depende de lo que desee lograr.

• Mueve Thing fuera de la clase Hello .

• Cambie Thing para que sea una clase anidada static .

   static class Thing

• Cree una instancia de Hello antes de crear una instancia de 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 }

La última solución (una clase anidada no estática ) sería obligatoria si alguna instancia de Thing dependiera de una instancia de Hello para tener sentido. Por ejemplo, si tuviéramos:

 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; } } ... }

cualquier intento en bruto de crear un objeto de clase Thing , como en:

 Thing t = new Thing(31);

sería problemático, ya que no habría un enormous valor obvio para probar 31 en su contra. Se necesita una instancia h de la clase externa Hello para proporcionar este valor h.enormous :

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

Porque no significa Thing si no tiene un Hello .

Para obtener más información sobre clases anidadas/internas: Clases anidadas (los tutoriales de Java)

Bueno ... tantas buenas respuestas, pero quiero agregar más. Una breve mirada a la clase interna en Java: Java nos permite definir una clase dentro de otra clase y poder anidar clases 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 hay necesidad de que el mundo exterior lo sepa.

2. Puede hacer que el código sea más fácil de mantener , ya que las clases se agrupan lógicamente alrededor de donde se necesitan.

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

Tenemos principalmente tres tipos de Inner Classes

1. Local interior
2. Clase interna estática
3. Clase interna anónima

Algunos de los puntos importantes a recordar

• Necesitamos un objeto de clase para acceder a la clase interna local en la que existe.
• Se accede directamente a Static Inner Class como a cualquier otro método estático de la misma clase en la que existe.
• Las clases internas anónimas no son visibles para el mundo externo, así como para los otros métodos o clases de la misma clase (en las que existe) y se utilizan en el punto donde se declaran.

Tratemos de ver los conceptos anteriores de manera práctica_

 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 ayude a todos. Por favor refiérase para más