Article Categories
Tag Cloud
Variables and objects are basically things you can hold (err, that the computer can hold in memory). They store some sort of data that represents something. We'll start by focusing on variables.
Variables have 5 properties: data, name, type, scope, and lifetime.
Variables can be thought of as buckets. Each bucket can hold something (an object). Importantly, variables can only hold 1 item in their bucket at any one time, but that item can be changed (unless the variable is final). The item that bucket is holding is the data/value of that variable.
A variable's name is pretty self explanatory. Imagine you have a big black marker, and you wrote on the variable a name. Then, anytime someone needed that bucket (whether to put something in or take something out), they'd get the bucket labeled with that name.
A variable's type is what kind of things that variable can hold. If you had a bucket for milking cows for example, you wouldn't want to use it to change the oil in you engine.
A variable's scope is anywhere the variable can be used. Say you had a bucket on a farm in Kansas. You can use that bucket anywhere on that farm in Kansas. However, if you decide you want to milk cows in Nebraska but happen to forget your bucket, you wouldn't be able to use that bucket. However, when you come back to your farm in Kansas, you can use that bucket again.
The last characteristic of variables is lifetime. Lifetime is when the bucket physically exists. If one day you decide you want to set off dynamite in your bucket, it will cease to exist, and can't be used again.
So enough with the analogies, let's discuss variables in Java. Java variables can have any standard name that you can give to anything else:
must start with any unicode character so long as it isn't a defined operator or a digit, and anything after that can be any unicode character that isn't a defined operator. (Thanks Json
Maybe I should actually learn something about Java before trying to help others). Quotes (single or double), brackets/braces/parenthesis, reserved Java keywords, and whitespaces are also dis-allowed.//valid variable names: Hello i _ $ p_3 Á
While any of these are valid variable names, there is a convention that is is followed in Java:
Try to find descriptive variable names. They should describe what it is that variable is for. Names like "sum", "index", and "average" are fairly common. Bad names would be "_", "$#@", etc.
It's important to note that Java is case sensitive. so the variable "Hello" would be different from the variable "hello". Conventionally, variables start with a single lower-case word, then subsequent words would have their first character capitalized. It's also fairly common to find variable names with subsequent words separated by underscores. In the latter case, all the letters are lower case.
public int averageHeight; public int average_height; public int index;
The type of a variable defines what that variable can hold. All variables in Java must be declared with their type and their name:
int someInt; // type int, name someInt double x; // type int, name x
If you want a variable to be constant, or final, use the final keyword:
final double pi = 3.141592;
final variables MUST have a value set to them right away, and that value cannot change for the lifetime of that variable.
There are two main data types in Java: primitive, and objects. Objects will be discussed later. The primitive Java data types are: byte, char, short, int, long, float, double, and boolean. Note: sometimes String is considered a primitive data type because of the way the JVM handles strings, but String here will be considered objects because it will be easier to understand them as objects (and also because they technically are objects).
Primitive variables are those that hold their value directly. Object variables are those that contain a reference to an object. Object variables will be discussed later.
Scope is a bit tricky to explain. I will find a good way to explain this and post it later. For now, here are some examples.
ex:
method scope
public static void main(String[] args)
{
int x = 0;
doIt();
// point 1
}
public static void doIt()
{
int y = 1;
// point 2
}Here, on our original sheet (main method), the variable x is in scope and is available for use anywhere in main. When doIt is called, x goes out of scope because we got out a scratch sheet to do work for the doIt method. On that new sheet, we have y in scope. When doIt ends, y goes out of scope (actually, it disappears completely in this case) and is not available to the original main method.
Curly bracket scope
int a=0, b=1;
if (true)
{
int c = 3;
// point 1
}
// point 2Here, at point 1, we still have everything available from the original scope, in addition to anything available in our current scope denoted by the curly braces. At point 2, the inner curly-brace stuff goes out of scope, and we only have a and b available.
Lifetime in Java is when the variable actually exists. It's probably even more confusing than scope, and a lot of people get it confused with scope. Because of Java's garbage collector, the lifetime of any variable is from when it's first instantiated to when all references to it are gone. Ex:
public static void doIt()
{
String a = "hello";
doNothing();
}
public static void doNothing()
{
String b = "goodbye";
}When someone calls the doIt method, the string a will be created (and it's lifetime has started). It is also in scope because it's in the little curly brackets of the doIt method. However, when the doNothing is called, a goes out of scope, but there is still a reference to it (due to the implementation of recursion, I won't discuss the details here). The string b is then created and is in the scope of the doNothing method. The doNothing method then returns, and b goes out of scope, and is also destroyed because there are no more references to it, thus ending its lifetime. The String a comes back in scope, and because there is nothing left to do int the doIt method, it too immediately goes out of scope and is destroyed.
Hopefully this makes sense, this is probably the most confusing part about computer science (memory management/keeping track of variables).
Here are some questions about variables and objects:
1. For each of the lettered comments, describe which variables are in scope and which are out of scope. Also, give the lifetime of all the variables (when are the created, and when are they destroyed).
public static void main(String[] args)
{
for (int i = 0; i < 5; i++)
{
System.out.println("Determining stats..."); // a
doIt(i);
// c
}
System.out.println("Done"); // b
}
public static void doIt(int number)
{
if (i % 2 == 0)
{
System.out.println(i + " is even"); // d
}
else
{
System.out.println(i + " is odd"); // e
}
}2. What is the output of this program?
public static void main(String[] args)
{
int i = 1;
int j = 2;
System.out.println(myFunc(i,j));
}
public static int myFunc(int j, int i)
{
if (i > j)
{
return j;
}
else
{
return i;
}
}3. Describe in your own words the 4 defining features of a variable: name, value, scope, and lifetime.
Answers are to come sometime
