静态方法和非静态方法Java

我知道我在做一些愚蠢的事情，但我无法弄清楚如何解决它。静态方法和非静态方法Java

问题出在private方法removeVowels特别是当使用vowels方法时。

编译器给

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


    }

来源

2011-12-24 Sobiaholic

请阅读编译错误消息。它完全描述***是什么问题。 – 2011-12-24 17:24:17

您已使用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 
    } 
}

来源

2011-12-24 17:29:43 Paul

不错！我没有这样想。我现在就试试这个。 – Sobiaholic 2011-12-24 18:05:26

已感染。描述它的好方法:) – rpax 2014-03-03 19:07:29

变化：

String vowels;

到：

static String vowels;

来源

2011-12-24 17:22:36 Makoto

woooooot！为什么我没有注意到这一点：S – Sobiaholic 2011-12-24 17:23:37

虽然这会使编译器错误消失，但这是一个非常错误的事情。您应该使用实例变量和实例数据，并为实用方法和类级数据（例如常量和缺省值）保留静态成员。 – 2011-12-24 17:26:40

我完全同意@AdamZalcman全心全意;它远远优于创建对象的实例，而不是将整个事物变为静态的。但没有迹象表明静态修饰符是作为赋值的一部分所必需的，或者不是。 – Makoto 2011-12-24 17:30:37

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

来源

2011-12-24 17:23:21

您不能从静态上下文中引用实例变量。您必须首先创建RecursionHW2的实例，或者使变量vowels静态更合理。或者您可以考虑从removeVowels方法中删除静态修饰符。

更新：
但是，您的类看起来像一堆的实用方法，所以你可能要使它非实例化（通过添加一个私有构造函数），让所有的方法静态的（因为他们清楚地不要在对象状态下操作）并将vowels作为removeVowels方法的附加参数。

来源

2011-12-24 17:23:22 jFrenetic

你可以使变量静态或只是保持一切非静态，这将得到解决。你需要问自己的更大问题是什么时候应该使用静态，什么时候不使用？

来源

2011-12-24 17:23:32

嗯你真的是对的。我对此很困惑。 – Sobiaholic 2011-12-24 17:26:18

如果一个方法不对任何特定对象的状态进行操作，它应该是静态的 – 2011-12-24 18:14:53

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

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

来源

2011-12-24 17:23:51

变化

String vowels;

到

static String vowels;

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

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

但是，如果你不使元音成为静态的，除非对象被实例化，否则它不存在。

来源

2011-12-24 17:23:58 Nicolas78

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

测试

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

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

来源

2011-12-24 17:39:27 Jhonathan

静态方法和非静态方法Java

回答

相关问题