Compiled Lecture Java

1

Course Objectives

• To revise Object Oriented Programming concepts • To introduce Java architecture and the basic syntax of Java • To introduce the implementation of object oriented concepts using Java • To introduce the Java library• To introduce exception handling in Java• To introduce annotations in Java• To introduce JDBC

2

Course Agenda (1/2)

• LOC 1– Object Oriented Concepts

– The Java Architecture

– The basic constructs in Java

– Arrays

• LOC 2– OO SDLC

– Classes and Objects

– Constructors

– Method Overloading

– Static Members

– Command Line Arguments

– Class Relationships

3

Course Agenda (2/2)

• LOC 3– Method Overriding

– Abstract classes

– Dynamic Binding and Runtime Polymorphism

– The final keyword

– Packages

– The Java Library

– Exception Handling

4

References

• Herbert Schildt, “The Complete Reference, Java J2SE 5 Edition”, Tata McGraw Edition

• Sierra, Kathy and Bates, Bert, “Head First Java, 2nd Edition”, Shroff Publishers

5

What is Java and where is Java being used?

• Java is a very powerful OO programming language developed by Sun Microsystems

• Java is widely used for developing web applications• Java is the programming language used for developing Enterprise

Applications using the JEE Platform

Copyright © 2007, Infosys Technologies Ltd

Object Oriented Programming – A Quick Revision

7

Software Complexity

• There are two categories of software

– Software developed for individuals for their own use

– Industrial strength software normally used by many people

• Industrial strength software is very complex in nature because of several

reasons

– Numerous Business rules (Functional Requirements)

– Non-Functional Requirements like Usability, Performance, Reliability etc

– Complexity due to development process

9

Ways to handle Software Complexity

• Unstructured Programming

– Use of goto statements

– Lengthy code with no modularity

– As size increases, code becomes more complex to maintain

• Procedural Programming or Structured Programming was introduced to

handle software complexity

– Brought in Modularity in coding, enhancing maintainability

– Complexity made manageable by hiding complexity inside functions (Concept

of APIs)

– Introduced the concept of structures (also known as data structures)

10

Limitations of Structured Programming

• In structured programming, focus is on the algorithm and importance is

given to the procedure (logic) and not to the data on which these

procedures operate

• The entire problem was divided into a number of smaller units

– Functions/Procedures

• All these units need to work on a data item to produce the result

– The data need to be global

– Global data made the code complex

• As the code size grows, maintaining code becomes difficult

11

Object Oriented Programming

• Object Oriented Programming

– The entire program is visualized as a number of objects interacting with each

other

• An object is a self-contained entity that contains attributes (data) and

behaviors (functions)

– Car, Telephone, Pen

• For using an object one needs to just invoke a method (function) on the

object

– No need to know the internal details (data) of the object

12

State and Behavior

• Example: Car object

– State

– Current Speed

– Current Gear

– Engine State (Running, Not Running)

– Behavior (Acts on the object and

changes state)

– Slow down

– Accelerate

– Stop

– Switch Off Engine

– Start Engine

• Example: Dog Object

– State

–Color

–Breed

–Activity (Barking/Not barking)

–Tail Activity (Wagging/Not

Wagging)

– Behavior

–Bark

–Wag Tail

–Eat

13

What is a Class? (1/3)

• A Class

– Is a blue print used to create objects.

– Is a software template that defines the methods and variables to be included

in a particular kind of Object.

• Examples

– Animal, Human Being, Automobiles, Bank Account, Customer

14


• A class contains state and behavior

• State (Member Variables)

– Variables defined inside the class

– Not exposed to external world

• Behavior (Member Methods)

– Functions defined inside the class

– Behavior exhibited by the class to external world

– Exposed to external world

• An object is an instance of a class

15


Class ‘Car’

45 km/h

CurrentSpeed

3

CurrentGear

5

Numberof Gears

7

SeatingCapacity

4

Numberof Doors

Accelerate

Brake

(Slo

w

Down)

Change Gear

(STATE)

(BEHAVIOR) Interface to externalworld (ThroughMethods/ Functionsonly)

State is internal tothe object. Notexposed to externalworld/other objects

16

Example: Objects and Classes

Daria

R002

Jane

R003

Brittany

R004

Jodie

R001

classobject

Class Student

name

rollNo

setName()

setRollNo()

getMarks()

17

Abstraction (1/2)

• The process of exposing the relevant details and hiding the irrelevant

details is called Abstraction

– Helps simplify the understanding and using of any complex system

– One does not have to understand how the engine works to drive a car

– Similarly one does not have to understand the internal implementation of a

software object to use it

Engine Driving

18

Abstraction (2/2)

• Consider a Stack

– The Stack can be implemented using an array or a linked list

– One need not know this to use the Stack object

– Just invoke the push method and pop method to make the Stack object work

19

Encapsulation

• Encapsulate = “En” + “Capsulate”; En = “In a”; Encapsulate = “In a

Capsule”

– Localization of information of knowledge within an object.

– Information hiding

– A car’s dashboard hides the complexity and internal workings of its engine.

20

Encapsulation (Data Hiding)

• Process of hiding the members from outside the class

• Implemented using the concept of access specifiers

– public, private etc.

• Typically in a class

– State is private (not accessible externally)

– Behavior is public (accessible externally)

• By enforcing this restriction, object oriented programming allows isolation

of complexity in a manageable way

21

Encapsulation (Data Hiding)

• In a class Stack, the data could be stored in an array which will be private

• The methods push and pop will be public

– A program cannot access the array directly from outside the class

– A program can access the array indirectly through the push and pop methods

22

Polymorphism

• Refers to an object’s ability to behave differently depending on its type– Poly = ‘many’

– morph = ‘form’

• Method Overloading is a way to achieve polymorphism• Practice of using same method name to denote several different

operations

23

Polymorphism

• For example, consider a class String which is designed to simplify string operations

• Append functions are overloaded to accept different types of data• One Append function appends an integer value to string, another Append

function appends a float value– void append(int)

– void append(float)

• The appropriate function will be invoked based on the type of the argument used in the function call

• Any number of functions can have the same name as long as they differ in any one of the following

– Type of arguments

– Number of arguments

– Order of arguments

24

UML and UML Class Diagrams

• Unified Modeling Language (UML) is a set of diagrams which pictorially represent object oriented design

• UML is extensively used by software engineers to communicate design• In OO Design

– Pictures are easier to understand than textual explanation

• UML Class diagram is a technique to represent classes and their relationships pictorially

25

Representing a class in UML Class Diagrams

+getName() : string+getAge() : int+getEmployeeNumber() : int+getBasicSalary() : float+getAllowances() : float+getTotalSalary() : float

-name : string-age : int-employeeNumber : int-basicSalary : float-allowances : float

Employee

UML Class Diagram Representation ofEmployee class

Class name

MemberVariables

MemberFunctions

• Some notations in UML

– ‘+’ before a member

indicates ‘public’

– ‘-’ before a member

indicates ‘private’

26

Relationships

• Different types of relationships can exist between classes• Identifying relationships helps design the objects better

– Analogous to relations between entities in RDBMS design

• There are 3 types of relationships• Has-A (or Part-Of)

– Car has an Engine

• Uses-A– Driver uses a Car

• Is-A (or Kind-Of)– Trainee is an Employee

27

Can you answer these questions?

• How is structured programming different from object oriented programming?

• What are classes and objects?• What is abstraction?• What is encapsulation?• What is polymorphism?• What is UML?• What are the relationships that can exist between classes?

28

Summary

• Classes and Objects• Abstraction• Encapsulation• Polymorphism• UML• Class relationships


Java Programming

30

Introduction to Java

• Java is a language developed by Sun Microsystems

• Java was developed initially for consumer devices

• Now it is a popular platform to develop web based enterprise applications

31

Salient Features of Java

• Object Oriented• Simpler language

– Compared to earlier OO languages like C++, it is simple

– Designed considering the pitfalls of earlier languages

• Architecture Neutral/Portable– Example: Java code compiled on Windows can be run on Unix without

recompilation

– Write Once, Run Anywhere

• Secure– Built -in security features like absence of pointers

32

Platform Independence

• Java is platform independent.

• A Java program that is written and compiled in one platform can run

on any other platform without any recompilation or modification

– Write Once Run Anywhere

33

Java Compiler

• The source code of Java will be stored in a text file with

extension .java

• The Java compiler compiles a .java file into byte code

– Byte code will be in a file with extension .class

– Languages like C compiles the program into the machine language format

of the hardware platform on which it is running

– Byte Code is NOT in the machine language format of the hardware

platform on which the code is compiled

– The hardware processor cannot understand the byte code

34

JVM (1/2)

• The byte code is in the machine language format of a machine known

as the Java Virtual Machine or the JVM

– Needs a JVM to execute the byte code

– JVM is not a real machine, it is just a virtual machine; implemented in

software

35

JVM (2/2)

• JVM is platform dependant; that is there is one JVM for Windows, another one for UNIX, yet another one for Mainframe etc

• All JVMs accept the same input, the byte code• Each JVM interprets the byte code into the machine language format of

the platform on which it is running• The same byte code can be run on any platform, if the JVM for that

platform is available– The JVMs for all platforms are available free (http://java.sun.com/) and hence

we say that the byte code runs in all platforms

36

Java Architecture

Compiler (javac)

Machine Code or Byte code (HelloWorld.class)

Operating System

Hardware

Source File (HelloWorld.java)

JVM

37

A Sample Java Application

• The following program can be created using any text editor

• Save the file as HelloWorld.java

• Take care; case of file name matters

public class HelloWorld{

public static void main(String [] args){

System.out.println(“Hello World!”);

}

}

38

To Compile

• Open a command prompt• Go to the directory in which the source file is saved• Type the following command

• The Java compiler will convert the source code into the byte code

– HelloWorld.class

javac HelloWorld.java

39

To execute

• Use the following command to execute the bytecode

java HelloWorld

40

Compilation & Execution

Java Program(.java)

Java Compiler(javac)

Byte Code(.class)

Interpreter(java) Interpreter(java) Interpreter(java)

Win32 Linux Mac

41

Primitive Data Types in Java

• Integer Types

– byte (1 byte)

– short (2 bytes)

– int (4 bytes)

– long (8 bytes)

• Floating Type

– float (4 bytes)

– double (8 bytes)

• All numeric data types are

signed

• The size of data types remain

the same on all platforms

42

Primitive Data Types in Java

• Textual

– char (2 bytes)

• Logical

– boolean (1 byte) (true/false)

• The char data type in Java is 2

bytes because it uses

UNICODE character set to

support internationalization

• UNICODE is a character set

which covers all known scripts

and language in the world

43

Comments in Java

• A single line comment in Java will start with //

• A multi line comment starts with a /* and ends with a */

// This is a single line comment in Java

/* This is a multi line

comment

in Java */

44

Variables in Java (1/2)

• Declaring and using primitive data types is Java similar to that of C

int count;

int max=100;

45

Variables in Java (2/2)

• Unlike C, in Java variables can be declared anywhere in the program

int i = 10;

System.out.println(“Program starts here”);

int j = 20;

for (int count=0; count < max; count++) {

int z = count * 10;

}

BEST PRACTICE: Declare a variable in program only when required. Do not declare variables upfront like in C.

46

Local Variables

• In Java, if a local variable is used without initializing it, the compiler will show an error

class Sample{

public static void main (String [] args){

int count;

System.out.println(count);//Error

}

}

47

Typecasting of primitive data types

• Variable of smaller capacity can be assigned to another variable of bigger capacity without any explicit typecasting

int i = 10;

double d;

d = i;

• Whenever a larger type is converted to a smaller type, the typecast operator has to be explicitly specified

double d = 10;

int i;

i = (int) d;

Type cast operator

48

Operators

• Operators in Java are very similar to operators in C– Assignment Operators

– Arithmetic Operators

– Relational Operators

– Logical Operators

49

Control Statements

• The syntax of the control statements in Java are very similar to that of C language

– if

– if-else

– for

– while

– do-while

– switch

– break

– continue

50

Methods in Java

• The syntax of writing methods in Java is similar to that of functions in C• Unlike C

– All methods in Java should be written inside a class

– There is no default return type for a Java method

51

Arrays in Java

• In Java, all arrays are created dynamically• The operator new is used for dynamic memory allocation• The following statement creates an array of 5 integers

new int[5]

• The above statement returns a reference to the newly created array

– References in Java are very similar to pointers in C

52

Reference variables in Java (1/4)

• Reference variables are used in Java to store the references of the objects created by the operator new

• Any one of the following syntax can be used to create a reference to an int array

int x[];

int [] x;

• The reference x can be used for referring to any int array

//Declare a reference to an int array

int [] x;

//Create a new int array and make x refer to it

x = new int[5];

53


• The following statement also creates a new int array and assigns its reference to x

int [] x = new int[5];

• In simple terms, reference can be seen as the name of the array

54


• Even though we can think of Java references as C pointers, their usages are different

Pointers References

Printing a pointer will print the address stored in it

Printing a reference will NOT print the address of the object referred by it

Pointer arithmetic like incrementing a pointer is valid in the case of a pointer

We cannot use arithmetic operators on references

A pointer has to be de-referenced using the * operator to get the value pointed by it

A reference is automatically de-referenced to give the data referred by it and no special operator is required for this

55

Reference Types in Java (4/4)

• A reference type can be assigned ‘null’ to show that it is not referring to any object

– ‘null’ is a keyword in Java

int [] x = null;

56

Initializing an array in Java

• An array can be initialized while it is created as follows

int [] x = {1, 2, 3, 4};

char [] c = {‘a’, ‘b’, ‘c’};

57

The length of an array

• Unlike C, Java checks the boundary of an array while accessing an element in it

– Java will not allow the programmer to exceed its boundary

• If x is a reference to an array, x.length will give you the length of the array– The for loops can be set up as follows

for(int i = 0; i < x.length; ++i){

x[i] = 5;

}

58

Multidimensional Arrays

• Multidimensional arrays are arrays of arrays. • To declare a multidimensional array variable, specify each additional

index using another set of square brackets.

int [][] x;

//x is a reference to an array of int arrays

x = new int[3][4];

/*Create 3 new int arrays, each having 4 elements

x[0] refers to the first int array, x[1] to the second etc

x[0][0] is the first element of the first array

x.length will be 3

x[0].length, x[1].length and x[2].length will be 4 */

59


• How is Java made platform neutral?• What is a reference variable in Java?

60

Summary:

• Review of Object Oriented Concepts• Java architecture • The basic constructs in Java • Arrays in Java


Classes and Objects in Java


OO Analysis

• OO SDLC has three phases

– OO Analysis (Identifying classes and their relationships)

– OO Design (Designing the data members and methods of a class)

– OO Implementation (Implementing the design using an OOP language)

• An easy way to identify the classes are to identify the nouns in the requirements specifications

• For example, a system to automate an Insurance company will have to manage the information about the Policy Holders

– class PolicyHolder


OO Design

• Once the class is identified, we have to identify the data members and methods required in the class

• Data Members

– Policy No– Name of the Policy Holder– Address– Details of the Policy– Bonus Amount– etc…

• Methods

– Set the Policy No– Get the Policy No– Set the Name of the Policy Holder– Get the Name of the Policy Holder– etc…


Access Modifiers – private and public

• Data members are usually kept private

– It is accessible only within the class• The methods which expose the behavior of the object are kept public• Key feature of OOP

– Encapsulation (binding of code and data together)

– State (data) is hidden and Behavior (methods) is exposed to external world


Classes in Java

public class PolicyHolder{

private int policyNo;

private double bonus;

//Other Data Members

public void setPolicyNo(int no){policyNo = no;}

public int getPolicyNo(){return policyNo;}

public void setBonus(char amount){bonus = amount;}

public double getBonus(){return bonus;}

//Other Methods

}

Data Members (State)

Methods (Behavior)

• The main method may or may not be present in a class depending on whether it is a starter class or not


Creating Objects in Java (1/2)

• In Java, all objects are created dynamically

– The operator new is used for dynamic memory allocation• The following statement creates an object of the class Student

new PolicyHolder()

• The above statement returns a reference to the newly created object


Creating Objects in Java (2/2)

• The following statement creates a reference to the class PolicyHolder

PolicyHolder policyHolder;

• The reference policyHolder can be used for referring to any object of type PolicyHolder

//Declare a reference to class PolicyHolder


//Create a new PolicyHolder object

//Make policyHolder refer to the new object

PolicyHolder policyHolder = new PolicyHolder();


Invoking methods in a class

• The following statement also creates a new PolicyHolder object and assigns its reference to policyHolder


• All the public members of the object can be accessed with the help of the reference


policyHolder.setPolicyNo(20);

System.out.println(policyHolder.getPolicyNo());

• The reference can be seen as the name of an object


The this Reference (1/2)

• The methods in a class have a reference called this

– “this” reference will refer to the object that has invoked the method

– When the method getPolicylNo is invoked by an object x, the

usage of “this” in this method refers to x

public int getPolicyNo(){

return policyNo;

//return this.policyNo;

//These statements are similar

}


this Reference (2/2)

• The this reference can be used in some cases to improve the readability of a program





public void setPolicyNo(int policyNo){this.policyNo = policyNo;}

public int getPolicyNo(){return policyNo;}

public void setBonus(char bonus){this.bonus = bonus;}

public double getBonus(){return bonus;}

//Other Methods

}


Constructors (1/5)

• A constructor is a special method that is called to create a new object


Calling the constructor

• It is not mandatory for the coder to write a constructor for the class

• It can be seen as a readily available, implicit method in every class


Constructors (2/5)

• The coder can write a constructor in a class, if required• If a user defined constructor is available, it is called just after the memory

is allocated for the object• If no user defined constructor is provided for a class, the implicit

constructor initializes the member variables to its default values

– numeric data types are set to 0– char data types are set to null character(‘\0’)– boolean data types are set to false– reference variables are set to null


Constructors (3/5)

• The user defined constructor is usually used to initialize the data members of the objects to some specific values, other than the default values

• A constructor method

– will have the same name as that of the class– will not have any return type, not even void


Constructors (4/5)


//policyHolder.bonus is initialized to 100


//Data Members

public PolicyHolder(){

bonus = 100;

}

//Other Methods

}

User defined

Constructor


Method Overloading (1/3)

• Two or more methods in a Java class can have the same name, if their argument lists are different

• Argument list could differ in

- No of parameters

- Data type of parameters

- Sequence of parameters• This feature is known as Method Overloading



void print(int i){

System.out.println(i);

}

void print(double d){

System.out.println(d);

}

void print(char c){

System.out.println(c);

}

• Calls to overloaded methods will be resolved during compile time

– Static Polymorphism



Not overloading. Compiler error.

Overloaded methods

void add (int a, int b)

void add (int a, float b)

void add (float a, int b)

void add (int a, int b, float c)

void add (int a, float b)

int add (int a, float b)


Overloading the Constructors

• Just like other methods, constructors also can be overloaded

• The constructor without any parameter is called a default constructor


Constructors (5/5)


//Data Members


bonus = 100;

}

public PolicyHolder(int policyNo, double bonus){

this.policyNo = policyNo;

this.bonus = bonus;

}

//Other Methods

}

PolicyHolder policyHolder1 = new PolicyHolder();

//policyHolder1.policyNo is 0 and bonus is 100

PolicyHolder policyHolder = new PolicyHolder(1, 200);

//policyHolder1.policyNo is 1 and bonus is 200


Memory Allocation (1/2)

• All local variables are stored in a stack

– These variables are de-allocated in a last in first out order as soon as the method terminates

• All dynamically allocated arrays and objects are stored in heap

– They need not be de-allocated in any specific order

– They can be garbage collected (removed from the memory) as and when their use is over


Memory Allocation (2/2)





public void sample(int x){

int y;

//More Statements

}

//More Methods

}

class Test{



policyHolder = new PolicyHolder();

}

}

Data members of the class are stored in the heap along

with the object. Their lifetime depends on the

lifetime of the object

Local variables x and y are stored in the

Stack

Local variable policyHolder is stored

in the Stack

Dynamic objects will be stored in the heap


Lifetime of objects (1 of 2)

• Policy policy1 = new Policy();• Policy policy2 = new Policy();• The two Policy objects are now living on the heap

– References: 2– Objects: 2

• Policy policy3 = policy2;


2

policyNo

bonus

1

policyNo

bonus

heap

policy1

policy2

2

policyNo

bonus

1

policyNo

bonusheap

policy1

policy2

policy3


Lifetime of objects (2 of 2)

• policy3 = policy1;


• policy2 = null;

– Active References: 2– null references: 1– Reachable Objects: 1– Abandoned objects: 1

2

policyNo

bonus

1

policyNo

bonusheap

policy1

policy2

policy3

2

policyNo

bonus

1

policyNo

bonus

policy1

policy2

policy3 heap

Null reference

This object can be garbage collected (Can be Removed

from memory)


Garbage Collection

• In programming languages like C and C++, the programmer has to de-allocate all dynamic memory

• An object that is not referred by any reference variable will be removed from the memory by the garbage collector

– Automatic Garbage Collection– If a reference variable is declared within a

function, the reference is invalidated soon as the function call ends

– Programmer can explicitly set the reference variable to null to indicate that the referred object is no longer in use

• Primitive types are not objects and they cannot be assigned null


Array of Objects

• An array of objects is created as follows

PolicyHolder [] policyHolder = new PolicyHolder[3];

/*3 PolicyHolder references policyHolder[0], policyHolder[1] and policyHolder[2] are created and all 3 references are null*/

for(int i = 0; i < policyHolder.length; ++i){

policyHolder[i] = new PolicyHolder();

//Creating PolicyHolder object

}

for(int i = 0; i < policyHolder.length; ++i){

System.out.println(policyHolder[i].getPolicyNo());

}


Object as Method Arguments and Return Types (1/2)

• Objects and arrays can be passed to a method by passing their references as arguments

• Similarly, they can be returned from a method by returning their references


//Data Members and Other Methods

public boolean isSame(PolicyHolder policyHolder){

return this.policyNo == policyHolder.policyNo;

}

}

if (policyHolder1.isSame(policyHolder2)){

//Statements

}


Object as Method Arguments and Return Types (2/2)



public PolicyHolder getObject(){


policyHolder.policyNo = policyNo;

policyHolder.bonus = bonus;

//More Statements

return policyHolder;

}

}

policyHolder2 = policyHolder1.getObject();


The static keyword

• The static keyword can be used in 3 scenarios:

– For class variables– For methods– For a block of code


Static Data Members

• Static data is a data that is common to the entire class• Assume that the class PolicyHolder wants to keep track of the total number of Policy

Holders

– The data common to the entire class– An int data member total should be declared as static– A single copy of total will be shared by all instances of the class




private static int total;

//Other Data Members and Methods

}

The static variable is initialized to 0, ONLY when the class is first loaded,

NOT each time a new instance is made


Static Methods (1/3)

• Static method is a method that is common to the entire class

• Consider a method getTotal() in the class PolicyHolder that returns the

value of the static data member total

– It is more logical to think of this method as a

method of the entire class rather than that of an

object

– The method getTotal() is declared as static






private static int total;

//Other Data Members and Methods


++total;

//Other Statements

}

public static int getTotal(){

return total;

}

}

Each time the constructor is invoked and an object gets

created, the static variable total will be incremented thus

keeping a count of the total no of PolicyHolder objects created



• Static methods are invoked using the syntax <ClassName.MethodName>

System.out.println(PolicyHolder.getTotal());

//Prints 0

//A static method can be invoked without creating an object

PolicyHolder policyHolder1 = new PolicyHolder ();


//Prints 1

PolicyHolder policyHolder2 = new PolicyHolder ();


//Prints 2

• Static methods can access only other static data and methods


The Static Block

• The static block is a block of statement inside a Java class that will be executed when a class is first loaded

class Test{

static{

//Code goes here

}

}

• A static block helps to initialize the static data members just like constructors help to initialize instance members


Strings in Java (1/3)

• String is a system defined class in Java• Declaring “Hello World” in code will create an object of type string with

data “Hello World” and returns a reference to it.

• Unlike C, the string is of fixed length and memory for the string is managed totally by the String class

–Prevents buffer overruns

–NULL terminator not used in strings

–String is not a simple array of characters

–String is immutable

System.out.println(“Hello World”);


Strings in Java (2/3)

• The + operator works with the String class and helps to concatenate other

Strings and objects with a String

String s1 = “Hello”;

String s2 = “World”;

String s3 = s1 + s2; //s3 will contain “HelloWorld”

int a = 20;

System.out.println(“The value of a is ” + a);

• A String object can be created without the new operator

String s = “Java”;



• What is a this reference?• What are Constructors?• What is method overloading?• What is Automatic Garbage Collection in Java?• What are the uses of the keyword static?


Class Relationships


Relationships between Classes

• Different types of relationships can exist between classes• Identifying relationships helps in understanding and designing the objects

better

– Analogous to relations between entities in RDBMS design

• There are 3 types of relationships

– Has-A (or Part-Of)– Uses-A– Is-A (or Kind-Of)


Has-A

• Has-A relationship occurs when a class contains another class as one of

its member

• Consider the class Policy in the insurance domain

– Data Members are Premium, Maturity Value etc

– Methods to Set the Premium, Get the Premium,

Set the Maturity Value, Get the Maturity Value etc


Has-A

public class Policy{

private double premium;

private double maturityValue;

//Other Data

public void setPremium(double premium){

this.premium = premium;

}

public double getPremium(){return premium;}

public void setMaturityValue(double maturityValue){

this.maturityValue = maturityValue;

}

public double getMaturityValue(){return maturityValue;}

//Other Methods

}


Has-A Relationship

• PolicyHolder has a Policy

– The class PolicyHolder has

a Policy object as a member

variable

+setPremium(in premium : double) : void+getPremium() : double+setMaturityValue(in maturityValue : double) : void+getMaturityValue(in Amount : double) : void

-premium : double-maturityValue : double

Policy

-policy : Policy

PolicyHolder

Part of

• Has-A relationship is

represented with a diamond

headed line in UML


Has-A


private Policy policy;

//Other Members

}


Uses-A

• Uses-A relationship occurs when one class interacts with another

– Loosely coupled relationship– A method of a class creates an object of the

other class– A method of a class invokes the method on an

object of the other class• Examples:

– Policy uses Calendar for calculating the maturity date of the policy


Uses-A Relationship

CalendarUses-A

1 0..*


Is-A

• Is-A Relationship or Inheritance occurs when a class is similar to another class

– A class is a different type of another class


Inheritance (1/3)

public class TermInsurancePolicy extends Policy{

//Data Members and Methods

}

• Assume that we require a class TermInsurancePolicy

–Needs all the features of the class Policy

–TermInsurancePolicy will have a pre defined number of years before they expire

–Needs to add an extra data called term and relevant methods

–No need to write from the scratch• The keyword extends is used in Java to inherit a sub class from a super

class


Inheritance (2/3)

• The class Policy is known as the

–super class

–base class

–parent class

• The class TermInsurancePolicy is known as

–sub class

–derived class

–child class


Inheritance (3/3)


private int term;

public void setTerm(int term){

this.term = term;

}

public int getTerm(){

return term;

}

public double getBenefit(){

//Calculate benefit based on

//premium, maturityValue and term

}

}


The protected Access

• The method getBenefit() needs to access the data members premium and maturityValue of the class Policy

• A class member that has the protected access specifier can be accessed by the sub classes also

–maturityValue and premium should be declared as protected


protected double premium;

protected double maturityValue;

//Other Members

}


Creating the sub class Object

TermInsurancePolicy policy = new TermInsurancePolicy();

policy.setPremium(100);

policy.setMaturityValue(5000);

policy.setTerm(36);

System.out.println(policy.getBenefit());

• A TermInsurancePolicy object can invoke all the public methods of the class Policy and those that are newly added in TermInsurancePolicy

• Thus code reusability is achieved


Is-A Relationship - Inheritance

Note: Inheritance is represented by a triangle head arrow in UML Class diagrams



Policy

+setTerm(in term : int) : void+getTerm() : int+getBenifit() : double

-term : int

TermInsurancePolicy


Multi-Level Inheritance

• A class can be further inherited from a derived class

– The new class inherits all the member of all its ancestor classes


Multiple Inheritance

• Concept of a class inheriting from more than one base class

– A Hybrid car can inherit from FuelCar and BatteryCar

– Multiple inheritance is rarely used because of the complexities it brings in

• Modern OO languages like Java and C# don’t support Multiple Inheritance


More on Inheritance

• Any number of sub classes can be created from a base class

• Consider a class EndowmentPolicy

– EndowmentPolicy is a Policy; EndowmentPolicy is extended from Policy

– Extra data members and methods are added

public class EndowmentPolicy extends Policy{

//Data Members and Methods

}


Generalization and Specialization

• To use inheritance

– One has to identify the similarities in different classes

– Move common data and methods to base class

• Generalization: Process of identifying the similarities among different classes

– class Policy represents generalization

– Common data and methods of all types of policies are in Policy class

• Specialization: Process of creating classes for specific need from a common base class

– Derived classes TermInsurancePolicy and EndowmentPolicy represent specialization

– Specific functionality has been achieved by extending the Policy class


Generalization and Specialization - Example



Policy

+setTerm(in term : int) : void+getTerm() : int+getBenifit() : double

-term : int

TermInsurancePolicy EndowmentPolicy

GeneralizationSpecialization



• What is a protected access?• What is multilevel inheritance?• What is Generalization and Specialization in inheritance?


The Java Library

• The Java library contains a number of useful classes and interfaces

– Reusability– Standardization

• The Java library is organized as a number of packages


Summary:

• OO SDLC• Classes and Objects

–Abstraction–Encapsulation

• Constructors• Method Overloading

–Polymorphism• Static Members• Command Line Arguments• Class Relationships

–Has A–Uses A–Is A (Inheritance)

• Java Library


Method Overriding and Dynamic Binding


Problem (1/5)

• Consider the read and write methods of the class Policy that read and write the member data



public void read(){

//Read the premium, maturityValue

//and other data

}

public void write(){

System.out.println("Premium:" + premium);

System.out.println("Maturity Value:" +

maturityValue);

//Write other data

}

}


Problem (2/5)

• The class TermInsurancePolicy also needs similar methods for reading and writing its data members

• The methods read() and write() can be redefined in the sub class


private int term;

public void read(){

//Read term

}


System.out.println(term);

}

//Other Methods

}


Method Overriding (1/4)

• The class TermInsurancePolicy has 4 methods

– read() and write() defined in the class Policy

– read() and write() defined in the class Student

• If x is a TermInsurancePolicy object, the method call x.read() will invoke

the read method of class TermInsurancePolicy reading only the term

• The case of the write() method is also similar

• The read() and write() methods of the class termInsurancePolicy are

overriding the corresponding methods of the class Policy

• Redefining a base class method in a sub class is called method

overriding



• The read() method of the class TermInsurancePolicy should first call the

read() method of the class Policy to read the premium, maturityValue etc

before reading the term

• The write() method of the class TermInsurancePolicy should first call the

write() method of the class Policy to write the premium, maturityValue etc

before writing the term

• An overriding method can call an overridden method using the syntax

super.methodName()




private int term;

public void read(){

super.read();

//Read term

}


super.write();

System.out.println(term);

}

//Other Methods

}


Dynamic Binding (1/4)

• Method calls policy.read() and policy.write() will invoke the read method and write method of the TermInsurancePolicy class

• JVM calls a method based on the data type of the object referred by the reference and NOT based on the data type of the reference

• This decision is taken at runtime and hence this is known as dynamic binding

Policy policy = new TermInsurancePolicy()

• A reference to a super class can refer to a sub class object



• Consider the class EndowmentPolicy– The read and write methods are overridden


//Data Members and Method

public void read(){

super.read();

//Read other data members

}


super.write();

//Write other data members

}

}



• The following program chooses a TermInsurancePolicy or EndowmentPolicy ate runtime

char choice;

//Read choice, T for TermInsurancePolicy, E for EndowmentPolicy

if (choice == ‘T’){

TermInsurancePolicy tiPolicy = new TermInsurancePolicy();

tiPolicy.read();

tiPolicy.write();

}

else{

EndowmentPolicy ePolicy = new EndowmentPolicy(); ePolicy.read();

ePolicy.write();

}



• The following program does the same work in a better way

char choice;

Policy policy;

if (choise == ‘T’){

policy = new TermInsurancePolicy();

}

else{

policy = new EndowmentPolicy();

}

policy.read();

//Calls the read of TermInsurancePolicy or EndowmentPolicy

//Decided at runtime

policy.write();

//Calls the write of TermInsurancePolicy or EndowmentPolicy

//Decided at runtime


Runtime Polymorphism (1/2)

• In the above program, the same command policy.read() is used to read a TermInsurancePolicy or EndowmentPolicy

– Same command invokes different methods based on the context

– Polymorphism

• Decision on which method is to be invoked is taken at runtime– Runtime polymorphism


Runtime Polymorphism (2/2)

• A base class reference can be used to access the sub class methods• Only those methods that were originally present in the base class and

later overridden by the sub class can be called in this way• A new method defined in the sub class cannot be called using the super

class reference


Static Vs Dynamic Polymorphism

Static Dynamic

Function Overloading - More than one method having same name but differing in argument list

Function Overriding - keeping the signature and return type same, method in the base class is redefined in the derived class

Resolved during compilation time Resolved during run time

Which method to be invoked is decided by the object that the reference points to and not by the type of the reference



• What is method overriding?• How can we achieve runtime polymorphism in Java?


Abstract Classes and Interfaces


Abstract Class (1/4)

• Assume that the insurance company has only two kinds of policies - TermInsurancePolicy and EndowmentPolicy

• The class Policy is created for– reusing the common data and methods

– grouping TermInsurancePolicy and EndowmentPolicy into a family

– referring any kind of Policy objects using a Policy reference and achieving runtime polymorphism



• Consider the method getBenefit() in the class Policy– Benefit is calculated in each of the sub class in a totally different way

– The getBenefit() method of class Policy will not have any body

– A method without a body is known as an abstract method and qualified by the keyword abstract

public abstract double getBenefit();



• A class that has at least one abstract method is known as an abstract class and should be qualified using the keyword abstract

public abstract class Policy{

//Other Data and Methods

public abstract double getBenefit();

}

• Abstract classes cannot be instantiated

– They are used as base classes for other classes

• Subclasses that extend an abstract class need to provide implementation

of all the abstract methods of the base class or declare the subclass also

as abstract






//Code goes here

}

}




//Code goes here

}

}


Uses of Abstract Classes

• An abstract class has two uses

• Abstract classes facilitates reusability like any other base class– The data members and concrete methods of the abstract class can be reused

• Abstract classes defined a standard interface for a family of classes– The concrete sub classes definitely will have the abstract methods

implemented


abstract – Rules to follow

• The following cannot be abstract

– Constructors

– Static methods

– Private methods


The final Keyword - done

• The “final” modifier has a meaning based on its usage

• For member data and local data in methods– Primitives: read-only (constant)– Objects: reference is read-only– use all upper case letters by convention

• The final methods cannot be overridden by the sub classes

final int NORTH = 1;

public final void sample(){

//Method Definition

}


The final Keyword - done

• A final classes cannot be extended

final class Test{

//Class Definition

}


Packages


Packages in Java

• A package is a collection of related classes and interfaces in Java

• Packages help in logical grouping of classes and interfaces

– All the classes and interfaces that are used for performing I/O operations

can be placed in the same package

– All the classes and interfaces that are used for writing network programs

can be placed in the same package


Creating a Package

• It would be better to group all the classes and interfaces related to

insurance in a package, insurance

– Create a folder insurance

– Place the following program in this folder

package insurance;


//Code goes here

}


Creating a Package

• Compile the program

– class Policy will be created in a package insurance

• The package statement, if existing, should be the very first

statement of the file

• The fully qualified name of a class that is stored in a package is

<packagename>.<ClassName>

– insurance.Policy

insurance.Policy policy = new insurance.Policy();


Packages to Prevent Name Clash

• Packages prevent the clash of class/interface names

– More than one class/interface can have the same name

– They should be in two different packages

– The fully qualified names of these classes/interfaces will be different


Importing a Class

• It is difficult to use the fully qualified name of a class through out the

program

• The import statement can be used to import a class into a program

so that the class name need not be fully qualified

import insurance.Policy;

class Test{


Policy policy = new Policy();

//Policy means insurance.Policy

}

}


Importing all Classes and Interfaces

• The statement import insurance.*

– Imports all the classes and interfaces in the package insurance

– All the classes and interfaces in this package can be used without qualifying

them with package name

BEST PRACTICE: Import only those classes that are required in your code, do not import the entire package


Packages and classpath

• Compiler and JVM must know location of the packages

– An environment variable classpath needs to be set

– The classpath will be pointing to a folder be one level up the package folder

– If the folder hierarchy is C:\work\java\insurance, the classpath should be set

using the following statement

>set classpath = %classpath%;C:\work\java


Sub Packages

• A package can in turn contain another sub package

• To create a sub package policy in insurance

– Create a sub folder policy inside the folder insurance

– Place the following code in the folder policy and compile

package insurance.policy;


//Code goes here

}

• A class Policy will be created in a package insurance.policy

– Fully qualified name will be insurance.policy.Policy


Access Modifiers - Revisited

• Java has 4 access control modifiers

– private: Accessible only within the class

– default: No keyword, Accessible only within the package

– protected: Similar to default with the addition that available to all child

classes; that is, even if child class is in a different package

– public: Accessible to all

• Data Members and Methods can have any of these specifier

• Classes and Interfaces can have either the public access or the default

access


Uses of Packages

• Logical grouping of classes and interfaces

• Avoiding clash of names

• Provides an extra level of protection to its members


Standard Java Packages

• java.lang

– Contains classes that form the basis of the design of the Java programming

language

– No need to explicitly import this package

– The String class, System class etc, belong to this package

• java.io

– Classes and interfaces to perform I/O operations

• java.util

– Utility classes and interfaces like List, Calendar etc

• java.awt

– Classes and interfaces to create GUI



• What are packages?• What are the uses of packages?


Summary:

• Method Overriding• Dynamic Binding and Runtime Polymorphism• Abstract classes• The final keyword• Interfaces• Packages


Thank You

“The contents of this document are proprietary and confidential to Infosys Technologies Ltd. and may not be disclosed in whole or in part at any time, to any third party without the prior written consent of Infosys Technologies Ltd.”

“© 2006 Infosys Technologies Ltd. All rights reserved. Copyright in the whole and any part of this document belongs to Infosys Technologies Ltd. This work may not be used, sold, transferred, adapted, abridged, copied or reproduced in whole or in part, in any manner or form, or in any media, without the prior written consent of Infosys Technologies Ltd.”

Compiled Lecture Java

Documents

Transcript of Compiled Lecture Java