Develop Reference

Return misconception

I feel somehow I don't understand point of using "return" value, so I will give you two examples and maybe someone will clear that up for me.
What is the difference between this method:
int giveSecret(){
return 42;
}
//code in between
int theSecret = life.giveSecret();
System.out.println(theSecret);
(my expected console output):
42
and this method:
void giveSecret(){
//code that "resets" variable to value 42
}
//code in between
int theSecret = life.giveSecret();
System.out.println(theSecret);
(my expected console output):
42

Sure, languages could work like your latter example. Every function could have a global variable associated with it where the "result" is stored. You would call the function then read the result from the global variable. However:
It's disgusting. Why need to have another global name? Why have to somehow know what variable is associated with which function?
It's not thread-safe. Multiple threads might call the function at the same time. Now, which thread's result is present in the global variable?
Language designers figured this stuff out long ago, and it has stuck.

How to block/bulk reset static variables using Java 7

I am parsing a text file looking for syntax matches. to complete this task, I created Variable class with static variables in it. Then I parse a file and I assign the parsed information to the variable class static elements.
Variable.name = "the parsed information";
Then I created a Baseline class to check and compare against the Variable elements to check if certain condition is met.
For example
if (BaseLine.x.equal(Variable.x) // do whatever.
Variable Class:
public class Variable {
static String name;
static String userID;
static Integer age
}
BaseLine Class:
public class BaseLine {
static String name;
static String userID;
static Integer age
}
Utilizing JavaFX I move between scenes to load a file, parse it, assign the parsed variable then compare it with my BaseLine class. Thus far, Everything works as expected until I hit the back button to go back to the original scene to load a new file. now, the issue that I am having how can I reset the variable inside my Variable class in bulk instead of doing it one by one inside my controller initialize statement? I want to do this to ensure that I don't capture any variable from the older file I just parsed before I hit the back button. what is the correct way of completing this task?
I was able to get what I am looking for when I reset the variables inside my initialize controller, but it seems to be a lengthy process to do for OOP I have over 100 variables (int/sets/strings...) to reset.
Here is what I did to reset the static Variables inside the controller initialize section.
#Override
public void initialize(URL url, ResourceBundle rb) {
Variable.name = null;
Variable.setName.clear();
Variable.age = null;

I was able to get what I am looking for when I reset the variables inside my initialize controller, but it seems to be a lengthy process to do for OOP I have over 100 variables (int/sets/strings...) to reset.
If you have hundreds of static variables, you are not doing OOP properly. In proper OO design, your application's state should be held in instance variables, and accessed via instance variables. Static variables should be kept to an absolute minimum. (You can eliminate them entirely, if you can use a dependency injection (DI) framework ...)
The bad news is that there is no >>good<< way to reset a large number of
static variables. There are a couple of >>bad<< ways; e.g. reflection, and messing around with classloaders ... but you just would be replacing one problem (clunky code) with a worse one (complex, fragile code). IMO.
But the good news is that you fix your design / implementation to be properly OO, then you won't have this nasty problem of resetting the variables. And a whole bunch of other things will be easier too ... like writing unit tests.

I am not aware of a way that would exists that would allow you to reset all static variables in one go. You would have to do one by one.
I think your problem lies somewhere else - and i believe you should refactor your code in that instance (if possible).
How about having all your variables as standard (non static) and set/get them like you normally would but when done just create new object and let the old one be collected by Garbage collector??
Edit:
Although you could perhaps use reflection ? Not entirely sure if that would work though.
Something like
Field[] fields = MyClass.class.getDeclaredFields();
for (Field field : fields) {
if (Modifier.isStatic(field.getModifiers() && isRightName(field.getName()) {
field = null;
}
}

Best practice to handle an impossible value for a static variable in Java?

(This question isn't about how it can be done, but rather how it should be done.)
I'm implementing a program that creates a decision tree. There are different ways the tree can be constructed, so I have a static variable 'type' that is assigned in the main function. In the Node class constructor, I have a switch statement that checks the value of this type variable and does something accordingly.
I want to know the best way to handle the case in which the value does not match any of the preset options (the 'default' case). This should be impossible and will probably never be executed, but I want to do it right nonetheless. If this case does happen, I want it to print a message and terminate the program.
I know I can do it by simply throwing an error there and catching it the main, but it doesn't seem intuitive for something that should never happen. Is "System.exit(1)," what I need?
public class Node {
// some attributes
public static int type;
public static final int TYPE1 = 0;
public static final int TYPE2 = 1;
public Node(**arguments**){
// do some stuff first
switch(this.type){
case Node.TYPE1:
splitType1();
break;
case Node.TYPE2:
splitType2();
break;
default:
// unrecognized type
System.err.print("Error: Unrecognized type");
System.exit(1);
}
// do some more stuff
}
}

Throw an exception and don't catch it. Let it propagate all the way up. If something you consider to be impossible has happened, then you should have no confidence at all in your ability to "handle" it... the world is hugely screwed up.
IllegalStateException is somewhat appropriate for this, although you might also want to consider using AssertionError, if it's really that impossible. (Consider whether you want any code that catches plain Exception to try to handle this situation - if not, Error is appropriate.)
In this case, given that you've got a public static variable, it seems entirely feasible for any code to change this and put it in an invalid state. IllegalStateException is therefore more reasonable.
If, however, you changed the code so that the variable was private, and the methods which changed its value all validated that the value became either 0 or 1 before setting it, then an AssertionError would be more appropriate.
(I'd personally use an enum for something that can be one of a fixed set of values, mind you. That limits the ability of this to get messed up...)

One of the ways would be to put the code in Try Catch and Finally block.
Set the flag in default case and handle the error accordingly in finally block.

Java - Remove "Variable", keep assignments with side effects

I am starting to develop for Android (And I am starting to think, does it worth it!). Eclipse keeps giving me a lot of strange warnings and errors too! Here is one that kept me frustrated for the last two hours with no luck on Google:
private String alertTitle= null;
There is an ! mark beside it saying Remove "alertTitle", keep assignments with side effects. What is this?! I am defining a variable exactly as Java states. I am using the variable later:
public ASAlertDialog setTitle(String title) {
this.alertTitle = title;
return this;
}
Another one that's a little bit similar is defining enum"
public enum MyStyles {
aStyle;
}
public MyStyles myStyle = aStyle;
This made Eclipse angry!

You may be using the variable name by assigning a value to it, but you are not using the value stored in the variable. To do that, you must use the variable name to retrieve the stored value, and do something with this retrieved value somewhere in your code.
Eclipse tags the variable as unused when the value is never retrieved (or more generally, it's never possible to retrieve it*). It means you're merely assigning values to it, but never making use of them anywhere. This makes the variable an unnecessary memory hog, hence the warning.
* public and protected variables won't get the warning because they can be retrieved in other classes even if they aren't retrieved within the class they are declared in, and even if they are currently never retrieved in any class (it may happen in the future due to library use).
For the enum, it should be:
public MyStyles myStyle = MyStyles.aStyle;
This is because an enum is something like a class, with the constants acting similar to static variables in the class. (This is just an analogy, not exact an language definition.) You would retrieve enum constants the same way you retrieve variables from an external class that are defined as static.

Your variable is not used, so eclipse informs you about that and therefore you get message Remove "alertTitle", keep assignments with side effects

For enums, you need to declare it as
public enum MODE
{
NO_ASYNC_TASK,
NO_DOWNLOADED_DRAWABLE,
CORRECT
};
Check my this answer for more information
And the warning is because you might not be using alertTitle variable after declaring it.

To your first question:
It just means that your variable isn't being used, so you can safely remove it. The warning will disappear once you start using the variable in your code. Side-effects are explained here:
http://www.cs.umd.edu/~clin/MoreJava/Intro/assign.html
Check under "Is Assignment an Expression?"
To your second question:
There is no ';' in defining an enum. Check this:
http://docs.oracle.com/javase/tutorial/java/javaOO/enum.html

Try
public enum MyStyles {
aStyle;
}
public MyStyles myStyle = aStyle;
Regarding to your String, maybe Eclipse informs you that your variable is never used.
By the way,
private String alertTitle;
is null by default, so why do you set "= null"?

Using a display method with local variables in java

So I have to write a program for an invoice where I define the variables locally, instead of globally. So it kinda looks like this the way I have it.
public void setAmount(int anyAmount)
{
int amount;
amount = anyAmount;
}
I then do the display method like this and get an error saying cannot find symbol
public void displayInvoice()
{
System.out.println("Amount: " + amount);
I can easily do this globally, but having troubles with this. Thank you!

When you declare a variable inside a function, such as in your setAmount, it only exists for as long as that function is executing; it only exists between the { and }. That's why you're unable to reference it later in the second function, as it no longer exists. Essentially, what you're doing is setting it, and then getting rid of it right away, through no effort on your code, but simply through the way memory is allocated and used in programs.
The way to get around this would be to use a "global" as you've said, or to pass it back after you set it, and put it into another variable, which you then send to your displayInvoice function. The last method requires that the setAmount and displayInvoice are part of a larger function themselves, and the intermediary variable is declared inside it. Over all, a "global" as you've said, is the easiest and probably best solution given what you've explained.
Unworking Example:
main() {
int amount = 0;
amount = setAmount(5);
displayInvoice(amount);
}
In doing so though, you may as well forgo the setAmount function, as you can see it's fairly redundant. Keeping set amount, you'd need to change it to
Public int setAmount(int anyAmount)

When you declare a variable inside a method it becomes local meaning it's only visible in that method, that is why you are getting that error, you can correct that by making it global.