Friday, September 20, 2013

Accumulator variables: Incrementing and decrementing

There is no actual such thing as an accumulator variable but it is a concept or rather a technique for using a normal variable to accumulate a value.

The following statement declares an int variable and assigns it a value of 0:

int num = 0;

if we then write another statement:

num = 10;

...what we have done is overwrite the value of num from 0 to 10.

But often, we want to increase the value of num with another number, rather than overwrite it's value.

In this case, we can use the add and (+=) operator, rather than the assignment operator (=):

int num = 0;
num += 10;
num += 3;

The value of num has accumulated a value of 13.

Consider the following example, which uses a for loop to accumulate a value:

int num = 0;
for (int x = 0 ; x < 10 ; x ++ ) {
   num += 10;
}

The loop runs 10 times and on each pass of the loop, num accumulates another value of 10. The end result is that num has a value of 100.

In the next example, we use the Java increment operator (++) to increase the value of num by 1:

int num = 0;
for (int x = 0 ; x < 10 ; x ++ ) {
   num ++;
}

You should also note that the loop counter itself makes use of the increment operator to add 1 to itself on each pass of the loop.

What about decrementing?

int num = 10;
num -= 5;
num -= 1;

Using the minus and (-=) operator, num now equals 4

and in a loop we might:

int num =10;
for (int x = 0 ; x < 10 ; x ++ ) {
   num --;
}

Using the decrement operator (--), num equals 0.

What about Strings?

Use the add and (+=) operator to append 1string to another:

String name = "Sabrina";
name += "Albright";


Simple Frames and Panels

CODE DOWNLOAD - FramesAndPanelsTute.zip

A JFrame is a Window that can contain other GUI components such as JPanel. We can override the JPanel's paint method to force the JPanel to draw the way we would like it to. In the demo code, the final result looks like the following:


In this example, inheritance has been used to extend both the JFrame and the JPanel class. Both of these classes come from the Java Swing library.

Wednesday, September 18, 2013

Overriding Methods

A child class can override concrete methods from the parent. This is done by precisely duplicating the parent's method signature, in the child.

Let's override the toString() method which our class inherits from the Object class:




Here's the call:




Here's the output:




When overriding, ensure the method signature is reproduced perfectly.

Here's a cat.



Friday, August 30, 2013

HashMap


A HashMap is just like TreeMap except that a HashMap is not ordered by its keys.

See long post on TreeMap for methods and iteration technique. Go!


Monday, June 3, 2013

Anatomy of a simple Java file

When we write java code, we will save our code files with the .java file extension. These .java files are written using the syntax, rules and conventions of the Java programming language and are human readable.



Java ‘code’ must be transformed into a form of code which is readable or executable by the machine. This is achieved by compiling the Java code in the .java file to transform it into bytecode which is stored in .class files. Bytecode is the language which is understood by machines that have the Java Virtual Machine (Java) installed.






public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello World!");
}


}
HelloWorld.java




The code above shows a simple example of a .java file. It contains the definition for a class called HelloWorld, a single method called main, and within that, a single statement which prints the words “Hello World!” to the console.


Java is case sensitive

Java is case sensitive! This means that main is different to Main.


All Java code is contained within a class

All Java code is contained within a class. The class begins with a class declaration. The .java file must have the same name as the class. The class declaration includes a set of curly braces, which contain all other code in the file.


public class HelloWorld {


}


You cannot omit either of the curly braces and you cannot place code outside of them either.


All Java apps contain exactly one main method

All Java applications contain exactly one main method. Think of the main method as the front door of the application. From the main method, program execution begins.


public static void main(String[] args) {
}


Additionally, the main method is able to accept a String array parameter. A String is any collection of alphanumeric characters (such as a file path) and an array is like a list of items.


(String[] args)


In this case we could say that the main method is able to accept a list of Strings. More on this later.

All methods are enclosed in a set of curly braces

All methods are enclosed in a set of curly braces (such as the main method above). There will be many sets of curly braces in your .java files. It is important that sets remain sets (don’t accidently delete a brace).


All method names are followed by parenthesis ()

All method names are followed by parenthesis - open and close round brackets. The parentheses contain parameters used by the method. Parameters are sometimes also called arguments. Not all methods use parameters but some methods may use one or more.


The example below shows an empty method (no code within the curly braces) called logout. The parenthesis following the world logout are empty. This method does not use any parameters.


public static void logout() {
}


The example below shows an empty method called login. The parenthesis following the world login contain two parameters; each is separated by a comma. This method uses the parameters to complete it’s task.


public static void login(String username, String password) {
}

All statements are terminated using the semi-colon ;

All statements are terminated using the semi-colon character. A statement is an instruction such as...


System.out.println("Hello World!");



Methods often contain many statements. The semi-colon ensures that all statements are separate.


// is used to comment the code

The double slash // is used to comment the code. Code commenting is useful as it provides internal documentation which allows yourself and others to read a description of the purpose of the code.


public class HelloWorld {
// This is the main method.
public static void main(String[] args) {
     // Prints Hello World! to the console.
System.out.println("Hello World!");
} // Closes the main method.

} // Closes the class.


Comments are ignored by the compiler.

Tuesday, May 28, 2013

JPanel


"How to Use Panels (The Java™ Tutorials > Creating a GUI With JFC/Swing > Using Swing Components)" ( http://bit.ly/ZaWraM )

"JPanel (Java Platform SE 6)" ( http://bit.ly/Rn8WMx )