Programming with Java

Shanmugapriya.V
 History of Java
• Java was created in 1991

• By James Gosling at Sun Microsystems

• The original language was called Oak. In honor of the tree outside
Gosling’s window, its name was changed to java because there was
already a language called Oak.

• One of the first projects developed using Java

a personal hand-held remote control named Star 7.

 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 JSE 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
The Java Virtual Machine

10
 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

11
 Phases of a Java Program

• The following figure describes the process of compiling

and executing a Java program

12
 Java source
code
(.java)

Compile (javac command)

Bytecodes
(.class)

execute (java command)

JVM JVM JVM

Unix OS Windows OS Other OS

13
 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

 NetBeans
 JDeveloper
 Eclipse

14
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

16
 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.

17
 Example 1.1

package com.training;

public class Greetings {

public String getMessage() {

return "Welcome to Java Programming";

18
 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());

19
 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

20
 Comments

• Java supports three forms of comments

– // single line comments

– /* multi
line
comment
*/

– /** a
* Javadoc
* comment
*/

21
 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

22
 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.

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

24
 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

25
 Initialization

• Local variables
– must be explicitly initialized before use

• Parameter variables
– Pass by value

• Class and instance variables

– Instance variables Have a Default Value

26
 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);

27
 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();
}
}
28
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

29
 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.

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
I ,1,J 1
if(j % 2==0)
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
System.out.println(“Super Method2");
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
implements keyword
interface Sort{
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 ,Run
{ Time
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

Sameclass Yes Yes Yes Yes

Samepackage- No Yes Yes Yes
subclass
Samepackage- 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

• 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
 Exception Handling

java.lang.Object

java.lang.Throwable

java.lang.Error java.lang.Exception

java.io.IOException java.lang.RuntimeException

153
 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.

154
 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.”);
}
}

155
 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.”);
}
}
}
156
 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!");
}
}
}
157
 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");

}
}
}
158
 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

159
 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...”);

160
 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>
}

161
 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

162
 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.

163
 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.

164
 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 }
165
 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

166
 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

167
 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

168
 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

169
 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

170
 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! =)”);

}
}
}

171
 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

172
 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
}

173
 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;
}

174
 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

175
 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.

176
 Enums

enum Season{
WINTER, SPRING, SUMMER, FALL
}

Using the enum…

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

177
 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);
}

}
178
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");

} }
179
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;
}

180
 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");

}
181