静态方法和非静态方法Java

Question

我知道我在做一些愚蠢的事情，但是我不知道该如何解决。

使用vowels方法时，问题出在private方法removeVowels内部。

编译器给出

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

这是我的代码：

   public class RecursionHW2 {

            String vowels;

            // Part (A) First way
            public static int upperCase(String myString){

                return upperCaseChecker(myString , 0 );
            }

            public static int upperCaseChecker(String myString, int index){

                int inc;

                //My Base Code
                if(myString.length() <= index) return 0;
                if(Character.isUpperCase(myString.charAt(index)) == true) inc= 1;
                    else inc= 0;

                return inc+upperCaseChecker(myString,index+1);
            }



            // First way of Solving part (B)
            public static int count(String str, char a)
            {
                if (str.length() == 0)
                    return 0;
                else if (str.charAt(0) == a)
                    return 1 + count(str.substring(1, str.length()), a);
                else
                    return count(str.substring(1, str.length()), a);
            }


            //Second way of solving part (B)
            public static int anotherCount(String myString, char myWord)
            {
                return anotherCount(myString, myWord, 0);
            }

            public static int anotherCount(String myString, char myWord, int index)
            {
                int inc;

                if (index >= myString.length())
                {
                    return 0;
                }

                if (myString.charAt(index) == myWord)  inc =1;
                    else
                        inc = 0;

                return inc + anotherCount(myString, myWord, index+1);
            }



            // part (C) solving
            public Boolean isSorted(int[] a, int n)
            {
            if(n == 0 || n == 1) return true;
            else
            return isSorted(a, n, 1);
            }

            private Boolean isSorted(int[] a, int n, int cur)
            {
                if(cur == n) return true;

                if(a[cur - 1] <= a[cur])
                    return isSorted(a, n, cur+1);
                else
                    return false;
            }



            //part (D) Solving
            public static String removeVowels(String myString)
            {
                return removeVowels(myString, "");
            }

            private static String removeVowels(String myString, String t)
            {
                if(myString.length() == 0) return t;

                if(vowels.contains(myString.charAt(0) + ""))
                    return removeVowels(myString.substring(1), t);
                else
                    return removeVowels(myString.substring(1), t + myString.charAt(0));
            }


        public static void main(String[] args){


            //I've wrote 2 ways to solve the Second Recursive Q2
            System.out.println("Method 1: Number of Occurence " + count("Hello  This is Mohammad Fadin",'o'));
        //  System.out.println("Method 2: Number of Occurence "+ anotherCount("Hello This is Mohammad Fadin",'o'));

            String s1 = "Hello WorlDD";
            System.out.println("Number of Upper Cases " + upperCase(s1));

            String s2 = "Hello";
            System.out.println("After Vowels Removed " + removeVowels(s2));
        }


    }

Answer 1

您已经通过main方法中的static “感染”了您的代码。 在您的main方法中，您应该执行以下操作，因此不必使所有内容都保持static ：

public class RecursionHW2
{
  public static void main(String[] args)
  {
    RecursionHW2 rhw2 = new RecursionHW2();

    int count = rhw2.count("Hello world");

    // and so on
  }
}

Answer 2

您不能从静态上下文引用实例变量。 您必须先创建RecursionHW2的实例，或者将变量vowels设为静态 ，这才有意义。 或者，您可以考虑从removeVowels方法中删除静态修饰符。

更新：
但是，您的类看起来像一堆实用程序方法，因此您可能希望使其不可实例化（通过添加私有构造函数），将所有方法设为静态（因为它们显然不对对象的状态进行操作）并传递vowels作为removeVowels方法的附加参数。

Answer 3

问题恰恰是编译器告诉您的：您是从静态上下文引用非静态（实例） vowels 。 实际上，几乎所有方法都是静态的，这是一个非常糟糕的设计。

使所有需要访问实例数据的方法（此处为： vowels实例变量）都是非静态的，并在main()实例化您的类。

Answer 4

更改：

String vowels;

至：

static String vowels;

Answer 5

您不能在静态方法中使用String元音，因为元音是非静态的。 您需要在字符串中添加static关键字，然后代码才能工作。

Answer 6

您可以将变量设为静态，也可以仅使所有内容保持非静态，这将得到解决。 您需要问自己的一个更大的问题是，什么时候应该使用static，什么时候不使用static？

Answer 7

更改

String vowels;

至

static String vowels;

您的所有方法都是静态的，因此不需要存在对象的实例-即，您不必说

x = new RecursionHW2(); 
x.upperCase(..);

但是，如果不将元音设为静态，则除非实例化对象，否则它不存在。

Answer 8

静态变量属于类，而静态变量不属于类实例（对象）。

测试

class Foo {

    private static String vowers;
    private String bar;

}


Foo a = new Foo ()

正在创建类Foo的新实例，每个实例都有其自己的变量栏，但是所有共享vowers变量都属于该类。 静态方法也是如此。

在静态方法（类方法）中，您不能引用非静态变量。 为什么会这样呢？

想象一下，从静态方法中引用的变量不是静态的

class Foo {
    private static String vowers;
    private String bar;

    public static void exampleMethod () {
       bar = "home";
    }

}

如果您这样做：

Foo a = new Foo () / / has a new bar
Foo b = new Foo () / / has a new bar

vowers是一个变量，属于类而不是实例

当你

Foo.exampleMethod()

如果实例a的变量或b的变量实例，则该方法不知道使用变量bar 。 因此，您只能从静态方法访问该类的静态变量