Variable no estática no puede ser referenciada desde un contexto estático

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 logro que mis métodos reconozcan las variables de mi clase?

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 comparas lo que ves con el “automóvil” de la clase . 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 ves es una instancia de la clase “automóvil” ya que tiene todas las propiedades que esperas: hay alguien conduciendo, tiene un motor, ruedas.

Entonces 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 se crea una instancia específica), la memoria se reserva para el color y se puede dar a esta instancia específica un color. Como 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 globales de ayuda (como Integer.parseInt() ). Para los campos, generalmente son constantes (como los tipos de autos, es decir, algo en donde tienes un conjunto limitado que no cambia a menudo).

Para resolver su problema, necesita instanciar 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í y no desea).

En tu caso, prueba este código como un 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 como main() se crea con la clase en lugar de con la instancia, puede hacerlo) y luego llama a un método de instancia ( run() ).

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 b “normal” y un método estático c , y convierte una instancia en a 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énticos. Usted principal podría verse así:

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

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 instancia como un objeto utilizando, por ejemplo, el 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. crea un objeto con el new operador que usa la clase para crear una instancia de la clase como un objeto real y luego cuando lo hagas con el objeto
  3. destruye el objeto que reclama los recursos que contiene, 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 progtwig 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 declararse 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 comando, 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 comstackdo de Java se carga en la máquina virtual Java. Entonces, la Máquina Virtual de Java busca un método en la clase helloworld que se llame main(String [] args) . este método debe ser static para que exista aunque la clase no se haya instanciado realmente como un objeto. La Máquina Virtual Java no crea una instancia de la clase creando un objeto de la clase. Simplemente carga la clase y comienza la ejecución en el método main() .

Entonces necesita crear una instancia de su clase como un objeto y luego puede acceder a los métodos y variables de la clase que no han sido declarados con el modificador static . Una vez que su progtwig 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, esas variables y 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 se haya creado una instancia de la clase como un objeto dentro del método main() . Después de crear el objeto, puede usar las variables y métodos del objeto. Un bash de utilizar las variables y métodos de la clase que no tienen el modificador static sin pasar por un objeto de la clase es capturado por el comstackdor de Java en tiempo de comstackción y marcado 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 } } 

Analicemos primero su progtwig. En su progtwig, su primer método es main() , y recuerde que es el método estático … Luego declara la variable local para ese método (compare Counting, bajo, alto, etc. .). El scope de esta variable es solo el método declarado, independientemente de que sea un método estático o no estático. Entonces no puedes usar esas variables fuera de ese método. Este es el error básico que cometió.

Luego llegamos al siguiente punto. Dijiste que la estática te está matando. (¡Puede matarte pero solo da vida a tu progtwig!) Primero debes comprender lo básico. * El método estático llama solo 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) * Debido a esto lo llama como una variable de clase o un método de clase. Y hay mucho más sobre la palabra clave “estática”. Espero que entiendas la idea. Primero cambie el scope de la variable y declare como estática (para poder usarla en métodos estáticos).

Y el consejo para usted es: no entendió la idea del scope de las variables y funcionalidades estáticas. Obtenga una idea clara sobre eso.

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, no se puede utilizar lo que no está cargado. Por lo tanto, el comstackdor de Java no permite que las cosas se manejen en tiempo de ejecución se resuelve en tiempo de comstackción. Es por eso que le está dando error. Las cosas no estáticas no pueden derivarse del contexto estático. Solo necesita leer acerca del scope del nivel de clase, el scope del nivel de instancia y el scope local.

Para poder acceder a ellos desde sus métodos estáticos, deben ser variables de miembros estáticos, 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 { ... 

Ahora puede 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(); } } 

Trataré de explicarte lo estático. En primer lugar, las variables estáticas no pertenecen a ninguna instancia particular de la clase. Ellos son reconocidos con el nombre de la clase. Los métodos estáticos nuevamente no pertenecen a ninguna instancia en particular. Solo pueden acceder a variables estáticas. Imagine que llama a MyClass.myMethod () y myMethod es un método estático. Si usa variables no estáticas dentro del método, ¿cómo demonios sabría qué variables usar? Es por eso que puede usar desde métodos estáticos solo variables estáticas. Repito de nuevo que NO pertenecen a ninguna instancia en particular.

  • Lo primero es saber la diferencia entre una instancia de una clase y la clase misma. Una clase modela ciertas propiedades y el comportamiento del todo 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 y no 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 p. ej. MyProgram7.main (…)
  • La vida útil de un campo / método estático es equivalente a la vida útil de su aplicación

Por ejemplo, el automóvil tiene el color de la propiedad y exhibe el comportamiento ‘movimiento’. Una instancia del automóvil sería un Escarabajo Volkswagen rojo en movimiento a 25kmph.

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

HTH

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

| * | Estático: los artículos estáticos se pueden llamar con nombre de clase
Si observa en los códigos, algunas funciones se invocan directamente con nombres de Clase como

 NamCls.NamFnc(); System.out.println(); 

Esto se debe a que NamFnc y println serán declarados usando palabras clave estáticas 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 punto después de la variable de clase y
luego llama a la función.

 NamCls NamObjVar = new NamCls(); NamObjVar.NamFnc(); 

A continuación, el código lo explica claramente

| * | Función estática y no estática en 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); } } } 

Antes de llamar a un método de instancia o variable de instancia Necesita un objeto (Instancia). Cuando se llama a la variable de instancia desde el método estático, el comstackdor no sabe a qué objeto pertenece esta variable. Porque los métodos estáticos no tienen un objeto (solo una copia siempre). Cuando llamas a una variable de instancia o métodos de instancia desde el método de instancia, se refiere a this 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 se marcan como static y las variables de instancia no tienen una palabra clave específica.

Es ClassLoader responsable de cargar los archivos de clase. Veamos 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 la variable b, c member. Pero ¿por qué ???. OK Para que lo veas. Aquí b, c son variables de instancia. Ya que la variable de instancia obtiene la memoria en el momento de la creación del objeto. Entonces aquí b, c no están teniendo ningún recuerdo todavía. Es por eso que no hay existencia de b, c. Entonces, solo existe existencia de a. Para ClassLoader, solo tiene una información sobre a. ClassLoader aún no reconoce b, c porque todavía no se ha instanciado el objeto.

Veamos otro ejemplo: Ejemplo 2:

 class StaticTest { public void display() { System.out.println("Static Test"); } public static void main(String []cmd) { display(); } } 

Ahora, si intentamos comstackr este código, el comstackdor emitirá el error CE. CE: la visualización del método no estático () no se puede referenciar desde un contexto estático.

Ahora para ClassLoader se ve así:

 class StaticTest { public static void main(String []cmd) { display(); } } 

En el ejemplo 2, el error CE se debe a que llamamos al 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 comstackción. Por lo tanto, se ha producido un error de tiempo de comstackción.

 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 comstackdores piensan “No sé de qué variable de intancia del objeto estás hablando”.

Java en línea

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

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 …!