Programming with Java

K.Srivatsan
VATSANK@GMAIL.COM
 History of Java
• Conceived as Programming language for embedded systems like
microwave ovens, televisions etc

• One of the first projects developed using Java

• personal hand-held remote control named Star 7.

• The original language was called Oak

• Java was developed in the year 1991 at Sun Microsystems

– Java is a simple, object oriented, ,interpreted distributed, robust,

secure, architecture neutral, portable high-performance, multithreaded,
and dynamic language

2
 The Architecture
• Java's architecture arises out of four distinct but interrelated technologies:
– the Java programming language
– the Java class file format
– the Java Application Programming Interface
– the Java virtual machine

3
 Application and Runtime Environment

• The JRE of the SDK contains the complete set of class files for all
the Java technology packages, which includes basic language
classes, GUI component classes, and so on.

• The Java Application Programming Interface (API) is prewritten

code, organized into packages of similar topics.

• Applet and AWT packages include classes for creating fonts,

menus, and buttons. The full Java API is included in the
Java 2 Standard Edition

4
 Application and Runtime Environment
• J2SE includes the essential compiler, tools, runtimes, and APIs for writing,
deploying, and running applets and applications in the Java programming
language.

• JDK is the short-cut name for the set of Java development tools, consisting
of the API classes, a Java compiler, and the Java virtual machine
interpreter, regardless of which version.

• The JDK is used to compile Java applications and applets. The most current
version is the J2SE is 6.0

5
Compile time and Runtime Environment

6
Java Run Time Environment

7
 Java Features

• Some features of Java:

– The Java Virtual Machine

– Garbage Collection

8
 The Java Virtual Machine

• Executes instructions that a Java compiler generates.

• This runtime environment, is embedded in various products, such as web
browsers, servers, and operating systems
• Its Imaginary machine that is implemented by emulating software on a real
machine
• Bytecode
– a special machine language that can be understood by the JVM
independent of any particular computer hardware,

9
 Garbage Collection

• Garbage collection thread is responsible for freeing any memory that can
be freed. This happens automatically during the lifetime of the Java
program.

• Programmer is freed from the burden of having to deallocate that memory

themselves

10
 Phases of a Java Program

• The following figure describes the process of compiling

and executing a Java program

11
 Java source
code
(.java)

Compile (javac command)

Bytecodes
(.class)

execute (java command)

JVM JVM JVM

Unix OS Windows OS Other OS

12
 Integrated Development Environments

• An IDE is the high-productivity tool

• Used to edit, compile, and test programs, manage projects, debugging,

building GUI interfaces, etc.

• IDE provides extensive programming support for editing and project

management,

• The Popular IDE’s

 Eclipse
 NetBeans
 JDeveloper

13
Java language syntax
 Objectives
 Identify the basic parts of a Java program

 Differentiate among Java literals, primitive data types,

 variable types ,identifiers and operators

 Develop a simple valid Java program using the concepts learned in this
chapter

15
 Program structure
• A program in Java consists of one or more class definitions

• One of these classes must define a method main(), which is where the
program starts running

 Java programs should always end with the .java extension.

 There can be More than one Class Definition in a class ,but only one
public class

 Source Filenames should match the name of the public class.

16
 Example 1.1

package com.training;

public class Greetings {

public String getMessage() {

return "Welcome to Java Programming";

17
 Example 1.1 (contd)
package com.training;

public class TestGreetings {

public static void main(String[] args) {

Greetings grtObj = new Greetings();

System.out.println(grtObj.getMessage());

18
 The System Class
• Its part of the java.lang package

• The classes in this package are available without the need for an import
statement

• This class contains several useful class fields and methods.

• It can’t be Instantiated

• It also Provides facilities for

– Standard Input
– Standard Output
– Error Output Streams
– Access to externally defined properties

19
 Comments

• Java supports three forms of comments

– // single line comments

– /* multi
line
comment
*/

– /** a
* Javadoc
* comment
*/

20
 Variables and Methods

• A variable, which corresponds to an attribute, is a named memory location

that can store a certain type of value.

• Variable is a kind of special container that can only hold objects of a certain
type.

• Primitive type Variable

• Basic, built-in types that are part of the Java language
• Two basic categories
– boolean
– Numeric
» Integral - byte, short, int, long, char
» Floating point - float, double

21
 Instance Variables and Methods
• Variables and methods can be associated either with objects or their
classes

• An instance variable and instance method belongs to an object.

• They can have any one of the four access levels

– Three access modifies – private, public , protected

– Can be Marked final, transient

• They have a default value

• A class variable (or class method) is a variable (or method) that is

associated with the class itself.

22
 Example for Variables
public class VariableTypes {
Instance
Variable
private int inst_empid;
private static String cls_empName
Class
Variable
public void getData() { }
public static void getSalary() { }
Parameter
Variable
public void showData(int a)
{ Local
int localVariable ; Variable
}
}

23
 Identifiers
• Identifiers are used to name variables, methods, classes and
interfaces

• Identifiers
– start with an alphabetic character
– can contain letters, digits, or “_”
– are unlimited in length

• Examples
– answer, total, last_total, relativePoint, gridElement, person, place, stack,
queue

24
 Initialization

• Local variables
– must be explicitly initialized before use

• Parameter variables
– Pass by value

• Class and instance variables

– Instance variables Have a Default Value

25
 Local Variable needs to Be Initialized
public class LocalVariable {
private String name;
public void display() Age Should be
Initialized
{
before Use
int age;
System.out.println("Age"+age);
System.out.println
System.out.println("Name"+name);

26
 Instance Variable have Default Values
class Values
{
private int a;
private float b;
private String c;
public void display()
{
System.out.println("integer"+a);
System.out.println("float"+b);
System.out.println("String"+c);
}
public class DefaultVales {

public static void main(String[] args) {

Values v = new Values();

v.display();
}
}

27
Assignment of reference variables
int x = 7;
int y = x;
String s = “Hello”;
String t = s;

x 7
Hello
y 7
s 0x01234
t 0x01234

28
 Pass-by-Value
• The Java programming language only passes arguments by value
for primitive data types.

• When an object instance is passed as an argument to a method,

the value of the argument is a reference to the object

• The contents of the object can be changed in the called method,

but the object reference is never changed

• For primitives, you pass a copy of the actual value.

• For references to objects, you pass a copy of the reference
• You never pass the object. All objects are stored on the heap.

29
Pass By Value

30
 Casting Primitive Types
• Casting creates a new value and allows it to be treated as a
different type than its source

• JVM can implicitly promote from a narrower type to a wider type

• To change to a narrow type explicit casting is required

• Byte -> short -> int -> long -> float -> double

31
 Casting Primitive Types
public class PrimCasting {

public static void main (String [] args){

int x = 99;
double y = 5.77;
x = (int)y; //Casting
System.out.println("x = "+ x);

double y1 = x; //No Casting

int i =42;
byte bt;
bt= (byte)i;

System.out.println("The Short number"+ bt);

}
}

32
 Wrapper Classes
• Primitives have no associated methods
• Wrapper Classes are used encapsulate primitives
• They also provide some static utility methods to work on them

Primitive Type Wrapper class

-boolean Boolean
-byte Byte
-char Character
-double Double
-float Float
-int Integer
-long Long
short Short

33
 Wrapping Primitives

• Wrapping a value
– int i = 288
– Integer iwrap = new Integer(i);

• unWrapping a value
– int unwrapped = iwrap.intValue();

• Methods In Wrapper Class

– parseXxx()
– xxxValue()
– valueOf()

34
 Wrapper Class Method
Convert String to Numbers
public class ParsingStrings
{
public static void main(String args[])
{
int ino=Integer.parseInt(args[0]);
floatfno = Float.parseFloat(args[1]);
double dno = Double.parseDouble(args[2]);
Long lno = Long.parseLong(args[3]);

System.out.println("Integer value" +ino );

String strIno = Integer.toString(ino);
System.out.Println(“String Value”+strIno);
}
}

35
 Auto Boxing
• Java 5.0 provided autoboxing

Integer n = new Integer(123) Integer n = new Integer(123);

Int m = n.intValue() n++;
m++; System.out.println(n);
n=new Integer(m);
System.out.println(n);

36
 Auto Boxing
public class ABoxing {

public void show(int a, float b)

{
System.out.println("Integer"+a*2);
System.out.println("Float"+b*2);
}

public static void main(String[] args) {

ABoxing abObj =new ABoxing ();

Integer a = 10;
Float b =20f;
abObj.show(a,b);

}
}

37
 Command Line Arguments
class CommandLineArgs
{
public static void main(String args[])
{
System.out.println("hello, welcome to the java world
"+args[0]+" to all "+args[1]);

System.out.println("it is "+args[2]+" a high level

language" +args[0]);
}
}

38
 java.util.Scanner Class
• A simple text scanner which can parse primitive types and strings using
regular expressions.

• A Scanner breaks its input into tokens using a delimiter pattern, which by
default matches whitespace.

• The resulting tokens may then be converted into values of different types
using the various next methods.

Scanner sc = new Scanner(System.in);

int i = sc.nextInt();

39
 java.util.Scanner Class

public void show()

{
Scanner sc = new Scanner(System.in);

System.out.println("Enter The Number");

int number = sc.nextInt();
System.out.println("Enter the Name");
String name = sc.next();
System.out.println(number + ":"+name);

40
 java.util.Scanner Class
public static void main(String[] args) {

String line="Java,is,in,OOP,Language";

Scanner sc1 = new Scanner(line);

sc1.useDelimiter(",");

while (sc1.hasNext())
{
System.out.println(sc1.next());
}

}
41
Flow Control
 Objectives

• Decision control structures (if, else, switch)

• Repetition control structures (while, do-while, for)

• Branching statements (break, continue, return)

43
 Control Structures

• To change the ordering of the statements in a program

• Two types of Control Structures

• decision control structures ,

– allows us to select specific sections of code to be executed

• if -- else , if – else if
• switch -- case

• repetition control structures

– allows us to execute specific sections of the code a number of times

• while
• do -- while
• for

44
 Decision Control Structures
• Types:
– if-statement
– if-else-statement
– If-else if-statement

• If Specifies that a statement or block of code will be executed if and

only if a certain boolean statement is true.

if( boolean_expression )
statement;
or
if( boolean_expression ){
statement1;
statement2;
}
• boolean_expression : can be an expression or variable.

45
 if-else statement

if( boolean_exp ){
if(boolean_exp1 )
Statement(s)
statement1;
}
else if(boolean_exp2)
else {
statement2;
Statement(s)
else
}
statement3;

 For Comparison == used instead =

 = being an assignment operator
 equals Method Should Be Used for Objects comparison

46
 switch-statement

• Allows branching on multiple outcomes.

• switch expression is an integer ,character expression or variable

• case_selector1, case_selector2 and unique integer or character

constants.

• If none of the cases are satisfied, the optional default block if present
is executed.
switch( switch_expression ){
case case_selector1:
Statement(s);
break;
case case_selector2:
Statement(s);
break;
default:
statement1;
}
47
 switch-statement

• When a switch is encountered,

– evaluates the switch_expression,

– jumps to the case whose selector matches the value of the expression.

– executes the statements in order from that point on until a break

statement is encountered

– break statement stops executing statements in the subsequent cases, it

will be last statement in a case.

– Used to make decisions based only on a single integer or character

value.

– The value provided to each case statement must be unique.

48
 switch-statement
public double CalculateDiscount(int pCode)
{
double discountPercentage=0.0d;

switch(pCode)
{
case 1:
discountPercentage=0.10d;
break;
case 2:
discountPercentage=0.15d;
break;
case 3:
discountPercentage=0.20d;
break;
default:
discountPercentage=0.0;
}
return discountPercentage;
}
49
 Switch-Case in a Method
• Can have Either Return or Break if present inside a Method, but should provide a
default Value

public String switchExample(int key) {

switch (key) {
case 1:
return "Good Morning";
case 2:
return "Good AfterNoon";
case 3:
return "Good Evening";
default:
return "Good Night";
}

50
 Repetition Control Structures
• while-loop

– The statements inside the while loop are executed as long as the
Boolean expression evaluates to true

• do-while loop

– statements inside a do-while loop are executed several times as long as

the condition is satisfied, the statements inside a do-while loop are
executed at least once
Watch
this
do{
while(boolean_expression){
statement1;
statement1;
statement2;
statement2;
}while(boolean_expression);
}

51
 for-loop
• Same code a number of times.

• for(Initialexpr;LoopCondition;StepExpr) {
statement1;
}
• InitialExpression -initializes the loop variable.
• LoopCondition - compares the loop variable to some limit
value.
• StepExpr - updates the loop variable.

for( ; ; ) {
System.out.println("Inside an endless loop");
}
• Declaration parts are left out so the for loop will act like an
endless loop.

52
 Enhanced For Loop
• The enhanced for loop, simplifies looping through an array or a collection.
• Instead of having three components, the enhanced for has two.

• declaration
– The newly declared block variable, of a type compatible with the
elements of the array being accessed.
• expression
– This must evaluate to the array you want to loop through. This could be
an array variable or a method call that returns an array

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

• for(int n : a)
• System.out.print(n);.

53
 Branching Statements
• Branching statements allows to redirect the flow of program
execution.

– break
– continue
– return.

• System.exit() All program execution stops; the VM shuts down.

54
 Branching Statement
• continue
• Unlabeled
– skips to the end of the innermost loop's body and evaluates the
Boolean expression that controls the loop,
– skipping the remainder of this iteration of the loop.

• Labeled :
– skips the current iteration of an outer loop marked with the given label.
• return
– Used to exit from the current Method
– Control returns to the statement that follows original method call
– The value to be returned is included after the “return” statement.
– The data value returned by return must match the type of the method's
declared return value

• return ++count; or return "Hello";

55
 Continue
public static void main(String[] args) {

for(int i=0;i<=2;i++)
{
for(int j=0;j<=3;j++)
{
I ,0,J 1
I ,0,J 3
if(j % 2==0) I ,1,J 1
I ,1,J 3
continue; I ,2,J 1
System.out.println("I ,"+i+",J "+j); I ,2,J 3

}
}
56
 break
public static void main(String[] args) {

for(int i=0;i<=2;i++)
{
for(int j=0;j<=5;j++)
0,0
{
0,1
0,2
System.out.println(i+","+j); 0,3
1,0
if(j==3)
1,1
break; 1,2
1,3
2,0
}
2,1
} 2,2
2,3
57
Arrays
 Introduction to Arrays

• Array is one variable is used to store a list of data and manipulate

• This type of variable is called an array.
• It stores multiple data items of the same data type, in a contiguous
block of memory, divided into a number of slots.

• The new keyword to create an array object.

• Need to tell the compiler how many elements will be stored in it.

59
 Creating Arrays

• There are three steps to creating an array,

• declaring

– int[] k;
– float[] yt;
– String[] names;

• allocating

– k = new int[3];
– yt = new float[7];
– names = new String[50];

• initializing

– int[ ] k = {1, 2, 3};

– float[ ] yt = {0.0f, 1.2f, 3.4f, -9.87f, 65.4f, 0.0f, 567.9f};

60
 Array Bounds
• All array subscripts begin with 0 and ends with n-1
• In order to get the number of elements in an array, can use the
length field of an array.

• The length field of an array returns the size of the array.

int list [] = new int[10];

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

{
System.out.println(list[i]);
}
• There is no array element arr[n]! This will result in an array-index-
out-of bounds exception.

61
 Array of Objects
public class Book
{
private int bookno;
private String bookname;
public Book(int bookno,String bookname)
{
this.bookno=bookno;
this.bookname=bookname;
}
public int getBookno()
{
return this.bookno;
}
public String getBookname()
{
return this.bookname;
}
}

62
 Array of Objects
public class ArrayofObject {

public void displaybooks(Book[] bks)

{
for(int i=0;i<bks.length;i++)
{
System.out.println("Book Number :="+bks[i].getBookno());
System.out.println("Book Name :="+bks[i].getBookname());
}
}
public static void main(String args[])
{
Book[] bk = new Book[2];
Book b1 = new Book(100,"java");
Book b2= new Book(101,"j2ee");
bk[0]=b1;
bk[1]=b2;
ArrayofObject ab= new ArrayofObject();
ab.displaybooks(bk);
}
}

63
Classes
 Classes

• The class declaration introduces a new class

– A class describes the structure and behavior of its instance objects
in terms of instance variables and methods
– Like variables, classes may be declared at different scopes. The
scope of a class directly affects certain properties of the class

Class declaration syntax

modifier class identifier {
constructorDeclarations
methodDeclarations
staticMemberDeclarations
instanceVariableDeclarations
staticVariableDeclarations
}

65
 Classes
Top-level classes can be declared as
– public
• a public class is globally accessible.
• a single source file can have only one public class or interface
– abstract
• an abstract class cannot be instantiated
– final
• a final class cannot be subclassed
– Default
• With any Modifier
• They can’t be declared as protected and private

66
 Constructors
• Have no return type
• Have the same name as the class
• If we don't’ put a constructor the compiler puts a default one
– The default constructor has the same access modifier as the class.
– The default constructor has no arguments.
– The default constructor is always a no-arg constructor, but a no-arg
constructor is not necessarily the default constructor
– The default constructor includes a no-arg call to the super constructor
(super()).
• They are not inherited and hence they are not overridden
• It can be Overloaded
• It can have any of the Four Access Modifies
• It cannot be synchronized
• It can have throws clause

67
 Instantiation with new
• It is the process by which individual objects are created.

– Class objectReference = new Constructor();

• Declaration
– Employee empObj;

• Instantiation
– empObj = new Employee()

• Declaration and Instantiation

– Employee empObj = new Employee()

– new operator allocates memory for an object.

68
 Constructor Overloading
• One constructor can call another overloaded constructor of the same class
by using this keyword.

• this() is used to call a constructor from another overloaded constructor in the

same class

• The call to this() can be used only in a constructor ,and must be the first
statement in a constructor

• A constructor can call its super class constructor by using the super
keyword.

• A constructor can have a call to super() or this() but never both

69
Overloaded Constructor
class Time Time.java
{
private int hour,min,sec;

// Constructor
Time()
{
hour = 0;
min = 0;
sec = 0;
}

//Overloaded constructor
Time(int h, int m, int s)
{
hour = h;
min = m;
sec = s;
}
}
// Code continues …

70
 this keyword
• Is a reference to the object from which the method was
invoked

this keyword

Time(int hour, int min, int sec)

{
this.hour = hour;
this.min = min;
this.sec = sec;
}

71
 Modifiers for declarations
• There are Four Access Level and 3 Modifiers
• Any declaration can be preceded by
– public
• a declaration is accessible by any class
– protected
• Accessible by any class in the same package as its class, and
accessible only by subclasses of its class in other packages.
• Works just like default , Except it also allows subclasses
outside the package to inherit the protected thing.
– default(no modifier)
• Only accessible by classes, including subclasses, in the same
package as its class(package accessibility).
– private
• a declaration is only accessible within the class in which it is
declared

72
 Method Overloading
• If two (or more) methods of a class have the same name but different
signatures, then the method name is said to be overloaded.

• The signature of a method consists of the name of the method and the
number and types of formal parameters in particular order.

• Method overloading is method name overloading.

• Several methods that implement similar behavior but for different data
types.

• They are independent methods of a class and can call each other just like
any other method.

• A method can be overloaded in the same class or in a subclass.

73
 Overloading Methods
• Overloaded methods MUST change the argument list.

• Overloaded methods CAN change the return type.

• Overloaded methods CAN change the access modifier.

• Overloaded methods CAN declare new or broader checked

exceptions.

74
 Overloading and AutoBoxing
public class Overloading {

public Integer add(Integer a , Integer b)

{
Integer c = a+b;

return c+100;
}

public int add(int a , int b)

{
return a+b;
}
75
 Main Method
public static void main(String[] args) {

Overloading olObj = new Overloading();

System.out.println(olObj.add(45, 55));

Output will be 100 and Not 200

76
 Static Variables and Methods
• A static method belongs to a class and not to its instance objects and
hence they are shared between Objects
• Static Methods can not be overridden
• They can only call other static methods

• They can access only static variables and not instance Variables
• They cannot refer to this or super
• Instance variable : 1 per instance and Static variable : 1 per class
• Static final variables are constants
• main( ) is defined to be a static method so as to be invoked directly

77
 Static Method access only static
public class StatClass {

private int id;

private static String name;
Can Access Static from Instance
Method
private void instMethod()
{
staticMethod();
System.out.println(id);
System.out.println(name);
}
private static void staticMethod()
{
System.out.println(id); Cannot Access Instance Variable
System.out.println(name); From Static
instMethod();
} Cannot Access Instance Method From
} Static

78
 Static block

• Used to initialize static variables

– Gets executed only once when the class is first loaded

StaticExample.java
class StaticExample{

static int a,b;

static{
a = 9;
b = 5;
}
// Other statements
}

79
 Static Import
import java.util.*;
import static java.lang.System.out;
import static java.lang.System.in;

public class StaticImport {

public static void main(String[] args) {

Scanner kb = new Scanner(in);

out.print("Enter an integer ");

int x = kb.nextInt();
out.print("Enter a double ");

double d = kb.nextDouble();
out.println("The sum is " + (x+d));
}
}

80
INHERITANCE
 Overview
– A class can inherit from another class
• Original class is the “superclass”
• New class is called the “subclass”
•Inheritance is a fundamental OO concept

Superclass
Car
Subclasses
SportsCar Taxi PoliceCar

82
 Example of Inheritance

– The Car class defines certain methods and variables

Car
– Taxi extends Car, and can:
• Add new variables
• Add new methods Taxi
• Override methods of the Car class

83
 Specifying Inheritance in Java
– Inheritance is achieved by specifying which superclass the
subclass
“extends”
•Taxi inherits all the variables and methods of Car

public class Car {

…
}
public class Taxi extends Car {
…
}

84
 Aspects of Inheritance

– Objects
• What does a subclass object look like?
– Construction
• How do constructors work now?
– Methods
• What methods can be called?
• How can methods be overridden?

85
 What Does an Object Look Like?
A subclass inherits all the instance variables of its
superclass

Car object
public class Car {
regNum
String regNum;
engineSize
int engineSize; …
}
Taxi object

regNum
public class Taxi extends Car {
engineSize
private int cabNum; …
} cabNum

86
 Default Initialization

– What happens when a subclass object is created?

Taxi object

regNum
Taxi taxi1 = new Taxi(); engineSize

– If no constructors are defined: cabNum

– No-arg constructor is called in superclass
• No-arg constructor called in subclass

87
 Nondefault Initialization

Specific initialization can be performed as follows:

public class Car {

Car(String r, int e) {
regNum = r;
engineSize = e;
} …

public class Taxi extends Car {

Use super() Taxi(String r, int e, int c) {
to call super(r, e);
superclass cabNum = c;
constructor } …

88
 Specifying Additional Methods

– The superclass defines methods that are applicable for all

kinds of Car
– The subclass can specify additional methods that are specific
to Taxis

public class Car {

public int getReg()…
public void changeOwner()…
… public class Taxi extends Car {
public void renewCabLicense()…
public boolean isBooked()…
…

89
 Overriding Superclass Methods
– A subclass inherits all the methods of its superclass
– The subclass can override a method with a specialized
version, if it needs to:

public class Car {

public String details() {
return "Reg:" + getReg();
}
public class Taxi extends Car {
public String details() {
return "Reg:" + getReg() + cabNum;
}
90
 Overriding
• When a sub-class defines a
– “method with same method name, argument types, argument order
and return type as a method in its super class, its called method
overriding. “
• Methods declared as final, static and private cannot be overridden.
• An overriding method can be declared as final
• The method can’t be less accessible
– Public => only public
– Protected => Both Public and Protected
– Default => default, public and protected

91
 Overriding
class Base extends keyword
{
protected int a;
base()
{
a = 20;
}
void display()
{
System.out.print(“a = “+a);
}
}
class Derived extends Base
{
private int b;
derived()
{
b = 25;
}
void display()
{
System.out.print(“b = “+b);
}
}

92
 Overriding –When Method Has Exceptions
• Any exceptions declared in overriding method must be of the same type as
those thrown by the super class, or a subclass of that type.

class MyBase {

public void method1() throws Exception

{ }
public void method2() throws RuntimeException
This is compile
{ } Time Exception
}
class Sub extends MyBase
{
public void method1() throws Throwable {
}
public void method2() throws
ArithmeticException {
This is Allowed
}
}
93
 Overriding with Compatible Return type
• Arguments must be same and return type must be compatible

class Base
{
private int i = 5;

public Number getNumber()

{
return i;
}
}

class Derived extends Base

{
@Override
public Integer getNumber()
{
return new Integer(10);
}
}

94
 Invoking Superclass Methods
– If a subclass overrides a method, it can still call the original
superclass method

– Use super.method()to call a superclass method from the subclass

– Though keyword super is used to refer super class, method call

super.super.method() is invalid.

public class Car {

public String details() {
return "Reg:" + getReg();
}
public class Taxi extends Car {
public String details() {
return super.details() + cabNum;
}
95
 super keyword
• The keyword super refers to the base class
– super( )
• invokes the base class constructor
• base class constructors are automatically invoked
– super.method( )
• invokes the specified method in the base class
– super.variable
• to access the specified variable in the base class
• super must be the first statement in a constructor

96
 Hiding-Fields and Static Members

• A Sub Class can hide the fields but cannot override that of the super class,
its done by defining fields with the same name as in the super class.

• Code in the subclass can use the keyword super to access such members

• A static method can hide a static method from the Super Class

• A hidden super class static method is not inherited., will result in compile
time Exception

97
 Hiding-Fields and Static Members
Variable
class MyBase class Mysub extends MyBase Method
Hiding
{ { Hiding
int var1=100 ; int var1 =200;

public static void method1() public static void method1()

{ {
System.out.println(“Super System.out.println(“Sub Class
Class Method1"); Method1");
}
public void method2()
}
{
public void method2()
System.out.println(“Sub Class
{ Method2");
System.out.println(“Super
Class method2 ");
System.out.println(“Var"+var1
}
+"superclass
} Var"+super.var1);
} }

98
 Abstract Class

•An abstract class is a shared superclass

– Provides a high-level partial implementation of some concept
– Cannot be instantiated
•Use the abstract keyword to declare a class as abstract

Abstract superclass Vehicle

Vehicle

Concrete subclasses Car

Car Truck

99
 Defining Abstract Classes in Java
– Use the abstract keyword to declare a method as abstract
• Only provide the method signature
• Class must also be abstract
– Must be implemented by a concrete subclass
• Each concrete subclass can implement the method differently

public abstract class Vehicle {

private String regNum;
public String getRegNum()…
public abstract boolean
isRoadWorthy();
}
public class Car public class Truck
extends Vehicle{ extends Vehicle{
private int numSeats; private int axles;
public void fitRack()… public void setLoad()…
100
 The Abstract Class-Super Class
Note
this
public abstract class BankAccount {

public abstract void deposit(float amount);

public abstract void withdraw(float amount);

public void sayHello() {

System.out.println("Thanks-Come Again");
}

101
 Child Class –Its alsoAbstract

public abstract class Savingaccount extends BankAccount

{

public abstract void getClientdetails();

}

102
 The Concrete Class
public class Supersavings extends Savingaccount {
float balance,amount ;
String custname;
int accno;
public void deposit(float amt)
{
balance+=amt;
}
public void withdraw(float amt)
{
balance-=amt;
}
public void getClientdetails()
{
System.out.println(custname);
System.out.println(accno);
System.out.println(amount);
System.out.println(balance);
}
}

103
Interfaces & Polymorphism
 Interfaces
– An interface is like a fully abstract class
• All of its methods are public and abstract
• No instance variables if present they are public static final
– An interface defines a set of methods that other classes can
implement
• A class can implement many interfaces, but can extend only one
class

– Can extend other interfaces and extend multiple interfaces

– Extends another sub interface inherits everything from super

interface

105
 Interface
• Interfaces define types in an abstract form
– An interface declaration allows the specification of a reference type
without providing an implementation
– The class that implements the interface decides how to implement

implements keyword
// the interface
interface Sort
{
void do_sort();
}
// the implementor
class BubbleSort implements Sort
{
public void do_sort()
{
// The sorting method implementation
}
}

106
 Example of Interfaces
– Interfaces describe an aspect of behavior that different classes
can support
– For example, any class that supports the “Steerable” interface can
be steered:

Steerable Not Steerable

107
 Defining an Interface in Java

– Use interface keyword instead of class

public interface Steerable {

int maxTurn = 135;

void turnLeft(int deg);
void turnRight(int deg);
}

108
 Implementing an Interface

public interface Steerable {

int maxTurn = 135;
void turnLeft(int deg);
void turnRight(int deg);
} public class Car
extends Vehicle
implements Steerable {

public void turnLeft(int deg)

{…}

public void turnRight(int deg)

{…}

109
 Partial Implementation of an Interface

• Declare the class as abstract if the class does not implement all
the methods of an interface

Public abstract class Car

extends Vehicle
implements Steerable {

public void turnLeft(int deg)

• Implement
{…} the methods in the sub class level

110
 Interface
• A single class can implement many interfaces

interface Sort{
implements keyword
void doSort();
}
interface List{
void createList();
}
class DataUtility implements Sort, List{
public void doSort(){
// Statements
}
public void createList(){
// Statements
}
}

111
 Using instanceof with Interfaces
– The instanceof operator can be used to check if an object
implements an interface
– Downcasting can be used if necessary, to call methods defined in
the interface

public void aMethod(Object obj) {

…
if (obj instanceof Steerable)
((Steerable)obj).turnLeft();
}
112
 Extending an Interface

• One Interface can extend another Interface

public interface Steerable {

int maxTurn = 135;
void turnLeft(int deg);
void turnRight(int deg);
}
public interface Navigator
extends Steerable {
void calcSpeed(int distance);

113
 Polymorphism
• This OO Principle allows the programmer to program abstractly

• Objects of a subclass can be treated as objects of its superclass

• The base class of a hierarchy is usually an abstract class or an Interface

– They define the common behavior (functionality)

• Classes and Subclasses inherit this behavior and extend it according to

their own properties by overriding the methods of the super class

• Subclass objects can be treated as super class objects through

references,
– But, super class objects are not subclass objects

114
 Polymorphism

• Allows for hierarchies to be highly extensible

• New classes can be introduced and can still be processed without

changing other parts of the program

• Same method can do different things, depending on the class that

implements it.

• Method invoked is associated with OBJECT and not with reference.

• Types of Polymorphism -
– Method Overloading.
– Method Overriding.

115
 Polymorphism
class SuperClass
{
int value = 100;

void callMe()
{
System.out.println("I am in Super Class");
}
}

class SubClass extends SuperClass

{
int value = 10;

void callMe()
{
System.out.println("I am in Sub Class");
}
}

116
 Polymorphism
This Object Reference is
public class TestDMD polymorphic
{
public static void main(String s[])
{

SuperClass objSuperClass = new SubClass();

objSuperClass.callMe();

System.out.println(objSuperClass.value);

}
• This means object variables are polymorphic , A variable of type Super
Class can refer to an object of type Super class as well as subclass.

117
 Substitution of Object References in Method
Calls
•A subclass object can be passed into any method that expects a
superclass object

•The method that got invoked, is the version that's present in the
object type and NOT the reference type.

public static void main(String[] args) {

Taxi t = new Taxi("ABC123", 2000, 79);
displayDetails(t);

public static void displayDetails(Car c) {

System.out.println(c.details());
}
118
 Dynamic Method Dispatch

• Related Through Inheritance

• superclass = subclass
– always valid
• subclass=(subclass)superclass
– valid at compile time, checked at runtime. if is invalid then the exception
ClassCastException is thrown.
• subclass = superclass
– not valid at compile time, needs a cast

• Unrelated Classes – Not Allowed

• someClass = someUnrelatedClass
– not valid, won’t compile
• somcClass = (someClass)someUnrelatedClass
– not valid, won’t compile

119
 subclass=
(subclass)sup
Dynamic Method Dispatch erclass

Valid at both
class First Compile
{ ,RunTime
First fst = new Second();
public void show()
{
Second sec = (Second)fst;
System.out.println("ShowFirst");
}
} sec.show();

class Second extends First

{ First fst2 = new First();
public void show()
subclass=
{
Second sec2 = (Second)fst2; (subclass)
System.out.println("Show Second"); erclass
}
}
sec2.show(); Valid at
Compile t
exception
at ,RunTim
120
 final keyword
• A final method or class is Java’s way of prohibiting inheritance
and/or overriding

• Final methods cannot be overridden by subclasses

• All private methods are implicitly final

• Final classes Cannot be extended and their methods are implicitly

final

• Can be applied to variables too

– The value of a final variable cannot be altered

– final int max_limit = 23

– final void method( )
– final class last_class

121
 Interface vs Abstract Class
• A class may implement several • A class may extend only one class
interface
• An abstract class can provide
• An interface cannot provide any complete or partial code
code at all

• Interfaces are often used to • An abstract class defines the core

describe the peripheral abilities of identity of its descendants.
a class, not its central identity,

122
 Interface, Abstract Class,Subclass,Class
• A plain class is designed when in doesn't pass the “is-a” test.
• A Plain class is designed when its not extending any other class
other than object class

• Make a subclass , when it needs to extend a super class

• Make a subclass, when it needs to override or add new behaviors

• Make an abstract class , when there is a requirement for a kind of

“template” for a group of subclasses, and there are some
implementation in the class which the subclass can use .
• Make an abstract class , to guarantee that nobody can make objects
of that type.
• Design an interface , to define a role that other classes can play,
regardless of the inheritance tree,

123
Packages
 Packages

• Packages are containers of classes

• An organized collection of classes that are logically related
• Mechanism for partitioning the class name space
• Helps Distributed Computing
• Some of Packages in Java are
– java.lang
– java.io
– java.util
– java.net
• User defined classes can also be organized into packages

125
 Package
• In the following example, the class class1 is part of the package pack1
• Use the javac -d option to compile

package keyword
package utility;
// indicates that class Sort is part of Utility package

class Sort
{
public void do_sort()
{
// Statements
}
}

126
 Package
• Use the import keyword to access the classes in a package

import keyword
import utility.*;

class Test
{
public static void main(String args[]){

Sort obj1;

// Code continues …

127
 CLASSPATH
• Is an environment variable which specifies the location of the
class files
• For compiling the Sort.java (listed earlier)
– javac -d c:\packages Sort.java
– this would create a sub-directory Utility under c:\packages and
store Sort.class over there
• While compiling test.java (listed earlier), set
– CLASSPATH = . ; c:\packages
• Any package can be included in the working package
• Include all packages in CLASSPATH
• import package_name.class_name;
• import package_name.subpackage_name.class_name;
• import package_name.*;

128
 Package - Access modifiers

Private No modifier Protected Public

Same class Yes Yes Yes Yes

Same package - No Yes Yes Yes
subclass
Same package - No Yes Yes Yes
nonsubclass
Different package -
subclass
No No Yes Yes
Different package - No No No Yes
nonsubclass

129
 Creating And Running Executable Jar Files
• Java .jar files are archive files, like .zip files, that can contain a collection of
Java artifacts including class files, source code, supporting documentation,
etc.
• They can be executed by adding a manifest to the .jar file that specifies the
name of the main application class.
• Steps involved in Creating a Executable Jar files

– Create Java program/(s) and save the resulting .class files in the proper
package structure

– Create a manifest file specifying the fully-qualified name of the main

application class

– Use the jar command to create the .jar file

130
 Create An Executable Jar File

• In the Mainfest.mf File of the Project Add

– Manifest-Version: 1.0
– Main-Class: package_name.className

• Jar Files are created using the command :

– jar cmf mainclass MyApp.jar

• The Files can be executed by invoking java command with the -jar switch :

– java -jar MyApp.jar

131
Object Class and Its Methods
 Object Class
• Every class in java extends class Object.

• If a class doesn’t explicitly extend any class ,implicitly extends Object class

– boolean equals()

– int hashCode()

– String toString()

– Object.clone()

133
 equals( ) method
• The equals operator (==) can be used to test primitives

• When its objects –

– it simply compares two object references to see if they refer to the same
object, which is not the same as comparing the objects themselves.

• The inherited equals( ) method can be used on the object

– It doesn't it does not compare fields
– It just returns the value of an == comparison on the two objects involved

134
 Rules for an equals( ) method
• It is reflexive:
• x.equals(x) must be true.
• It is symmetrical:
• x.equals(y) must be true if and only if y.equals(x) is also true.
• It is transitive:
• if x.equals(y) is true and y.equals(z) is true, then x.equals(z) must
also be true.
• It is repeatable:
• multiple calls on x.equals(y) return the same value (unless state
values used in the comparison are changed, as by calling a set
method).
• It is cautious:
• x.equals(null) must return false rather than accidentally throwing a
NullPointerException .

135
 Overriding Equals Methods
public boolean equals(Object otherObject)
{
// check objects are identical
if(this==otherObject)
return true ;
//check for null
if(otherObject==null)
return false;
// check for the class of the object
if(getClass()!=otherObject.getClass())
return false;
// cast the object to the right type
Exampleobject eobj =
(Exampleobject)otherObject;
//check the instance variables
return customername.equals(eobj.customername)
&& orderno==(eobj.orderno);

136
 The hashCode( ) method
• It returns an integer that should uniquely identify different objects.

• A properly written hashCode( ) method will follow these rules:

• It is repeatable:
– hashCode(x) must return the same int when called repeatedly, unless
set methods have been called.

• It is consistent with equality:

– if x.equals(y), then x.hashCode( ) must == y.hashCode( ).

137
 Overriding HashCode
• Acceptable Overriding but not Efficent

public int hashCode()

{
return this.orderno + (7 * this. orderno);

• Violates Hashcode Rule

public int hashCode()

{
int no = (int)Math.random()* 100 ;
return this.orderno+no ;
}

138
 toString( )
• The objectS can be passed to
– System.out.println( )
– Methods
– Or Can be used string concatenation,
• Java automatically calls its toString( ) method.

• The toString() just prints the class name, an @ sign, and the object's
memory address -hashCode) value

• toString( ) implementation prints the state of the object which will result in
formatting control in println( ) and anywhere objects get referred to in a
String context.

139
 Object.clone( )
• Need for cloning
– While method-calling ,the called method can modify the state of
constructed object!

• Cloning the input object before calling the method allows to pass a copy of
the object, keeping the original safe.

• The two steps to make a class cloneable:

– Override Object's clone( ) method.
– Implement the empty Cloneable interface

• The Protected clone( ) method in Object throws

CloneNotSupportedException .

• Convention, the Cloned object should be obtained by calling super.clone.

• it may be necessary to modify one or more fields of the object returned by

super.clone before returning it

140
 Clone Method
public class Employee implements Cloneable {

public Object clone()

{
Note this
try {

return super.clone( );
}
catch (CloneNotSupportedException e )
{
e.printStackTrace();
}
}
}

141
 GC of Object
• Objects become eligible for garbage collection
– Reference goes out of permanently
void add()
{
Employee e = new Employee();
}

– Reference assigned to another object

Class EmpTest {
Employee e = new Employee();
void add()
{
e=new Employee();
}

142
f a shallow copy is performed on obj1, then it is copied but its contained objects are not

Shallow Clone
• f a shallow copy is performed on obj1, then it is copied
but not its contained objects.

143
 Deep Clone
• A deep copy occurs when an object is copied along with the objects to
which it refers.

• If either of these contained objects themselves contain objects, then, in a

deep copy, those objects are copied as well, and so on until the entire graph
is traversed and copied.

• Each object is responsible for cloning itself via its clone() method.

144
 GC of Object
– The Reference is explicitly set to null

Class EmpTest {
Employee e = new Employee();
void add()
{
e=null;
}

145
 Finalize Method()
public class Book {

String bookName;

Book(String bookName)
{
this.bookName=bookName;
}
public String toString()
{
return this.bookName;
}
public void finalize()
{
System.out.println("Inside Finlize“+this);
}

146
 Finalize Method()
public static void main(String[] args) {

Book textbook = new Book("Java");

System.out.println(textbook);

textbook =new Book("J2EE");

System.gc();

System.out.println(textbook);

textbook=null;

System.gc();

System.out.println(textbook);
}

147
 Math Class
• The methods in the Math class don’t use any instance variable values

• The Methods are “static” methods , and they don’t need to have an instance
of the Math class

• Some of the Methods in the class are

– Math.random() – returna double number between 0.0 to 1.0
– Math.abs() – absolute value of the argument
– Math.round() – returns int or long based on float,double rounded to
nearest integer value
– Math.min() and Math.max() – maximum or minimum of two args
– Math.sqrt() – return the sqaure root of the given argument

148
Exception handling

149
 Topics
• Define exceptions
• Use try, catch, and finally statements
• Describe exception categories
• Identify common exceptions
• Develop programs to handle your own exceptions
• Use assertions
• Distinguish appropriate and inappropriate uses of assertions
• Enable assertions at runtime

150
 Exception and Assertions
• Exceptions handle unexpected situations – Illegal argument,
network failure, or file not found

• Assertions document and test programming assumptions – This

can never be negative here

• Assertion tests can be removed entirely from code at runtime, so the

code is not slowed down at all.

151
 Exceptions
• Conditions that can readily occur in a correct program are checked
exceptions.

• These are represented by the Exception class.

• Problems that reflect program bugs are unchecked exceptions.

• Fatal situations are represented by the Error class.

• Probable bugs are represented by the RuntimeException class.

• The API documentation shows checked exceptions that can be

thrown from a method

152
 Call Stack Mechanism

• If an exception is not handled in the current try-catch

block, it is thrown to the caller of that method.

• If the exception gets back to the main method and is not

handled there, the program is terminated abnormally.

153
 The finally Clause
• The finally clause defines a block of code that always
executes.
try {
startFaucet();
waterLawn();
} catch (BrokenPipeException e) {
logProblem(e);
} finally {
stopFaucet();
}

154
155
156
 Handle or Declare Rule
• Use the handle or declare rule as follows:

• Handle the exception by using the try-catch-finally block.

• Declare that the code causes an exception by using the
• throws clause.
• void trouble() throws IOException { ... }
• void trouble() throws IOException, MyException { ... }
• Other Principles

• You do not need to declare runtime exceptions or errors.

• You can choose to handle runtime exceptions

157
 Method Overriding and Exceptions
• The overriding method can throw:
• No exceptions
• One or more of the exceptions thrown by the overridden
method
• One or more subclasses of the exceptions thrown by the
overridden method
• The overriding method cannot throw:
• Additional exceptions not thrown by the overridden
method
• Superclasses of the exceptions thrown by the overridden
method

158
 User Defined Exceptions
public class ServerTimedOutException extends Exception {
private int port;

public ServerTimedOutException(String message, int port) {

super(message);
this.port = port;
}

public int getPort() {

return port;
}
}

Use the getMessage method, inherited from the Exception class, to get the
reason for which the exception was made.

159
 Handle user defined Exception
• A method can throw a user-defined, checked exception:
• 1 public void connectMe(String serverName)
• 2 throws ServerTimedOutException {
• 3 boolean successful;
• 4 int portToConnect = 80;
• 5
• 6 successful = open(serverName, portToConnect);
• 7
• 8 if ( ! successful ) {
• 9 throw new ServerTimedOutException("Could not connect",
• 10 portToConnect);
• 11 }
• 12 }

160
 Assertions
• • Syntax of an assertion is:
• assert <boolean_expression> ;
• assert <boolean_expression> : <detail_expression> ;
• • If<boolean_expression> evaluates false, then an
• AssertionError is thrown.
• • The second argument is converted to a string and used

161
162
 Example of Exception
public class ExceptionDemo {
public static void main(String [] args) {

System.out.println(3/0);
System.out.println(“Hi”);

}
}
}
• Default exception handler
– Provided by Java runtime ,Prints out exception description
– Prints the stack trace
• Hierarchy of methods where the exception occurred
– Causes the program to terminate

163
 What Happens When an Exception
Occurs
• When an exception occurs within a method,
– the method creates an exception object and hands it off to the runtime
system - “throwing an exception”
– These Exception object contains information about the error, including
its type and the state of the program when the error occurred
– The runtime system searches the call stack for a method that contains
an exception handler

164
 What Happens When an Exception
Occurs
• When an appropriate handler is found, the runtime system passes the
exception to the handler
– An exception handler is considered appropriate if the type of the
exception object thrown matches the type that can be handled by the
handler
– The exception handler chosen is said to catch the exception.

• If appropriate exception handler is not found by the runtime system the

application terminates and uses the default exception handler

165
 Exception Handling

java.lang.Object

java.lang.Throwable

java.lang.Error java.lang.Exception

java.io.IOException java.lang.RuntimeException

166
 Checked and Unchecked
• Checked exceptions include all subtypes of Exception, excluding classes
that extend Runtime Exception.

• Checked exceptions are subject to the handle or declare rule; any method
that might throw a checked exception
– must either declare the exception using the throws keyword, or handle
the exception with an appropriate try/catch.

• Subtypes of Error or Runtime Exception are unchecked, so the compiler

doesn’t enforce the handle or declare rule.

167
 Catching Exceptions

class DivByZero {
public static void main(String args[]) {
try {
System.out.println(3/0);
System.out.println(“Please print me.”);
} catch (ArithmeticException exc) {
//Division by zero is an ArithmeticException
System.out.println(exc);
}
System.out.println(“After exception.”);
}
}

168
 Catching Exception –Multiple Catch
class MultipleCatch {
public static void main(String args[]) {
try {
int den = Integer.parseInt(args[0]);
System.out.println(3/den);
}
catch (ArithmeticException exc)
{
System.out.println(“Divisor was 0.”);
}
catch (ArrayIndexOutOfBoundsException exc2)
{
System.out.println(“Missing argument.”);
}
System.out.println(“After exception.”);
}
}
}

169
 Catching Exception –Nested Try’s
public static void main(String args[]){
try {
int a = Integer.parseInt(args[0]);
try {
int b = Integer.parseInt(args[1]);
System.out.println(a/b);
}
catch (ArithmeticException e1)
{
System.out.println("Div by zero error!");
}
}
catch(ArrayIndexOutOfBoundsException e2)
{
System.out.println("Need 2 parameters!");
}
}
}
170
 err Field in the System Class
public class Example_ErrField {

public static void main(String[] args) {

PrintStream prt;
System.setErr(prt);

try {
prt = new PrintStream(new File("a.err"));

}
catch (FileNotFoundException e)
{

System.err.println("printed using Error Field");

}
}
}
171
 Redirecting Output
public static void main(String[] args) {
OutputStream outs = System.out;
PrintStream dos = new PrintStream(outs);
try {
PrintStream ps =
new PrintStream(
new FileOutputStream("MyOutput.txt",true));

System.setOut(ps);

System.out.println("Hello World");
ps.flush();
System.out.close();
System.setOut(dos);
System.out.println("I am Back");
}
catch(FileNotFoundException e)
{
System.out.println("Inside Exception Block");
} }

172
 Finally block
• Its optional and will always be invoked,
– whether an exception in the corresponding try is thrown or not,
– whether a thrown exception is caught or not.

• finally-will-always-be-called except if the JVM shuts down. When

the try or catch blocks may call System.exit();

• Block of code is always executed despite of different scenarios:

– Forced exit occurs using a return, a continue or a break statement
– Normal completion
– Caught exception thrown
– Exception was thrown and caught in the method
– Uncaught exception thrown
– Exception thrown was not specified in any catch block in the method

173
 Throwing Exceptions
• The throw Keyword

• Java allows you to throw exceptions (generate exceptions)

– throw <exception object>

• An exception you throw is an object

– You have to create an exception object in the same way you create any
other object

• Example:
– throw new ArithmeticException(“testing...”);

174
 Throws Clause
• A method is required to either catch or list all exceptions it might throw
– Except for Error or RuntimeException, or their subclasses

• If a method may cause an exception to occur but does not catch it, then it
must say so using the throws keyword

• Applies to checked exceptions only

<type> <methodName> (<parameterList>) throws <exceptionList>

{
<methodBody>
}

175
 Uncaught Exception

• Uncaught exceptions propagate back through the call stack,

• Starting from the method where the exception is thrown and ending with
either the first method that has a corresponding catch for that exception type
or a JVM shutdown

176
 Effective Exception Hierarchy

• The exception classes are arranged in a hierarchy.

• Catches for specific exceptions should always be written prior to the generic
handler.

• FileNotFoundException is a child of IOException, a catch for

FileNotFoundException should occur before the one for IOException.

• A generic handler for Exception would cover any missing situation.

177
 Assertions
• Allow the programmer to find out if an assumption was met
– Example: month

• Extension of comments wherein the assert statement informs the person

reading the code that a particular condition should always be satisfied

• Running the program informs you if assertions made are true or not

– If an assertion is not true, an AssertionError is thrown

• User has the option to turn it off or on at runtime

178
 What are Assertions
• Allow the programmer to find out if an assumption was met

• Extension of comments wherein the assert statement informs the person

reading the code that a particular condition should always be satisfied

– Running the program informs you if assertions made are true or not

– If an assertion is not true, an AssertionError is thrown

• User has the option to turn it off or on at runtime

179
 Enabling or Disabling Assertions
• Program with assertions may not work properly if used by clients not aware
that assertions were used in the code
• Compiling
– With assertion feature:
– javac –source 1.4 MyProgram.java
• Without the assertion feature:
– javac MyProgram.java
• Enabling assertions:
– Use the –enableassertions or –ea switch.
– java –enableassertions MyProgram

180
 Assert Syntax
• assert <expression1>;
– where <expression1> is the condition asserted to be true
• assert <expression1> : <expression2>;
– <expression1> is the condition asserted to be true
– <expression2> is some information helpful in diagnosing why the
statement failed

181
 Assert Syntax
class AgeAssert {

public static void main(String args[]) {

int age = Integer.parseInt(args[0]);

assert(age>0);

if (age >= 18) {

System.out.println(“You're an adult! =)”);

}
}
}

182
 Use & Miss Use of Assertions
• Use

– To validate Arguments of Private Method

– In Public Methods to check for cases that you know are never
ever supposed to happen
• Miss Use
– To validate Arguments of a Public Method
– To validate Command Line Arguments
– Don’t use Assertions that can cause side effect

183
 Don’t Use assertion to validate Arguments of a
Public Method
• A public method has to be called from code that you don’t control for from
code you have never seen,

• public methods are interface to the outside word , that should guarantee
that any constraints on the arguments will enforced by the method itself.

• Assertions aren’t guaranteed to actually run , the enforcement won’t happen

if assertions are not enabled ,

Public void doStuff()

{
Assert (x>0)
}

• Same Principle applicable for command Line Arguments

184
 Asserting in the Right Way
• Use Assertions to validate Arguments of Private Method
Private void doStuff()
{
Assert(x>0)
}

• Don’t use Assertions that can cause side effect

public void doStuff()

{
Assert(modifythings());
}
public boolean modifythings()
{
y= x++;
return true
}

185
 Asserting in the Right Way
• Use , Even in Public Methods to check for cases that you know are
never ever supposed to happen
• Example in a case block that should never be reached , including a
default switch statements as given

Switch(x)
{
case 1: y-3;break;
case 2: y=y-5;break;
default
Assert false;
}

186
 Enums
• Previously, the standard way to represent an
enumerated type was to use the
• int Enum pattern:

public static final int WINTER = 0;

• Not TypeSafe
– you could add seasons or pass an arbitrary season

• No Namespace
– With other enum types

• Uninformative printed values

• Can not add methods to enum values

187
 Enums
• Enums are classes that extend java.lang.Enum.

• Each declared value is an instance of the enum.

• Enum values are public, static and final.

• Enums can be compared with == or equals().

• Enums are Comparable and Serializable

• The Enum type can be declared with a constructor, and each enum
constant is declared with parameters to be passed to the constructor.

188
 Enums

enum Season{
WINTER, SPRING, SUMMER, FALL
}

Using the enum…

if (type == Season.WINTER)
System.out.println (…)

189
 ENUM -Examples
enum language {JAVA,J2EE,FORTRAN}

public class Enum_Ex1 {

enum dbprds {ORACLE,DB2,MYSQL}

private dbprds database;

private language prglang;

public static void main(String[] args) {

Enum_Ex1 myObj = new Enum_Ex1();

myObj.database = dbprds.ORACLE;
myObj.prglang = language.JAVA;

System.out.println(myObj.database);
System.out.println(myObj.prglang);
}

190
public class Enum_Ex2 {

flashDrive usbDrives;

enum flashDrive {SANDISK(1) ,SONY(2),PHILIPS(3);

private int size;

flashDrive(int size)
{
this.size=size;
}
public int getCap()
{
return this.size;
}
}
public static void main(String[] args) {

Enum_Ex2 myObj = new Enum_Ex2();

myObj.usbDrives = flashDrive.SANDISK;

System.out.println("Capacity :"+myObj.usbDrives.size+" Mb");

} }

191
public class Enum_Ex5 {

enum Servers {WEBLOGIC,WEBSPHERE,ORACLE,APACHE};

public static void main(String[] args) {

Servers myserver=Servers.WEBLOGIC;

switch (myserver)
{

case WEBLOGIC:
System.out.println("BEA");
break;
case WEBSPHERE:
System.out.println("IBM");
break;
case APACHE:
System.out.println("Open Source");
break;
}

192
 for(Servers s:Servers.values())
{
System.out.println(s);
}

myserver = Servers.APACHE;

if(myserver==Servers.APACHE)
{
System.out.println("Good Choice for WEB Applications");
}

if(Servers.APACHE.equals(Servers.ORACLE))
System.out.println("equals");
else System.out.println("not equal");

193
194