Home / Questions / 103009
Accepted
I likeThatMeow
Asked: 2020-09-18 21:29:49 +0800 CST 2020-09-18 21:29:49 +0800 CST

Why is it that if I change the order of a `String` declaration I get an error?

  • 772

I have to do this declaration String op = tokens.next();inside the loop while , if I put it outside the loop, ie String op=null; while{...op=tokens.next();...}I get an error that says: The assigned value is never used, but it is a contradiction because I do use it inside the while.

Then on other occasions it requires that the declaration be outside the loop, such as in loops for.

public static int postfixEvaluate(String exp) {
    Stack<Integer> s = new Stack<Integer> ();
    Scanner tokens = new Scanner(exp);
    //String op =null;
    while (tokens.hasNext()) {
        if (tokens.hasNextInt()) 
            s.push(tokens.nextInt());
         else {
            int num2 = s.pop();
            int num1 = s.pop();
            String op = tokens.next();

            if (op.equals("+")) 
                s.push(num1 + num2);
            else {
                                if (op.equals("-")) 
                s.push(num1 - num2);
                                else{
                                    if (op.equals("*")) 
                s.push(num1 * num2);
            else 
                s.push(num1 / num2);



        }
    }}}
    return s.pop();

    }}
java

4 Answers

  1. Best Answer

    I. It is neither an error nor a compiler thing

    Actually it is not an error, but a warning (warning), but not from the compiler, but rather a functionality of the IDE, in this case Netbeans (as you have confirmed in comments).

    This functionality is called Unused Assignment , and it was introduced in NetBeans 7.1:

    Unused allocation

    Introduced a new pair of tips, unused assignment and dead branch . Unused assignment finds values ​​that are calculated and assigned to a variable, but are never used when reading the variable. The dead branch track looks for forks of code that can never be executed.

    You can see this JavaWorld article about it: NetBeans 7.1's Unused Assignment and Dead Branch Hints

    What happens is what @Flowen says in his answer: you assign a value that you never use , so in colloquial language the IDE tells you: Why assign me a value if you are not going to use it ?

    Let's look at two code snippets:

    Fragment 1:

    The IDE won't ask you for anything, because you assign the value and use it:

    String op=null;
for(int i=10; i>1; i--)
{
    System.out.println("Variable inicial: "+op);
}

    Fragment 2:

    The IDE will claim you, because you assign the value and don't use it:

    String op=null;
for(int i=10; i>1; i--)
{
    // System.out.println("Variable inicial: "+op);
}

    And if I do it like this, does he claim me too? Here if I use opright?

    String op=null;
for(int i=10; i>1; i--)
{
    op="a";
    System.out.println("Variable inicial: "+op);

}

    It also claims you, because you assigned nullfor nothing (what is printed is the value of opchanged to the value a.

    II. It is a functionality loaded with bugs

    As already stated in I , this is an IDE feature, which is full of bugs. To check it out, just do this google search: site:netbeans.org unused assignmentit will show you all about this feature on netbeans.org, not by chance most of the search results are bug reports.

    III. What I do?

    The lesson that Unused assignement wants to teach us is that you do not declare anything with values ​​that you are not going to use.

    If you are not going to use the nullthere is no use declaring your variable like this:

    String op=null;

    Declare it like this:

    String op; //=null;

    And assign the value only if you are going to use it:

    for(int i=10; i>1; i--)
{
    op="a";
    System.out.println("Variable: "+op);
}

    But if you do this:

    for(int i=10; i>1; i--)
{
    op="a";
    System.out.println("Variable: "+op);
    op="b";
}

    In op="b"it you will have the same warning: Unused assignment . Why? The IDE is not as dumb as it is made out to be. Even though it goes through the loop, that op=bone will never be used.

    The warning would be removed if you did this:

    for(int i=10; i>1; i--)
{
    op="a";
    System.out.println("Variable inicial: "+op);
    op="b";
    System.out.println("Variable cambiada: "+op);

}
    • 3

  2. The assigned value is never used

    What it tells you is that the value nullyou have assigned to it is never used. And it's true, since you replace it with tokens.next();inside the while.

    That is, it tells you about valorthe variable, not the variable opitself.

    • 2

  3. The assigned value is never usedmeans that it is useless to assign a value to that variable opwhen declaring it, since the following expression that refers to opis precisely an assignment of a new value withop = tokens.next();

    If you want to declare the variable opoutside the loop while, you can do so without assigning values ​​to it, like so:

    String op;

    and when assigning it inside the loop, you use:

    op = tokens.next();
    • 2

  4. but it is a contradiction because I do use it inside the while

    You use the variable op as long as the is executedelse and for the parser, both the ifand the elsehave the same chance of being executed so it warns you that if the is executed if, the variable opis not being used. So it is recommended that you declare the variable in the else.

    If you remove the initial assignment the warning will go away:

    String op;      
while (tokens.hasNext()) 
{

    Or if for example you print the value of opthe if, the warning will also disappear:

    String op = null;      
while (tokens.hasNext()) 
{

    if (tokens.hasNextInt()) 
    {
        System.out.println(op);
        s.push(tokens.nextInt());
    }
    else {
//...

    You obviously don't use the variable opin the branch ifwhich indicates that the parser isn't smart enough to ignore the warning.

    • 1