java - usar - static programacion

Cómo crear instancias de clases internas no estáticas dentro de un método estático

Question

Tengo el siguiente fragmento de código:

public class MyClass{
   class Inner{
     int s,e,p;
   }

   public static void main(String args[]){
     Inner in;
   }
}

Hasta esta parte el código está bien, pero no puedo instanciar ''in'' dentro del método principal como in=new Inner() ya que muestra que non static field cannot be referenced in static context . ¿Cuál es la forma en que puedo hacerlo? No quiero que mi clase interna estética.

Answer 1

Alexei Kaigorodov es la respuesta correcta. Su solución le permite crear instancias de clases internas desde un método estático, como main () de la misma clase. De lo contrario, no puede crear una instancia de una clase interna dentro de un método estático. No compila La solución de Alexei sí compila y te permite crear instancias de clases internas a partir de un método estático. Las otras respuestas son notas secundarias interesantes, pero no las encuentro receptivas a la pregunta real.

import java.awt.Graphics;
import java.awt.Color;
import javax.swing.JPanel;
import javax.swing.JFrame;

public class Example {
    public class InnerClass extends JPanel {
        public void paint(Graphics g) {
            g.setColor(Color.BLACK);
            g.fillRect(getX(),getY(),getWidth(),getHeight());
            g.setColor(Color.RED);
            g.fillRect(5, 20, 195, 20);
            g.setColor(Color.BLACK);
            g.drawString("This was written by an inner class.", 10, 35);
        }
    }

    public void demonstrate() {
        InnerClass sc = new InnerClass();//<---this is key
        JFrame jf = new JFrame();
        jf.add(sc);
        jf.setSize(220, 130);
        jf.setLocation(450, 450);
        jf.show();
    }

    public static void main(String[] params) {
        Example e = new Example();//<---so is this
        e.demonstrate();//<---and this is also key
    }
}

Answer 2

Si desea crear un new Inner() desde dentro de un método, hágalo desde un método de instancia de la clase MyClass :

public void main(){
  Inner inner = new Inner();
}

public static void main(String args[]){
  new MyClass().main();
}

Answer 3

También debe tener una referencia a la otra clase externa.

Inner inner = new MyClass().new Inner();

Si Inner fuera estático, entonces sería

Inner inner = new MyClass.Inner();

Answer 4

Una clase interna "regular" tiene un puntero oculto (implícito) a una instancia de clase Outer. Esto permite que el compilador genere el código para buscar el puntero sin tener que escribirlo. Por ejemplo, si hay una variable "a" en la clase externa, entonces el código en su clase interna puede hacer "a = 0", pero el compilador generará código para "outerPointer.a = 0" manteniendo el puntero oculto bajo las cubiertas.

Esto significa que cuando crea una instancia de una clase interna, debe tener una instancia de una clase externa para vincularla. Si realiza esta creación dentro de un método de la clase externa, entonces el compilador sabe usar "this" como el puntero implícito. Si desea vincular a alguna otra instancia externa, entonces usa una sintaxis especial "nueva" (vea el fragmento de código a continuación).

Si haces que tu clase interna sea "estática", entonces no hay un puntero oculto y tu clase interna no puede hacer referencia a los miembros de la clase externa. Una clase interna estática es idéntica a una clase normal, pero su nombre tiene un ámbito interno.

Aquí hay un fragmento de código que demuestra la sintaxis para crear clases internas estáticas y no estáticas:

public class MyClass {

    int a,b,c; // Some members for MyClass

    static class InnerOne {
        int s,e,p;
        void clearA() {
            //a = 0;  Can''t do this ... no outer pointer
        }
    }

    class InnerTwo {
        //MyClass parentPointer;      Hidden pointer to outer instance
        void clearA() {         
            a = 0;
            //outerPointer.a = 0      The compiler generates this code
        }       
    }

    void myClassMember() {
        // The compiler knows that "this" is the outer reference to give
        // to the new "two" instance.
        InnerTwo two = new InnerTwo(); //same as this.new InnerTwo()
    }

    public static void main(String args[]) {

        MyClass outer = new MyClass();

        InnerTwo x = outer.new InnerTwo(); // Have to set the hidden pointer
        InnerOne y = new InnerOne(); // a "static" inner has no hidden pointer
        InnerOne z = new MyClass.InnerOne(); // In other classes you have to spell out the scope

    }

}