Java：即使該方法稍后在類中聲明，也無法找到該方法的符號。 其余的代碼正在尋找一個類。

Question

這是一種分配，我們使用Java中的字符串來分析電話號碼。 我遇到的錯誤是在tester = invalidCharacters（c）以下； 無法編譯，因為每行經過tester = invalidCharacters（c）; 正在尋找符號或類。 在get invalidResults中，我要做的就是評估給定字符串的非字母字符，例如*，（，^，＆，％，@，＃，）等。

怎么辦：為什么會產生錯誤，什么會起作用，還有沒有使用正則表達式的簡單方法。

這是作業的鏈接： http : //cis.csuohio.edu/~hwang/teaching/cis260/assignments/assignment9.html

public class PhoneNumber {
            private int areacode;
            private int number;
            private int ext;

            /////Constructors/////
            //Third Constructor (given one string arg) "xxx-xxxxxxx" where first three are numbers and the remaining (7) are numbers or letters
            public PhoneNumber(String newNumber){
                    //Note: Set default ext to 0
                    ext=0;

                    ////Declare Temporary Storage and other variables////
                    //for the first three numbers
                    String areaCodeString;
                    //for the remaining seven characters
                    String newNumberString;
                    //For use in testing the second half of the string
                    boolean containsLetters;
                    boolean containsInvalid;

                    /////Separate the two parts of string/////
                    //Get the area code part of the string
                    areaCodeString=newNumber.substring(0,2);
                    //Convert the string and set it to the area code
                    areacode=Integer.parseInt(areaCodeString);

                    //Skip the "-" and Get the remaining part of the string
                    newNumberString=newNumber.substring(4);

                    //Create an array of characters from newNumberString to reuse in later methods for
                    int length=newNumberString.length();
                    char [] myCharacters= new char [length];
                    int i;
                    for (i=0;i<length;i++){
                        myCharacters [i]=newNumberString.charAt(i);
                    }

                    //Test if newNumberString contains letters & converting them into numbers
                    String reNewNumber="";
                    //Test for invalid characters
                    containsInvalid=getInvalidResults(newNumberString,length);
                    if (containsInvalid==false){
                        containsLetters=getCharResults(newNumberString,length);
                        if (containsLetters==true){
                            for (i=0;i<length;i++){
                            myCharacters [i]=(char)convertLetNum((myCharacters [i]));
                            reNewNumber=reNewNumber+myCharacters[i];
                            }
                        }
                    }
                    if (containsInvalid==false){
                    number=Integer.parseInt(reNewNumber);
                    }
                    else{
                        System.out.println("Error!"+"\t"+newNumber+" contains illegal characters. This number will be ignored and skipped.");
                    }
            }

            //////Primary Methods/Behaviors///////
            //Compare this phone number with the one passed by the caller
            public boolean equals(PhoneNumber pn){
                boolean equal;
                String concat=(areacode+"-"+number);
                String pN=pn.toString();
                if (concat==pN){
                    equal=true;
                }
                else{
                    equal=false;
                }
                return equal;
            }
            //Convert the stored number to a certain string depending on extension
            public String toString(){
                String returned;
                if(ext==0){
                    returned=(areacode+"-"+number);
                }
                else{
                    returned=(areacode+"-"+number+" ext "+ext);
                }
                return returned;
            }

            //////Secondary Methods///////
            //Method for testing if the second part of the string contains any letters
            public static boolean getCharResults(String newNumString,int getLength){
                //Recreate a character array
                int i;
                char [] myCharacters= new char [getLength];
                for (i=0;i<getLength;i++){
                    myCharacters [i]=newNumString.charAt(i);
                }
                boolean doesContainLetter=false;
                int j;
                for (j=0;j<getLength;j++){
                if ((Character.isDigit(myCharacters[j])==true)){
                    doesContainLetter=false;
                }
                else{
                    doesContainLetter=true;
                    return doesContainLetter;
                }
                }
                return doesContainLetter;
            }
            //Method for testing if the second part of the string contains any letters
            public static boolean getInvalidResults(String newNumString,int getLength){
                boolean doesContainInvalid=false;
                int i;
                char c;
                boolean tester;
                char [] invalidCharacters= new char [getLength];
                for (i=0;i<getLength;i++){
                    invalidCharacters [i]=newNumString.charAt(i);
                    c=invalidCharacters [i];
                    tester=invalidCharacters(c);
                    if(tester==true)){
                        doesContainInvalid=false;
                    }
                    else{
                        doesContainInvalid=true;
                        return doesContainInvalid;
                    }
                }
                    return doesContainInvalid;
            }

            //Method for evaluating string for invalid characters
            public boolean invalidCharacters(char letter){
                boolean returnNum=false;
                    switch (letter){
                        case 'A': return returnNum;
                        case 'B': return returnNum;
                        case 'C': return returnNum;
                        case 'D': return returnNum;
                        case 'E': return returnNum;
                        case 'F': return returnNum;
                        case 'G': return returnNum;
                        case 'H': return returnNum;
                        case 'I': return returnNum;
                        case 'J': return returnNum;
                        case 'K': return returnNum;
                        case 'L': return returnNum;
                        case 'M': return returnNum;
                        case 'N': return returnNum;
                        case 'O': return returnNum;
                        case 'P': return returnNum;
                        case 'Q': return returnNum;
                        case 'R': return returnNum;
                        case 'S': return returnNum;
                        case 'T': return returnNum;
                        case 'U': return returnNum;
                        case 'V': return returnNum;
                        case 'W': return returnNum;
                        case 'X': return returnNum;
                        case 'Y': return returnNum;
                        case 'Z': return returnNum;
                        default: return true;
                    }

            }
            //Method for converting letters to numbers
            public int convertLetNum(char letter){
                int returnNum;
                    switch (letter){
                        case 'A': returnNum=2;return returnNum;
                        case 'B': returnNum=2;return returnNum;
                        case 'C': returnNum=2;return returnNum;
                        case 'D': returnNum=3;return returnNum;
                        case 'E': returnNum=3;return returnNum;
                        case 'F': returnNum=3;return returnNum;
                        case 'G': returnNum=4;return returnNum;
                        case 'H': returnNum=4;return returnNum;
                        case 'I': returnNum=4;return returnNum;
                        case 'J': returnNum=5;return returnNum;
                        case 'K': returnNum=5;return returnNum;
                        case 'L': returnNum=5;return returnNum;
                        case 'M': returnNum=6;return returnNum;
                        case 'N': returnNum=6;return returnNum;
                        case 'O': returnNum=6;return returnNum;
                        case 'P': returnNum=7;return returnNum;
                        case 'Q': returnNum=7;return returnNum;
                        case 'R': returnNum=7;return returnNum;
                        case 'S': returnNum=7;return returnNum;
                        case 'T': returnNum=8;return returnNum;
                        case 'U': returnNum=8;return returnNum;
                        case 'V': returnNum=8;return returnNum;
                        case 'W': returnNum=9;return returnNum;
                        case 'X': returnNum=9;return returnNum;
                        case 'Y': returnNum=9;return returnNum;
                        case 'Z': returnNum=9;return returnNum;
                        default: return 0;
                    }

        }
    }

注意：請不要使用該程序在自己的課堂上作弊。 為確保這一點，如果在2013年底之前仍未回答該問題，或者不再需要解釋，或者該課程的學期結束，我將把這個問題記下來。

Answer 1

getInvalidResults是一個靜態方法，試圖調用非靜態invalidCharacters方法。 這是不允許的，因為非靜態方法需要類的實例。 在這種情況下， invalidCharacters應該是靜態的。

Answer 2

實際上，此過程比看起來容易得多。 關鍵是使用構造函數，getCharResults（）方法和switch語句對我有利。

對於構造函數，在reNewNumber聲明之下的任何內容都應為以下內容：

int i;
containsLetters=getCharResults(newNumberString,length);
if (containsLetters==true){
    for (i=0;i<length;i++){
        //Resets area code to 0 if a character is invalid (aka !@#$%^&* and so on)
        if((Character.isLetterOrDigit(myCharacters [i]))==false){
            areacode=0;
        }
        //Converts every character to a number (stored as a character)
        myCharacters [i]=convertLetNum((myCharacters [i]));
        //Recreates the string in all-number format
        reNewNumber=reNewNumber+myCharacters[i];
            }
    }
    number=Integer.parseInt(reNewNumber);
}

並且getCharResults（）方法應擴展為：

public static boolean getCharResults(String newNumString,int getLength){
        //Recreate a character array
        char [] myCharacters=newNumString.toCharArray();
        boolean doesContainLetter=false;
        int j;
        for (j=0;j<getLength;j++){
            //Tests if character is a digit
            if ((Character.isDigit(myCharacters[j])==true)){
                doesContainLetter=false;
            }
            //Tests if character is an illegal character and prints out the required error message
            else if((Character.isLetterOrDigit(myCharacters[j])==false)){
                System.out.println("Error!"+"\t"+newNumString+" contains illegal characters. Any invalid character will be set to zero.");
                doesContainLetter=true;
                return doesContainLetter;
            }
            //Test if the character is a letter
            else{
                doesContainLetter=true;
                return doesContainLetter;
            }
        }
        return doesContainLetter;
}

最后，convertLetNum（）方法應為：

public char convertLetNum(char letter){
        char returnNum;

其中returnNum返回一個數字作為char類型 。

此外，我們添加了大小寫來測試並返回已經是數字的字符，如下所示：

                case '0': returnNum='0';return returnNum;
                case '1': returnNum='1';return returnNum;
                case '2': returnNum='2';return returnNum;
                case '3': returnNum='3';return returnNum;
                case '4': returnNum='4';return returnNum;
                case '5': returnNum='5';return returnNum;
                case '6': returnNum='6';return returnNum;
                case '7': returnNum='7';return returnNum;
                case '8': returnNum='8';return returnNum;
                case '9': returnNum='9';return returnNum;

請注意，不需要returnNum，但是需要使用“＃”。

任何其他代碼都是多余且不必要的。 如果在構造函數中正確設置，則生成的代碼將完美無缺。