Vishal Layka [Vishal Layka] - Learn Java for Web Development: Modern Java Web Development

About the Author

Vishal Layka is the chief technology officer of Star Protocol. He is involved in the architecture, design, and implementation of distributed business systems, and his focus is on consulting and training with the JVM languages. His language proficiencies include Java, Groovy, Scala, and Haskell. Vishal is also the lead author of Beginning Groovy, Grails, and Griffon (Apress, 2012). When he needs a break from technology, Vishal reads eclectically from calculus to star formation.

About the Technical Reviewer

Boris Minkin is a senior technical architect at a major financial corporation. He has more than 20 years of experience working in various areas of information technology and financial services. Boris obtained his masters degree in information systems at Stevens Institute of Technology in New Jersey. His professional interests are in Internet technology, service-oriented architecture, enterprise application architecture and development, cloud computing, distributed caching, Java, and grid and high-performance computing. You can contact Boris at .

Appendix A

Introduction to Java

One of the fundamental ways in which complexity can be handled is abstraction, which is applied in almost every discipline. For instance, abstract art is art that does not represent or imitate external reality or the objects of nature. As another example, some words are abstract, existing only in the mind, like truth or justice. In Java, abstraction allows developers to layer complex systems into manageable pieces by using class hierarchies that highlight the essential properties and behaviors of an object, differentiating it from other objects.

Classes and Objects

A class is the fundamental building block of object-oriented (OO) programs..

. A Java Class

class ClassA {
// members declarations
}

An object is an instance of a class.

. Creating the Object

ClassA var1 = new ClassA();

The process of creating objects involves declaring a reference variable to store the reference value of the object and then creating the object using the new keyword followed by initializing the object by a call to a constructor. The concept of constructor is explained later in the appendix. to show the declaration and creation as separate steps.

. The Declaration and Creation in Separate Steps

1. ClassA var1 ;
2. var1 = new ClassA();

• Line 1 declares the variable var1 . The reference variable var1 can now be used to manipulate the object whose reference value is stored in the reference variable.
• Line 2 creates the object using the new keyword and initialization by calling a constructor ClassA() .

Variables

In Java, variables store values of primitive data types and reference values of objects.

illustrates variable declarations that can store primitive values.

. Variable Declarations

int a, b, c; // a, b and c are integer variables.
boolean flag; // flag is a boolean variable.
int i = 10, // i is an int variable with initial value 10

Variables that store reference values of objects are called reference variables. The reference variables specify the type of reference that can be a class, an array, or an interface.

. Reference Variable Declarations

ClassA var1 ; // Variable var1 can reference objects of class ClassA.

The declaration in the does not create any object of class ClassA ; it just creates variable that can store references of objects of ClassA .

Instance Members

Each object created (as illustrated in ) to distinguish them from static members, which belong only to the class.

. The Instance Members

1. class ClassA{
2. // instance Members
3. int i ; // instance variable
4. void methodA(){// instance method
5. // do something
6. }
7. }

• In line 3, i is an instance variable of type int , and int is the primitive data type of i .
• In line 4, methodA(){} is an instance method.

Static Members

Static members, declared with the keyword static , are the members that belong only to the class and not to any specific objects of the class. A class can have static variables and static methods. Static variables are initialized when the class is loaded at runtime. Similarly, a class can have static methods that belong to the class and not to any specific objects of the class, as illustrated in

. Static Members

1. class ClassA{
2. static int i ;
3. static void methodA(){
4. // do something
5. }
6. }

Unlike instance members, static members in a class can be accessed using the class name, as shown here:

ClassA.i // accessing static variable in Line 2 of

Though static members in a class can be accessed via object references, it is considered bad practice to do so.

Method Overloading

Each method has a name and a formal parameter list. The name of the method and its formal parameter list together with the type and the order of the parameter in the parameter list constitute the signature of the method. shows five implementations of the method methodA .

. Overloaded MethodA( )

1. void methodA{(int a, double b) }
2. int methodA(int a) { return a; }
3. int methodA() { return 1; }
4. long methodA(double a, int b) { return b; }
5. long methodA(int c, double d) { return a; } // Not ok.

• The first four implementations of method are overloaded correctly, each time with a different parameter list and, therefore, different signatures.
• The declaration on line 5 has the same signature methodA(int, double) as the declaration on line 1. Changing just the return type is not enough to overload a method; the parameter list in the declarations must be different.

Note Only methods declared in the same class and those that are inherited by the class can be overloaded.

Arrays

An array is a data structure that is comprised of a fixed number of data elements essentially of the same data type. declares references that refer to the array objects.

. Array Declarations

int [] intArray;
ClassA[] classAArray ;

The two declarations in declare intArray and classAArray to be reference variables that can refer to arrays of int values and arrays of ClassA objects. An array can be constructed for a fixed number of elements of a specific type, using the new operator. Given the previous array declarations, the arrays can be constructed as follows:

intArray = new int[10]; // array for 10 integers
classAArray = new ClassA[5]; // array of 5 objects of ClassA

Constructors

When an object is created using a new operator, the constructors are called to set the initial state of an object. A constructor declaration is comprised of the accessibility modifier followed by the parameter list with the following declarations:

• Modifiers other than an accessibility modifier are not permitted in the constructor header.
• Constructors cannot return a value and, therefore, do not specify a return type, not even void, in the constructor header.
• The constructor name must be the same as the class name.

When no constructors are specified in a class, then an implicit default constructor, that is, an implicit constructor without any parameters, is generated for the class by the compiler that comprises a call to the superclasss constructor. The compiler inserts this call to a superclasss constructor to ensure that the inherited state of the object is initialized. illustrates a call to an implicit default constructor.

Next page