Variável não-estática não pode ser referenciada a partir de um contexto estático

Eu escrevi este código de teste:

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

Mas dá o seguinte erro:

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

Como obtenho meus methods para reconhecer minhas variables ​​de class?

Você deve entender a diferença entre uma class e uma instância dessa class. Se você vir um carro na rua, sabe imediatamente que é um carro, mesmo que não consiga ver qual modelo ou tipo. Isso porque você compara o que vê com a class “carro”. A class contém o que é semelhante a todos os carros. Pense nisso como um modelo ou uma ideia.

Ao mesmo tempo, o carro que você vê é uma instância da class “carro”, já que tem todas as propriedades que você espera: há alguém dirigindo, tem um motor, rodas.

Então a class diz “todos os carros têm uma cor” e a instância diz “esse carro específico é vermelho”.

No mundo OO, você define a class e dentro da class, você define um campo do tipo Color . Quando a class é instanciada (quando você cria uma instância específica), a memory é reservada para a cor e você pode dar a essa instância específica uma cor. Como esses atributos são específicos, eles não são estáticos.

Campos e methods estáticos são compartilhados com todas as instâncias. Eles são para valores específicos da class e não uma instância específica. Para methods, isso geralmente são methods auxiliares globais (como Integer.parseInt() ). Para campos, geralmente são constantes (como tipos de carro, ou seja, algo em que você tem um conjunto limitado que não muda com frequência).

Para resolver seu problema, você precisa instanciar uma instância (criar um object) de sua class para que o tempo de execução possa reservar memory para a instância (caso contrário, instâncias diferentes replaceiam umas às outras que você não deseja).

No seu caso, tente este código como um bloco inicial:

 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 } 

O novo método main() cria uma instância da class que ele contém (parece estranho, mas como main() é criado com a class em vez de com a instância, ele pode fazer isso) e, em seguida, chama um método de instância ( run() ).

Campos e methods estáticos estão conectados à class em si e não a suas instâncias. Se você tiver uma class A , um método ‘normal’ b e um método estático c , e fizer uma instância da class A , as chamadas para Ac() e ab() serão válidas. O método c() não tem idéia de qual instância está conectada, portanto, não pode usar campos não estáticos.

A solução para você é que você torna seus campos estáticos ou seus methods não-estáticos. Você principal poderia se parecer com isso então:

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

A palavra-chave static modifica o ciclo de vida de um método ou variável dentro de uma class. Um método static ou variável é criado no momento em que uma class é carregada. Um método ou variável que não é declarado como static é criado apenas quando a class é instanciada como um object, por exemplo, usando o new operador.

O ciclo de vida de uma class, em termos gerais, é:

  1. o código-fonte para a class é escrito criando um modelo ou padrão ou carimbo que pode ser usado para
  2. criar um object com o new operador usando a class para fazer uma instância da class como um object real e, em seguida, quando feito com o object
  3. destrua o object recuperando os resources que ele está mantendo, como memory, durante a garbage collection.

Para ter um ponto de input inicial para um aplicativo, o Java adotou a convenção de que o programa Java deve ter uma class que contenha um método com um nome combinado ou especial. Este método especial é chamado main() . Como o método deve existir se a class que contém o método main foi instanciada ou não, o método main() deve ser declarado com o modificador static para que, assim que a class for carregada, o método main() esteja disponível.

O resultado é que, quando você inicia seu aplicativo Java por uma linha de comando, como java helloworld uma série de ações acontece. Em primeiro lugar, uma máquina virtual Java é inicializada e inicializada. Em seguida, o arquivo helloworld.class contendo o código Java compilado é carregado na Java Virtual Machine. Então o Java Virtual Machine procura por um método na class helloworld que é chamado main(String [] args) . Esse método deve ser static para que ele exista mesmo que a class não tenha sido instanciada como um object. A Java Virtual Machine não cria uma instância da class criando um object da class. Apenas carrega a class e inicia a execução no método main() .

Então você precisa criar uma instância de sua class como um object e então você pode acessar os methods e variables ​​da class que não foram declarados com o modificador static . Uma vez que seu programa Java tenha iniciado com a function main() , você pode usar quaisquer variables ​​ou methods que tenham o modificador static já que eles existem como parte da class que está sendo carregada.

No entanto, essas variables ​​e methods da class que estão fora do método main() que não possuem o modificador static não podem ser usados ​​até que uma instância da class tenha sido criada como um object dentro do método main() . Depois de criar o object, você pode usar as variables ​​e os methods do object. Uma tentativa de usar as variables ​​e os methods da class que não possuem o modificador static sem passar por um object da class é capturada pelo compilador Java em tempo de compilation e marcada como um erro.

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

Vamos analisar primeiro o seu programa. Em seu programa, seu primeiro método é main() , e tenha em mente que é o método estático … Então você declara a variável local para esse método (compareCount, low, high, etc. . O escopo dessa variável é apenas o método declarado, independentemente de ser um método estático ou não estático. Então você não pode usar essas variables ​​fora desse método. Este é o erro básico que você fez.

Então chegamos ao próximo ponto. Você disse estática está matando você. (Pode estar matando você, mas só dá vida ao seu programa!) Primeiro você deve entender o básico. * O método estático chama apenas o método estático e usa apenas a variável estática. * Variável estática ou método estático não dependem de nenhuma instância dessa class. (isto é, se você alterar qualquer estado da variável estática, ela refletirá em todos os objects da class) * Por causa disso, você a chama como variável de class ou método de class. E há muito mais sobre a palavra-chave “estática”. Espero que agora você tenha a ideia. Primeiro altere o escopo da variável e declare-a como estática (para poder usá-la em methods estáticos).

E o conselho para você é: você entendeu mal a ideia do escopo das variables ​​e das funcionalidades estáticas. Tenha uma ideia clara sobre isso.

O mais básico é que variables ​​estáticas ou methods estáticos estão no nível da class. Variáveis ​​ou methods de nível de class são carregados antes de methods ou variables ​​de nível de instância. E, obviamente, a coisa que não está carregada não pode ser usada. Portanto, o compilador java que não permite que as coisas sejam manipuladas no tempo de execução é resolvido em tempo de compilation. É por isso que está dando erro não-estático as coisas não podem ser referidas a partir do contexto estático. Você só precisa ler sobre Escopo no Nível da Classe, Escopo do Nível da Instância e Escopo Local.

Para poder acessá-los a partir de seus methods estáticos, eles precisam ser variables ​​de membros estáticos, assim:

 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 { ... 

Agora você pode adicionar / usar instâncias com no 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(); } } 

Vou tentar explicar a coisa estática para você. Em primeiro lugar, as variables ​​estáticas não pertencem a nenhuma instância específica da class. Eles são reconhecidos com o nome da class. Os methods estáticos novamente não pertencem novamente a nenhuma instância específica. Eles podem acessar apenas variables ​​estáticas. Imagine que você chama MyClass.myMethod () e myMethod é um método estático. Se você usa variables ​​não-estáticas dentro do método, como diabos ele saberia quais variables ​​usar? É por isso que você pode usar a partir de methods estáticos apenas variables ​​estáticas. Repito novamente que eles não pertencem a nenhuma instância específica.

  • A primeira coisa é saber a diferença entre uma instância de uma class e a própria class. Uma class modela certas propriedades e o comportamento do todo no contexto dessas propriedades. Uma instância definirá valores específicos para essas propriedades.

  • Qualquer coisa vinculada à palavra-chave static está disponível no contexto da class, e não no contexto de uma instância da class

  • Como corolário do acima

    1. variables ​​dentro de um método não podem ser estáticas
    2. campos estáticos e methods devem ser invocados usando o nome da class, por exemplo, MyProgram7.main (…)
  • O tempo de vida de um campo / método estático é equivalente ao tempo de vida de sua aplicação

Por exemplo, o carro tem a cor da propriedade e exibe o comportamento ‘movimento’. Um exemplo do carro seria um Fusca Vermelho em movimento a 25 km / h.

Agora, uma propriedade estática do carro seria o número de rodas (4) na estrada, e isso se aplica a todos os carros.

HTH

Isso é um pouco diferente para explicar a palavra chave estática para todos os iniciantes.
Você saberá claramente quando trabalhar mais com Classes e Objetos.

| * | Estático: itens estáticos podem ser chamados com o nome da class
Se você observar em códigos, algumas funções são chamadas diretamente com nomes de classs como

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

Isso ocorre porque NamFnc e println serão declarados usando palavras-chave estáticas antes deles.

| * | Não estático: itens não estáticos podem ser chamados com variável de class
Se não é estático, você precisa de uma variável da class,
colocar ponto após a variável de class e
então chame a function.

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

Abaixo do código explica-o com cuidado

| * | Função estática e não estática na aula:

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

| * | Classe estática e não estática dentro de uma class:

 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 chamar um método de instância ou variável de instância, ele precisa de um object (Instância). Quando a variável de instância é chamada pelo compilador de método estático, não sabe qual é o object ao qual esta variável pertence. Porque os methods estáticos não possuem um object (somente uma cópia sempre). Quando você chama uma variável de instância ou methods de instância do método da instância, ela se refere ao object this . Isso significa que a variável pertence a qualquer object criado e cada object tem sua própria cópia dos methods e variables ​​da instância.

Variáveis ​​estáticas são marcadas como static e variables ​​de instância não possuem uma palavra-chave específica.

É ClassLoader responsável por carregar os arquivos de class. Vejamos o que acontece quando escrevemos nossas próprias classs.

Exemplo 1:

 class StaticTest { static int a; int b; int c; } 

Agora podemos ver que a class “StaticTest” tem 3 campos.Mas, na verdade, não há existência de b, c membro variável.Mas por que ???. OK, para que não veja. Aqui b, c são variables ​​de instância. Como variável de instância obtém a memory no momento da criação do object. Então, aqui, b, c não estão tendo nenhuma memory ainda. É por isso que não há existência de b, c. Portanto, existe apenas a existência de um. Para o ClassLoader, ele tem apenas uma informação sobre a. ClassLoader ainda não reconhece b, c porque seu object ainda não foi instanciado.

Vamos ver outro exemplo: Exemplo 2:

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

Agora, se tentarmos compilar esse compilador de código, haverá um erro CE. CE: o método não estático display () não pode ser referenciado a partir de um contexto estático.

Agora, para o ClassLoader, parece:

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

No Exemplo 2, o erro CE é porque chamamos o método não estático de um contexto estático. Portanto, não é possível para o ClassLoader reconhecer o método display () em tempo de compilation. Portanto, ocorreu um erro de tempo de compilation.

 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) } } 

Os compiladores pensam “Eu não sei de qual variável intance do object você está falando”.

Java Online

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

Tente isso ..

 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 ajude ..!