Java Pebbles

Java Pebbles Has a New Blog Location

2010-05-08T14:01:00.001+08:00

Please visit Jessica's Journal for it's new blog location. Thanks for the visits.

Declaring Object References, Instantiating Objects and Initializing Object References

2009-12-01T10:03:00.002+08:00

Object reference variables are variables containing an address to an Object in memory.

To declare, instantiate and initialise an Object Reference Variable:

Declare - Specifies its identifier and the Object Type of the referenced class
Instantiate - Using the new keyword
Initialise - Assigns the Object to the Object Reference Variable

Declaring Object Reference Variables:
Syntax:
Classname identifier;
where
Classname is the Class or the type of Object referred to with the Object Reference
identifier is the variable name of type Classname

Instantiating an Object:
Syntax:
new Classname();
where
new keyword is used to create an Object Instance from a Class
Classname is the Class or Type of Object being created

Initializing Object Reference Variables:
Syntax:
identifier = new Classname();

Using an Object Reference Variable to Manipulate Data:
The dot (.) operator is used with the Object Reference to manipulate the values or to activate the Object methods

Storing Object Reference Variables in Memory:
Object Reference Variables hold the memory address of Objects in memory. Memory addresses are usually written in hexadecimal notation such as 0x332006. Local Object Reference Variables and their values are stored in Stack Memory while the Objects that they reference to are stored in Heap Memory.

Assigning a Reference From One Variable to Another:
Upon execution of the above codes, both myShoe and yourShoe reference variables contain the same address to the same object. Unless another reference variable was pointing myShoe object, it would be garbage collected.

Using Promotion and Type Casting

2009-11-29T08:06:00.000+08:00

Promotion is used when you try to assign a data type that holds a smaller value range to data type that holds a bigger value range. This is to prevent precision lost in the assigned data type value. For example, promoting a byte data type to integer data type.

Typecast is used to lower the value range by changing its data type such as double floating point to floating point. This is normally done when developer need to access methods that only accept certain data types as arguments or to save memory.

Promotion In Use:

Data Type Promotion may occur automatically by Compiler if the data would not be lost. For examples:

Assign a smaller data type to a larger data type
Assign an integral data type to a floating point data type (no decimal value places to lose)

Type Casting:

Syntax:
identifier = (target_type) value
where
identifier is the Variable Namevalue is the value assign to the Identifier
value is the value assigned to the Identifier
(target_type) is the type that you wish to type cast the value

For example:
int number1 = 20; //32 bits of memory used
int number2 = 10; // 32 bits of memory used
byte number3 = 0; // 8 bits of memory lost
number3 = (byte) (number1 + number2); // no data loss

Compiler Assumptions for Integral and Floating Point Data Types:

Values are automatically converted to an int value (or higher) if the primitive data type values are used in an expression with certain operators (*, /, -, +, %).
Values assigned to a floating point data types are always defaulted to a double data type.

Using Arithmetic Operators

2009-11-28T08:18:00.003+08:00

Standard Mathematical Operators:

Addition ( + )
Subtraction ( - )
Multiplication ( * )
Division ( / )
Remainder ( % )

Increment ( ++ ) and Decrement ( -- ) Operators:

Pre-Increment and Pre-Decrement - the operation is applied before any subsequent calculations or assignments are performed.
Post-Increment and Post-Decrement - the operation is applied after any subsequent calculations or assignments are performed.

Examples:

Pre-Increment:
int x = 6;
int y = ++x;
x is 7, y is 7

Post-Increment:
int x = 6;
int y = x++;
x is 7, y is 6

Pre-Decrement:
int x = 6;
int y = --x;
x is 5, y is 5

Post-Decrement:
int x = 6;
int y = x--;
x is 5, y is 6

Operator Precedence Order:

Parentheses
Increment and Decrement Operators
Multiplication and Division Operators (Evaluated from Left to Right)
Addition and Subtraction Operators (Evaluated from Left to Right)

Declaring Variables and Assigning Values to Variables

2009-11-26T11:03:00.002+08:00

Naming a Variable:

Must have a unique and descriptive Identifier

Assigning a Value to a Variable:

Variables are automatically initialised according to their data types (if value assignments are not available during declaration) such as integral types are set to 0; floating point types are set to 0.0; char type is set to null character ('\u0000); and boolean type is set to false.
Assign value when the variable is declared.
Assign the value of one variable to another variable.
Assign the result of an expression to integral, floating point ot boolean type variables.
Assign the return value of a method call to a variable.

More than 1 Variables can be declared on the same line of code, but only if they belong to the same data type.
Syntax:
type identifier = value [, identifier = value];

The Use of Constants:

Represents values that cannot be changed.
Example: final double UNIT_TAX = 3.85; where the final keyword indicates that the value cannot be changed once it is set.
Program needs to be re-compiled if the constant value is changed in the program

Storing Primitives Constants in Memory:

Heap Memory is dynamically allocated memory which contains information used to hold objects (Attribute Variables and Methods).
Stack Memory is used to store items for a brief period which is shorted than the life of an object such as Local Variables declaration.

Java Primitive Data Types

2009-11-25T10:31:00.002+08:00

8 Primitive Data Types in Java:

Integral - byte, short, int and long
Floating Point - float and double
Textual - char
Logical - boolean

Integral Primitive Types - No Decimal Points:

byte - normally used to save memory consumption:

Length is 8 bits
Range is -27 to 27 -1 (-128 to 127, or 256 possible values)

short - normally used to save memory consumption:

Length is 16 bits
Range is -215 to 215 -1 (-32,768 to 32,767, or 65,535 possible values)

int - default integral type:

Length is 32 bits
Range is -231 to 231 -1 (-2,147,483,648 to 2,147,483,647 or 4,294,967,296 possible values)

long - value ends with a capital L to indicate it is a long value:

Length is 64 bits
Range is -263 to 263 -1(-9,223,372,036854,775,808 to 9,223,372,036,854,775,807, or 18,446,744,073,709,551,616 possible values)

Floating Point Primitive Types - wtih Decimal Points:

float - value ends with a capital F to indicate it is a float value:

Length is 32 bits
Example is public float price = 0.0F;

double - default floating point type

Length is 64 bits
Example is public double price = 0.0;

Textual Primitive Types:

char - stores single-character value:

Length is 16 bits
Example is char ShoeColour = 'b';

Logical Primitive Type:

boolean - stores true or false

Used to store the Java programming language literals or the results of an expression

Choosing a Data Type:

Numeric Variables normally use int, long or double Data Types.

Identifying Variable Use and Syntax

2009-11-23T11:12:00.002+08:00

Variables are used to store and retrieve values for programs.

Attribute Variables (variables declared outside of a method and without the keyword static) are called Member or Instance Variables. Instance Variables contain data specific to a particular object instance which is instantiated from a class.

Local Variables are variables defined within methods. They are only used within the method in which they are declared.

Uses for Variables:

Store unique attribute data for an Object Instance
Assign the value of one variable to another variable
Represent values within a mathematical expression
Print values to screen
Hold references to other objects

Variable Declaration and Initialization:

Instance Variable Syntax:
[modifiers] type identifier [=value];

Local Variable Syntax:
type identifier;
identifier = value;
or
type identifier = [value];

Do not use [modifiers] in Local Variables declaration.

Compiling and Executing (Testing) a Program

2009-11-21T08:03:00.004+08:00

Compiling a Program:
Compiling converts a the Class File into bytecode which can be executed by the JVM (Java Virtual Machine). The Class File must have a .java extension.

Syntax:
javac .java
where
javac is the compilation command

Upon successful compilation, a bytecode file (.class) will be created. All objects that are referenced by the compiled class will be automatically compiled if they are not compiled yet.

Executing (Testing) a Program:
JVM is used to execute the bytecode file (.class).

Syntax:
java
where
java is the program execution program.

Testing is in the 4th stage of the PLC (Product Life Cycle).

Creating and Using a Test Class

2009-11-19T08:10:00.002+08:00

Classes need to be instantiated as an Object and be called from a Test or Main Class before it can be executed.

Test Classes performs 2 basic tasks:

Provide a starting point (main method) for a program
Create an Object instance of the class and testing its methods

The Main Method:

The main method is a special method which is recognised by JVM (Java Virtual Machine) as a starting point for every Java program that runs from the Command Line.

Syntax:
public static void main (String args[])
where
public static is the 2 required modifiers
void keyword means the main method doesn't return any value
main is the method identifier name
(String args[]) allows the method to accept values a string of arguments on the Command Line to be used during program runtime

Only 1 main method can exists in a Java program. The array (args) name that the main method accepts can be changed.

Identifying A Class Components

2009-11-18T10:53:00.004+08:00

Classes are the blueprints used to create Objects in a program.

An application usually has a Controller Object or a Main Object which is the starting point of a program.

Every object is an instance of a blueprint or Class. Java Technology API (Application Programming Interface) provide classes which we can instantiate to be used as objects in programs. We may also create our own Class which can be easily instantiate.

Structuring Classes:

A Java Class File consists of 4 sections:

Class Declaration
Attribute Variable Declarations and Initialization(Optional)
Comments (Optional)
Methods (Optional)

Class Declaration Syntax:
[modifier] class class_identifier {
class_body_code
}
where
modifier determines the accessibility of other classes which can be public, abstract and final.
class keyword identifies the block of codes as Class Declaration
class_identifier is the name given to the Class
{ marks the start of the class_body_code
class_body_code is the statements within the Class
} marks the end of the class_body_code

Variable Declarations and Assignments Syntax:
[modifiers] type name;
where
[modifiers] determines the accessibility of the attributes which can be public and private.
type denotes the kind of values that the variable can hold, such as Integer or String.
name identifies the variable name.

Comments Syntax:
Single-line comments - //
Tradtional comments - /* */
/** */ comments can be used to create documentation using Javadoc software.

Methods Syntax:
[modifiers] return_type method_identifier ([arguments]) { method_code_block}
where
[modifiers] determines the accessibility of the methods and it is Optional as it appears in square brackets.
return_type identifies the type of value that the method returns. If the method returns nothing, then the void keyword will be used.
method_identifier is the method name
([arguments]) represents a list of variables whose values will be passed to the method.
method_code_block identifies the method statements.

Class Design

2009-11-16T08:23:00.003+08:00

Classes are the blueprints for Objects. In Object-Oriented design terms, each Object (created shoe) is created using the class (blueprint) and it is called an instance of a class. In other words, each object created from the class can have a specific state for each of its attributes but has the same attributes and operations from the same class.

In the Java Programming Language context, attributes are represented by variables and operations by methods. Variables are using to hold data while methods are used to perform operations.

Designing Classes:
Classes are modeled in the Design stage where each class is represented as a Class diagram in the UML (Unified Modeling Language) notation. In the Class diagram box, it starts with ClassName at the top followed by a list of attributes variables (attributeVariableName) which may include a range of values and list of methods (methodName).

Analyze a Problem Using Object-Oriented Analysis and Design

2009-11-15T11:36:00.004+08:00

Object-Oriented Analysis and Design (OOAD) principles:

Identifying a Problem Domain:
Problem Domain is the scope of the problem that needs to be resolved where the objects can be identified.

Identifying Object Properties:

Identify Object's Attributes and State.
Identify Object's Operations (things they can do) and Behaviour (operations that an object performs). Object Operation includes setting a value or displaying on the screen while an Object Behaviour can be an operation that allows other objects to change the objects's colour attribute from one state to another, such as green to blue.

Additional Criteria for Recognizing Objects:

Relevance to the problem domain - Does the object exist within the boundaries of the problem domain? Is the object required for the solution to be complete? Is the object required as part of an interaction between a user and the solution?
Independence Existence - For an item to be an object and not an attribute of another object, it must exist independently in the context of the problem domain. Objects can be connected and still have independent existence. When evaluating potential objects, ask yourself if the object needs to exist independently, rather than being an attribute of another object.

Software Product Life Cycle Stages

2009-11-13T08:33:00.001+08:00

Analysis:
The investigation process involved in solving a product issue which includes tasks such as definining the issue, the market niche, the system to be create, product scope and identifying the product sub-components.

Design:
The process of applying the findings made during Analysis stage to the actual product design which include tasks such as developing product blueprints and components of the system.

Development:
The process of creating the actual product components based on the product blueprints created in the Design stage.

Testing:
The process of ensuring the developed product and components meet the requirements of the specification stated in the Design stage which include Unit Test by the developers and Quality Assurance Test by Quality Assurance Team and End-Users.

Implementation:
The process of making the product available to customers which is also known as First Customer Ship (FCS) in the computer industry.

Maintenance:
The process of fixing the product problems raised by customer once the product is released to the customer.

End-of-life (EOL):
The process of ensuring that customers and employees are aware that the product is no longer available in the market or supported and a new product is available.

Java Technology Product Groups

2009-11-11T09:28:00.002+08:00

J2ME (Java 2 Mobile Edition):

To create applications for resource-constrained consumer devices.
Consumer Solutions include Cell phones, PDAs, TV set-top boxes and Car navigation systems.

J2SE (Java 2 Standard Edition):

To develop applets and applications that run within Web browsers and on desktop computers.
Desktop Solutions include Standalone Applications and Applets.

J2EE (Java 2 Enterprise Edition):

To create large, enterprise, server-side and client-side distributed applications.
Enterprise Solutions include eCommerce and eBusiness.

Each edition include SDK (Software Developer's Kit) and JVM (Java Virtual Machine) for their respective needs.

Java 2 Platform, Standard Edition's SDK includes:

Java Runtime Environment (JVM and Java Class Libraries for the chosen platform)
A Java Compiler
Java Class Library (API) documentation
Additional Utilities such as for creating JAR (Java Archive) Files and for debugging Java programs
Java Example Programs

Key Concepts of the Java Programming Language

2009-11-09T07:21:00.003+08:00

Java(TM) programming language originated in 1991 as part of a research project to develop a programming language, called Oak. It was initially planned to be used as a communication method among the consumer devices. However, fail deals with the consumer devices companies had forced the software development team (Green team) to look into alternatives. At that time, World Wide Web was gaining popularity and the team realised the new programming language was great for developing multimedia components over the web, known as applets.

The Java(TM) programming language was designed to be Object-Oriented, Distributed, Simple, Multithreaded, Secure and Platform-Independent.

Object-Oriented Programming (OOP) was in mind when Java was created. OOP started with SIMULA-67 programming language in 1967 and has gained popularity since then with newer languages such as C++ and Microsoft C Sharp. Procedural programming such as COBOL and RPG stresses on sequence of coding statements in solving a problem while OOP stresses on the Object creation and the interaction among the Objects.

Java(TM) programming language is a distributed language because it supports distributed network technologies such as Method Invocation (RMI), Common Object Request Broker Architecture (CORBA) and Universal Resource Locators (URLs). In addition, the dynamic class loading capabilities allow codes to be downloaded over the Internet and executed on a personal computer.

Java(TM) programming language is simple as it removes the complex programming constructs found in predecessor programming languages. For example, pointers to memory location manipulations in C and C++ are oftenly misused. Java substitues it with Object References method. Garbage Collection feature found in Java also automatically removes objects that are no longer used. Java Boolean data type is either a true or false as compared to 1 or 0 in predecessor programming languages.

Multithreading, ie. performing more than 1 tasks at a time, optimises the system resources usage.

Java(TM) programming language, in conjunction with the JRE (Java Runtime Environment) ensure security via measurements such as prohibition of memory pointers manipulation and reading/writing to computer hard disk by distributed programs such as applets; verifies that all programs contain valid codes; supports digital signatures.

Java(TM) programming language is platform-independent, as it Write Once, Run Anywhere. A JVM (Java Virtual Machine) is required in every platform that runs Java program. JVM interprets the Java bytecode, loads the Java Class Libraries (also known as API - Application Programming Interface) and executes the Java programs.

Java Arithmetic Expressions

2009-11-07T09:28:00.000+08:00

An arithmetic expression consists of operands and operators.

Basic Arithmetic Expression Operators:

+ Addition
- Substraction
* Multiplication
/ Division

If an interger operand is added to a double operand, Java automatically casts the integer data type to a double data type variable in order to retain the decimal values stored in the result variable.

Java Assignment Statement

2009-11-06T08:13:00.000+08:00

Java variable value is assigned to its variable using the assignment statements.

Assignment Statement Syntax:
type variableName = value;
where
type is the variable data type
variableName is the variable name
value is the value assigned to the variable

2.1: UML Representation of Object-Oriented Concepts

2009-11-04T08:33:00.003+08:00

2.1 Recognize the UML representation of classes, (including attributes and operations, abstract classes, and interfaces), the UML representation of inheritance (both implementation and interface), and the UML representation of class member visibility modifiers (-/private and +/public).

UML diagrams are used by Software Designer to model the classes for an application which are then used by developers to develop the program codes. The diagrams can also be used by many UML modeling tools to automatically generate program codes known as reverse code engineering.

Abstract classes, concerate classes and interfaces are represented in a rectangle with their names in boldface. Abstract classes are italicized. Interfaces are prefaced by the word interface between guillemet characters.

Generalization describes a is-a relationship where a class allows its more general attributes and operations to be inherited. Let's say classN inherits from classM, then it is said classN is-a classM. The generalization class relationship is displayed with a solid line and a closed arrowhead.

Realization is the general principle of implementing an interface. For example, classM implements the InterfaceZ interface. The realization relationship is displayed with a dotted line and a closed solid arrowheard.

Attributes or member variables defines the state of a class. The attributes section is optionally displayed under the name class diagram's name section. The simplified attributes format is visibility variable_name : type = default_value where all fields are optional except for variable_name.

Operations or member functions defines the behaviour of a class. The operations section is optionally displayed displayed under the class diagram's attributes section. The simplifield operations format is visibility method_name parameter0list : return-type where all fields are option except for method_name.

4 Types of Visibility Modifiers as Described in UML:

public + (plus sign)
private - (minus sign)
protected # (pound sign)
package-private ~ (tilde sign)

UML Timeline

2009-11-02T13:13:00.003+08:00

1997 November
UML 1.1

Various Periods
UML 1.3, UML 1.4.X, UML 1.5

2005 July
UML 2.0

2007 August
UML 2.1.1

2007 November
UML 2.1.2

2009 February
UML 2.2

Java Variables Declaration and Initialization

2009-10-31T09:23:00.006+08:00

Java Variables are used to store values and their values vary during program execution.

Variables Syntax:

type variableName = value;
where
type is the Data Type of the Variable
variableName is the Variable Name
value is the assigned initial value of the Variable

Java has 8 Primitive Data Types, namely int, float, boolean, char, byte, short, long and double.

Java Main Method Declaration

2009-10-29T09:16:00.001+08:00

Java Main Method serves as a starting point for a Java application.

Main Method Syntax:

public static void main(String[ ] args)
{
statements
}
where
public means the main method is accessible by any other classes
static means the main method can be called without instantiated
void means the main method doesn't return any values
String[ ] args is an array of String parameters that the main method receives

Section 2: UML Representation of Object-Oriented Concepts

2009-10-28T08:26:00.002+08:00

2.1 Recognize the UML representation of classes, (including attributes and operations, abstract classes, and interfaces), the UML representation of inheritance (both implementation and interface), and the UML representation of class member visibility modifiers (-/private and +/public).

2.2 Recognize the UML representation of class associations, compositions, association multiplicity indicators, and association navigation indicators.

Java Class Declaration

2009-10-26T08:20:00.007+08:00

Developers store their program codes in a class.

Class Syntax:

[public or private] class ClassName
{
statements
}
where
public and private are the Access Modifiers
class indicates that it is a Class
ClassName indicates the Class Name
statements are the class codes

Only 1 public class can be defined in a *.java file. The ClassName name must be the same as the ClassName.java filename.

Java Identifiers

2009-10-23T13:02:00.002+08:00

Developers create Java Identifiers in a program such as names for class, object, method and variables.

Java Idenfiers Rules:

Begin with a letter, _ or $. Use letters, $, _ or digits for subsequent characters
Use up to 255 characters
Cannot use Java keywords
Use meaningful words
Avoid abbreviations

Remember that Java is a case-sensitive programming language.

1.5: Fundamental Object-Oriented Concepts

2009-10-21T09:26:00.006+08:00

1.5 Describe polymorphism as it appplies to classes and interfaces, and describe and apply the "program to an interface" principle.

Polymorphism word originates from Greeks which simply means many forms. In Java context, polymorphism means 1 object can take the place of an object of different type.

Polymorphism via Class Inheritance occurs when a certain object type is required and an object of that type or its inherited object is accepted in its place. In this case, polymorphism utilizes the is-a relationship. A subclass is said to have an is-a relationship with its superclass. When an object is polymorphically acting as another object, the more specific object is restricted to only using the public interface of the more general object. The is-a relationship is unidirectional, ie., only the subclass can take the place of its superclass.

Polymorphism via Interfaces occurs when a class implements an interface, it is required to implement all the methods in the interface. Hence, the class includes all the functionalities that the interface defines. This allows all objects instantiated from the classes to polymorphically behave as the data type of the interface.

Programming to an interface concept specifies that the code should interact based on a defined set of functionality instead of an explicitly defined object type. In other words, it is better for the public interfaces of objects to use data types that are defined as interfaces than to a particular class. This allows code to be more abstract and flexible.

Java Statements and Comments

2009-10-18T08:18:00.001+08:00

A Java program consists of statements and comments. Statements are the steps that tell that program what to do while Comments are internal documentation that explain what the statements do.

Most statements end with a semi-colon ( ; ) while a block of statements starts with an opening brace ( { ) and ends with an ending brace ( } ).

Single comment starts with // followed by the comment. A block of comments start with /* and ends with */ .

To Use Eclipse IDE

2009-10-16T12:18:00.007+08:00

Lots of IDEs (Integrated Development Environments) are available in the market for Java Programming Language. An IDE not only serves as program text editor but also for compilation, monitoring, debugging and tool for developing Graphical User Interfaces (GUIs). The popular IDEs are Eclipse, Netbeans and Rational.

To Download Eclipse IDE:

Access Downloads section of the Eclipse website
Under the Eclipse Downloads webpage, select the Eclipse IDE for Java Developers (92MB) link
Under the Eclipse downloads - mirror selection webpage, proceed to download the eclipse-java-galileo-SR1-win32.zip file by selecting a mirror site link

To install Eclipse IDE:

Unzip the downloaded eclipse-java-galileo-SR1-win32.zip file
Open the eclipse.exe file to execute the Eclipse IDE
A Workspace Launcher window pops up
Select the default Workspace or your change it to your preferred workspace
Select the OK button to start using the Eclipse IDE

1.4: Fundamental Object-Oriented Concepts

2009-10-13T13:25:00.012+08:00

1.4 Describe information hiding (using private attributes and methods), encapsulation, and exposing object functionality using public methods; and describe the JavaBeans conventions for setter and getter methods.

Encapsulation uses object to store related data and method together and enforces Information Hiding concept. It allows objects interactions while hiding the implementation details. Developer ends up with better maintainable codes.

Access modifiers are the keywords that determine the accessibility of the class, methods and instance variables. Unauthorized access leads to program compilation error.

3 Types of Access Modifiers:

Private - Can only be accessed within the same class (not by subclass) and it is most restrictive.
Default (package-private) - Can be accessed within the same package. No keyword and it is used when the access modifier keyword is omitted.
Protected - Can be accessed within the same package and also by its subclass outside of the package.
Public - No restriction on its accessibility

Instance variable is usually set as private while public class methods such as Setters and Getters are used to interact with the outside world. JavaBeans naming convention is also used in the public class methods. In Setters method, it starts with a lowercase set, followed by the variable name (first letter capitalized) with no spaces. Getters method use the same convention but starts with a lowercase get. However, there is an exeption when a boolean value is returned. In this case, is is used rather than get.

To Use Java SE API Documentation

2009-10-11T10:13:00.004+08:00

Application Programming Interface (API) contains Java classes that are handy in building Java applications. Java™ Platform, Standard Edition 6 - API Specification can be viewed online on the Sun Microsystem website or can be viewed offline.

To download Java™ Platform, Standard Edition 6 - API Specification:

Access the Java Download section of the Sun Microsystem website
Under the Additional Resources section, click on the Download button for Java SE 6 Documentation
Under the Java SE Development Kit Documentaion 6 webpage, select the Language, tick on the I agree to the Java SE Development Kit Documentation 6 License Agreement checkbox and click on the Continue button
Under the Download Java SE Development Kit Documentation 6 for Documentation, English webpage, click on the jdk-6u10-docs.zip file (56.16 MB) to download the Zip file directly or via the Sun Download Manager tool

To install Java™ Platform, Standard Edition 6 - API Specification:

Unzip the downloaded jdk-6u10-docs file
Access the index.html file in the jdk-6u10-docs> docs folder
Under the JDKTM 6 Documentation webpage, select the API, Language, and VM Specs tab
Under the API, Language, and VM Specs section, the Java Platform API Specification is available for selection for further offline viewving

Java Program Compilation and Execution via DOS Command Prompt

2009-10-08T08:21:00.008+08:00

Activate the DOS Command Prompt in Windows Vista environment via the Windows button at the Desktop: All Programs> Accessories> Command Prompt

To compile Java Program:
C:\javac JavaProgram.java

To execute Java Program:
C:\java JavaProgram

Java is a case-sensitive programming language, inclusive of its filenames. Do remember to set the Command Path and Class Path in your Operating System environment.

1.3: Fundamental Object-Oriented Concepts

2009-10-06T09:15:00.019+08:00

1.3 Describe, compare, and contrast class compositions, and associations (including multiplicity: (one-to-one, one-to-many, and many-to-many), and association navigation.

Composition and Association describe a class relationship which is formed between 2 objects with reference to the other. The reference is usually stored as instance variable and can be in 1 direction or bidirectional.

An association relationship is a weak relationship of 2 objects where neither has direct dependency on the other for logical meaning. In other words, if the relationship is lost, both objects still retain the same meaning as they previously possesed.

A composition relationship has a stronger tie than the association relationship. Composition means 1 object is composed (depends on) of another object or multiple objects. If the relationship is lost, the logical meaning of the objects will be lost or significantly altered. Normally, it is required to manage the objects life cycle.

4 Types of Class Relationships:

Direct Association
Composition Association
Aggregation Association
Temporary Association

Direct Association describes a has-a relationship. It is associated with association relationship due to its weak relationship. This tends to be the default association when nothing else can accurately describe the relationship.

Composition Association is associated with composition relationship due to its strong relationship. It is described as composed-of relationship. The containing object is responsible to manage the life cycle of the internal object. In other words, the containing object must make reference to the internal object else the Java Virtual Machine (JVM) will destroy it. If the containing object is destroyed, any referenced objects will be automatically destroyed as well.

Aggregation Association represents a part-of the whole relationship. It can still retain its own meaning independently eventhough the relationship is lost. Neither object depends on the other for its existence. It is generalized as an association relationship.

Temporary Association is also known as dependency. Typically, a temporary will be an object used as a local variable, return value or method parameter. It is the weakest form of association relationship and does not persist for the entire life cycle of the object.

Multiplicity exists in every object relationship which refers to the number of objects used as part of a relationship.

3 Types of Relationship Multiplicity:

1-to-1
1-to-Many
Many-to-Many

A 1-to-1 relationship is where 1 object contains a reference to another object. All 4 association relationships may be valid.

A 1-to-Many relationship is where 1 object contains reference to a group of like objects which are normally stored in an array or a collection. A Many-to-1 relationship is also possible. All 4 association relationships may be valid.

A Many-to-Many relationship is only possible for weak associations, namely aggregation, direct and temporary. It is not required to have an equal number of objects on each side of the relationship.

Association Navigation refers to the direction in which a relationship can be traveled. An object that is contained within another object is said to be navigable if the containing object has methods for accessing the inner object. Its relationship can be either in 1 direction or bidirectional.

To Set Class Path in Windows Vista

2009-10-02T08:12:00.003+08:00

The Class Path tells the Windows Operating System where to locate all the Java Classes that are required by Java Runtime Environment (JRE) to execute a program. The Class Path for most systems include the current directory by default. However, if the Java Classes reside in a different directory, you may want to add that to the Class Path in order to avoid changing the current directory at DOS Prompt command to the directory that contains the Java Class files for each Java program execution.

To Set Class Path in Windows Vista:

Access Windows button in the Windows Desktop> Control Panel> System and Maintenance> System> Advanced system settings and click on the Continue button when the User Account Control window pops up
Under the System Properties window, select the Advanced tab and click on the Environment Variables button
Under the Environment Variables window, select CLASSPATH variable in the System Variables section and click on the Edit button
Under the Edit System Variable window, adds a semicolon ( ; ) to the end of the existing Variable value and then adds the path for the Java Classes to the list ( C:\java\classes; )

You may confirm that the above Class Path is set correctly by typing set at the DOS Command Prompt. The C:\java\classes; should be visible.

To Set Command Path in Windows Vista

2009-09-30T11:38:00.009+08:00

Setting up the Command Path in the Windows Vista environment make it easier to compile and execute the Java programs. Instead of having to type the full command path (\Program Files\jdk1.6.0\bin\javac) for each program compilation or execution, you just need to type the javac command at DOS Command Prompt. The Command Path on a Windows environment tells the Windows where to look for the commands that it is told to execute.

To Set Command Path in Windows Vista:

Access Windows button in the Windows Desktop> Control Panel> System and Maintenance> System> Advanced system settings and click on the Continue button when the User Account Control window pops up
Under the System Properties window, select the Advanced tab and click on the Environment Variables button
Under the Environment Variables window, select Path variable in the System Variables section and click on the Edit button
Under the Edit System Variable window, adds a semicolon ( ; ) to the end of the existing Variable value and then adds the path for the bin subdirectory of JDK 1.6 to the list ( C:\Program Files\Java\jdk1.6.0_16\bin>; )

You may confirm that the above Command Path is set correctly by typing path at the DOS Command Prompt. The C:\Program Files\Java\jdk1.6.0_16\bin>; should be visible.

Q&A: Inherited Method

2009-09-28T13:28:00.004+08:00

Question:
May I know if Class B inherits from Class A, will the private methods in Class A be extended to Class B too?

Answer by Priety Sharma:
I think by methods in Class A be extended to Class B You intend to say that are they accessible from Class B.

No, private methods are accessible only from within that class.

If you want these methods of Class A to be accessible from its subclass i.e. Class B in this case then you could make them protected. This will allow a subclass residing outside the package of its superclass to access these methods.

If the subclass is in the same package as the super class then default access for the method will do. That is specifing no access modifier before the method signature.

If you want more info then search for java access modifiers for methods on the net:
It will give you details about the modifiers: public , protected , default and private.

This should clarify all your doubts.

Answer by Campbell Ritchie:
If these methods were private, it was in order that they be not accessible. There was surely a good reason for making the private; don't change the access modifier.

1.2: Fundamental Object-Oriented Concepts

2009-09-26T09:03:00.011+08:00

1.2 Describe, compare, and contrast concrete classes, abstract classes, and interfaces, and how inheritance applies to them.

A concrete class is a regular class that can be instantiated.

An abstract class cannot be instantiated and must be extended. It may also contain abstract methods which are not implemented. The abstract keyword is used to indicate that it is an abstract class. They have valid method signature ut must be overriden and implemented in the calss that extends the abstract class. The purpose of an abstract method is to define the required functionality that any subclass must have.

Interfaces are used to define a required set of functionalities from that classes that implement the interface. Unlike inheriting from base classes, a class is free to implement as many interfaces as needed by using the extends keyword, followed by a comma-delimited list of interfaces. A class that implements an interface is required to implement all of the methods defined in the interface. Any unimplemented methods will result in compilation errors. Generally, interfaces are used to create a standard public interface for similar items. The interface keyword is used to specify that it is an interface while the implements keyword is used to implement an interface.

Inheritance allows general classes to be created and then be used as the foundation for multiple unique classes. In order words, unique classes are allowed to inherit the methods and instance variables of more general classes. Inheritance reduces codes redundancy and makes codes more maintainable. Inheritance enables Polymorphism to be used. A class can only extend 1 class where multiple inheritance is impossible. The extends keyword is used to inherits from a superclass to become a subclass. The subclass may then adds new methods and instance variables that are unique to the subclass.

A class that extends another class may override any inherited method by defining another method of the same name with the same arguments as in the superclass. A class may override all, none or only some of the methods it inherits from a super class. A subclass may also execute the superclass overriden method by using the super keyword (opposite of this keyword).

Object is the base class in Java programming language and does not need to be explicitly extended with the extends keyword.

Java Development Kit Directories and Files

2009-09-23T09:29:00.004+08:00

Java Development Kit (JDK) is installed under the C:\Program Files\Java\jdk1.6.0 directory in the Microsoft Windows environment. Under the installation main directory, there are some important directories and files:

Directories:

bin - Java Development tools and commands
jre - Java Runtime Environment (JRE) which includes Java Interpreter
lib - Additional libraries of code used by the development tools
docs - Java documentation for offline viewing

Files:

readme.html - A webpage that specifies important information on Java Standard Edition (JSE) such as System Requirements, Features and Document Links
src.zip - A zip file that contains the source code for Java Standard Edition API (Application Programming Interface)

Java Development Kit Installation

2009-09-20T08:13:00.004+08:00

Java Development Kit (JDK) needs to be installed on the Computer System before Java programming language can be used to develop applications. JDK can be obtained from the Download - Java 2 Standard Section section in the Sun Microsystems website. You may download the current JDK 6 Update 16 version which is about 73.5MB. You will also be prompted to specify the Operating System platform that the JDK will be installed. You may click on the jdk-6u16-windows-i586.exe filename for a direct download or you may use the Sun Download Manager (SDM) tool. Upon completion of the JDK download, click on the executable filename and respond to the dialog boxes. In the Microsoft Windows Operating System, the default installation directory is C:\Program Files\Java\jdk1.6.0.

1.1: Fundamental Object-Oriented Concepts

2009-09-18T09:11:00.011+08:00

1.1 Describe, compare, and contrast primitives (integer, floating point, boolean, and character), enumeration types, and objects.

An application consists of Variables and Program Codes that manipulates the Variables. Primitives are used to store Basic Data Types which are used to create more Advanced Objects Data Types.

Java Primitives include int (integer), float (floating point), boolean (boolean), char (character), byte, short, long and double.

In program source code, Integer refers to an object while int refers to a primitive that contains an integer. Primitive variables can only be set of read and also be accessed much faster than objects.

int (Integer) stores a whole number and has a default value of 0 which occupies 32 bits in memory. It can stores a 32-bit signed two's complement non-floating point number. The maximum and minimum values are 2,417,483,647 and -2,417,483,648 respectively.

float (floating point) stores decimal values with default value of 0.0f. It requires a 32-bits of memory with maximum and minumum values of 3.4e(+38) and 1.4e(-45) respectively.

boolean (boolean) stores a 1-bit value of true or false (default value).

char (character) stores a single 16-bit Unicode character and requires 16-bits of memory. It has a default value of '\u0000' or 0. The maximum and minimum values are '\uffff' (65,535) and '\u0000' (0). It is the only unsigned Java primitive.

Java has a built-in wrapper class for each primitive which converts a primitive to an object. The Wrapper Classes are Integer, Float, Boolean and Character. As of J2SE 5.0, conversion between primitive and wrapper class is automatically performed (autoboxing and unboxing).

Enumerations are a special data type that allows for a variable to be set to predefined constants. For example, enum TrafficLights { RED, YELLOW, GREEN } where enum is the keyword. Object can function as enumerations but the later is more reader and reduces developer's error.

Java is Strongly Typed which means programmer needs to declare the data type of each variable expicitly. However, Java Virtual Machine (JVM) may converts the data types automatically such as placing an int variable value to a float variable. Developer may perform variables castings to different data types or objects by placing the new data type in parentheses in front of the variable. Data can only be cast to compatible data types else runtime exception will occur.

Naming Conventions resulted in readable and better maintainable codes. Naming convention by Sun Microsystem:

Class - name is to be noun; first letter be capitalised alng with each internal word after the first; short and descriptive; for example: TrafficLight
Variables - starts with a lowercase letter with each sequential internal word to be capitalized; short and meaningful names; can use 1-letter names for temporary variables; for example: cupContent

Objects consists of data and methods. Data is the state of the object while Methods are used to perform actions on the data. Object size is dynamic at runtime. An object must be declared like the primitive and initialised or set to a value before it can be used.

A Class is a blueprint used to create Object by using the new keyword in the program source code. During program runtime, Java Virtual Machine (JVM) recognises the new keyword and instantiate an object. For example, Train fastTrain = new Train(100, true) where Train is the class and fastTrain is the object created.

An Array is a series of variables (either primitive data types or objects) of the same type that can accessed by an index , starting from 0. An array is always considered as an object eventhough it is an array of primitives. If an array is used in a loop, developer needs to watch out for array index that is out of bounds. An out of bounds index will cause the Java Virtual Machine (JVM) to throw an exception at runtime. Once the array size is declared, it cannot be changed. In other words, array size is not dynamic. For example, int[] electionResult = new int[100] .

Java Code Compilation and Interpretation

2009-09-15T09:59:00.006+08:00

A programmer uses a Text Editor like Notepad and Textpad or IDE (Integrated Development Environment) to enter, edit and save the Program Source Code. The program source code file (program.java) is translated by the Java Compiler into a platform-independent format, known as Java Bytecodes (program.class). The Java Interpreter which is a part of the Java Virtual Machine (JVM) executes the Java Bytecodes. Unique JVMs are available for all major Operating Systems such as Windows, Solaris, Linux and Macintosh.

3 Types of Java Programs

2009-09-13T13:28:00.006+08:00

Java programs can be Application, Applet or Servlet. Application is normally a program that you can execute on your Computer Desktop. An Applet is a unique type of web-based application that can be downloaded from a Web Server and executed inside a Java-enabled browser. Applets can also be distributed via the Internet or Intranet. A Servlet is a unique type of Java application that executes on the Server and can be called by a Client like a Web Browser. A Web Browser calls a Servlet where the Server executes the program logic and returns the result to the Web Browser in the form of a HTML webpage. As processing is performed on the Server, no plugin is required on the Client (Web Browser) unlike an Applet. JavaServer Pages (JSPs) make it easier to display the result of a Servlet on the Web Browser.

Java Timeline

2009-09-11T09:29:00.001+08:00

1996 January
Java Development Kit 1.0 (JDK 1.0)

1997 February
Java Development Kit 1.1 (JDK 1.1)

1998 December
Java 2 Platform (SDK 1.2)

1999 August
Java 2 Platform Standard Edition (J2SE)

1999 December
Java 2 Platform Enterprise Edition (J2EE)

2000 May
Java Platform Standard Edition (SDK 1.3)

2002 February
Java Platform Standard Edition (SDK 1.4)

2004 September
Java Platform Standard Edition 5.0 (SDK 1.5)

2006 December
Java Platform Standard Edition 6.0 (SDK 1.6)

Early 2010
Java Platform Standard Edition 7.0 (SDK 1.7)

Section 1: Fundamental Object-Oriented Concepts

2009-09-08T10:12:00.004+08:00

1.1 Describe, compare, and contrast primitives (integer, floating point, boolean, and character), enumeration types, and objects.

1.2 Describe, compare, and contrast concrete classes, abstract classes, and interfaces, and how inheritance applies to them.

1.3 Describe, compare, and contrast class compositions, and associations (including multiplicity: (one-to-one, one-to-many, and many-to-many), and association navigation.

1.4 Describe information hiding (using private attributes and methods), encapsulation, and exposing object functionality using public methods; and describe the JavaBeans conventions for setter and getter methods.

1.5 Describe polymorphism as it applies to classes and interfaces, and describe and apply the "program to an interface" principle.

CX-310-019 SCJA Exam Objectives

2009-09-06T08:16:00.003+08:00

Section 1: Fundamental Object-Oriented Concepts

Section 2: UML Representation of Object-Oriented Concepts

Section 3: Java Implementation of Object-Oriented Concepts

Section 4: Algorithm Design and Implementation

Section 5: Java Development Fundamentals

Section 6: Java Platforms and Integration Technologies

Section 7: Client Technologies

Section 8: Server Technologies

CX-310-019 SCJA Exam Format

2009-09-03T09:03:00.000+08:00

Exam Name: (CX-310-019) Sun Certified Java Associate, Version 1.0
Delivered at: Authorized Prometric Testing Centers
Prerequisites: None
Exam type: Multiple choice and Drag and Drop
Number of questions: 51
Pass score: 68% (35 of 51 questions)
Time limit: 115 minutes

Java Certifications

2009-09-01T10:13:00.000+08:00

Java is basically spilt into 3 Java worlds, namely SE (Standard Edition), EE (Enterprise Edition) and ME (Micro Edition). SE is the basic Java development and runtime environment. It is mainly used for desktop applications. EE is mainly used for enterprise applications like network distributed applications. ME is used for mobile devices applications like handphones and pdas. Java is a very flexible programming language that’s supported by other IT platforms, namely IBM and Oracle products. SUN offers a good range of certifications for IT developers of all levels, from beginners (junior developers) to advanced (architect):

Beginners in IT industry or project managers who need to gain an insight on Java technology are advised to pursue SCJA (Sun Certified Java Associate) as their first Java certification. SCJA gives an fundamental knowledge on application development and software project management using Java technology. However, it is not a pre-requisite for any of the Java certifications. Experienced Object Oriented developers in other programming languages like Microsoft C Sharp may aim for SCJP (Sun Certified Java Programmer) certification for a deeper understanding of the Java programming language. SCJP is a pre-requisite for other Java certifications: SCJD (Sun Certified Java Developer, SCWCD (Sun Certified Web Component Developer), SCBCD (Sun Certified Business Component Developer) and SCMAD (Sun Certified Mobile Application Developer).