Free Java Tutes - Free Examples and SCJP Tips

Using prewritten classes in java in Java

2009-06-18T01:19:00.000-07:00

Java contains many prewritten classes which are stored in a package. The package is implicitly imported into every java program is named “java.lang”. The classes it contains are the fundamental classes. Other classes that you may want to import known as “optional classes”.
The class “java.lang.Math” contains constants and methods that can be used to perform common mathematical functions. All of the constants and methods in the Math class are static. Common useful Math class methods include those used for finding an absolute value, finding maximum or minimum value, rounding values etc… To use a prewritten class other than “java.lang” you must use the path with the class name and import the class or import the package that contain the class.

Ex:
import javax.swing.*;
import java.util.*;

Easiest way to import prewritten classes is, importing whole package it contains. We use “*” to indicate we need all classes in the package as in above example.

Math class Methods:

· Max(x,y) Larger of x and y
· Min(x,y) Smaller of x and y
· Pow(x,y) X raised to the y power
· Sqrt(x) Square root of x
· Round(x) Closest integer to x(where x is a float or double, and the return value is an integer or long
· Rint(x) Closest integer to x(x is a double, and the return value is expressed as a double
· Floor(x) Largest integral value not greater than x
· Celi(x) Smallest integral value not greater than x
· Random() Random double number between 0.0 and 1.0
· Abs(x) Absolute value of x
· Sin(x) Sine of x
· Cos(x) Cosine of x
· Tan(x) Tangent of x
· Asin(x) Arcsine of x
· Acos(x) Arccosine of x
· Atan(x) Arctangent of x
· Atan2(x,y) That a component of the polar coordinate
· Exp(x) Exponent, where x is the base of the natural algorithms
· Log(x) Natural algorithm of x

Sample Program:
Case: We will use fundamental class “Math” in “java.lang” to manipulate some numbers. We have used float numbers and while assigning values, the values follow letter”f” to indicate that casting shouldn’t carry out.

public class TestMathClass
{
public static void main(String[] args)
{
float num1 = 4f;
// becouse we're using float data type, it's better to use assigning its values followed by 'f'
float num2 = 5f;
float num3 = 6.3f;
float num4 = 6.8f;

System.out.println("Larger value amoung num1 and num2 is: " + Math.max(num1, num2));
System.out.println("Smaller value amoung num1 and num2 is: " + Math.min(num1, num2));
System.out.println("Power of num1 raised to the num2 power is: " + Math.pow(num1, num2));
System.out.println("Largest integral value not less than num3 is: " + Math.floor(num3));
System.out.println("Closest integer to num2 is: " + Math.rint(num4));
}
}

This is the output:

What is the difference between Variables and Constants?

2009-06-18T01:18:00.002-07:00

Constants are unchangeable and variables are changing its values throughout the program. After a program is compiled, literal strings (Also known as literal constants) never change. Also, the value stored in symbolic constants never change. You create a symbolic constant by inserting the keyword “final” before a variable name. By convention, constant fields are written using upper case letters. A constant must be initialized with a value.

Ex:
static final int COMPANY_ID = 57575;
static final private int COMAPNY_ID = 52525;

Sample Program:
Case: We will define a constant and then used it straight away.

public class Constants
{
static final int COMPANY_ID = 56644;

public static void main(String[] args)
{
System.out.println("Company ID is: " + COMPANY_ID);
anotherMethod();
}

public static void anotherMethod()
{
System.out.println("Company ID is: " + COMPANY_ID);
}
}

The output is:

What is “this” in Java?

2009-06-18T01:18:00.001-07:00

As we stated earlier, you just store one copy of a class (including methods) for use with each object. You store separate fields (variables defined just after class declaration) for each object. The compiler access the correct object’s data fields because you implicitly pass a ‘this’ reference to class methods. In general sense, ‘this’ reference removes confusable states occurs with object declarations. If you have more than one objects based on the same class which has class data fields, then java use implicitly ‘this’ reference to keep in track of fields of each object.

You don’t want to worry about this “this” because java will implicitly do most of it. We will bother about “this” later where we want to explicitly define it.

Tip: he Java keywords this and super are closely related to the method invocation. The use of this and super keywords is twofold. They can be used:
As a reference to access the instance members or the superclass members (as we have seen earlier in section 1.4.2)
OR
As a method name for calling the constructors of the class or its superclass
The this keyword used within an instance method refers to the instance on which the method is called upon.

How to Overloading Methods in Java?

2009-06-18T01:15:00.000-07:00

Overloading involves writing methods with the same name, but different argument lists.

Ex: If you have enough information. You can do the same task “telling time” in following three different ways.

Public static void tellTime(hour, min); // Only hour and minutes
Public static void tellTime(hour, min, sec); // Only hour, minutes and also seconds
Public static void tellTime(date, hour, min, sec); // Date of the month, and all.

Java can do the same thing. If method receives enough information it can do the same task in different ways. This is what you called as overloading and it provides “Polymorphism” features in java.

Sample Program:
Case: We will define three variables and three methods with same name. It’s your computers work to catch the right method according to arguments it receives.

public class MethodOverloading
{
public static void main(String[] args)
{
String aText1 = "Text 1";
String aText2 = "Text 2";
String aText3 = "Text 3";

aMethod(aText1);
aMethod(aText1,aText2);
aMethod(aText1,aText2,aText3);
}

public static void aMethod(String text)
{
System.out.println("I received one text only: " + text);
}

public static void aMethod(String text, String text2)
{
System.out.println("I received two text only: " + text + " and " + text2);
}

public static void aMethod(String text, String text2, String text3)
{
System.out.println("I received all texts: " + text + ", " + text2 + " and " + text3);
}
}

The Output is:

Tip: Polymorphism helps you write systems that are flexible andmodification resistant. It allows a method to take on "many forms" which in turn makes it re-usable and therefore more flexible.

Tip: Be careful, If you have a mixed collection arguments of integer, long like data types, there may be unexpected errors. To avoid such errors, when assigning values use letter ‘L’ for ‘long’ values, and ‘f’ for float values.

Ex: long aLong = 11338833L;
Ex: float aFloat = 34.7f;

How to Overload Constructors?

Constructor methods can receive arguments and be overloaded. If you explicitly create a constructor for a class, the automatically created constructor does not exist.

How to cast or convert variables in Java?

2009-06-18T01:13:00.001-07:00

Casting is a data type conversion technique. You many use these castings often. As we mentioned earlier, every keyboard input receives as String. Imagine, you’re making calculator software. To do mathematical functions with numbers you want data types like integer, long, float, byte or short but not Strings. Then you need to do the conversion Strings into integer, long etc…

If you need to convert value in a larger capacity data type in to a smaller capacity data type, then you need a casting.

Ex: (long variables capacity: 8 bits, and integer variables capacity 4 bits. Casing the value in long into integer)
Int myInteger = (int)myLong;

Casing can be used to conversions of two different data types with similar capacity.
Ex: (integers are 4 bits and floats are 4 bits too. Casing the value in integer into float)
Float myfloat = (float)myInteger;

Sample Program:
Case: We will define 3 variables and we will cast them.

public class Casting
{
public static void main(String[] args)
{
int myInteger = 64; //integers are 4bytes
float myFloat = 0; //floats are 4bytes
byte myByte = 0; // bytes are 1 byte

System.out.println("Casting similar capacity variables...");
myFloat = (float)myInteger;
System.out.println(myFloat);

System.out.println("Casing larger variable value into samller...");
myByte = (byte)myInteger;
System.out.println(myByte);

}
}

This is the output:

Blocks and Scopes in Java

2009-06-18T01:01:00.000-07:00

Within any class or method, the code between a pair of curly braces is called a block. When you declare a variable within a block, you can not reference that variable outside the block. The portion of a program within which you can reference a variable is the ‘Variables scope’.

Sample Program:
Case: This program defines a variable called ‘x’ inside main method. The scope of the variable x starts with its declaration and must be ends with main method closing curly brace. You can retrieve its value on that scope, but you can’t do it out f scope. So, when you compile program you’ll get “Cannot resolve symbol” error in line 12 which is out of scope of variable ‘x’.

public class VariableScope
{
public static void main(String[] args)
{
//scope of the main method starts
int x = 12;
System.out.println("x is: " + x);
anOtherMethod();
}
//scope of the main method ends

public static void anOtherMethod()
{
//scope of the anOtherMethod starts
System.out.println("x is: " + x);
}
//scope of the anOtherMethod ends
}

This is the output:

Now take a look at this, you may define two variables in different scopes and the variables may overlap.

public class OverlapScope
{
public static void main(String[] args)
{
int x = 55;
System.out.println("main method:- x is: " + x);
overlap();
System.out.println("main method:- x is: " + x);
}

public static void overlap()
{
int x = 66;
System.out.println("overlap method:- x is : " + x);
}
}

The output is:

Even the variable names overlapped, java knows keep in track both variables separately. This is also known as nesting variables.

How to create constructors in Java?

2009-06-18T00:58:00.000-07:00

A constructor method establishes an object and provides specific initial values for the objects data fields. A constructor method always has the same name as the class of which it is a member.
Sample Program:
Case: This is an implementation of previous program. From line 5 to line 8 is the new part to study. That is the constructor. The constructor will execute automatically and assign a value to strText whenever method starts. Constructors do not have ‘void’ keyword.

public class InstanceVariables
{
String strText;

public InstanceVariables()
{
strText = "This value given by constructor";
}

public InstanceVariables(String text)
{
//opening constructor with an argument
strText = text;
}
//closing constructor with an argument

public void setText()
{
strText = "This is variableUser method.";
}

public String getText()
{
return strText;
}
}

This is the output:

Instance Variables in Java

2009-06-18T00:57:00.001-07:00

The data components of a class are often referred to as the instance variables of that class. Also, class object attributes are often called fields to help distinguish them from other variables you might use.

This is the source class for ‘myObject’. In line 3 we have declared a instance variable (known as a class field, because it declares inside class block, not in a method). ‘setText’ method will set a value to strText, and ‘getText’ method will return the value in strText.
Save this class as “InstanceVariables.java”

public class InstanceVariables
{
String strText;

public void setText()
{
strText = "This is VariableUserMethod";
}

public string getText()
{
return strText
}
}

This is the class which uses “InstanceVariables.java” through the object “myObject”.

public class TextEdit
{
public static void main(String[] args)
{
InstanceVariables myObject = new InstanceVariables();
//without arguments
InstanceVariables myArgObject = new InstanceVariables("With Arguments");

System.out.println("Getting the value with myObject");
System.out.println("Value is:" + myObject.getText());

System.out.println("Getting the value with myNewObject");
System.out.println("Value is:" + myArgObject.getText());
}
}

This is the output:

Tip: An object is constructed by instantiating a class. The process of creating an object of a class is called as instantiation and the created object is called as an instance.

How to create Objects in Java?

2009-06-18T00:53:00.000-07:00

An object is an instantiation of a class, or one tangible example of a class. To create an object as an instantiation of a class, you can use following syntax:

Syntax: = new ();
Ex: Employee security = new Employee();

When you create an object, the source class is copied into memory and it referred by your object name. Therefore, you can make as much as objects using the same class. Computer will make copies of same class over and over again.

Sample Program:
Case: This program needs two classes; ‘Computer’ class which we will use to create an object named ‘myComputer’. ‘ComputerUser’ class which use the object to access ‘Computer’ class.

First create “Computer.java” which is the source of object.

public class Computer
{
public static void ComputerName()
{
System.out.println("Dual Core");
}
}

Then create “ComputerUser.java” which create the object and use it.

public class ComputerUser
{
public static void main(String[] args)
{
Computer myComputer = new Computer();
myComputer.ComputerName();
}
}

This is the output:

Tip: Objects have a state (also known as member variables, fields, data) and certain behavior (also known as operations, methods, procedures, functions).

Tip: A class represents a blueprint that defines the variables and the methods common to all objects of a certain kind.

Tip: Objects communicate by sending a message or a request to another object to do a particular task. It is usually a call to a method of another object.

How to implement class declaration in Java?

2009-06-18T00:52:00.000-07:00

To create a class, you must provide;
1. An optional access modifier (Default is ‘public’, private etc…)
2. The Keyword ‘class’
3. Any legal class identifier
4. Open curly brace
5. Closing curly brace

How to return values in Java?

2009-06-18T00:48:00.000-07:00

Sometimes, methods need to send information about the task they carry out back, where the method called from. This is known as returning values. If a method returns a value; instead of the keyword ‘void’, the return data type must be indicated. Method can return a class too.

Sample Program:
Case: This is an implementation of previous sample program. Instead of printing value, ‘multiplyMethod’ will return the result back to main method.

public class myHomeWorksReturn
{
public static void main(String[] args)
{
int value1 = 4;
int value2 = 2;
int ReceivedValue;
//declaring a variable that can hold values from multiplyMethod
ReceivedValue = multiplyMethod(value1, value2);
//Calling to method with arguments
System.out.println("Received Value is: " + ReceivedValue);
}

public static int multiplyMethod(int number1, int number2)
{
int Result = number1 * number2;
return Result; //returns value back
}
}

This is the output:

Improving Method Declaration

2009-06-10T23:51:00.000-07:00

In this chapter we will discuss about some declarations we used in previous chapters.

How to implement method declaration?

A Method is a series of statements that carry out a task. A method declaration include, as we mentioned earlier:

Declaration

Optional access modifiers (public, private, protected …)
The return type of the method (void or returning data type)
The method name (Ex: main)
An opening parenthesis
Optional list of method arguments
Closing parenthesis

An Opening curly brace
A body
A closing curly brace

Any method can be called by other methods under certain limitations added by access modifier. “public” is no restrictions, every one can access it. “private” is to restrict method access only within the class it declared.

Ex: public void calculateMethod() {}

Ex: private void idNumberMethod() {}

SCJP Tip: you can use more-than-one modifier while declaring class or its members. When you do so, the modifiers may appear in any order in that declaration. For example , you can apply the access modifiers either before or after or in between the other modifiers.

Arguments or parameters consist of information that a method requires to perform certain task. You can provide as many as parameters within braces in line with method declaration.

Ex: public void idNumberMethod (int myNumber)

Indicating method name with arguments within parenthesis can make a call to that method. A method in a class can be called from another class.

Ex: calculateMethod(319);

Sample Program:

Case: This program will print a literal string from method named “printSomething”. ‘main’ method call this method in line 5. Check line 5 again. You may find that this calling do not send any arguments as the parenthesis is empty. Also in the method declaration in line 8, you can see empty parenthes is. Save this code as “Caller.java”.

This is the output:

When you write a method declaration for a method that can receive an argument, you must include the type of the argument and a local name for that argument.

Sample Program:

Case: This is an implementation of “Caller.java”. Instead of print something, main method send a text to printSomething method.

This is the output:

A method may require more than one argument. If so, you have to indicate data type of each argument separately and to define a local name. Arguments can be separated by commas.

Ex: public void calculateMethod(int Number1, intNumber2, String operator)

To make a call to this method: calculateMethod(22, 4, “+”);

Sample Program:

Case: You have two numbers to multiply. You can send those numbers to another method as arguments.

This is the output:

SCJP Tip: That’s basic again! Now the real declaration of a method:

[modifiers] returntype methodName([argumentList]) {

[method body]

}

[modifiers] : You know! It’s ‘public’ like thing!

returntype : If you want to return something (As in next sample program) then you want to state its data type here.

methodName : ID of your method (Method Name).

([argumentList]) : Arguments that the method will receive.

Tip: There’re a method type known as ‘Abstract Methods’. They have no method body and instead a semi colon will be at the end of method declaration. You’ll learn these later.

Ex: public string find(String wordToFind);

Java Operators and Concatenation

2009-06-10T23:37:00.000-07:00

An operator is a symbol that tells the computer to perform a vertain mathematical or logical manipulation. Values used by an operator are known as operands.

There’re arithmetic and comparison operators.

Integer Arithmetic Operators	Description	Example
+	Addition	1 + 2 = 3
-	Subtraction	12 – 2 = 10
*	Multiplication	10 * 3 = 30
/	Division	100 / 4 = 25
%	Modulus (Reminder)	3 % 2 = 1

Comparison Operators	Description	Example
Comparison Operators	Description	Returns True	Returns False
<	Less than	2 <>	100 <>
>	Greater than	500 > 1	1 > 500
==	Equal to	1 == 1	1 == 2
<=	Less than or equal	1 <= 1 , 0.5 <= 1	2 <= 1
>=	Greater than or equal	50 >= 50 , 100 >= 50	1 >= 2
!=	Not equal	1 != 2	1 != 1

Other than this “=” operator known as assignment operator. It can be used within mathematical sums and also to assign values to variables.

Escape sequence

You can use escape sequences within literal strings to format text.

Escape Sequence	Description
\b	Back Space
\t	Tab
\n	New Line or line feed
\f	Form feed
\r	Carriage return
\”	Double quotation mark
\’	Single quotation mark
\\	Backslash

Increment, Decrement operators

You can use operators like +, - as follows.

Ex:

++ adds one to value in variable x. And then print it (Prefix).

Ex:

Computer prints the value in x and then adds 1 to value in x (Postfix).

You can use -- same way.

Concatenation

Joining strings with other data types within a single statement is known as: Concatenation”.

Ex:

‘+’ sign is also known as “Concatenating operator”. Above example concatenate a literal string “Value in x is:” with value in x which is an integer.

Java Variable Declaration

2009-06-10T23:30:00.000-07:00

Variables are named memory locations that your program can use to store values. Line 5 declares our variable “strCountry” as follows.

String strCountry;

“String” is the data type of the variable. That means this variable can hold texts, numbers or set of different characters.

“strCountry” is the name of the variable and known as variable identifier.

Other than strings, you may want to declare variables that can hold only numbers, but not characters; or variables that can hold images. Java provides eight primitive variable types and three reference variable data types. (Primitive variable types are the building blocks of Reference data types.)

The primitive types (also known as bulletin data types) comprise of all the numeric types along with a boolean type. The numeric types are four integral types- byte, short, int, long, andchar, and two floating-point types- float and double.

Primitive Data Type	Usage	Capacity	Default Value	Maximum Value able to hold	Minimum Value able to hold
byte	Sign integer	1 byte	0	127	-128
char	Single character	1 byte	u\0000	-	-
short	Sing integer	2 bytes	0	32, 767	-32,768
boolean	True or false	2 bytes	false	-	-
int	Sign integer	4 bytes	0	232-1	-232
float	Floating point values	4 bytes	0.0f	3.4*1038-1	-3.4*1038
long	Sing integer	8 bytes	0L	264-1	-264
double	Floating point values	8 bytes	0.0	1.7*10308-1	-1.7*1-308

The variables of a reference type hold thereferences to the actual objects.

Reference Data Type	Usage	Capacity	Default Value	Maximum	Minimum
Array
Object

Variable Naming Rules

Variable name must be start with a letter, doller sign or underscore.
No embedded space characters allowed within variable name.
Cannot use keywords as variable names.

You can use access modifies like “private” with variable declaration. Default access modifier in “public” that means if you haven’t declare a access modifier, then java will assume it as a “public” variable.

Ex: private String strCountry;

Variable names usually start with lowercase letters to distinguish them from class names.

You can do the variable declaration and assigning values in one statement.

Ex: String strCountry = “India”;

Also be aware how to indicate assignment of value. String variables need its assigning value within “”. Integer, double, float, long, short, byte need value directly. Char needs its assigning values within ‘’.

Ex:

String strCountry = “Sri Lanka”;

Int intCountryCode = 94;

Char chrCountryLetter = ‘S’;

Every text you input using the keyboard into the program is receives as a String. And every thing you print to screen must be a string. You can print an integer on screen using the statement (If x is an integer): System.out.println(x);. Computer will convert integer ‘x’ into String data type and then prints on screen.

We’ll discuss about reference types later.

Tip: Java is a strongly typed language, which means that every variable and expression has a type that is known at compile-time itself

SCJP Tip: Variables declare inside the class declaration, but not inside a method known as ‘class data fields’ or ‘member variables’. Then variables declare inside methods known as ‘local variables’.

SCJP Tip: There’re two kinds of member variables. (1)The static variable is a member variable declared using the keyword static within a class body. Static variables are also known as class variables. They are created when the class is loaded. (2) The instance variable is also a member variable, but it is declared without the keyword static. Instance variables come into life when an instance (i.e. object) of a class is created and they remain associated with that instance. Instance variables are destroyed as soon as that particular instance is destroyed.

Improving your code

2009-06-10T23:19:00.000-07:00

There is no use of a program at least it can’t hold the data given by its user. So, lets do something to improve our sample code we used in chapter one,

This is what we coded in chapter 01:

Now this program has no ability to hold values from the user. On the other hand, that means

your program do not interact with computer memory seriously. It just prints “First Java Program” that defined as a literal string inside the program code.

Following is little bit changed, and improved code. Other than printing texts directly from the code, this program first hold texts in computer main memory, and then gets them back and print on screen.

In this code, we use something called “Variable”. A Variable is a named memory location that we can use to hold/store values. This program will declare a memory location called “strCountry” and then assign a value “Sri Lanka”.

Line 1: Declares the class “Variables01”.

Line 2: Open the class

Line 3: Declares the method “main”

Line 4: Opens the method

Line 5: Creating a variable in computer memory known as “strCountry”

Line 6: Set the value in “strCountry” to “Sri Lanka”

Line 7: Prints “Your Country is:” on screen

Line 8: Prints value in “strCountry” on screen

Line 9: Closing “main” method

Line 10: Closing “Variables01” class

Following figure shows how to compile and run this program, and also its output.

This is how your memory looks like while the program is running.

What Else I need to know about Java as a beginner?

2009-06-10T23:16:00.000-07:00

Remind that Java is case sensitive and its statements end with a semicolon (‘;’).

You have used periods in the First.java. Periods (called dots) are used to separate classes, objects, and methods in program code.

This is quite enough anyone to get on with java development. Let your mind to be busy with Java. Because what you must really want to know as a beginner is that, java is quite easily forgettable for most. Keep it using daily!

Java is Ok! But you need to know some ‘Command Prompt’ manipulations which are easier to do than reading this!

To Start Command Prompt: Press “CTRL” + “R” together and you’ll get “Run” program. Type “CMD” and press enter. Otherwise you can start it traditional way, using start menu and look for “Accessory” sub menu.

To move into a folder: Type CD
To move out from a older: Type CD..
To move into root hard disk partition of current address: Type CD\
To see the contents in current folder: Type DIR
To locate Java within Command Prompt: Type PATH /bin
To Compile Java Classes: Type JAVAC ,java
To run your Java Programs: Type JAVA

If You hope to get a job in Java Programming, then best place to start is SCJP (Sun Certified Java Programmer) examination. There're sub versions of this examination and check http://www.java.com for guides.

Java Comments

2009-06-10T23:14:00.000-07:00

Comments are used by java programmer to describe what is going on with a program code. Comments will ignored by java compiler, so feel free to type as you want but, you must indicate that you are going to write a comment.

This can be done in three ways:

Single Line Comments: Starts with “//” and will end when you moved to another line
Block Comments (Multiline Comments): Starts with “/*” and ends with “*/”
javaDoc comments: Starts with “/**” and ends with “*/”

Example:

In this tute, comments will be shown in green color. (Any you may see java keyword in blue color) We’ll use comments along to describe sample codes in this tute.

Java Method Declaration

2009-06-10T23:12:00.000-07:00

Methods use to command computer how to do certain things in order to complete a certain task. You may need many methods within the class because most of the time software is to complete a job (Set of tasks).

Line 4 declares the method named “main”.

“public” is same as in class declaration and known as “Access Modifier”.

“static” means that the method will execute as a stream, not dynamically.

“void” means that you’ll start and finish complete task inside the method, any you have nothing to hand over data to elsewhere. (You have nothing to return)

“main” is the name of the method, also know as method identifier.

Within the brackets we will add any raw data that will used by the method, know as arguments or paramethers of a method.

All methods starts with a “{“ and ends with “}”.

The ‘main()’ method is a compulsory method in java applications. When the application starts to execute, compiler uses this method to interact with other methods.

Class Declaration

2009-06-10T23:09:00.000-07:00

Class is the outer cover of your program. All methods, resources and others are inside the class.

Let’s look at the class definition we used in the First.java.

‘ { ‘ bracket opens a class and ‘}’ closes it. ‘public class First’ is the line defining a class named “First”.

‘public’ means the class you want to create can be accessible from anywhere. You may use “protected”, “private” later to restrict access to the class. This word is known as “Access Modifier”.

And then “class” is a keyword that signs compiler that you are defining a new class.

That is basic! Following is the real! You might not understand many of notations now. But you’ll later. Every thing in squire brackets are optional and others are keywords.

[accessModifier] [classModifiers] class ClassName [extends SuperClassName] [implements InterfaceList]

{

[classbody]

}

If you are very keen on this tuff class declaration; this is what it says:

[accessModifier] : ‘public’, ‘private’, or other access modifier

[classModifiers] : ‘abstract’ for example, says you can’t create objects using this class. That is another kind of restriction known as Moderation.

class ClassName : Key words we must add to class declaration.

[extends SuperClassName] : Your class become an extend of a supper class.

[implements InterfaceList] : Tells compiler it’s time to use some interfaces with the class, such as ActionListener to sence user clickings.

Java Class Naming Rules

There’re certain rules in java you want to concern when defining a class and known as Syntax of the language.

A Class Name must begin with a letter of the alphabet (which includes any non-English letter, such as alpha), an underscore or a dollar sign.
A Class Name can contain only letters, digits, underscores, or dollar signes.
A Class Name cannot be a java programming language reserved keyword. (Such as ‘public’, ‘class’)
A Class name cannot be one of the following values: “true”, “flase” or “null

Class Names are conventionally starts with capital letters as it is easy to distinguish class names from other names you used for various other components. And be careful Java is Case Sensitive!

What Java Can Do?

2009-06-10T23:06:00.000-07:00

Java is one of the best programming languages ever built. Its programs will run on a stand alone computer, through a network or inside your mobile phone.

There’re four types of java programs;

Java Applications

You can build programs that run on stand alone computer. It can be an old fashioned DOS like program (Known as Console Applications. For the first few chapters we will use console applications as they’re very easy to build) or attractive windowed GUI (Graphical User Interface) programs with Icons.

Java Applets

Web based programs that can be embedded in a web page. They have very limited resource handling abilities, but gives attractive graphical functions.

Java Servlets

Servlets are Server-side

Java MIDlets

Java Programs that will run in smart devices.

What Did I installed?

2009-06-10T23:01:00.000-07:00

The Java Platform consists of two parts.

API (Java Application Programming Interface)

API is a collection of pre-written classes that we’ll used to develop new software.

Java Virtual Machine (JVM)

This is the environment for Java program. The JVM will run your programs build on Windows even in Linux!

When you install J2SE (JDK) then you'll get both of these. What J2ME and J2EE do is that they some more program files into J2SE. There's a bullet-in JVM in JDK. But, sometimes this JVM doesn't work with your browser. So, we install JVM seperately for better performance.

Features of Java and Object Oriented Programming

2009-06-10T22:56:00.000-07:00

Features of Java

Java is;

Simple
Object Oriented
Compiled And Interpreted
Multithreaded
Secure
Portable
Garbage Collection Enabled
Architecture Natural

Java follows Object Oriented Programming Techniques (OOP). OOP involves creating objects within the program and enable the program to use those objects. For example, you may create your own short note book that will use before you go to exam. Objects are made up of States (attributes) and Methods. For example your short note book has ‘short’ text and it is a ‘note’. ‘Short’ and ‘Note’ are attributes of Short Note book. What you’ll do with it is ‘Read’ or ‘Write’ short notes. ‘Read’ and ‘Write’ are methods.

A Collection of Objects that have common attributes and metho

ds are known as a ‘Class’. For example ‘small’ children class and ‘big’ children class, where all small children can ‘dance’, but big children have to ‘learn’. So there we got “Small Children Class” and “Big Children Class”.

But all of them are ‘Children’. So you can group those two classes into one class ‘Children’. This ‘mega’ class known as “Parent Class” in Java, while those children classes known as “Child Classes’. Parent classes are also known as ‘Super Classes’ while Child classes known as ‘Sub Classes’.

We build our own classes in java and it’s already have prewritten classes. When we build our programs we will use these prewritten classes as an ‘instance’ to our program. That means we use an object to use that class. For example, to watch DVDs we use DVD player. Movie or Video will be the class and we will enjoy watching it.

When we create classes we divide it into logical portions (groups) known as procedures. This make easier to track operations within our program.

Important: A Java class provides common implementation for a set of similar objects. It does so by defining a set of methods and data variables. Unlike Java class, a Java interface merely describes a common public behavior of similar objects. Therefore, it contains a set of method declarations. A Java class may implement an interface by providing implementation for the interface methods. Java uses another construct called package to organize them (Package = Classes + Interfaces). A Class is the specification of objects. A Class must therefore declare where to store the states of each object and how the behavior of object implemented. Java does not allow extending from multiple classes, it may implement multiple interfaces.

OOP Features in Java

Encapsulation

Encapsulation is hiding the implementation of program. For example when we watch DVD, we don’t know how exactly DVD player played it because of its outer cover. Therefore we will aware of its internal functions. This will protect its internal components from unauthorized access. There are two kinds of encapsulation: encapsulation for information hiding and encapsulation for modularity.

Inheritance

Reusing existing classes again and again is Inheritance. This will reduce programmer work load. For example we do not want to trouble about how to use our new TV. Because we got a old TV and probably we can do some old fashioned work with new one too!

Polymorphism

Polymorphism is versatility. Same Object will behave in verity according to situation. For example you’ll buy a TV because you want one. But sometimes you’ll buy a TV because it’s free with $50000 Home Theater System.

Abstraction

Ignoring unnecessary details and extracting important details known as Abstraction. Garbage Collection is a important OOP feature of Java. We will discuss about this later.

Tip: OOP is simply a way of thinking about problem and their solutions. Instead of tackling the problem in a procedural way, OOP attempts to break down a problem into component objects. The solution focuses on these independent objects and their relationship with each other.

What You Should Know About Java

2009-06-10T22:50:00.000-07:00

Generally software has its own windows, tools that you able to click and type something. With Java, it’s quite opposite.

How and who’s?

Java developed as a modern world option for computer programming. Don’t think about why, but machines do not know how to communicate in English or any other human language. Machines (or Computer Hardware) know how to work with binaries which are zeros and ones (0 and 1) and probably we don’t. Java knows how to convert English into these 0s and 1s and work with hardware.

Tip: Machine Language: The language used in computer hardware. It has only zeros and ones (0 and 1). This language is far more serious to learn and understand. Machine language is the most circuitry level computer language. 0s represents off state of a switch while 1s represent on state.

Tip: High Level Languages: Programming languages that converts English like words into machine language are known as High Level Programming Languages. To do this, java uses two software elements, Compiler and Interpreter. A high level language allows using vocabulary of reasonable terms, and also allows designing intuitive names to areas of computer memory.

Anyhow, we need to give program description to Java to convert it into machine language (0s and 1s). In JAVA this description is known as ‘Source Code’. A Source Code file has .java extension (Remind: First.java).

We tell Java to convert description into Machine language using ‘JAVAC’ command. Java will convert this into ‘intermediate code’ but not to Machine language. As mentioned earlier, this converting process takes out by two software elements, Compiler and Interpreter. ‘JAVAC’ command will start Compiler and makes .class extension file. This consists of ‘intermediate code’, that means contents of this file are not JAVA or Machine language. Interpreter will convert this file into machine language when you run the program with ‘JAVA’ command. Check the folder where you create First.java. You may see First.class too!

These are the Java program production steps.

First you create .java file. That is the ‘Source Code’.
Compile it using JAVAC command and you are compiling it into .class file; known as ‘Intermediate Code’.
You run the program with JAVA command. Interpreter interprets .class into machine language and run.

Interpreter needs support of JRE (Java Runtime Environment) to complete running process.

First Tour! Build Your First Program in 3 minutes!

2009-06-10T22:18:00.000-07:00

Java wants only one thing from you that is your program description. You may give this description to java using a ‘.java ’ file. Description will include what your program going to do when it started.

Following program describes, it will show ‘First Java Program’ text on screen when user start it. Type the following java code description into your text editor. (Note: Numbers in the gray column are line numbers and it s just for easy reading. Do not type those things in your file!)

Save file into a directory (folder) using file name “First.java” (ex.: C:\MyJava\First.java)

Start Run application by pressing ‘CTRL’ key and ‘R’ key together. Type ‘CMD’ and press enter

to Start Command Prompt or DOS prompt.

Now you are going to start Java. Java software has no any graphical user interface as in Visual Basic. So, you can’t start Java using Windows Start Menu.

Follow the figure while reading this part and also take a look at DOS help at the end of this chapter.

To start java type ‘PATH ’ (ex: C:\JDK1.4\bin) and press enter. You’ll see nothing special! But wait!

Now you want to move Command Prompt to location where you save “First.java”. Type ‘CD ’ (ex: CD MyJava)

Tip: You may use ‘CD\’ command to jump into root of C: drive because according to this example our .java file is in ‘C:\MyJava’ folder.

Now you have to say, “Create my program please!’ Try this! ‘JAVAC First.java’

To Run Your Program Type ‘JAVA First’ and press enter (Be careful: Java is

Case Sensitive).

You must see ‘First Java Program’ appeared on screen.

If you get some errors, please check your code again. Look for missing semicolons and spellings, letter cases etc… Then check your “PATH” command is OK (Can you find bin folder of java manually?). Finally check you are at the right location to compile your code (In this example; I saved my code in C:\MyJava. You can see that Command prompt; prompt it at the last line).

That’s all! You will repeat this process every time you write a Java program. Lets See How to develop it into real windowed program from next chapter!

Get ready to go! How to Install Java?

2009-06-10T22:06:00.000-07:00

1. Install Java (JDK/ J2SE)
Double click setup file of Java to start installation. This’ll install java program files. Remember where you installed Java. (Default Location is: ‘C:\jdk’ (ex: ‘C:\jdk1.4’).

2. Install Java Run Time Environment (JRE)
Install Java Run Time Environment by double clicking the setup file and there’s nothing to configure manually.

3. You can use your windows notepad to write java source code. Otherwise install any text editor you wish.

Following installations are optional. If you hope to study Servlets and Midlets then you may want these. What you must know is the location (in Hard Drive) where they installed.

4. Install J2EE and J2ME and the installer may provide instructions.

5. Install TomCat server