java - uncompilable - La variable no estática no puede ser referenciada desde un contexto estático

non-static variable cannot be referenced from a static context solucion

Question

He escrito este código de prueba:

class MyProgram
{
    int count = 0;
    public static void main(String[] args)
    {
        System.out.println(count);
    }
}

Pero da el siguiente error:

Main.java:6: error: non-static variable count cannot be referenced from a static context
        System.out.println(count);
                           ^

¿Cómo consigo mis métodos para reconocer mis variables de clase?

Answer 1

Ahora puedes agregar / usar instancias con el método

public class Myprogram7 {

  Scanner scan;
  int compareCount = 0;
  int low = 0;
  int high = 0;
  int mid = 0;  
  int key = 0;  
  Scanner temp;  
  int[]list;  
  String menu, outputString;  
  int option = 1;  
  boolean found = false;  

  private void readLine() {

  }

  private void findkey() {

  }

  private void printCount() {

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

    Myprogram7 myprg=new Myprogram7();
    myprg.readLine();
    myprg.findkey();
    myprg.printCount();
  }
}

Answer 2

Antes de llamar a un método de instancia o variable de instancia, se necesita un objeto (Instancia). Cuando se llama a la variable de instancia desde el método estático, el compilador no sabe a qué objeto pertenece esta variable. Porque los métodos estáticos no tienen un objeto (solo una copia siempre). Cuando llama a una variable de instancia o métodos de instancia desde el método de instancia, se refiere al objeto. Significa que la variable pertenece a cualquier objeto creado y cada objeto tiene su propia copia de métodos y variables de instancia.

Las variables estáticas están marcadas como static y las variables de instancia no tienen una palabra clave específica.

Answer 3

Debe comprender la diferencia entre una clase y una instancia de esa clase. Si ve un automóvil en la calle, inmediatamente sabe que es un automóvil, incluso si no puede ver qué modelo o tipo. Esto se debe a que compara lo que ve con la clase "auto". La clase contiene que es similar a todos los coches. Piense en ello como una plantilla o una idea.

Al mismo tiempo, el automóvil que ve es una instancia de la clase "automóvil", ya que tiene todas las propiedades que usted espera: hay alguien que lo conduce, tiene un motor, ruedas.

Así que la clase dice "todos los autos tienen un color" y la instancia dice "este auto específico es rojo".

En el mundo OO, define la clase y dentro de la clase, define un campo de tipo Color . Cuando se crea una instancia de la clase (cuando creas una instancia específica), la memoria se reserva para el color y puedes darle un color a esta instancia específica. Dado que estos atributos son específicos, no son estáticos.

Los campos y métodos estáticos se comparten con todas las instancias. Son para valores que son específicos de la clase y no una instancia específica. Para los métodos, esto generalmente son métodos de ayuda global (como Integer.parseInt() ). Para los campos, por lo general son constantes (como los tipos de automóviles, es decir, algo donde tienes un conjunto limitado que no cambia con frecuencia).

Para resolver su problema, necesita crear una instancia de una instancia (crear un objeto) de su clase para que el tiempo de ejecución pueda reservar memoria para la instancia (de lo contrario, diferentes instancias se sobrescribirían entre sí, lo que no desea).

En tu caso, prueba este código como bloque de inicio:

public static void main (String[] args)
{
    try
    {
        MyProgram7 obj = new MyProgram7 ();
        obj.run (args);
    }
    catch (Exception e)
    {
        e.printStackTrace ();
    }
}

// instance variables here

public void run (String[] args) throws Exception
{
    // put your code here
}

El nuevo método main() crea una instancia de la clase que contiene (suena extraño, pero dado que main() se crea con la clase en lugar de con la instancia, puede hacerlo) y luego llama a un método de instancia ( run() ).

Answer 4

Es responsable de ClassLoader cargar los archivos de clase. Vamos a ver qué sucede cuando escribimos nuestras propias clases.

Ejemplo 1:

class StaticTest {

      static int a;
      int b;
      int c;
}

Ahora podemos ver que la clase "StaticTest" tiene 3 campos. Pero en realidad no existe una variable miembro de b, c. ¿Pero por qué? OK para que veamos. Aquí b, c son variables de instancia. Desde que la variable de instancia obtiene la memoria en el momento de la creación del objeto. Así que aquí b, c no están recibiendo ningún recuerdo todavía. Por eso no hay existencia de b, c. Así que solo existe la existencia de un. Para ClassLoader solo tiene una información sobre a. ClassLoader aún no reconoce b, c porque su objeto aún no ha sido instanciado.

Veamos otro ejemplo: Ejemplo 2:

class StaticTest {

      public void display() {
          System.out.println("Static Test");
      }


      public static void main(String []cmd) {

             display();       
      }

}

Ahora si tratamos de compilar este compilador de código le daremos un error de CE. CE: no se puede hacer referencia a la visualización del método no estático desde un contexto estático.

Ahora para ClassLoader parece:

class StaticTest {

      public static void main(String []cmd) {

             display();       
      }

}

En el Ejemplo 2, el error CE se debe a que llamamos método no estático desde un contexto estático. Por lo tanto, no es posible que ClassLoader reconozca la visualización del método () en tiempo de compilación. Por lo tanto, se produjo un error de tiempo de compilación.

Answer 5

Este es un poco difícil de explicar acerca de la palabra clave estática para todos los principiantes.
Lo aprenderás claramente cuando trabajes más con Clases y Objetos.

| * | Estático: los elementos estáticos se pueden llamar con Nombre de clase
Si observa en los códigos, algunas funciones se llaman directamente con nombres de clase como

NamCls.NamFnc();

System.out.println();

Esto se debe a que NamFnc e println se declararán usando la palabra clave static antes que ellos.

| * | No estático: los elementos no estáticos se pueden llamar con Variable de clase
Si no es estático, necesita una variable de la clase,
poner el punto después de la variable de clase y
luego llamar a la función.

NamCls NamObjVar = new NamCls(); NamObjVar.NamFnc(); A continuación el código te explica claramente

| * | Función estática y no estática en la clase:

public class NamCls { public static void main(String[] args) { PlsPrnFnc("Tst Txt"); NamCls NamObjVar = new NamCls(); NamObjVar.PrnFnc("Tst Txt"); } static void PlsPrnFnc(String SrgPsgVal) { System.out.println(SrgPsgVal); } void PrnFnc(String SrgPsgVal) { System.out.println(SrgPsgVal); } } | * | Clase estática y no estática dentro de una clase:

public class NamCls
{
    public static void main(String[] args)
    {
        NamTicCls NamTicVaj = new NamTicCls();
        NamTicVaj.PrnFnc("Tst Txt");

        NamCls NamObjVar = new NamCls();
        NamNicCls NamNicVar = NamObjVar.new NamNicCls();
        NamNicVar.PrnFnc("Tst Txt");
    }

    static class NamTicCls
    {
        void PrnFnc(String SrgPsgVal)
        {
            System.out.println(SrgPsgVal);
        }
    }

    class NamNicCls
    {
        void PrnFnc(String SrgPsgVal)
        {
            System.out.println(SrgPsgVal);
        }
    }
}

Answer 6

Intentaré explicarte lo estático. En primer lugar, las variables estáticas no pertenecen a ninguna instancia particular de la clase. Se reconocen con el nombre de la clase. Los métodos estáticos nuevamente no pertenecen de nuevo a ninguna instancia en particular. Solo pueden acceder a variables estáticas. Imagina que llamas MyClass.myMethod () y myMethod es un método estático. Si usa variables no estáticas dentro del método, ¿cómo diablos en la tierra sabría qué variables usar? Es por eso que puedes usar desde métodos estáticos solo variables estáticas. Repito una vez más que no pertenecen a ningún caso en particular.

Answer 7

La palabra clave static modifica el ciclo de vida de un método o variable dentro de una clase. Se crea un método o variable static en el momento en que se carga una clase. Un método o variable que no se declara como static se crea solo cuando la clase se crea una instancia como un objeto, por ejemplo, mediante el uso del new operador.

El ciclo de vida de una clase, en términos generales, es:

1. el código fuente de la clase se escribe creando una plantilla o patrón o sello que luego se puede usar para
2. cree un objeto con el new operador utilizando la clase para crear una instancia de la clase como un objeto real y luego cuando termine con el objeto
3. destruye el objeto reclamando los recursos que tiene, como la memoria durante la recolección de basura.

Para tener un punto de entrada inicial para una aplicación, Java ha adoptado la convención de que el programa Java debe tener una clase que contenga un método con un nombre acordado o especial. Este método especial se llama main() . Dado que el método debe existir ya sea que la clase que contiene el método principal haya sido instanciada o no, el método main() debe ser declarado con el modificador static para que tan pronto como se cargue la clase, el método main() esté disponible.

El resultado es que cuando inicia su aplicación Java mediante una línea de comandos como java helloworld , suceden una serie de acciones. En primer lugar, se inicia y se inicializa una máquina virtual Java. A continuación, el archivo helloworld.class que contiene el código Java compilado se carga en la Máquina Virtual de Java. Luego, la máquina virtual de Java busca un método en la clase helloworld que se llama main(String [] args) . este método debe ser static para que exista aunque la clase no haya sido instanciada como un objeto. La máquina virtual de Java no crea una instancia de la clase creando un objeto de la clase. Simplemente carga la clase e inicia la ejecución en el método main() .

Por lo tanto, debe crear una instancia de su clase como un objeto y luego puede acceder a los métodos y variables de la clase que no se han declarado con el modificador static . Una vez que su programa Java haya comenzado con la función main() , puede usar cualquier variable o método que tenga el modificador de static ya que existen como parte de la clase que se está cargando.

Sin embargo, las variables y los métodos de la clase que están fuera del método main() que no tienen el modificador static no se pueden usar hasta que una instancia de la clase se haya creado como un objeto dentro del método main() . Después de crear el objeto, puede utilizar las variables y los métodos del objeto. El compilador de Java captura un intento de usar las variables y los métodos de la clase que no tienen el modificador static sin pasar por un objeto de la clase en el momento de la compilación y se marca como un error.

import java.io.*;

class helloworld {
    int myInt;      // this is a class variable that is unique to each object
    static int myInt2;  // this is a class variable shared by all objects of this class

    static void main (String [] args) {
        // this is the main entry point for this Java application
        System.out.println ("Hello, World/n");
        myInt2 = 14;    // able to access the static int
        helloworld myWorld = new helloworld();
        myWorld.myInt = 32;   // able to access non-static through an object
    }
}

Answer 8

Lo más básico es que las variables estáticas o los métodos estáticos están a nivel de clase. Las variables o métodos de nivel de clase se cargan antes de los métodos o variables de nivel de instancia. Y, obviamente, la cosa que no está cargada no se puede usar. Así que el compilador Java no permite que las cosas que se manejan en el tiempo de ejecución se resuelvan en el momento de la compilación Es por eso que le está dando error, las cosas no estáticas no pueden ser referidas desde el contexto estático Solo necesita leer sobre el alcance de nivel de clase, el alcance de nivel de instancia y el alcance local.

Answer 9

Los campos y métodos estáticos están conectados a la clase en sí y no a sus instancias. Si tiene una clase A , un método ''normal'' b y un método estático c , y crea una instancia de su clase A , las llamadas a Ac() y ab() son válidas. El método c() no tiene idea de qué instancia está conectada, por lo que no puede usar campos no estáticos.

La solución para usted es que haga que sus campos sean estáticos o sus métodos no estáticos. Usted principal podría verse así entonces:

class Programm {
  public static void main(String[] args){
    Programm programm = new Programm();
    programm.start();
  }
  public void start(){
    // can now access non-static fields
  }
}

Answer 10

Para poder acceder a ellos desde sus métodos estáticos, deben ser variables miembro estáticas, como esta:

public class MyProgram7 {
  static Scanner scan = new Scanner(System.in);
  static int compareCount = 0;
  static int low = 0;
  static int high = 0;
  static int mid = 0;  
  static int key = 0;  
  static Scanner temp;  
  static int[]list;  
  static String menu, outputString;  
  static int option = 1;  
  static boolean found = false;

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

Answer 11

Primero analicemos su programa ... En su programa, su primer método es main() , y tenga en cuenta que es el método estático ... Luego declara la variable local para ese método (compareCount, low, high, etc. .). El alcance de esta variable es solo el método declarado, independientemente de que sea un método estático o no estático. Así que no puedes usar esas variables fuera de ese método. Este es el error básico que cometiste.

Luego llegamos al siguiente punto. Dijiste que la estática te está matando. (¡Puede que te esté matando, pero solo le da vida a tu programa!) Primero debes entender lo básico. * El método estático solo llama al método estático y usa solo la variable estática. * La variable estática o el método estático no dependen de ninguna instancia de esa clase. (es decir, si cambia cualquier estado de la variable estática, se reflejará en todos los objetos de la clase) * Por este motivo, la denomina como una variable de clase o un método de clase. Y mucho más hay sobre la palabra clave "estática". Espero que ahora tengas la idea. Primero, cambie el alcance de la variable y declare como estático (para poder usarlo en métodos estáticos).

Y el consejo para usted es: usted malinterpretó la idea del alcance de las variables y las funcionalidades estáticas. Obtener una idea clara sobre eso.

Answer 12

Prueba esto..

public class StaticTest {

    private int count=0;
    public static void main(String args[]) throws IOException {
        StaticTest test = new StaticTest(); //accessing static variable by creating an instance of class
        System.out.println(test.count);
    }       
}

Espero que te ayude ..!

Answer 13

class MyProgram
{
  int count = 0; // non-static variable / instance variable
  public static void main (String[] args) // static method
  {
    MyProgram c = new MyProgram(); // create c as reference variable
    System.out.println(c.count); // call non-static variable using a reference variable name (c)
  }
}

Los compiladores piensan "No sé de qué variable intance del objeto estás hablando".

Java Online

body, html, iframe { 
  width: 100% ;
  height: 100% ;
  overflow: hidden ;
}

<iframe src="https://ideone.com/SIDcv1" ></iframe>

Answer 14

• Lo primero es saber la diferencia entre una instancia de una clase y la clase en sí. Una clase modela ciertas propiedades y el comportamiento del conjunto en el contexto de esas propiedades. Una instancia definirá valores específicos para esas propiedades.

• Cualquier cosa vinculada a la palabra clave estática está disponible en el contexto de la clase en lugar de en el contexto de una instancia de la clase

• Como corolario de lo anterior.

  1. Las variables dentro de un método no pueden ser estáticas.
  2. los campos estáticos y los métodos deben invocarse utilizando el nombre de clase, por ejemplo, MyProgram7.main (...)

• La vida útil de un campo / método estático es equivalente a la vida útil de su aplicación

Por ejemplo, digamos que el automóvil tiene el color de la propiedad y muestra el comportamiento "movimiento". Una instancia del automóvil sería un Red Volkswagen Beetle en movimiento a 25 km / h.

Ahora, una propiedad estática del automóvil sería el número de ruedas (4) en la carretera, y esto se aplicaría a todos los automóviles.

HTH