Core Java Handout v1.0

(1)

Handout: Core Java

Version: Core Java/Handout/0408/1.0

Date: 30-04-08

Cognizant 500 Glen Pointe Center West Teaneck, NJ 07666 Ph: 201-801-0233 www.cognizant.com

(2)

Introduction

About this Module

This module provides students with the knowledge and skills that are needed to develop applications by using the Sun Java (Java Standard Edition, version 2.0).

Target Audience

This module is designed for beginners of Java who are expected to know the basic concepts of Object Oriented Programming.

Module Objectives

After completing this module handout, you will be able to:

Describe the characteristics of Java language

Define Java platform

Explain the concepts of packages, classes, objects, main method and System.out.println methods in Java language

Create Java application programs manually

Run Java application programs manually

Describe the features of Standard Development Environment (SDE)

Create a simple JAVA program in SDE

Execute a simple JAVA program in SDE

Write Java programs using keywords, variable declaration, operators, data types, arrays and Enum

Write Java programs using Control Flow statements, wrapper classes and autoboxing

Write Java programs using access specifiers, constructors, and methods

Write Java programs using the concepts of inheritance, interfaces, and abstract classes

Write Java programs implementing exceptions handling

Write Java programs using Strings, StringBuffer, StringBuilder, and its functions

Write Java programs using Collections and Util package

Write Java programs based on threading concepts

Write Java programs based on I/O operations

Write database application Java programs using JDBC

Explain Garbage Collection concepts

Implement Annotations in Java programs

List the new features of JDK 1.6

Pre-requisite

(29)

Session 02: Introduction to OOPS

Learning Objectives

After completing this session, you will be able to:

Describe OOP as a programming methodology

Explain classes and objects

Object Oriented Programming

OOP maps your problem in the real world.

OOP defines “things” (objects), which can either do something or have something done to them. OOP creates a “type” (class) for these objects so that you do not have to redo all the work in defining the properties and behavior of an object.

Examples of class:

Classroom

Car

Person

Procedural Versus OOP

“Nouns” refer to data and “Verbs” refer to operations. Procedural Languages:

C or Pascal and so on

Verb-oriented

No formal noun-verb structure (not enforced by language or compiler)

OOP languages: Operations (verbs) are performed by or on “Actors” (objects), which have names

and store data (nouns)

Objects

An object is a unique programming entity that has attributes to describe it (like adjectives in grammar) and methods to retrieve or set attribute values (like verbs in grammar).

Part of a program which:

Models some real or conceptual object

Has behavioural responsibilities (behaviors)

Has informational responsibilities (attributes)

Behaviors (methods):

(30)

Like procedures and functions in other languages

Attributes (fields):

Information an object “knows” (has-a)

Like data and variables in other languages (records)

Class

Exists once:

The class is the template for the object Defines the attributes and behavior of the objects

Every object must belong to a class: The creation (construction) of an object is called instantiation. The created object is often called an instance (or an instance of class X)

Example:

Person is a class

EdmundHillary is an instance of class Person

Try It Out

Problem Statement:

What is the difference between a class and an object?

Answer:

A class is not an object. But it is used to construct objects.

A class is a blueprint for an object. It tells the virtual machine how to make an object of that

particular type. Each object made from the class can have its own values for the instance variables of that class. Class Book { String id; String title; String author; void getChaptersList() {

System.out.println(“Getting the chapters list”); }

public static void main(String[] args) { Book book1 = new Book();

book1.getChaptersList(); Book book2 = new Book(); book2.getChaptersList(); }

(31)

Refer File Name: Book.java to obtain soft copy of the program code How It Works:

In the example provided, you have used the Book class to make different books, and each book has its own id, title, and author.

Tips and Tricks

Please tell whether the following file could be compiled: Class DiscDeck {

boolean canRecord = false; void playDisc() { System.out.println(“disc playing”); } void recordDisc() { System.out.println(“disc recording”); }

public static void main(String[] args) { dd.canRecord = true; dd.playDisc(); if (dd.canRecord == true) { dd.recordDisc(); } } }

Solution: The preceding file will result in compilation error since object is not created for the

DiscDeck class. This error will be fixed by adding DiskDeck dd = new DiscDeck(); statement in the main method.

Summary

Object-oriented programming lets you to extend a program without having to touch the working code that is tested earlier.

A class describes how to make an object of that class type. A class is like a blueprint.

An object knows things and does things.

The things an object knows about itself are called instance variables. They represent the state of an object.

The things an object does are called methods. They represent the behavior of an object.

Test Your Understanding

Find out who am I from the following: 1. I am compiled from a .java file ____ 2. I behave like a template or blueprint ____ 3. I have behaviors ____

(32)

4. I declare methods ____ 5. I represent ‘state’ ____

6. I am used to create object instances ____ 7. I am located in objects ____, ____

(33)

Session 03: Introduction to OOPS

Describe abstraction, encapsulation, and inheritance

Abstraction

One of the chief advantages of object oriented programming is the idea that programmers can essentially focus on the “big picture” and ignore specific details regarding the inner-workings of an object. This concept is called abstraction.

Encapsulation

Abstraction in OOP is closely related to a concept called encapsulation.

The Object Orientation has two major promises/benefits. They are: flexibility and maintainability.

You have to write your classes and code in a way that supports flexibility and maintainability.

The ability to make changes in your implementation code without breaking the code of others who use your code is a key benefit of encapsulation.

If you want maintainability, flexibility and extensibility your design must include encapsulation.

The following are some of the ways to include encapsulation:

o Keep instance variables protected (with an access modifier, often private). o Make public accessor methods, and force calling code to use those methods

rather than directly accessing the instance variable.

o For the methods, use the JavaBeans naming convention of set<someProperty> and get<someProperty>

Encapsulation is the mechanism that binds together the code and the data it manipulates, and keeps both safe from outside interference and misuse.

public variables and methods

private variables and methods

public variables are not recommended

(34)

Encapsulation: Example Bank machine Hidden data Account balance Personal information Interface

Deposit, Withdraw, Transfer Display account information

Class Hierarchy

Classes are arranged in a tree hierarchy:

A class’ “superclass” is the class preceding it in the hierarchy

Classes following it are “subclasses” Classes have all the properties of their superclasses:

General: Towards the root (top)

More specific: Towards the leaves (down)

NB: In Computer Science trees grow upside down!

Class Hierarchy: Example

Object Animal Bird Duck ... ... ... ... Inheritance

One of the main tenets of OOP is inheritance.

The process by which a class inherits the properties of its superclasses is called inheritance:

Methods

Instance variables

A child class inherits its properties and attributes from its parents.

Inheritance is the process by which one object acquires the properties of another object. By use of inheritance, an object needs only to define all of its characteristics that make it unique within its class; it can inherit its general attributes from its parent.

The inheriting class contains all the attributes and behaviors of its parent class. Moreover the inheriting class can define its own attributes and behaviors.

(35)

The inheriting class can override the definition of existing methods by providing its own implementation.

The code of the inheriting class consists only the changes and additions to the base class.

Need of inheritance

Inheritance is required for the following reasons:

Modular coding, which means less code and easier to get an idea about the code

Code reuse:

Do not break what is already working

Easier updates

Inheritance: Example

Try It Out

Problem Statement:

Design a class inheritance class diagram (tree structure) for the following:

Class Superclasses Subclasses

Clothing --- Shirt, Trouser

Shirt Clothing BankAccount int acctNum Client acctHolder double balance bankAccount(Client info) void deposit(double amt) boolean withdraw(double amt) void printStatement() double interestRate double accruedInterest Time lastBalanceChange savingsAccount(...) void updateIntRate(double rate)

void deposit(double amt) boolean withdraw(double amt) CurrentAccount double minBalance currentAccount(…) boolean withdraw(double amt) double calcServiceFee() SavingsAccount

(36)

Class Superclasses Subclasses

Trouser Clothing

Answer:

Inheritance Class Diagram

Refer File Name: Clothing.java, Shirt.java, Trouser.java to obtain soft copy of the program code

How It Works:

In the given example, Clothing is the superclass and its subclasses are Shirt and Trouser that is a Shirt extends Clothing and also a Trouser extends Clothing.

Tips and Tricks

1. The typical problems include real-time problems and challenges: 2. Are there any practical limits on the level of subclassing using Java? 3. Can you extend any class in Java?

Solution: With regard to Java API, there is no hard limit for the limits on the level of subclassing.

Using Java, you cannot extend any class as such. The factors like access control and access modifier determine whether a class can be subclassed.

Summary

A class can inherit instance variables and methods from a more abstract superclass.

1. Fill in the blanks for the following:

a) A sub class ______ all the public instance variables and methods of the super class.

b) If the base class or super class has functionality, then its ______ automatically gets the same functionality.

2. State true or false for the following: a) Guitar extends Instrument b) Animal extends Cat

Clothing

Trouser Shirt

(37)

Session 04: Introduction to OOPS

Describe polymorphism

Explain the relationship between objects

Polymorphism

Polymorphism (from Greek, meaning “many forms”) is a feature that allows one interface to be used for a general class of actions that is one interface with multiple methods.

Idea of polymorphism:

See internet definition: On Google type “definition polymorphism” and see the results

Moreover, refer the following url:

http://www.wordiq.com/definition/Polymorphism_%28computer_science%29

Generally, polymorphism allows you to mix methods and objects of different types in a consistent way.

Method Overloading

This is called ad hoc polymorphism, or method overloading. In this case, different methods within the same class or in a common hierarchy share the same name but have different method signatures (name + parameters)

public static float max(float a, float b)

public static float max(float a, float b, float c) public static int max(int a, int b)

When a method is called, the call signature is matched to the correct method version.

Note: This is done during program compilation

Subclassing Polymorphism

Subclassing polymorphism is sometimes called “true polymorphism”. It consists basically of two ideas:

Method overriding:

o A method defined in a superclass is redefined in a subclass with an identical method signature.

o As the signatures are identical, rather than overloading the method, it is instead overriding the method:

o For subclass objects, the definition in the subclass replaces the version in the superclass.

Dynamic (or late) binding:

o The code executed for a method call is associated with the call during run-time. o The actual method executed is determined by the type of the object and not the

(38)

o Allows superclass and subclass objects to be accessed in a regular and consistent way:

o Array or collection of superclass references can be used to access a mixture of superclass and subclass objects

o This is very useful if you want access collections of mixed data types (for example draw different graphical objects using the same draw() method call for each)

Example of a class

move()

Example of objects of the subclasses

Each subclass overrides the move() method in its own way. Animal [] A = new Animal[3];

A[0] = new Bird(); A[1] = new Person(); A[2] = new Fish();

for (int i = 0; i < A.length; i++) A[i].move();

References are all the same, but objects are not.

The method invoked is associated with the object and not with the reference.

Relationship Between Objects

Association:

Association states that there is a relation between two classes.

Example: The relation is of association type between Car and Owner or BankAccount

(39)

Aggregation:

Aggregation is a special form of association. The relation may be referred alternatively as “contains”, “is composed of”, or “is part of”.

Example: A car contains wheels. Wheels can exist independently from the car and

are not necessarily destroyed when the car is wrecked. Composition:

Composition is the relation in which the objects cannot exist independently from the whole.

Example: The car registration cannot exist without a car. So the relationship between

car and car registration number is composition.

Tips and Tricks

If you do not have access to the source code for a class, but you want to change the way a method of that class works, then could you use subclassing to do that that is to extend the “bad” class and override the method with your own better code?

Solution: Yes. This is a great feature of Object Oriented approach, and sometimes it saves you

from having to rewrite the class from scratch, or track down the programmer who is hiding the source code.

Summary

All Java code is defined in a class.

A class describes how to make an object of that class type. A class is like a blueprint.

An object can take care of itself, you do not have to know or care how the object does it.

An object knows things and does things.

The things an object knows about itself are called instance variables. They represent the state of an object.

The things an object does are called methods. They represent the behavior of an object.

When you create a class, you may also want to create a separate test class, which you will use to create objects of your new class type.

A class can inherit instance variables and methods from a more abstract superclass.

At run-time, a Java program is nothing more than objects ‘talking’ to other objects.

1. State true or false for the following:

a) Polymorphism means many forms.

(40)

Session 05: Introduction to Java and SDE

Explain the history of Java

Describe the features or characteristics of Java

Explain applets

Describe Java Virtual Machine (JVM) and bytecode

Explain Java Runtime Environment (JRE) and Java Development Kit (JDK)

History of Java

The original name of Java was Oak, and it was developed as a part of the Green project at Sun Microsystems.

Java was conceived by James Gosling, Patrick Naughton, Chris Warth, Ed Frank, and Mike Sheridon at Sun Microsystems in 1991.

The ultimate objectives of the team were:

To ensure security

To ensure reliability

To set up a platform independent language completely that would function seamlessly, regardless of the CPU

The World Wide Web (WWW), by nature, had requirements such as reliability, security, and architecture independence, which were fully compatible with the design patterns of Java. Sun formally announced the Java SunWorld in 1995.

Java Technology

Java is a programming language.

Java is a development environment that provides tools such as compiler, interpreter, documentation generator, and so on.

Java is an application environment to run standalone programs that run on any machine where the Java Runtime Environment (JRE) is installed.

Java is a deployment environment that supplies Java2 Software Development Kit (J2SDK) with complete set of Application Programming Interface (APIs) as packages.

Java provides an easy-to-use language by avoiding pitfalls of other languages, such as pointer arithmetic and memory management, which affect the robustness of the code.

(41)

Features or Characteristics of Java

The features of Java are:

Simple Object oriented Secure Platform independent Robust Portable

Automatic garbage collection

Dynamic

Multithreaded

Distributed

Applets

An applet is a program written in the Java programming language that can be included in a HTML page, much in the same way an image is included in a page.

An applet is designed to be transmitted over the Internet and is executed by a Java compatible Web browser.

An applet can react to user input dynamically.

Because applets are executed in the client machine, Java enforces a lot of restriction on applets.

Overview of Java Virtual Machine

Java Virtual Machine (JVM) specification defines the JVM as an imaginary (virtual) machine that is implemented by emulating it in software on a real machine. Code for the JVM is stored in .class files, each of which contains code for at most one public class.

The specification enables the Java language to be platform independent.

JVM is implemented in a Java technology development tool or in a Web browser.

Bytecode: Bytecode is a highly optimized set of instructions designed to be executed

by the JVM.

The key that allows Java to solve both the security and the portability problem is the output of Java compiler, which is not an executable code rather it is the bytecode.

The JVM is ported to different platforms to provide hardware and operating system independence, which is environment independent of hardware and operating system.

JVM needs to be implemented for each platform.

Java SE or J2SE Runtime Environment

J2SE stands for Java 2 Standard Edition. From Java SDK API version 1.5 onwards, this is referred to as Java SE (Java Standard Edition).

The JRE provides the libraries, JVM, Java Interpreter, and other components necessarily for you to run applets and applications written in Java.

(42)

JRE is responsible for loading, verifying, and executing the bytecodes.

The JDK includes the JRE as well as command-line development tools, such as compilers and debuggers that are necessary or useful for developing applets and applications.

The Java API is a code that is written earlier, organized into packages of similar topics, and it is a part of JDK libraries.

Tips and Tricks

What is a Java program? What do you actually deliver?

Solution: A Java program is a pile of classes (or at least one class). In a Java application, one of

the classes must have a main method, used to start-up the program. So as a programmer, you write one or more classes, which you deliver. If the end-user does not have a JVM, then you will also need to include that with the classes of your application, so that they can run your program. There are a number of installer programs that lets you to bundle your classes with a variety of JVMs (say, for different platforms), and put it all on a CD-ROM. Then the end-user can install the correct version of JVM (assuming they do not already have it on their machine.).

Summary

Keeping the following objectives in mind, Java language has been developed: o Security

o Reliability

Completely platform independent and functions seamlessly regardless of the type of CPU

Java is a development environment, which provides tools like compiler, interpreter, documentation generator, and so on.

Secure, object oriented, robust, portable, platform independent, multithreaded are some of the salient features of Java.

An applet is a program, which is downloaded in the client machine and executed by the JVM of the client machine.

Bytecode is a highly optimized set of instructions designed to be executed by the JVM.

The JRE provides the libraries, JVM, Java Interpreter, and other components necessary for you to run applets and applications written in Java.

a) Java is an Object Oriented Programming language. b) Java is developed at Microsoft.

c) Java is secure, robust, and multi-threaded. d) Java is platform dependent.

e) A Java source file (*.java) is compiled and the corresponding bytecode is available in the *.class file.

f) To run a Java program on any Operating System, JRE appropriate to that OS must be available.

(43)

Session 06: Introduction to Java and SDE

Define a class

Create objects

Identify packages, import statement, and Object class

Explain object messaging

Defining a Class

A class is a basic building block of an object oriented language.

A class is a template that describes the data and the methods that manipulate the data. Examples of class:

Classroom

Car

Person

The following Java program defines a class Person with data member name: Class Person

private String name;

public void setName(String aName) { name = aName;

}

public String getName() { return name;

} }

The data members in a class can be defined as follows:

Instance variable:

o This differentiates one object from another, giving an object its individuality. For example, the particular name and address for a given Person object is declared as an instance variable.

o An instance variable relates to an instance (object) of its class.

Class variable:

o The data that is shared by all the objects are declared as class variables.

o There is only one copy of each of these variables no matter how many objects are created for the class.

(44)

o These variables are also referred to as static fields because they are declared with the keyword static.

o Data members of the class are normally declared as instance variables using the keyword private.

Creating Objects

An object is created from a class.

The following statement creates an object: Person EdmundHillary = new Person();

The preceding statement has three parts:

Declaration: This notifies the compiler that you will use name to refer to data whose

type is type;

Person EdmundHillary

Instantiation: The new keyword is a Java operator that creates the object.

EdmundHillary = new Person()

Initialization: The new operator is followed by a call to a constructor. The constructor

will contain code that initializes the new object to the desired values.

Packages

Every class in the Java library belong to a package.

In the Java API, classes are grouped into packages.

A class has a full name, which is a combination of the package name and the class name. For example, the class ArrayList is actually java.util.ArrayList.

To use a class in a package other than java.lang, you must tell Java the full name of the class.

Packages are important for three main reasons:

o Firstly, they help in the overall organization of a project or library.

o Secondly, packages give you a name-scoping, to help to prevent collisions if many programmers in a company decide to make a class with the same name.

o Thirdly, packages provide a level of security, because you can restrict the code, which you write so that only other classes in the same package can access it.

To put a class in a package, put a package statement at the top of the source code file, before any import statement like package com.mypack;.

To be in a package, a class must be in a directory structure that exactly matches the package structure. For a class, com.mypack.Book, the Book class must be in a directory named mypack, which is in a directory named com.

Organizing your classes into packages prevents naming collisions with other classes, if you preponed your reverse domain name on to the front of a class name.

Import Statement

A typical set of import statements might look like the following:

import java.io.*;

(45)

import java.util.Date;

import java.util.Properties;

The import statements must come right after the package statement, before the class statement. Purpose of import statement:

Because of the rigid source code naming convention, the Java compiler can easily find the corresponding source or class files just from the fully qualified name of a package and class. This can be illustrated with the following example:

java.util.ArrayList myList = new java.util.ArrayList(50);

The alternative to this long-winded style of coding (as shown earlier), is to use import statements like the following:

import java.util.ArrayList;

…

ArrayList myList = new ArrayList(50);

To derive a class from an external superclass, you must first import the superclass using the import statement.

Object Class

Every class in Java extends class Object that is the Object class is the mother of all classes. It is the superclass of everything.

Any class that does not explicitly extend another class, implicitly extends Object class. Few of the important methods of the Object class are as follows:

equals(Object obj) : Indicates whether some other object is "equal to" this one

and it returns a boolean value as true or false

toString() : Returns a string representation of the object

hashCode() : Returns a hash code value (of integer type) for the object

Object Messaging

Objects cooperate and communicate with other objects in a program by passing messages to one another (setting a value, returning a value, or sending an email).

When an object invokes a method on itself or on the method of another object, it is said to pass a message to the object that contains the target method.

The message contains the name of the method and any data that the method requires.

Example: person.setName(“EdmundHillary”);

Data that are passed to a method are known as arguments. The required arguments for a method are defined by a parameter list of the method.

After performing the operation, the body of the method uses the return statement to return the value to the calling object.

this keyword:

o Used to represent the object that invokes the method:

(46)

this keyword

this keyword refers to the object that is currently executing.

this keyword also allows one constructor to explicitly invoke another constructor in the same class.

It is useful for a method to refer to instance variables relative to this keyword when a local variable hides the data member with the same name, like the following code: Class Person { String name; Person(String name) { this.name = name; } ……. } Try It Out Problem Statement:

Illustrate the importance of the objects with relevant to entries in the address book.

Code:

class AddressBook { String id;

int telephoneNumber;

public void getName() { }

public String setName(String aName) { } public String changeName(String aName) { } }

Refer File Name: AddressBook.java to obtain soft copy of the program code How It Works:

One analogy for objects is a packet of unused visiting cards in the address book.

Each card has the same blank fields (the instance variables).

When you fill out a card, you are creating an instance (object), and the entries you make on that card represent its state.

The methods of the class are the things you do to a particular card.

getName() , changeName(String aName) , and setName(String aName) could all be the methods for the class AddressBook.

So, each card can do the same things (getName() , setName(String aName) ,and so on), but each card knows things unique to that particular card.

(47)

Tips and Tricks

What if you have a hundred classes or a thousand? Is not that a big pain to deliver all those individual files? Can these classes be bundled into one application thing?

Solution: Yes, it would be a big pain to deliver a huge bunch of individual files to your end-users,

but you will not have to. You can put all of your application files into a Java Archive or a .jar file that is based on the pkzip format. In the jar file, you can include a simple text file formatted as

something called a manifest, that defines which class in that jar holds the main() method that should run.

Summary

A class describes how to make an object of that class type. A class is like a blueprint.

An object knows things and does things.

The things an object knows about itself are called instance variables. They represent the state of an object.

The things an object does are called methods. They represent the behaviour of an object.

a) The package statement in a Java program, if available, can be written anywhere in the code.

b) The import statement can be placed next to the package statement in a Java program.

c) A Java class is made up of data members and methods. d) Every class in Java does not extend the Object class.

Core Java Handout v1.0

Handout: Core Java

TABLE OF CONTENTS

Introduction

Session 02: Introduction to OOPS

Session 03: Introduction to OOPS

Session 04: Introduction to OOPS

Session 05: Introduction to Java and SDE

Session 06: Introduction to Java and SDE