нестатическая переменная ma не может быть указана из статического контекста Android Studio [duplicate]

Вы должны понимать разницу между классом и экземпляром этого класса. Если вы видите машину на улице, вы сразу же знаете, что это автомобиль, даже если вы не можете видеть, какую модель или тип. Это связано с тем, что вы сравниваете то, что видите с классом «автомобиль». Класс содержит то, что похоже на все автомобили. Подумайте об этом как о шаблоне или идее.

В то же время автомобиль, который вы видите, является экземпляром класса «автомобиль», поскольку он обладает всеми свойствами, которые вы ожидаете: есть кто-то за рулем , у него есть двигатель, колеса.

Итак, класс говорит, что «все автомобили имеют цвет», и экземпляр говорит, что «этот конкретный автомобиль красный».

В мире OO, вы определяете класс и внутри класса, вы определяете поле типа Color. Когда экземпляр класса создается (когда вы создаете конкретный экземпляр), память зарезервирована для цвета, и вы можете присвоить этому конкретному экземпляру цвет. Поскольку эти атрибуты специфичны, они нестатические.

Статические поля и методы совместно используются для всех экземпляров. Они предназначены для значений, которые относятся к классу, а не к конкретному экземпляру. Для методов это обычно глобальные вспомогательные методы (например, Integer.parseInt()).

Чтобы решить вашу проблему, вам необходимо создать экземпляр экземпляра (создать объект) вашего класса, чтобы среда выполнения могла зарезервировать память для экземпляра (в противном случае разные экземпляры переписывали бы друг друга, чего вы не хотите).

В вашем случае попробуйте этот код как начальный блок:

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
}

Новый main() метод создает экземпляр класса, который он содержит (звучит странно, но поскольку main() создается с классом вместо экземпляра, он может это сделать), а затем вызывает метод экземпляра (run()).

Самая простая вещь - статические переменные или статические методы находятся на уровне класса. Переменные или методы уровня класса загружаются до методов или переменных уровня экземпляра. И, очевидно, вещь, которая не загружена, не может быть использована. Поэтому java-компилятор, не позволяющий обрабатывать вещи во время выполнения, решает во время компиляции. Вот почему он дает вам ошибку, не статические вещи не могут быть переданы из статического контекста. Вам просто нужно ознакомиться с областью уровня класса, областью уровня экземпляра и локальной областью.

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

Компиляторы думают: «Я не знаю, какой объект является переменной экземпляра, о которой вы говорите».

Java Online

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

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

• Прежде всего, нужно знать разницу между экземпляром класса и самим классом. Класс моделирует определенные свойства и поведение целого в контексте этих свойств. Экземпляр определит конкретные значения этих свойств.
• Все, связанное с ключевым словом static, доступно в контексте класса, а не в контексте экземпляра класса
• As следствием вышеперечисленных переменных внутри метода не может быть статическое статическое поле, и методы должны быть вызваны с использованием имени класса, например MyProgram7.main (...)
• Время жизни статического поля / метода эквивалентно времени жизни вашего приложения

Например. Скажем, автомобиль имеет цвет свойства и демонстрирует поведение «движение». Экземпляром автомобиля будет Красный жук Volkswagen в движении на 25 км / ч.

Теперь статическим свойством автомобиля будет количество колес (4) на дороге, и это применимо ко всем автомобилям .

HTH

Статические поля и методы связаны с самим классом, а не с его экземплярами. Если у вас есть класс A, «нормальный» метод b и статический метод c, и вы создаете экземпляр a вашего класса A, вызовы A.c() и a.b() действительны. Метод c() не знает, какой экземпляр подключен, поэтому он не может использовать нестатические поля.

Решение для вас состоит в том, что вы либо статируете свои поля, либо ваши методы не статичны. Вы могли бы выглядеть так:

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

Давайте сначала проанализируем вашу программу. В вашей программе ваш первый метод main(), и помните, что это статический метод ... Затем вы объявляете локальную переменную для этого метода (compareCount, low, high , и т.д..). Область действия этой переменной - это только объявленный метод, независимо от того, что это статический или нестационарный метод. Таким образом, вы не можете использовать эти переменные вне этого метода. Это основная ошибка u.

Затем мы переходим к следующей точке. Вы сказали, что статичность убивает вас. (Это может убить вас, но это дает жизнь вашей программе!) Сначала вы должны понять основную вещь. * Статический метод вызывает только статический метод и использует только статическую переменную. * Статическая переменная или статический метод не зависят от какого-либо экземпляра этого класса. (т. е. если вы измените какое-либо состояние статической переменной, оно будет отражено во всех объектах класса). Из-за этого вы называете это переменной класса или методом класса. И многое другое о «статическом» ключевом слове. Надеюсь, теперь у вас есть идея. Сначала измените область действия переменной и объявите ее как статическую (чтобы использовать ее в статических методах).

И совет для вас: вы неправильно поняли идею сферы переменных и статические функции. Получите ясное представление об этом.

Ответственность за загрузку файлов класса несет ClassLoader. Давайте посмотрим, что произойдет, когда мы напишем наши собственные классы.

Пример 1:

class StaticTest {

      static int a;
      int b;
      int c;
}

Теперь мы можем видеть, что класс «StaticTest» имеет 3 поля. Но на самом деле нет существования переменной b, c. Но почему ???. Ладно, посмотрим. Здесь b, c - переменная экземпляра. Поскольку переменная экземпляра получает память во время создания объекта. Итак, здесь b, c пока не получают никакой памяти. Вот почему не существует b, c. Итак, существует только существование a. Для ClassLoader у него есть только одна информация о. ClassLoader еще не распознает b, c, потому что объект еще не создан.

Давайте посмотрим другой пример: Пример 2:

class StaticTest {

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


      public static void main(String []cmd) {

             display();       
      }

}

Теперь, если мы попытаемся скомпилировать этот код, компилятор даст Ошибка CE. CE: отображение нестатического метода () не может ссылаться на статический контекст.

Теперь для ClassLoader это выглядит так:

class StaticTest {

      public static void main(String []cmd) {

             display();       
      }

}

В примере 2 Ошибка CE - это потому, что мы вызываем нестационарный метод из статического контекста. Таким образом, ClassLoader не может распознавать метод display () во время компиляции. Так возникает ошибка компиляции.

Чтобы иметь доступ к ним из ваших статических методов, они должны быть статическими переменными-членами, например:

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

Я попытаюсь объяснить вам статическую вещь. Прежде всего статические переменные не принадлежат ни одному конкретному экземпляру класса. Они распознаются с именем класса. Статические методы снова не относятся к какому-либо конкретному экземпляру. Они могут получить доступ только к статическим переменным. Представьте, что вы вызываете MyClass.myMethod (), а myMethod - это статический метод. Если вы используете нестатические переменные внутри метода, как, черт возьми, он знает, какие переменные использовать? Вот почему вы можете использовать из статических методов только статические переменные. Повторяю, они НЕ принадлежат ни одному конкретному экземпляру.

Ключевое слово static изменяет жизненный цикл метода или переменной внутри класса. Метод / переменная static создается во время загрузки класса. Метод или переменная, которая не объявлена ​​как static, создается только тогда, когда класс создается как объект, например, с помощью оператора new.

Жизненный цикл класса в широком смысле, is:

1. записывается исходный код для класса, создающий шаблон или шаблон или штамп, которые затем могут использоваться для
2. создать объект с помощью оператора new, используя класс, чтобы сделать экземпляр класса как фактического объекта, а затем, когда он сделан с объектом
3. , уничтожает объект, восстанавливающий ресурсы, которые он держит, например, память во время сбора мусора.

Чтобы иметь начальную точку входа для приложения, Java приняла соглашение о том, что программа Java должна иметь класс, который содержит метод с согласованным или специальным именем. Этот специальный метод называется main(). Поскольку метод должен существовать независимо от того, был ли экземпляр класса, содержащего основной метод, метод main() должен быть объявлен с помощью модификатора static, так что, как только класс будет загружен, доступен метод main().

В результате, когда вы запускаете приложение Java с помощью командной строки, например java helloworld, происходит серия действий. Прежде всего запускается и инициализируется виртуальная машина Java. Затем файл helloworld.class, содержащий скомпилированный Java-код, загружается в виртуальную машину Java. Затем виртуальная машина Java ищет метод в классе helloworld, который называется main(String [] args). этот метод должен быть static, так что он будет существовать, даже если класс фактически не был создан как объект. Виртуальная машина Java не создает экземпляр класса, создавая объект из класса. Он просто загружает класс и запускает выполнение по методу main().

Итак, вам нужно создать экземпляр вашего класса в качестве объекта, а затем вы можете получить доступ к методам и переменным класса, у которых нет был объявлен с помощью модификатора static. После того, как ваша Java-программа началась с функции main(), вы можете использовать любые переменные или методы, которые имеют модификатор static, поскольку они существуют как часть загружаемого класса.

Однако эти переменные и методы класса, которые находятся вне метода main(), которые не имеют модификатора static, не могут использоваться до тех пор, пока экземпляр класса не будет создан как объект в рамках метода main(). После создания объекта вы можете использовать переменные и методы объекта. Попытка использовать переменные и методы класса, которые не имеют модификатора static, не проходя через объект класса, улавливается компилятором Java во время компиляции и помечена как ошибка.

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

Это бит-бит, чтобы объяснить статическое ключевое слово для всех новичков. Вы узнаете это, когда будете работать больше с Классами и Объектами.

| * | Static: Статические элементы могут быть вызваны с именем класса. Если вы наблюдаете в кодах, некоторые функции вызываются непосредственно с именами классов, такими как

NamCls.NamFnc();

System.out.println();

. Это потому, что NamFnc и println будут объявленный с использованием ключевого слова static перед ними.

| * | Non Static: Нестатические элементы могут быть вызваны с помощью переменной класса. Если ее не статично, вам нужна переменная класса, поместите точку после переменной класса и затем вызовите функцию.

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

Ниже код объясняет вам аккуратно

| * | Статическая и нестатическая функция в классе:

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

| * | Статический и нестатический класс внутри класса:

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

Перед вызовом метода экземпляра или переменной экземпляра ему нужен объект (экземпляр). Когда экземпляр переменной вызывается из статического метода, компилятор не знает, к какому объекту принадлежит эта переменная. Поскольку статические методы не имеют объекта (только одна копия всегда). Когда вы вызываете переменную экземпляра или методы экземпляра из метода экземпляра, она ссылается на объект this. Это означает, что переменная принадлежит к любому объекту, созданному, и каждый объект имеет свою собственную копию методов и переменных экземпляра.

Статические переменные отмечены как static, а переменные экземпляра не имеют определенного ключевого слова.

Теперь вы можете добавлять / использовать экземпляры с помощью метода

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