Java Notes 3

CONTENTS
• Introduction
• Class Definition in Java
• Declaring Variables
• Constructors
• Variable Types
• Polymorphism in Java
o Dynamic Method Dispatch
• Access Specification in Java
• Practice Questions
• Assignment
• Q&A
Introduction
The basic element of object oriented Programming in Java is a class. Class is used to build an
Application, to define an applet. A class defines the shape and behavior of an object. In Java,
programmers are allowed to define their own classes or can borrow the class definition from
outside (such as from built in classes, packages etc). In this Chapter, we will learn the theoretical
notion of Object Oriented Programming : encapsulation, inheritance, and polymorphism. We will
discuss how to create, extend, and instantiate our own classes. After the learning of this Chapter
we will begin to utilize the real power of Java-oriented programming style.
Class Definition in Java

A Class is a template for an object. Every object has a class which defines the structure of an
object (that means what are various component in it, termed as member elements) its functional
inter feces (called methods) which decide what messages the object will respond to and how.
The general form of class definition is shown below.
Class Class Name [extends SuperClassName ]

[ implements Interface ] {
[declaration of member elements ]
[ declaration of methods ]
}
Those are included with [...] are optional. Member elements will be declared with usual
convention as in C++ with the following syntax :
type ElementName;
Methods are declared with the same convention of C ++ as :
[Modifier ] returnType MethodName (parameter list){

Statements (s) ; // Code for definition
of the method.
}
Putting the member elements and methods into together in the definition of a class called is
called encapsulation. Following is a simple example to illustrate the defining a class.
Illustration 3.1 // Encapsulation //
// A program that uses the circle class

// Call this file Demonstration_31.java
class Circle {
double x,y; // The coordinates of the center
double r; // The radius
// Method that returns circumference
double circumference(){
return 2*3.14159*r;
}
// Method that returns area
double area(){
return (22/7)*r*r;
}
}
//The following class declares an object of type Circle

class Demonstration_31{
public static void main(String args[]){
Circle c = new Circle();
c.x = 0.0;
c.y = 0.0;
c.r = 5.0;
System.out.println("Circumference" + c.circumference());
System.out.println("Area" + c.area());
}
}
OUTPUT:
Circumference31.4159
Area75.0
In the above Illustration 3.1, we have defined two classes namely Circle and Demonstration_31.
Circle contains two member elements namely x and y and a method namely Circle( ). The class
Demonstration_31 act as the main class which contains main( ). Note that how an object
(instance of a class) can be created with new operator. This new operator creates a single
instance of a named class and returns a reference to that object.
For example, P1, P3 and P4 are three reference to three instances of object Point. These three
objects are instantiated by the getPoint() method. It also should be noted the multiple references
to the same object , e.g. P1 and P2 are the two reference to point the same object; this means
that any change to the object, the same object to which P1is referencing. Another important point
to note in this regard is that, memory is allocated only when they are referred; when control
reaches to P1 = null one reference of the same object is ceased to exist and at P2 =null , the
memory allocated to it automatically freed. This automatic memory allocation and deallocation is
due to automatic garbage collector in Java .
Illustration 3.2 // Encapsulation //
// A program that declares two objects of the Circle class

// Call this file CircleDemo2.java
class Circle {
double x, y;
double r;
return 2*3.14159*r;
}
double area(){
return (22/7)*r*r;
}
}
//The following class declares multiple objects of type Circle
class Demonstration_32
{
Circle c1 = new Circle();
// Initialize the circles
c1.x = 3.0;
c1.y = 4.0;
c1.r = 5.0;
c2.x = -4.0;
c2.y = -8.0;
c2.r = 10.0;
System.out.println("Circumference Circle 1" + c1.circumference());
System.out.println("Area Circle 1" + c1.area());
}
}
OUTPUT:
Circumference Circle 131.4159
Area Circle 175.0
Area Circle 2300.0
Constructors
In the last example, we have used the method viz circle(..) to initialize an object.
Illustration 3.3
class Circle {
double x,y;
double r;
return 2*3.14159*r;
}
double area(){
return (22/7)*r*r;
}
}
class Box{
double width;
double height;
double depth;
double area(){
double a;
a = (width*height + height*depth + width*depth) * 2;
return a;
}
double volume(){
double v;
v = width*height*depth;
return v;
}
}
// Declaring objects of type Circle and Box

class Demonstration_33 {
Circle c = new Circle();
Box b = new Box();
// Initialize the circles
c.x = 3.0; c.y = 4.0; c.r = 5.0;
b.width = 3.0; b.height = 4.0; b.depth = 5.0;
System.out.println("Circumference Circle" + c.circumference());
System.out.println("Area Circle" + c.area());
System.out.println("Area of Box" + b.area());
System.out.println("Volume of Box" + b.volume());
}
}
OUTPUT:
Circumference Circle31.4159
Area Circle75.0
Area of Box94.0
Volume of Box60.0
Illustration 3.4
// A program that uses simple Point class and na�ve initialization of its data.
class Point {
int x;
int y;
}
// This class declares an object of type Point.

public static void main(String args[]) {
Point mypoint = new Point();
// assign values to mypoint's instance variables

mypoint.x = 10;
mypoint.y = 20;
// access the values from mypoint�s instance variable

System.out.println("x " + mypoint.x);
System.out.println("x " + mypoint.y);
}
}
OUTPUT:
x 10
x 20
Illustration 3.5
/* Encapsulation: Defining a class with method */

class Point
{
int x,y;
void setPoint( ) {
x = 10;
y = 10;
}
}
// definition of another class. This is a main class
{
float distance;
public static void main (String args[ ]) {
Point p = new Point( );
p.setPoint();
System.out.println ( " x = "+ p.x );
System.out.println ( " y = "+ p.y );
}
}
OUTPUT:
x = 10
y = 10
Illustration 3.6
/* Automatic initialization in Java through the constructor as in C++*/
/* Encapsulation: Defining a class having method with parameter */
class Point
{
int x,y;
void setPoint( int a, int b ) {
x = a;
y = b;
}
}
{
float distance;
Point p1 = new Point( );
p1.setPoint(15, 20);
p2.setPoint(0, 0);
System.out.println ( " x = "+ p1.x );
System.out.println ( " y = "+ p1.y );
System.out.println ( " x = "+ p2.x );
System.out.println ( " y = "+ p2.y );
}
}
OUTPUT:
x = 15
y = 20
x=0
y=0
Illustration 3.7
/* Encapsulation: Utilization of objects in a program */

class Point
{
int x,y;
void getPoint(int a, int b) {
x = a;
y = b;
}
}

{
static double distance;
Point p2 = p1;
Point p3 = new Point ( );
p1.getPoint (5, 10 );
p2.getPoint (15, 20);
System.out.println (" X1 = " + p1.x + "Y1 = " + p1.y );

System.out.println ("X2=" + p2.x + "Y2 = " +p2.y );
int dx = p3.x - p4. x; // X2 - X1
int dy = p3.y - p4. y; // y2 - y1
distance = Math.sqrt (dx * dx + dy * dy );// (X2-X1)2 + (Y2-Y1)2
System.out.println ( " Distance = "+ distance );
}
}
OUTPUT:
X1 = 15 Y1 = 20
X2=15 Y2 = 20
Distance = 14.142135623730951
Illustration 3.8 //constructor//
// A Java program to demonstrate working of constructor in Java
class Circle {
double x,y;
double r;
return 2*3.14159*r;
}
double area(){
return (22/7)*r*r;
}
Circle(double a, double b, double c){
x = a; // Set center x-coordinate
y = b; // Set center y-coordinate
r = c; // Set radius
}
}
public static void main(String arge[]){
Circle c1 = new Circle(3.0,4.0,5.0);
Circle c2 = new Circle(-4.0,8.0,10.0);
}
}
OUTPUT:
Area Circle 175.0
Area Circle 2300.0
Illustration 3.9 // Constructor //
/* Demontration of constructor Overloading */

// Edit Demonstration_39.java
class Circle {
double x,y;
double r;
Circle(double a, double b, double c){
x = a; y = b; r = c;
}
Circle(double c){
x = 0; y = 0; r = c;
}
Circle(Circle c){
x = c.x; y = c.y; r = c.r;
}
Circle(){
x = 0.0; y = 0.0; r = 1.0;
}
return 2*3.14159*r;
}
double area(){
return (22/7)*r*r;
}
}
Circle c2 = new Circle(5.0);
Circle c3 = new Circle(c1);
}
}
OUTPUT:
Area Circle 175.0
Area Circle 275.0
Area Circle 375.0
Area Circle 43.0
Illustration 3.10
/*The following program shows the use of this() to avoid the name-space collision.
*/
//Edit Demonstration_310.java
class Student{
int rollno;
String name, course;
float fee;
Student(int rollno, String name, String course){
this.rollno = rollno;
this.name = name;
this.course = course;
}
Student(int rollno, String name, String course, float fee){

this(rollno,name,course);//reusing constructor
this.fee=fee;
}
void display(){
System.out.println(rollno+" "+name+" "+course+" "+fee);}
}
Student s1=new Student(111,"ankit","java");
Student s2=new Student(112,"sumit","java",6000f);
s1.display();
s2.display();
}
}
OUTPUT:
111 ankit java 0.0
112 sumit java 6000.0
Illustration 3.11
/*Demontration of constructor Overloading */

class Circle {
double x,y;
double r;
Circle (double x, double y, double r){
this.x = x; this.y = y; this.r = r;
}
Circle (double r){
x = 0; y=0; this.r = r;
}
Circle (Circle c){
x = c.x; y = c.y; r = c.r;
}
Circle (){
x = 0.0; y = 0.0; r = 1.0;
}
return 2*3.14159*r;
}
double area(){
return (22/7)*r*r;
}
}
}
}
OUTPUT:
Area Circle 175.0
Area Circle 275.0
Area Circle 375.0
Area Circle 43.0
Illustration 3.12
// Program to demonstrate use of this: to invoke current class method

class A{
void m(){System.out.println("hello m");}
void n(){
System.out.println("hello n");
this.m();
}
}
A a=new A();
a.n();
}
}
OUTPUT:
hello n
hello m
Illustration 3.13
/* Special use of this keyword: No object creation to invoke method

*/
//Edit Demonstration_313.java
class A{
A(){
this(5);
System.out.println("hello a");
}
A(int x){
System.out.println(x);
}
}
A a=new A();
}
}
OUTPUT:
5
hello a
Illustration 3.14
/* Demontration of constructor Overloading */

class Circle {
double x,y;
double r;
Circle (double x, double y, double r){

}
Circle (double r){

this(0.0, 0.0, r);
}
Circle (Circle c){

this(c.x, c.y, c.r);
}
Circle (){
this(0.0, 0.0, 1.0);
}
return 2*3.14159*r;
}
double area(){
return (22/7)*r*r;
}
}
}
}
OUTPUT:
Area Circle 175.0
Area Circle 275.0
Area Circle 375.0
Area Circle 43.0
Inheritance
When encapsulation is the first mechanism in Object Oriented Programming, the second
fundamental Object Oriented mechanism is inheritance. This allows descendants of a class to
inherit all of its member elements and methods from its ancestors as well as creates its own.
These descendants are known as subclasses. A class�s immediate parent is called its super
class. In Java, a special key word extends is used to implement this mechanism. Following is the
example to illustrate this.
Illustration 3.15 // Example of Inheritance in Java //
/* A simple example of inheritance. */

// Create a superclass.
class A {
int i, j;
void showij() {
System.out.println("i and j: " + i + " " + j);
}
}
// Create a subclass by extending class A.

class B extends A {
int k;
void showk() {
System.out.println("k: " + k);
}
void sum() {
System.out.println("i+j+k: " + (i + j + k));
}
}
A superOb = new A();
B subOb = new B();
// The superclass may be used by itself.
superOb.i = 10;
superOb.j = 20;
System.out.println("Contents of superOb: ");
superOb.showij();
System.out.println();
/* The subclass has access to all public members of its superclas

s. */
subOb.i = 7;
subOb.j = 8;
subOb.k = 9;
System.out.println("Contents of subOb: ");
subOb.showij();
subOb.showk();
System.out.println("Sum of i, j and k in subOb: ");
subOb.sum();
}
}
OUTPUT:
Contents of superOb:
i and j: 10 20
Contents of subOb:
i and j: 7 8
k: 9
Sum of i, j and k in subOb:
i+j+k: 24
Illustration 3.16
/* Inheritance example: initializing through constructor */

class Box {
double width;
double height;
double depth;
Box(){ // Default setting by this constructor

width = 0.0;
height = 0.0;
depth = 0.0;
}
Box(double w, double h, double d) {
width = w;
height = h;
depth = d;
}
double volume() { // compute and return volume

return width * height * depth;
}
}
// Here, Box is extended to include weight.

class BoxWeight extends Box {
double weight; // weight of box
// constructor for BoxWeight

BoxWeight(double w, double h, double d, double m) {
width = w;
height = h;
depth = d;
weight = m;
}
}
class Demonstration_62a {
Box mybox1 = new Box();
BoxWeight mybox2 = new BoxWeight(2, 3, 4, 0.076);
double vol;
vol = mybox1.volume();
System.out.println("Volume of mybox1 is " + vol);
System.out.println("Weight of mybox2 is " + mybox2.weight);
}
}
OUTPUT:
Volume of mybox1 is 0.0
Weight of mybox2 is 0.076
Illustration 3.17

class Box {
double width;
double height;
double depth;
Box(){ // Default setting by this constructor

width = 0.0;
height = 0.0;
depth = 0.0;
}

width = w;
height = h;
depth = d;
}

}
}

// Constructors for BoxWeight

BoxWeight() { // Default constructor
super(); // Call the default constructor in the super c
lass
weight = 0.0;
}

super(w, h, d); // Call the overloaded constructor in the super
class
weight = m;
}
}
class Demonstration_62b {
Box mybox1 = new Box(10, 20, 15);
double vol;
// System.out.println("Weight of mybox1 is " + mybox1.weight); ER
ROR!
}
}
OUTPUT:
Illustration 3.18
/* Example of a superclass variable referring to a subclass Object*/
class Box {
double width;
double height;
double depth;
Box() { // default constructor

}
// constructor used when all dimensions specified

width = w;
height = h;
depth = d;
}

}
}


width = w;
height = h;
depth = d;
weight = m;
}
}
BoxWeight weightbox = new BoxWeight(3, 5, 7, 8.37);
Box plainbox = new Box();
double vol;
vol = weightbox.volume();
System.out.println("Volume of weightbox is " + vol);
System.out.println("Weight of weightbox is " + weightbox.weight);
// assign BoxWeight reference to Box reference

plainbox = weightbox;
vol = plainbox.volume(); // OK, volume() defined in Box
System.out.println("Volume of the box is " + vol);
/* The following statement is invalid because plainbox does not d
efine a weight member. */
// System.out.println("Weight of plainbox is " + plainbox.weight)
;
}
}
OUTPUT:
Volume of weightbox is 105.0
Weight of weightbox is 8.37
Volume of the box is 105.0
Illustration 3.19 // Example of Inheritance in Java //
/* Simple example of super concept */
// A complete implementation of BoxWeight.

class Box {
double width;
double height;
double depth;

width = w;
height = h;
depth = d;
}
// compute and return volume

double volume() {
}
}
// BoxWeight now fully implements all constructors.

// constructor when all parameters are specified

super(w, h, d); // call superclass constructor
weight = m;
}
}
double vol;
}
}
OUTPUT:
Illustration 3.20
/* Example of super to overcome name hiding */
class A {
int i;
}

class B extends A {
int i; // this i hides the i in A
B(int a, int b) {
super.i = a; // i in A
i = b; // i in B
}
void show() {
System.out.println("i in superclass: " + super.i);
System.out.println("i in subclass: " + i);
}
}
B subOb = new B(1, 2);
subOb.show();
}
}
OUTPUT:
i in superclass: 1
i in subclass: 2
Illustration 3.21
/* Code sharing through super concept */
class Cat {
void speak() {
System.out.println("Meaon ! ");
}
}
class PetCat extends Cat { // PetCat is one type of Cat
void speak() {
System.out.println(" Meow ! ");
}
}
class MagicCat extends Cat { // MagicCat is another kind of Cat

static boolean noOne;
void speak() {
if (noOne) {
super.speak(); // use the super class definition
} else {
System.out.println(" Hello World !");
}
}
}
PetCat c1 = new PetCat();
MagicCat c2 = new MagicCat();
c2.noOne = true;
c2.speak();
c1.speak();
c2.noOne = false;
c2.speak();
}
}
OUTPUT:
Meaon !
Meow !
Hello World !
Illustration 3.22
/* Example of multilevel inheritance. */
// Start with Box.

class Box {
private double width;
private double height;
private double depth;

width = w;
height = h;
depth = d;
}

double volume() {
}
}
// Add weight.
weight = m;
}
}
// Add shipping costs

class Shipment extends BoxWeight {
double cost;

Shipment(double w, double h, double d, double m, double c) {
super(w, h, d, m); // call superclass constructor
cost = c;
}
}
Shipment shipment1 = new Shipment(10, 20, 15, 10, 3.41);
Shipment shipment2 = new Shipment(2, 3, 4, 0.76, 1.28);
double vol;
vol = shipment1.volume();
System.out.println("Volume of shipment1 is " + vol);
System.out.println("Weight of shipment1 is " + shipment1.weight);
System.out.println("Shipping cost: $" + shipment1.cost);
}
}
OUTPUT:
Volume of shipment1 is 3000.0
Weight of shipment1 is 10.0
Shipping cost: $3.41
Volume of shipment2 is 24.0
Weight of shipment2 is 0.76
Shipping cost: $1.28
Illustration 3.23
/* A simple abstract class example */
abstract class Base {

abstract void fun();
}
class Derived extends Base {

void fun() { System.out.println("Derived fun() is called"); }
}
// Uncommenting the following line will cause compiler error as the

// line tries to create an instance of abstract class.
// Base b = new Base();
// We can have references of Base type.

Base b = new Derived();
b.fun();
}
}
OUTPUT:
Derived fun() is called
Illustration 3.24
// An abstract class with constructor

Base() { System.out.println("Base constructor is called"); }
abstract void fun();
}

Derived() { System.out.println("Derived constructor is called"); }
}
Derived d = new Derived();
d.fun();
}
}
OUTPUT:
Base constructor is called
Derived constructor is called
Illustration 3.25
// An abstract class without any abstract method

void fun() { System.out.println("Base fun() is called"); }
}

}
d.fun();
}
}
OUTPUT:
Derived constructor is called
Illustration 3.26
// Final Class Inheritance � An Example
final class Bike{}
class Honda1 extends Bike{

void run(){
System.out.println("Running safely with 100kmph");
}
}
final class Demonstration_611 {

Honda1 honda = new Honda1();
honda.run();
}
}
Illustration 3.27
// An abstract class without any abstract method

void fun() { System.out.println("Base fun() is called"); }
}

}
d.fun();
}
}
OUTPUT:
Final fun() is called
Illustration 3.28
// An abstract class with a final method
final void fun() { System.out.println("Final fun() is called"); }
}

}
class Demonstration_612b {
Base b = new Derived();
b.fun();
}
}
Polymorphism in Java
Another fundamental object oriented mechanism in Java is the polymorphism. Java allows
polymorphism on methods. Polymorphism, meaning one object many shapes, is a simple
concept that allows a method to have multiple implementations. This is also known as method
overloading. Following is the Illustration 3.29 to illustrate the idea of polymorphism .
Illustration 3.29 // Polymorphism concept //
class Point {
int x,y;
Point ( int x, int y ) { // It is a constructor
this.x = x;
this.y = y;
}
/*M1*/ float distance ( int x, int y) { // One definition of distance

int dx = this.x - x;
int dy = this.y - y;
return (float) Math.sqrt ( dx* dx + dy * dy );
}
/*M2*/ float distance (Point p) { // Overloaded definition of dist

ance .
return distance ( p.x, p.y) ;
}
}
class Point3D extends Point {
int z ;
Point3D ( int x, int y, int z ) { // Constructor
of Point3D
super ( x, y );
this.z = z;
}
/*M3*/ float distance (int x,int y, int z ) { // Another definition of distanc
e
int dx = this.x - x;
int dy = this.y - y;
int dz = this.z - z ;
return (float) Math.sqrt ( dx * dx + dy*dy + dz*dz );
}
/*M4*/ float distance (Point3D pt) {

return distance (pt.x, pt.y, pt.z );
}
}
class PointDistance {
public static void main ( String args [ ] ) {
Point p1 = new Point (10, 5) ; // 2-D point
Point p3 = new Point3D (5, 10, 5); // 3-D point
Point p2 = new Point (4, 1) ; // another 2-D point
Point p4 = new Point3D ( 2,3,4 ); // another 3-D point
float d0 = p1.distance ( 0,0); // M1 will be referred
float d1 = p1.distance ( p2); // M2 will be referncd
System.out.println ( "Distance from P2 to Origin = " + d0);
System.out .println ( " Distance from P2 to P1 = " + d1) ;
d1 = p4.distance (p3); // M4 will be referred
System.out.println ( "Distance from P3 to P4= "+ d1);
}
}
OUTPUT:
Distance from P2 to Origin =
11.18034
Distance from P2 to P1 =
7.2111025
Distance from P3 to P4=
7.615773
In the above example, we have seen, how the same method can be implemented in different
ways. The concept of this type of method overloading is same as in C++. However, C++ allows
the operator overloading too, Java does not.
Dynamic Method Dispatch

Method can be called dynamically in Java. Whenever, a method is called on an object reference,
the declared type of the object reference is checked at compile time to make sure that the
method exists in the declared class. At run time, the object reference could be referring to an
instance of some subclass of the declared reference type. This is illustrated in Illustration 3.30.
Illustration 3.30 // Method resolution during execution //
class A {
void callMe ( ) {
System.out. println ( "I am from A ") ;
}
}
class B extends A {
void callMe ( ) {
System.out.println ( "I am from B ");
}
}
public class Who {
public static void main(String args [ ] ) {
A a = new B ( ) ;
a.callMe ( );
}
}
OUTPUT:
I am from B
In the above mentioned Illustration 3.30, we declared the variable to be of type A, then stored a
reference to an object of class B in it. Now, when we call the methodcallMe( ) on a, the Java run
time notices that the reference is actually an instance of B, so it calls B� s callMe( ) method
instead of A�s.
This form of dynamic run time resolution is one of the most powerful mechanisms that Object
Oriented in Java brings to bear on code reuse and robustness. The ability for existing code
libraries to call methods on instance of new classes without recompiling while maintaining a
clean abstract interface is a profoundly powerful tool.
Access Specification in Java

The mechanism by which one can control the use of objects, its member elements and methods
is known as the access specification. This is done in Java by using three access modifier key
words public, private , and protected.
Public : Member elements and methods can be marked as public and then they can be
accessed from any other method in Java Programs. To indicate a method or element is public,
precede it with the public key word .
The public modifier can be applied to classes as well as methods and variables. It then allows to
make a class accessible to other classes in other Packages.
The public access specification is automatic, in the sense that, if no access specifier is
mentioned then by default it is having public accessibility.
Private : Member elements and methods marked private can be used only marked private can
be used only from inside their class. A private element / method is not visible in any other class,
including subclasses . Also, a subclass cannot override a non-private method and make the new
method private.
Protected : Member elements and methods marked protected can be used only from inside their
class or in subclasses of that class. A subclass can still override a protected method or variable.
Note : It can be noted that the private and protected modifier can not be applied to classes.
Final: Apart of these, there is another access modifier known in Java which is known as final. All
methods and member elements may be overridden by default. In Java, one can declare that
methods or member elements cannot be allowed to override by subclasses. For those method
and member elements final key word can be specified. Like member elements and methods,
classes also can be declared final and a final class cannot be sub classed.
Abstract : Just as one can specify that a method can never be sub classed by marking it as final,
one can indicate that a method must always be sub classed by using the abstract keyword in the
method definition. When applied to a class, the abstract modifier indicates that the class has not
been fully implemented and that it should not be instantiated. If applied to a member function
declaration, the abstract modifier means that the function will be implemented in a subclass.
Since the function has no implementation, the class cannot be instantiated, and must be
declared as abstract .
Illustration 3.31
/* Example-1 of default access modifier */
//Save the following classes in the same file named as Demonstration_71.java
class A {
void msg(){System.out.println("Hi! I am in Class A");
}
}
A obj = new A();
obj.msg();
}
}
OUTPUT:
Hi! I am in Class A
Illustration 3.32
//Save the following class as A.java

class A {
}
}
//Save the following classes in the same file named as Demonstration_72.java
A obj = new A();
obj.msg();
}
}
OUTPUT:
Hi! I am in Class A
Illustration 3.33
//Save this program as A.java in a sub-directory �pack1�
//Save the following class as A.java
class A {
}
}
/* Save this program as Demonstration_73.java in another sub-directory �pack2�

*/
//Save the following class as Demonstration_73.java
A obj = new A();
obj.msg();
}
}
OUTPUT:
Hi! I am in Class A
Illustration 3.34
//Save this program as A.java in a sub-directory �pack1�
package pack1;
public class A {
public void msg(){System.out.println("Hi! I am in Class A");
}
}
/* Save this program as Demonstration_74.java in another sub-directory �pack2�

*/
package pack2;
import pack1.*;
A obj = new A(); //Compile Time Error
obj.msg(); //Compile Time Error
}
}
Note: Run the main class Demonstration_74 from pack2 �
Illustration 3.35
/* Example-5 of public access modifier */
class A{
public int data=40;
public void msg(){
System.out.println("Class A: Hello Java!");
}
}
A obj = new A(); //OK : Class A is public
System.out.println(obj.data); //OK : data is public
obj.msg(); //OK: msg is public
}
}
OUTPUT:
40
Class A: Hello Java!
Illustration 3.36
//Example-6 : Java program to illustrate public modifier
package pack1;
public class A1 {
int data = 100;
public void display()
{
System.out.println("NPTEL " + data);
}
}
package pack2;
import pack1.*;
public static void main(String args[])
{
A1 obj = new A1();
obj.display();
}
}
Illustration 3.37
/* Example-1 : Private access modifier */
public class A{
private int data = 40;
public void msg(){
}
}
public class Demonstration_77 {

System.out.println(obj.data); //Compile Time Error : data is private
obj.msg(); //OK : msg is public
}
}
Illustration 3.38
/* Example-2: Private access modifier */
class A{
private int data = 40;
public void msg(){
System.out.println("Class A: Hello Java!" + data);
}
}

//private int data2 = 100;
//public int data2 = 100;
int data2 = 100;
System.out.println("Class B:"+ data2); //OK: private data in the
same class
obj.msg(); // Private data is accessable through public method
}
}
OUTPUT:
Class B:100
Class A: Hello Java!40
Illustration 3.39
/* Example-3: Private access modifier */
class A{
private A(){
//private constructor
}
void msg(){
}
}

A obj = new A(); //Compile Time Error
}
}
Illustration 3.40
/* Example 1: protected modifier */
//Save by A.java in a sub-directory pack1
package pack1;
public class A {
protected int rollNo = 555;
protected void msg(){
System.out.println("Class A: Hello Java!" + rollNo);
}
}
//Save by B.java in another sub-directory pack2
package pack2;
import pack1.*;
A obj = new A();
obj.msg();
}
}
OUTPUT:
Illustration 3.41
/* Example 2: protected access specifier*/
//Save by A.java in a subdirectory pack1
package pack1;
public class A{
protected int rollNo = 555;
protected void msg(){
System.out.println("Class A: Hello Java!" +rollNo);
}
}
//Save by B.java in another sub-directory pack2
package pack2;
import pack1.*;
class Demonstration_711 extends A{

A obj = new A();
obj.msg();
System.out.println("Class B: Hello Java!" +obj.rollNo);
}
}
OUTPUT:
Class B: Hello Java!555
Illustration 3.42
//Example-3: Java program to illustrate protected modifier
package p1;
//Class A
public class A
{
protected void display() {
System.out.println("NPTEL");
}
}
//Java program to illustrate protected modifier
package p2;
import p1.*; //importing all classes in package p1
//Class B is sub-class of A
class Demonstration_712 extends A {
{
A obj = new A ();
obj.display();
}
}
OUTPUT:
NPTEL
Illustration 3.43
//Example-4: Java program to illustrate protected modifier
package p1;
//Class A
protected class A // A class cannot be declared as protected�.

{
void display() {
System.out.println("NPTEL");
}
}
//Java program to illustrate protected modifier
package p2;
import p1.*; //importing all classes in package p1
//Class B is sub-class of A
class Demonstration_712 extends A {
{
A obj = new A();
obj.display();
}
}
Illustration 3.44
/* Simple example of access modifier. In a class hierarchy, private members remain

private to their class.
This program contains an error and will not compile. */
class A {
int i; // public by default
private int j; // private to A
void setij(int x, int y) {

i = x;
j = y;
}
}
// A's j is not accessible here.
class B extends A {
int total;
void sum() {
total = i + j; // ERROR, j is not accessible here
}
}
B subOb = new B();
subOb.setij(10, 12);
subOb.sum();
System.out.println("Total is " + subOb.total);
}
}
Illustration 3.45
/* Another example of access modifier with public, private and protected data */
class BaseClass {
public int x = 10;
private int y = 10;
protected int z = 10;
int a = 10; //Implicit Default Access Modifier
public int getX() {

return x;
}
public void setX(int x) {

this.x = x;
}
private int getY() {

return y;
}
private void setY(int y) {

this.y = y;
}
protected int getZ() {

return z;
}
protected void setZ(int z) {

this.z = z;
}
int getA() {
return a;
}
void setA(int a) {
this.a = a;
}
}
public class Demonstration_715 extends BaseClass {

BaseClass rr = new BaseClass();
rr.z = 0;
Demonstration_715 subClassObj = new Demonstration_715();
//Access Modifiers - Public
System.out.println("Value of x is : " + subClassObj.x);
subClassObj.setX(20);
// If we remove the comments it would result in a compilaton
// error as the fields and methods being accessed are privat
e
/* System.out.println("Value of y is : "+subClassObj.y);
subClassObj.setY(20);
System.out.println("Value of y is : "+subClassObj.y);*/
//Access Modifiers - Protected

System.out.println("Value of z is : " + subClassObj.z);
subClassObj.setZ(30);
//Access Modifiers - Default
System.out.println("Value of x is : " + subClassObj.a);
subClassObj.setA(20);
}
}
OUTPUT:
Value of x is : 10
Value of x is : 20
Value of z is : 10
Value of z is : 30
Value of x is : 10
Value of x is : 20
Illustration 3.46
/* Example of method-overiding */
class A{
public void msg1() {
System.out.println("Class A: Public!");
}
private void msg2() {

System.out.println("Class A: Private!");
}
protected void msg3(){
System.out.println("Class A: Protected!");
}
}
public class Demonstration_716 extends A{

void msg(){
System.out.println("Class Main: Welcome!");
}
public void msg1() { // If modifire is set to default it cannot overide.
System.out.println("Overriding public method!");
void msg2() {
System.out.println("Overriding private method!");
}
// If modifire is set to private it can be overidden.
public void msg3(){
System.out.println("Overriding protected method!");
}

Demonstration_716 obj = new Demonstration_716();
obj.msg();
//obj.msg1();
//obj.msg2();
//obj.msg3();
}
}
OUTPUT:
Class Main: Welcome!
Static method and variable

In general, each instance of a class has its own copy of any member variables. However, it is
possible to designate a member variable as belonging to the class itself independent of any
object of that class. Such member variables are called static members and are declared with the
static key word. These are often work as global variable about the instances of a class. Likewise,
methods can also be declared as static. Such static methods then can be used outside of the
context of any instances.
In order to initialize static variable, one may declare a static block which gets executed exactly
once, when the class is first loaded. The following is a complete listing in order to understand
static modifier.
Illustration 3.47 // Static extent of a variable or method

//
public class Demo{

int b=0;
System.out.println("Value of b = "+b);
Student s1 = new Student();
s1.showData();
Student s2 = new Student();
s2.showData();
}
}
class Student {
static int b;
Student(){
//Constructor incrementing static variable b
b++;
}
public static void showData(){
System.out.println("Value of b = "+b);
}
}
OUTPUT:
Value of b = 0
Value of b = 1
Value of b = 2
From the foregoing discussion, it is evident that static is useful for creating methods which may
be called directly by referring to name of the class in which they are declared. This is how Java
implements global functions and global variables. This is why our main() should always be
declared as static so that the classes contain the scope of the names to avoid collisions.
Control, Scope and Recursion
Illustration 3.48
/* while loop example */
public class Demonstration_51{
public static void main(String[] args){
int count = 1;
System.out.println("Printing first 10 odd numbers");
while (count < 11) {
System.out.print(" " +((2*count)-1));
count++;
}
}
}
OUTPUT:
Printing first 10 odd numbers
1 3 5 7 9 11 13 15 17 19
Illustration 3.49
/* Do-While loop example */

int count = 1;
System.out.println(" Printing first 10 even numbers");
do {
System.out.print(" " + 2*count);
count++;
} while (count < 11);
}
}
OUTPUT:
Printing first 10 even numbers
2 4 6 8 10 12 14 16 18 20
Illustration 3.50
/* For loop example */

for(int i=1; i<11; i++){
System.out.println("Count is: " + i);
}
}
}
OUTPUT:
Count is: 1
Count is: 2
Count is: 3
Count is: 4
Count is: 5
Count is: 6
Count is: 7
Count is: 8
Count is: 9
Count is: 10
Illustration 3.51
/* Loop example with continue */

for(int i=0; i<10; i++) {
System.out.print(i + " ");
if (i%2 == 0) continue;
System.out.println(" ");
}
}
}
OUTPUT:
01
23
45
67
89
Illustration 3.52
/* Loop example with break*/

for(int i=1; ; i++) {
if(i%10 ==0 ) break; // terminate loop if i is 10
System.out.println("i: " + i);
}
System.out.println("Loop complete.");
}
}
OUTPUT:
i: 1
i: 2
i: 3
i: 4
i: 5
i: 6
i: 7
i: 8
i: 9
Loop complete.
Illustration 3.53
/* Test for primes */

int num;
boolean isPrime = true;
num = Integer.parseInt(args[0]);
for(int i=2; i <= num/2; i++) {
if((num % i) == 0) {
isPrime = false;
break;
}
}
if(isPrime) System.out.println("Prime");
else System.out.println("Not Prime");
}
}
Illustration 3.54
/* Menu selection using do-while and switch-case */

public static void main(String args[]) throws java.io.IOException {
char choice;
do {
System.out.println("Help on:");
System.out.println(" 1. if");
System.out.println(" 2. switch");
System.out.println(" 3. while");
System.out.println(" 4. do-while");
System.out.println(" 5. for\n");
System.out.println("Choose one:");
choice = (char) System.in.read();
} while( choice < '1' || choice > '5');
System.out.println("\n");
switch(choice) {
case '1':
System.out.println("The if:\n");
System.out.println("if(condition) statement;");
System.out.println("else statement;");
break;
case '2':
System.out.println("The switch:\n");
System.out.println("switch(expression) {");
System.out.println(" case constant:");
System.out.println(" statement sequence");
System.out.println(" break;");
System.out.println(" // ...");
System.out.println("}");
break;
case '3':
System.out.println("The while:\n");
System.out.println("while(condition) statement;");
break;
case '4':
System.out.println("The do-while:\n");
System.out.println("do {");
System.out.println(" statement;");
System.out.println("} while (condition);");
break;
case '5':
System.out.println("The for:\n");
System.out.print("for(init; condition; iteration)");
System.out.println(" statement;");
break;
}
}
}
Illustration 3.55
/* A variable declared inside pair of brackets �{� and �}� in a method has scop
e withing the brackets only.*/
public class Demonstration_58
{
{
{
// The variable x has scope within
// brackets
int x = 10;
}
// Uncommenting below line would produce

// error since variable x is out of scope.
// System.out.println(x);
}
}
OUTPUT:
10
Illustration 3.56
{
{
for (int x = 0; x < 4; x++)
{
}
// uncommenting Will produce error
//System.out.println(x);
}
}
OUTPUT:
0
1
2
3
Illustration 3.57
// Above program after correcting the error

{
{
int x;
for (x = 0; x < 4; x++){
}
}
}
OUTPUT:
0
1
2
3
4
Illustration 3.58
// Another example of scope of variable in a block�
int x;
x = 10;
if(x == 10) {
int y = 20;
System.out.println("x and y: " + x + " " + y);
x = y * 2;
}
//y = 100; // Error: Out of scope
System.out.println("x is " + x);
}
}
OUTPUT:
x and y: 10 20
x is 40
Illustration 3.59
// Example of static variable
public class Circle{

static int circlecount = 0; // class variable
public double x,y,r; // instance variables
public Circle(double x, double y, double r){
}
public Circle(double r){
this(0.0,0.0,r);
circlecount++;
}
public Circle(Circle c){
this(c.x,c.y,c.r);
circlecount++;
}
public Circle(){
this(0.0,0.0,0.1);
circlecount++;
}
public double circumference(){

return (2*3.14159*r);
}
public double area(){
return(3.14159*r*r);
}
public static void main(String args[ ]){
System.out.println("c1#"+ c1.circlecount);


System.out.println("c1#"+ c1.circlecount + " c2# " + c2.circlecount

+ " c3#"+ c3.circlecount);
}
}
OUTPUT:
c1#1
c2#2
c3#3
c1#3 c2# 3 c3#3
Illustration 3.60
// Example of static method

// A class method and instance method
public class Circle{

public double x,y,r;
static int circlecount=0;
public Circle(double x, double y, double r){
//circlecount++;
}
public Circle(double r){
this(0.0,0.0,r);
circlecount++;
}
public Circle(Circle c){
this(c.x,c.y,c.r);
circlecount++;
}
public Circle(){
this(0.0,0.0,0.1);
circlecount++;
}
// An instance method. Return the bigger of two circles.
public Circle bigger(Circle c){
if(c.r>r) return c;
else return this;
}
// A class method: Return the bigger of two classes.
public static Circle bigger (Circle a, Circle b) {
if (a.r > b.r) return a;
else return b;
}
Circle a = new Circle (2.0);
Circle b = new Circle (3.0);
Circle c = a.bigger (b);
Circle d = Circle.bigger (a,b);
}
}
Illustration 3.61
// Example of factorial calculation
public class RecursiveFactorial{

int n;
int factorial(int n) {
if (n == 0)
return(1);
else
return(n*factorial(n-1));
}
public static void main(String[] args) {

RecursiveFactorial x = new RecursiveFactorial();
x.n = Integer.parseInt(args[0]);
System.out.println("Factorial of "+ x.n + ": " + x.factorial(x.n));
}
}
Illustration 3.62
// Example of Fibonacci sequence
class RecursiveFibonacci {
int n;
int fibonacci(int n){
if (n == 0)
return 0;
else if (n == 1)
return 1;
else
return(fibonacci(n-1) + fibonacci(n-2));
}
RecursiveFibonacci x = new RecursiveFibonacci();
x.n = Integer.parseInt(args[0]);
for(int i = 0; i <= x.n; i++){
System.out.println(x.fibonacci(i));
}
}
}
Illustration 3.63
// Example of GCD Calculation

public class RecursiveGCD {
int m, n;
int gcd(int m, int n){
if(m>n) return gcd(n,m);
if(m==n)return m;
if(m==0)return n;
if(m==1)return 1;
return gcd(m,n%m);
}

RecursiveGCD g = new RecursiveGCD();
g.m = Integer.parseInt(args[0]);
g.n = Integer.parseInt(args[1]);
System.out.printf("GCD of %d and %d is %d.", g.m, g.n, g.gcd(g.m, g.n));
}
}
Illustration 3.64
/* Example of recursion : Practic 1 */

static void myMethod( int counter){

if(counter == 0)
return;
else
{
System.out.println("Hello "+counter);
myMethod(--counter);
System.out.println(counter);
return;
}
}

myMethod(10); // pass positive integer
}
}
OUTPUT:
Hello 10
Hello 9
Hello 8
Hello 7
Hello 6
Hello 5
Hello 4
Hello 3
Hello 2
Hello 1
0
1
2
3
4
5
6
7
8
9
Illustration 3.65
/* Example of recursion : Practic 2 */

static int count = 0;
static void p(){
count++;
if(count <= 5){
System.out.println("Hello " + count);
p();
}
}

p();
}
}
OUTPUT:
Hello 1
Hello 2
Hello 3
Hello 4
Hello 5
Practice questions
Practice 3.1
/* A program that uses simple Point class. Call this file PointDemo.java */
class Point {
int x;
int y;
}
// This class declares an object of type Point.

class PointDemo {
Point mypoint = new Point();
// assign values to mypoint's instance variables

mypoint.x = 10;
mypoint.y = 20;
// access the values from mypoint�s instance variable

System.out.println("x " + mypoint.x);
System.out.println("x " + mypoint.y);
}
}
Is the compilation successful? What is the output?
Practice 3.2
/* Encapsulation: Defining a class with method */
class Point
{
int x,y;
void setPoint ( ) {
x = 10;
y = 10;
}
}
class PointDemo
{
float distance;
public static void main (String args[ ] {
p.setPoint();
}
}
Is the compilation successful? What is about the execution?
Practice 3.3
/* Encapsulation: Defining a class with method with parameter */
class Point
{
int x,y;
void setPoint ( int a, int b, ) {
x = a;
y = b;
}
}
class PointParameterDemo
{
float distance;
p.setPoint(15, 20);
}
}
(This problem has a minor mistake. Identify the mistake and then write the correct
code.)
Practice 3.4
/* Encapsulation: declare more than one object of a class */
class Point
{
int x,y;
void getPoint ( int a, int b ) {
x = a;
y = b;
}
}

class PointsDemo
{
float distance;
Point p2 = p1;
p1.getPoint (5, 10 );
System.out.println (" X1 = " + p1.x + "Y1 = " + p1.y );

System.out.printlin ("X2=" + p2.x + "Y2 = " +p2.y );
int dx = p3.x - p4. x; // X2 - X1
int dy = p3.y - p4. y; // y2 - y1
distance = Math.sqrt (dx * dx + dy * dy );// (X2-X1)2 + (Y2-Y1)2
System.out.println ( " Distance = "+ distance );
}
}
What is the output?

Practice 3.5
/* Example of constructors. (one default and one parameterized constructor) */
public class Cube {
int length;
int breadth;
int height;
public int getVolume() {
return (length * breadth * height);
}
Cube() {
length = 10;
breadth = 10;
height = 10;
}
}
Class DemoCube{
Cube cubeObj;
cubeObj = new Cube();
System.out.println("Volume of Cube is : " + cubeObj.getVolume());
}
}
What is the output?

Practice 3.6
/* Example of a cube class containing 2 constructors. (one default and one paramet
erized constructor) */
public class Cube1 {
int length;
int breadth;
int height;

}
Cube1() {
length = 10;
breadth = 10;
height = 10;
}
Cube1(int l, int b, int h) {

length = l;
breadth = b;
height = h;
}
}
class Cube1Demo{
Cube1 cubeObj1, cubeObj2;
cubeObj1 = new Cube1();
cubeObj2 = new Cube1(10, 20, 30);
System.out.println("Volume of Cube1 is : " + cubeObj1.getVolume());

}
}
What is the output?

Practice 3.7
/* Automatic initialization - concept of constructor */
class Point () {
int x, y;
Point () {
x = 10 ;
y = 5;
}
printPoint() {
System.out.println("X = "+ this.x + " Y= " + this.y);
}
}
class PointCreate1 {
Point p = new Point ();
p.printPoint();
}
}
What is the output?
Practice 3.8
/* Automatic initialization - concept of constructor */
class Point () {
int x, y;
Point ( int x, int y ) {

this.x = x ;
this.y = y;
}
printPoint() {
}
}
Point p = new Point (10, 20 );
p.printPoint();
}
}
What is the output?
Practice 3.9
/* Automatic initialization � more than one constructor */
class Point () {
int x, y;
Point () {
x = 30;
y = 40;
}
Point ( int x, int y ) {

this.x = x ;
this.y = y;
}
printPoint() {
}
}
Point p1 = new Point ();
Point p2 = new Point (10, 20 );
p1.printPoint();
p2.printPoint();
}
}
What is the output?

Practice 3.10
/* Passing objects as parameter */
class Test {
int a,b;
Test(int i, int j) {
a = i;
b = j;
}
boolean equals(Test o) {
if((o.a == a) && (o.b == b)) return true;
else return false;
}
}
class PassObjectParameter {
Test ob1 = new Test(100,22);
Test ob2 = new Test(100,22);
Test ob3 = new Test(-1,-1);
System.out.println("ob1 == ob2: " + ob1.equals(ob2));

System.out.println("ob1 <> ob3: " + ob1.equals(ob3));
}
}
What is the output?

Practice 3.11
/* Returning an object */
class Test {
int a;
Test(int i) {
a = i;
}
Test incrByTen() {
Test temp = new Test(a+10);
return temp;
}
}
class RetOb {
Test ob1 = new Test(2);
Test ob2;
ob2 = ob1.incrByTen();
System.out.println("ob1.a: " + ob1.a);
System.out.println("ob2.a: " + ob2.a);
ob2 = ob2.incrByTen();
System.out.println("ob2.a after second increase: " + ob2.a);
}
}
What is the output?
Practice 3.12
/* Example of access modifier */
class BaseClass {
public int x = 10;
private int y = 10;
public int getX() {

return x;
}

this.x = x;
}

return y;
}

this.y = y;
}

return z;
}

this.z = z;
}
int getA() {
return a;
}
void setA(int a) {
this.a = a;
}
}
public class SubclassInSamePackage extends BaseClass {

rr.z = 0;
SubclassInSamePackage subClassObj = new SubclassInSamePackage();

// error as the fields and methods being accessed are private


}
}
what is the output?
Practice 3.13
/* The following program, ArrayDemo, creates an array of integers, puts some value
s in it, and prints each value to standard output. */
class ArrayDemo {
int[] anArray; // declares an array of integers
anArray = new int[10]; // allocates memory for 10 integers
anArray[0] = 100; // initialize first element

anArray[1] = 200; // initialize second element
anArray[2] = 300; // etc.
anArray[3] = 400;
anArray[4] = 500;
anArray[5] = 600;
anArray[6] = 700;
anArray[7] = 800;
anArray[8] = 900;
anArray[9] = 1000;
System.out.println("Element at index 0: " + anArray[0]);

}
}
what is the output?

Practice 3.14
/* Another array example */
class ArrayDemo {
int[] arrayOfInts = { 32, 87, 3, 589, 12, 1076, 2000, 8, 622, 127 };
int i;
for (i = 0; i < arrayOfInts.length; i++) {
System.out.println("arrayOfInts[" + i + "] = " + arrayOfInts[i]);
}
}
}
what is the output?
Practice 3.15
/* Average an array of values */
class Average {
double nums[] = {10.1, 11.2, 12.3, 13.4, 14.5};
double result = 0;
int i;
for(i=0; i<5; i++)
result = result + nums[i];
System.out.println("Average is " + result / 5);
}
}
what is the output?

Practice 3.16
/* Demonstrate a two-dimensional array */
class TwoDArray {
int twoD[][]= new int[4][5];
int i, j, k = 0;
for(i=0; i<4; i++)
for(j=0; j<5; j++) {
twoD[i][j] = k;
k++;
}
for(i=0; i<4; i++) {
for(j=0; j<5; j++)
System.out.print(twoD[i][j] + " ");
}
}
}
what is the output?
Practice 3.17
/* Example of 2D Array: Manually allocate differing size second dimensions. */
class TestTwoDimArrays {
static int [][] myArray = new int[3][]; // initialize # of rows
myArray[0] = new int[3]; // initialize # of cols
myArray[1] = new int[4]; // in each row
myArray[2] = new int[5];
for(int i=0; i<3; i++) // fill and print the array

fillArray(i, i+3);
}
private static void fillArray(int row, int col) {

for( int i=0; iwhat is the output?
Practice 3.18
/* Example Multidimentional Array */
class MultiDimArrayDemo {
String[][] names = {{"Mr. ", "Mrs. ", "Ms. "}, {"Smith", "Jones"}};
System.out.println(names[0][0] + names[1][0]); //Mr. Smith
System.out.println(names[0][2] + names[1][1]); //Ms. Jones
}
}
what is the output?

Practice 3.19
/* The following program, ArrayCopyDemo, declares an array of char elements, spell
ing the word "decaffeinated". It uses arraycopy to copy a subsequence of array com
ponents into a second array */
class ArrayCopyDemo {
char[] copyFrom = { 'd', 'e', 'c', 'a', 'f', 'f', 'e',
'i', 'n', 'a', 't', 'e', 'd' };
char[] copyTo = new char[7];
System.arraycopy(copyFrom, 2, copyTo, 0, 7);
System.out.println(new String(copyTo));
}
}
what is the output?
Practice 3.20
/* Example ArrayList */
import java.util.*;
class ArrayListDemo {
// create an array list
ArrayList al = new ArrayList();
System.out.println("Initial size of al: " + al.size());
// add elements to the array list
al.add("C");
al.add("A");
al.add("E");
al.add("B");
al.add("D");
al.add("F");
// display the array list

System.out.println("Contents of al: " + al);
al.add(1, "A2");
System.out.println("Size of al after additions: " + al.size());

System.out.println("Index of D : " + al.indexOf("D"));
System.out.println("Value at 2: " + al.size());
System.out.println("The second elements is " + al.get(1));
// Remove element from the array list

al.remove("F");
System.out.println("Size of al after deletions: " + al.size());

// replacing an element at a particular index
al.set(2,"G");

// Remove element from the array list

al.remove(2);
// Remove all elements from the array list

al.clear();
}
}
what is the output?
Practice 3.21
/* Example: convert an ArrayList into array */
import java.util.*;
class ArrayListToArray {
// Create an array list
ArrayList al = new ArrayList();
// Add elements to the array list
al.add(new Integer(1));
// get array
Object ia[] = al.toArray();
int sum = 0;
// sum the array
for(int i=0; iwhat is the output?
Practice 3.22
/* Example LinkList */
import java.util.*;
public class LinkedListDemo{

LinkedList link=new LinkedList();
link.add("a");
link.add("b");
link.add(new Integer(10));
System.out.println("The contents of array is" + link);
System.out.println("The size of an linkedlist is" + link.size());
link.addFirst(new Integer(20));
link.addLast("c");
link.add(2,"j");
link.add(1,"t");
link.remove(3);
//access element using iterator
Iterator iterator;
//Create a iterator
iterator = link.iterator();
while (iterator.hasNext()){
System.out.print(iterator.next()+" ");
}
//Check list empty or not
if (link.isEmpty()){
System.out.println("Linked list is empty");
}
else{
System.out.println( "Linked list size: " + link.size());
}
}
}
what is the output?

Practice 3.23
/* Example Vector */
//java.util.Vector and java.util.Enumeration;
import java.util.*;
public class VectorDemo{

Vector< Object> vector = new Vector< Object>();
int primitiveType = 10;
Integer wrapperType = new Integer(20);
String str = "tapan joshi";
vector.add(primitiveType);
vector.add(wrapperType);
vector.add(str);
vector.add(2, new Integer(30));
System.out.println("the elements of vector: " + vector);
System.out.println("The size of vector are: " + vector.size());
System.out.println("The elements at position 2 is: " + vector.elementAt(2
));
System.out.println("The first element of vector is: " + vector.firstEleme
nt());
System.out.println("The last element of vector is: " + vector.lastElement
());
vector.removeElementAt(2);
Enumeration e=vector.elements();
System.out.println("The elements of vector: " + vector);
while(e.hasMoreElements()){
System.out.println("The elements are: " + e.nextElement());
}
}
}
what is the output?

Practice 3.24
/* Example Stack class */
import java.util.*;
public class StackDemo{

Stack stack=new Stack();
stack.push(new Integer(10));
stack.push("a");
System.out.println("The contents of Stack is" + stack);
System.out.println("The size of an Stack is" + stack.size());
System.out.println("The number poped out is" + stack.pop());
System.out.println("The number poped out is " + stack.pop());
//System.out.println("The number poped out is" + stack.pop());
System.out.println("The contents of stack is" + stack);
System.out.println("The size of an stack is" + stack.size());
}
}
what is the output?

Practice 3.25
/* Implement Stack in Java */
import java.io.*;
import java.util.*;
public class StackImplement{

Stack stack;
String str;
int num, n;

StackImplement q = new StackImplement();
}
public StackImplement(){
try{
stack = new Stack();
InputStreamReader ir = new InputStreamReader(System.in);
BufferedReader bf = new BufferedReader(ir);
System.out.print("Enter number of elements : ");
str = bf.readLine();
num = Integer.parseInt(str);
for(int i = 1; i <= num; i++){
System.out.print("Enter elements : ");
n = Integer.parseInt(str);
stack.push(n);
}
}
catch(IOException e){}
System.out.print("Retrieved elements from the stack : ");
while (!stack.empty()){
System.out.print(stack.pop() + " ");
}
}
}
what is the output?

Practice 3.26
/* Example queue */
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Queue;
public class QueueExample {

Queue qe=new LinkedList();
qe.add("b");
qe.add("a");
qe.add("c");
qe.add("e");
qe.add("d");
// access queue using iterator
Iterator it=qe.iterator();
System.out.println("Initial Size of Queue :"+qe.size());
while(it.hasNext()){
String iteratorValue=(String)it.next();
System.out.println("Queue Next Value :"+iteratorValue);
}
// get value and does not remove element from queue
System.out.println("Queue peek :"+qe.peek());
// get first value and remove that object from queue
System.out.println("Queue poll :"+qe.poll());
System.out.println("Final Size of Queue :"+qe.size());
}
}
what is the output?

Practice 3.27
/* Implement Queue in Java */
import java.io.*;
import java.util.*;
public class QueueImplement{

LinkedList list;
String str;
int num;

QueueImplement q = new QueueImplement();
}
public QueueImplement(){
try{
list = new LinkedList();
InputStreamReader ir = new InputStreamReader(System.in);
BufferedReader bf = new BufferedReader(ir);
System.out.println("Enter number of elements : ");
if((num = Integer.parseInt(str)) == 0){
System.out.println("You have entered either zero/null.");
System.exit(0);
}
else{
System.out.println("Enter elements : ");
for(int i = 0; i < num; i++){
int n = Integer.parseInt(str);
list.add(n);
}
}
System.out.println("First element :" + list.removeFirst());
System.out.println("Last element :" + list.removeLast());
System.out.println("Rest elements in the list :");
while(!list.isEmpty()){
System.out.print(list.remove() + "\t");
}
}
catch(IOException e){
System.out.println(e.getMessage() + " is not a legal entry.");
System.exit(0);
}
}
}
what is the output?
Practice 3.28
/* String operation example */
public class stringmethod{
// Construct one String from another

char c[] = {'J', 'a', 'v', 'a'};
String s1 = new String(c);
String s2 = new String(s1);
System.out.println(s1);
//calculate string length

System.out.println(s2.length());
//use the case functions:

System.out.println("toUpperCase: " + s1.toUpperCase());
System.out.println("toLowerCase: " + s1.toLowerCase());
//check for a certain character using indexOf()

System.out.println("indexOf('s'): " + s1.indexOf('s'));
System.out.println("indexOf('v'): " + s1.indexOf('v'));
System.out.println("indexOf('av'): " + s1.indexOf("av"));
//print out the beginning character using charAt()

System.out.println("first character: " + s1.charAt(0));
// Construct string from subset of char array.

byte ascii[] = {65, 66, 67, 68, 69, 70 };
String s3 = new String(ascii);
String s4 = new String(ascii, 2, 3);
//string concatination
String age = "9";
String s = "He is " + age + " years old.";
System.out.println(s);
String string1 = "Hi";

String string2 = new String("Hello");
if (string1 == string2) {
System.out.println("The strings are equal.");
} else {
System.out.println("The strings are unequal.");
}
String str = "Her name is Tamana and Tamana is a good girl.";
String strreplace = "Sonia";
String result = str.replaceFirst("Tamana", strreplace);
System.out.println(result);
}
}
what is the output?
Practice 3.29
/* Simple version of bubble sort */
public class bubbleSort{

public static void main(String a[]){
int i;
int array[] = {12,9,4,99,120,1,3,10};
System.out.println("Values Before the sort:\n");
for(i = 0; i < array.length; i++)
System.out.print( array[i]+" ");
bubble_srt(array, array.length);
System.out.print("Values after the sort:\n");
for(i = 0; i <="" n;="" i++){="" for(j="1;" j="" (n-i);="" j++){="" if(a[
j-1]="" style="box-sizing: border-box;"> a[j]){
t = a[j-1];
a[j-1]=a[j];
a[j]=t;
}
}
}
}
}
what is the output?

Practice 3.30
/* Simple version of bidirectional bubble sort */

public class BidirectionalBubbleSort{
int i;
int array[] = {12,9,4,99,120,1,3,10};
System.out.println("Values Before the sort:\n");
bidirectionalBubble_srt(array, array.length);
for(i = 0; i <="" n)="" {="" st++;="" n--;="" for="" (j="st;" j="" n;=""
j++)="" if="" (array[j]="" style="box-sizing: border-box;"> array[j + 1]) {
int T = array[j];
array[j] = array[j + 1];
array[j + 1] = T;
}
}
for (j = n; --j >= st;) {
if (array[j] > array[j + 1]) {
int T = array[j];
array[j] = array[j + 1];
array[j + 1] = T;
}
}
}
}
}
what is the output?
Practice 3.31
/* Simple version of bidirectional insertion sort */
public class InsertionSort{

int i;
int array[] = {12,9,4,99,120,1,3,10};
System.out.print("Values Before the sort:\n");
insertion_srt(array, array.length);
for(i = 0; i <="" n;="" i++){="" j="i;" b="array[i];" while="" ((j="" sty
le="box-sizing: border-box;"> 0) && (array[j-1] > B)){
array[j] = array[j-1];
j--; }
array[j] = B;
}
}
}
what is the output?

Practice 3.32
/* Simple version of bidirectional merge sort */
public class mergeSort{

int i;
int array[] = {12,9,4,99,120,1,3,10};
System.out.print("Values Before the sort:\n");
mergeSort_srt(array,0, array.length-1);
for(i = 0; i = high) {
return; }
int middle = (low + high) / 2;
mergeSort_srt(array, low, middle);
mergeSort_srt(array, middle + 1, high);
int end_low = middle;
int start_high = middle + 1;
while ((lo <= end_low) && (start_high <= high)) {
if (array[low] < array[start_high]) {
low++; }
else {
int Temp = array[start_high];
for (int k = start_high- 1; k >= low; k--) {
array[k+1] = array[k];
}
array[low] = Temp;
low++;
end_low++;
start_high++;
}
}
}
}
what is the output?

Practice 3.33
/* Selection sort as a method of array */
class ArraySel
{
private double[] a;// ref to array a
private int nElems; // number of data items
public ArraySel(int max) // constructor
{
a = new double[max]; // create the array
nElems = 0; // no items yet
}
public void insert(double value) // put element into array
{
a[nElems] = value; // insert it
nElems++; // increment size
}
public void display() // displays array contents
{
for(int j=0;j< nElems; j++) // for each element
System.out.print(a[j] + " "); // display it
System.out.println("");
}
public void selectionSort()
{
int out, in, min;
for(out=0; out< nElems-1; out++) // outer loop
{ min = out; // minimum
for(in=out+1; in< nElems; in++) // inner loop
if(a[in] < a[min] ) // if min greater,

min = in; // we have a new min
swap(out, min); // swap them
} // end for(outer)
} // end selectionSort()
private void swap(int one, int two)
{
double temp = a[one];
a[one] = a[two];
a[two] = temp;
}
} // end class ArraySel
class SelectSortApp {
int maxSize = 100; // array size
ArraySel arr; // reference to array
arr = new ArraySel(maxSize); // create the array
arr.insert(77); // insert 10 items
arr.insert(99);
arr.insert(44);
arr.insert(55);
arr.insert(22);
arr.insert(88);
arr.insert(11);
arr.insert(00);
arr.insert(66);
arr.insert(33);
arr.display(); // display items
arr.selectionSort(); // selection-sort them
arr.display(); // display them again
}
}
what is the output?

Practice 3.34
/* Quick sort as method of array */
class ArrayIns {
private double[] theArray; // ref to array theArray
public ArrayIns(int max) // constructor
{
theArray = new double[max]; // create the array
}
public void insert(double value) // put element into array
{
theArray[nElems] = value; // insert it
}
{
System.out.print("A=");
for(int j=0; j<="0)" if="" size="" return;="" already="" sorted="" else="
" is="" 2="" or="" larger="" double="" pivot="theArray[right];" rightmost="" item=
"" partition="" range="" right,="" pivot);="" recquicksort(left,="" partition-1);=
"" sort="" left="" side="" recquicksort(partition+1,="" right);="" right="" end=""
recquicksort()="" partitionit(int="" pivot)="" leftptr="left-1;" (after="" ++)=""
rightptr="right;" right-1="" --)="" while(true)="" find="" bigger="" while(thearra
y[++leftptr]="" (nop)="" smaller="" while(rightptr="" style="box-sizing: border-bo
x;"> 0 && theArray[--rightPtr] > pivot); // (nop)
if(leftPtr >= rightPtr) // if pointers cross,
break; // partition done

else // not crossed, so
swap(leftPtr, rightPtr); // swap elements
} // end while(true)
swap(leftPtr, right); // restore pivot
return leftPtr; // return pivot location
} // end partitionIt()
public void swap(int dex1, int dex2) // swap two elements
{
double temp = theArray[dex1]; // A into temp
theArray[dex1] = theArray[dex2]; // B into A
theArray[dex2] = temp; // temp into B
} // end swap( } // end class ArrayIns
class QuickSort1App {
public static void main(String[] args)
{
int maxSize = 16; // array size
ArrayIns arr;
arr = new ArrayIns(maxSize); // create array
for(int j=0; j< maxSize; j++) // fill array with
{
// random numbers
double n = (int)(java.lang.Math.random()*99);
arr.insert(n);
}
arr.quickSort(); // quicksort them
} // end main() } // end class QuickSort1App
what is the output?

Practice 3.35
/* Sorting array of objects using insertion sort */
class Person {
private String lastName;
private String firstName;
private int age;
public Person(String last, String first, int a)
{
// constructor
lastName = last;
firstName = first;
age = a;
}
public void displayPerson() {
System.out.print(" Last name: " + lastName);
System.out.print(", First name: " + firstName);
System.out.println(", Age: " + age); }
public String getLast() // get last name
{
return lastName;
}
} // end class Person
class ArrayInOb {
private Person[] a; // ref to array a
public ArrayInOb(int max) // constructor
{
a = new Person[max]; // create the array
} // put person into array
public void insert(String last, String first, int age)
{
a[nElems] = new Person(last, first, age);
}
{
for(int j=0; j0 && a[in-1].getLast().compareTo(temp.getLast())>0) // unt
il smaller one found,
{
a[in] = a[in-1]; // shift item to the right
--in; // go left one position
}
a[in] = temp; // insert marked item
} // end for } // end insertionSort()
} // end class ArrayInOb
////////////////////////////////////////////////////////////////
class ObjectSortApp {
public static void main(String[] args)
{ int maxSize = 100; // array size
ArrayInOb arr; // reference to array
arr = new ArrayInOb(maxSize); // create the array
arr.insert("Evans", "Patty", 24);
arr.insert("Smith", "Doc", 59);
arr.insert("Smith", "Lorraine", 37);
arr.insert("Smith", "Paul", 37);
arr.insert("Yee", "Tom", 43);
arr.insert("Hashimoto", "Sato", 21);
arr.insert("Stimson", "Henry", 29);
arr.insert("Velasquez", "Jose", 72);
arr.insert("Vang", "Minh", 22);
arr.insert("Creswell", "Lucinda", 18);
System.out.println("Before sorting:");
arr.insertionSort(); // insertion-sort them
System.out.println("After sorting:");
} // end main()
} // end class ObjectSortApp
what is the output?

Practice 3.36
/* This example shows how to sort elements of Java ArrayList in descending order u
sing comparator and reverseOrder method of Collections class. */
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
public class SortArrayListInDescendingOrderExample {
//create an ArrayList object
ArrayList arrayList = new ArrayList(); //Add elements
to Arraylist
arrayList.add("A");
arrayList.add("B");
arrayList.add("C");
arrayList.add("D");
arrayList.add("E");
/* To get comparator that imposes reverse order on a Collection u
se static Comparator reverseOrder() method of Collections class */
Comparator comparator = Collections.reverseOrder();
System.out.println("Before sorting ArrayList in descending order
: " + arrayList);
/* To sort an ArrayList using comparator use, static void sort(Li
st list, Comparator c) method of Collections class. */
Collections.sort(arrayList,comparator);
System.out.println("After sorting ArrayList in descending order :
" + arrayList);
}
}
what is the output?
Practice 3.37
/* Example of binary search in sorted array */
public class BinarySearch {
public static final int NOT_FOUND = -1;
public static int binarySearch( Comparable [ ] a, Comparable x )
{
int low = 0;
int high = a.length - 1;
int mid;
while( low <= high )
{
mid = ( low + high ) / 2;
if( a[ mid ].compareTo( x ) < 0 )
low = mid + 1;
else if( a[ mid ].compareTo( x ) > 0 )
high = mid - 1;
else
return mid;
}
return NOT_FOUND; // NOT_FOUND = -1
}
// Test program
public static void main( String [ ] args ) {
int SIZE = 8;
Comparable [ ] a = new Integer [ SIZE ];
for( int i = 0; i < SIZE; i++ )
a[ i ] = new Integer( i * 2 );
for( int i = 0; i < SIZE * 2; i++ )
System.out.println( "Found " + i + " at " +binarySearch(
a, new Integer( i ) ) );
}
}
what is the output?

Practice 3.38
/* Binary search in ArrayList */
/* Perform Binary Search on Java ArrayList Example

This java example shows how to search an element of Java ArrayList using binar
ySearch method of Collections class. binarySearch method uses
binary search algorithm to search an element.
*/
import java.util.ArrayList;
import java.util.Collections;
public class BinarySearchArrayListExample {
//create an ArrayList object
ArrayList arrayList = new ArrayList();
//Add elements to Arraylist
arrayList.add("1");
arrayList.add("4");
arrayList.add("2");
arrayList.add("5");
arrayList.add("3");
/* To Search an element of Java ArrayList using binary sear
ch algorithm use,static int binarySearch(List list, Object element) method of Coll
ections class.This method returns the index of the value to be searched, if found
in the ArrayList. Otherwise it returns (- (X) - 1) where X is th
e index where the the search value would be inserted.
i.e. index of first element that is grater than the search valu
e or ArrayList.size(), if all elements of an ArrayList are less than the sea
rch value.
Please note that the ArrayList MUST BE SORTED before it can be searchedus
ing binarySearch method. */
//First sort an ArrayList using sort method of Collections class
Collections.sort(arrayList);
System.out.println("Sorted ArrayList contains : " + arrayList);
//search an element using binarySearch method of Collections clas
s
int index = Collections.binarySearch(arrayList,"4");
System.out.println("Element found at : " + index);
}
}
what is the output?
Practice 3.39
/* Example of Binary Search Tree */
class Node {
private int key;
private Node parent;
private Node leftChild;
private Node rightChild;
public Node(int key, Node leftChild, Node rightChild)
{
this.setKey(key);
this.setLeftChild(leftChild);
this.setRightChild(rightChild);
}
public void setKey(int key) {
this.key = key;
}
public int getKey() {
return key;
}
public void setParent(Node parent) {
this.parent = parent;
}
public Node getParent() {
return parent;
}
public void setLeftChild(Node leftChild) {
this.leftChild = leftChild;
}
public Node getLeftChild() {
return leftChild; }
public void setRightChild(Node rightChild)

{
this.rightChild = rightChild;
}
public Node getRightChild() {
return rightChild;
}
}
class BinarySearchTree {
private Node root;
public void insert(int key) {
insert(new Node(key, null, null));
}
public void insert(Node z) {
Node y = null;
Node x = root;
while (x != null) {
y = x;
if (z.getKey() < x.getKey())
{
x = x.getLeftChild();
}
else {
x = x.getRightChild();
}
}
z.setParent(y);
if (y == null){
root = z;
}
else if (z.getKey() < y.getKey()) {
y.setLeftChild(z);
}
else {
y.setRightChild(z);
}
}
public void preorderTraversal() {
preorderTraversal(root); }
public void preorderTraversal(Node node) {
if (node != null) {
System.out.print(node.getKey() + " ");
preorderTraversal(node.getLeftChild());
preorderTraversal(node.getRightChild());
}
}
public void inorderTraversal() {
inorderTraversal(root); }
private void inorderTraversal(Node node) {
if (node != null) {
inorderTraversal(node.getLeftChild());
inorderTraversal(node.getRightChild());
}
}
public void postorderTraversal() {
postorderTraversal(root);
}
private void postorderTraversal(Node node) {
if (node != null) {
postorderTraversal(node.getLeftChild());
postorderTraversal(node.getRightChild());
}
}
}
class BinarySearchTreeTest {
BinarySearchTree bst = new BinarySearchTree();
int[] input = new int[] { 8, 3, 10, 1, 6, 14, 4, 7, 13 };
for (int i : input) {
bst.insert(i);
}
System.out.println("Preorder Traversal:");
bst.preorderTraversal();
System.out.println( "\nInorder Traversal:");
bst.inorderTraversal();
System.out.println("\nPostorder Traversal:");
bst.postorderTraversal();
}
}
what is the output?

Practice 3.40
/* Method overloading. */
class OverloadDemo {
void test() {
System.out.println("No parameters");
}
// Overload test for one integer parameter.

void test(int a) {
System.out.println("a: " + a);
}
// Overload test for two integer parameters.

void test(int a, int b) {
System.out.println("a and b: " + a + " " + b);
}
// overload test for a double parameter

double test(double a) {
System.out.println("double a: " + a);
return a * a;
}
}
class Overload {
OverloadDemo ob = new OverloadDemo();
double result;
// call all versions of test()
ob.test();
ob.test(10);
ob.test(10, 20);
result = ob.test(123.25);
System.out.println("Result of ob.test(123.25): " + result);
}
}
what is the output?

Practice 3.41
/* Constructor overloading */
public class Cube {
int length;
int breadth;
int height;

}
Cube() {
this(10, 10);
System.out.println("Initialized with Default Constructor");
}
Cube(int l, int b) {
this(l, b, 10);
System.out.println("Initialized with Constructor having 2 params");
}
Cube(int l, int b, int h) {

length = l;
breadth = b;
height = h;
System.out.println("Initialized with Constructor having 3 params");
}
Cube(Cube ob) { //pass object to constructor

length = ob.length;
breadth = ob.breadth;
height = ob.height;
System.out.println("Finished with Constructor having object params");
}

Cube cubeObj1, cubeObj2, cubeObj3;
cubeObj1 = new Cube();
cubeObj2 = new Cube(10, 20, 30);
cubeObj3 = new Cube(cubeObj2); // Creating clone object
}
}
what is the output?

Practice 3.42
/* A simple example of inheritance. */
class A {
int i, j;
void showij() {
System.out.println("i and j: " + i + " " + j);
}
}

class B extends A {
int k;
void showk() {
System.out.println("k: " + k);
}
void sum() {
System.out.println("i+j+k: " + (i + j + k));
}
}
class SimpleInheritance {
A superOb = new A();
B subOb = new B();
// The superclass may be used by itself.
superOb.i = 10;
superOb.j = 20;
System.out.println("Contents of superOb: ");
superOb.showij();
/* The subclass has access to all public members of its superclass. */
subOb.i = 7;
subOb.j = 8;
subOb.k = 9;
System.out.println("Contents of subOb: ");
subOb.showij();
subOb.showk();
System.out.println("Sum of i, j and k in subOb:");
subOb.sum();
}
}
what is the output?

Practice 3.43
class Box {
double width;
double height;
double depth;
Box(){ // constructor used when all dimensions specified

}

width = w;
height = h;
depth = d;
}

}
}


width = w;
height = h;
depth = d;
weight = m;
}
}
class DemoBoxWeight {
double vol;
}
}
what is the output?

Practice 3.44
class Box {
double width;
double height;
double depth;
Box(){ // constructor used when all dimensions specified

}

width = w;
height = h;
depth = d;
}

}
}


width = w;
height = h;
depth = d;
weight = m;
}
}
class DemoBoxWeight {
double vol;
}
}
what is the output?

Practice 3.45
/* Example of a superclass variable referring to a subclass Object*/
class Box {
double width;
double height;
double depth;
Box() { // default constructor

}

width = w;
height = h;
depth = d;
}

}
}


width = w;
height = h;
depth = d;
weight = m;
}
}
class RefDemo {
BoxWeight weightbox = new BoxWeight(3, 5, 7, 8.37);
Box plainbox = new Box();
double vol;
vol = weightbox.volume();
System.out.println("Volume of weightbox is " + vol);
System.out.println("Weight of weightbox is "
+ weightbox.weight);
// assign BoxWeight reference to Box reference
plainbox = weightbox;
vol = plainbox.volume(); // OK, volume() defined in Box
System.out.println("Volume of plainbox is " + vol);
/* The following statement is invalid because plainbox does not define a
weight member. */
// System.out.println("Weight of plainbox is " + plainbox.weight);
}
}
what is the output?

Practice 3.46
/* Simple example of access modifier. In a class hierarchy, private members remain
private to their class. This program contains an error and will not compile. */
class A {
int i; // public by default
private int j; // private to A
void setij(int x, int y) {

i = x;
j = y;
}
}
// A's j is not accessible here.

class B extends A {
int total;
void sum() {
total = i + j; // ERROR, j is not accessible here
}
}
class Access {
B subOb = new B();
subOb.setij(10, 12);
subOb.sum();
System.out.println("Total is " + subOb.total);
}
}
what is the output?

Practice 3.47
/* Another example of access modifier with public, private and protected data */
class BaseClass {
public int x = 10;
private int y = 10;
public int getX() {

return x;
}

this.x = x;
}

return y;
}

this.y = y;
}

return z;
}

this.z = z;
}
int getA() {
return a;
}
void setA(int a) {
this.a = a;
}
}
public class SubclassInSamePackage extends BaseClass {

rr.z = 0;
SubclassInSamePackage subClassObj = new SubclassInSamePackage();
// error as the fields and methods being accessed are private

}
}
what is the output?

Practice 3.48
/* Sinple example of super concept */
// A complete implementation of BoxWeight.

class Box {

width = w;
height = h;
depth = d;
}

double volume() {
}
}
// BoxWeight now fully implements all constructors.


weight = m;
}
}
class DemoSuper {
double vol;
}
}
what is the output?

Practice 3.49
/* Example of super to overcome name hiding */
class A {
int i;
}

class B extends A {
int i; // this i hides the i in A
B(int a, int b) {
super.i = a; // i in A
i = b; // i in B
}
void show() {
System.out.println("i in superclass: " + super.i);
System.out.println("i in subclass: " + i);
}
}
class UseSuper {
B subOb = new B(1, 2);
subOb.show();
}
}
what is the output?

Practice 3.50
/* Code sharing through super concept */
class Cat {
void speak() {
System.out.println("Meaon ! ");
}
}
class PetCat extends Cat { // PetCat is one type of Cat
void speak() {
System.out.println(" Meow ! ");
}
}
class MagicCat extends Cat { // MagicCat is another kind of Cat

static boolean noOne;
void speak() {
if (noOne) {
super.speak(); // use the super class definition
} else {
System.out.println(" Hello World !");
}
}
}
class ManyCats {
PetCat c1 = new PetCat();
MagicCat c2 = new MagicCat();
c2.noOne = true;
c2.speak();
c1.speak();
c2.noOne = false;
c2.speak();
}
}
what is the output?

Practice 3.51
/* Example of multilevel inheritance. */
// Start with Box.

class Box {

width = w;
height = h;
depth = d;
}

double volume() {
}
}
// Add weight.
weight = m;
}
}
// Add shipping costs

class Shipment extends BoxWeight {
double cost;

Shipment(double w, double h, double d, double m, double c) {
super(w, h, d, m); // call superclass constructor
cost = c;
}
}
class DemoShipment {
Shipment shipment1 = new Shipment(10, 20, 15, 10, 3.41);
Shipment shipment2 = new Shipment(2, 3, 4, 0.76, 1.28);
double vol;
}
}
what is the output?

Practice 3.52
/* Polymorphism and Overriding concept */
//base class
class Base
{
int i=1;
int j=2;
public Base(){
}
public void display(){
System.out.println("i="+i);
System.out.println("i="+j);
}
}
//derived class
class Derived extends Base{
int p=3;
int q=4;
public Derived(){
}
public void display(){

System.out.println("p="+p);
System.out.println("q="+q);
}
public void uniqueDisplay(){

System.out.println(" This display is unique to Derived");
}
}
public class AccessCheck{

Base b=new Base();
Derived d=new Derived();
b.display();
d.display();
d.uniqueDisplay();
// derived is assigned to base
b=d;
// Object is derived, reference is of base type
b.display();
//b.uniqueDisplay(); // Uncomment this line, and check
}
}
what is the output?

Practice 3.53
/* Using run-time polymorphism. */
class Figure {
double dim1;
double dim2;
Figure(double a, double b) {
dim1 = a;
dim2 = b;
}
double area() {
System.out.println("Area for Figure is undefined.");
return 0;
}
}
class Rectangle extends Figure {

Rectangle(double a, double b) {
super(a, b);
}
// override area for rectangle

double area() {
System.out.println("Inside Area for Rectangle.");
return dim1 * dim2;
}
}
class Triangle extends Figure {

Triangle(double a, double b) {
super(a, b);
}
// override area for right triangle

double area() {
System.out.println("Inside Area for Triangle.");
return dim1 * dim2 / 2;
}
}
class FindAreas {
Figure f = new Figure(10, 10);
Rectangle r = new Rectangle(9, 5);
Triangle t = new Triangle(10, 8);
Figure figref;
figref = r;
System.out.println("Area is " + figref.area());
figref = t;
figref = f;
}
}
what is the output?
Assignment
Q: Read at most 10 names of students and store them into an array of String
nameOfStudents[10]. Sort the names into the lexicographic order.
Display the sorted list of names.
Q: Define a class Complex to represent an object for a complex number like
Z = X + i.Y with the following methods:
Complex add(Complex z1, Complex z2) //To add two complex numbers
Complex sub(Complex z1, Complex z2) //To subtract two complex numbers
Complex mul(Complex z1, Complex z2) // To multiply two complex numbers
float magnitude(Complex z) // To find the modulus
Complex conjugate(Complex z) // To find the complex conjugate
Write the main class and instantiate the objects of the above mentioned
classes.
Q: Add the necessary methods in the class PointCreate3 (Practice 3.8) to
calculate the area and perimeter of a rectangle given the two corner
coordinates.
Q: Read at most 10 names of students and store them into an array of String
nameOfStudents[10]. Sort the names into the lexicographic order.
Display the sorted list of names.
Q: Define a class Employee with usual member for an employee like
empCode(String), empName(String), dateOfBirth(Date), dateOfJoin(Date),
designationCode(int), salary(float).Create a list to store data about 10
employees using Vector. Manipulate the list using the methods in class
Vector.
Q: Define an one dimensional array "vivid" of type float. Read the values
from the keyboard to load the array. Calcualte and then print the average
of all the values in "vivid"..
Q: Define two 2D arrays of integers, namely A[3]4] and B[4][2]. Store the
values into them. Store the result of matrix multiplication into an another
2D array, say C.
Q: Write a program to store a lists of name in a List. Reverse the order of the
names in the list using Stack. You should use class ArrayList to store the
names (String) and class Stack for reversing..
Q: Create a class ArrSort which contains one double array to store the data
and one integer variable to store the number of elements.
Q: Write a program to read the content of a file and count the number of
words in the file.
Q: Write a program to copy contents from one file to another file.
Q: Write a program to merge two file contents into another file.
Q&A
Q: What are the principle concepts of OOPS?
A: There are four principle concepts upon which object oriented design and
programming rest. They are:
• Abstraction
• Polymorphism
• Inheritance
• Encapsulation
(i.e. easily remembered as A-PIE).

Q: What is Abstraction?
A: Abstraction refers to the act of representing essential features without including
the background details or explanations.
Q: What is Encapsulation?
A: Encapsulation is a technique used for hiding the properties and behaviors of an
object and allowing outside access only as appropriate. It prevents other
objects from directly altering or accessing the properties or methods of the
encapsulated object.
Q: What is the difference between abstraction and encapsulation?
A: • Abstraction focuses on the outside view of an object (i.e. the interface)
Encapsulation (information hiding) prevents clients from seeing it�s inside
view, where the behavior of the abstraction is implemented.
• Abstraction solves the problem in the design side while Encapsulation is the
Implementation.
• Encapsulation is the deliverables of Abstraction. Encapsulation barely talks
about grouping up your abstraction to suit the developer needs.
Q: What is Inheritance?
A: Inheritance is the process by which objects of one class acquire the properties
of objects of another class.
• Inheritance is the process by which objects of one class acquire the
properties of objects of another class.
• A class that is inherited is called a superclass.
• The class that does the inheriting is called a subclass.
• Inheritance is done by using the keyword extends.
• The two most common reasons to use inheritance are:
• To promote code reuse

• To use polymorphism
Q: What is Polymorphism?
A: Polymorphism is briefly described as "one interface, many implementations."
Polymorphism is a characteristic of being able to assign a different meaning or
usage to something in different contexts - specifically, to allow an entity such
as a variable, a function, or an object to have more than one form.
Q: How does Java implement polymorphism?
A: (Inheritance, Overloading and Overriding are used to achieve Polymorphism in
java). Polymorphism manifests itself in Java in the form of multiple methods
having the same name.
• In some cases, multiple methods have the same name, but different
formal argument lists (overloaded methods).
• In other cases, multiple methods have the same name, same return
type, and same formal argument list (overridden methods).
Q: Explain the different forms of Polymorphism.

A: There are two types of polymorphism one is Compile time polymorphism and
the other is run time polymorphism. Compile time polymorphism is method
overloading. Runtime time polymorphism is done using inheritance and
interface. Note: From a practical programming viewpoint, polymorphism
manifests itself in three distinct forms in Java:
• Method overloading
• Method overriding through inheritance
• Method overriding through the Java interface
Q: What is runtime polymorphism or dynamic method dispatch?

A: In Java, runtime polymorphism or dynamic method dispatch is a process in
which a call to an overridden method is resolved at runtime rather than at
compile-time. In this process, an overridden method is called through the
reference variable of a superclass. The determination of the method to be
called is based on the object being referred to by the reference variable.
Q: What is Dynamic Binding?
A: Binding refers to the linking of a procedure call to the code to be executed in
response to the call. Dynamic binding (also known as late binding) means that
the code associated with a given procedure call is not known until the time of
the call at run-time. It is associated with polymorphism and inheritance.
Q: What is method overloading?
A: Method Overloading means to have two or more methods with same name in
the same class with different arguments. The benefit of method overloading is
that it allows you to implement methods that support the same semantic
operation but differ by argument number or type.
Note:
• 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
• A method can be overloaded in the same class or in a subclass
Q: What is method overriding?

A: Method overriding occurs when sub class declares a method that has the same
type arguments as a method declared by one of its superclass. The key benefit
of overriding is the ability to define behavior that�s specific to a particular
subclass type.
Note:
• The overriding method cannot have a more restrictive access modifier

than the method being overridden (Ex: You can�t override a method
marked public and make it protected).
• You cannot override a method marked final
• You cannot override a method marked static
Q: Can overloaded methods be override too?

A: Yes, derived classes still can override the overloaded methods. Polymorphism
can still happen. Compiler will not binding the method calls since it is
overloaded, because it might be overridden now or in the future.
Q: Is it possible to override the main method?
A: NO, because main is a static method. A static method can't be overridden in
Java.
Q: How to invoke a superclass version of an Overridden method?
A: To invoke a superclass method that has been overridden in a subclass, you
must either call the method directly through a superclass instance, or use the
super prefix in the subclass itself. From the point of the view of the subclass,
the super prefix provides an explicit reference to the superclass'
implementation of the method.
// From subclass
super.overriddenMethod();
Q: What is super?
A: super is a keyword which is used to access the method or member variables
from the superclass. If a method hides one of the member variables in its
superclass, the method can refer to the hidden variable through the use of the
super keyword. In the same way, if a method overrides one of the methods in
its superclass, the method can invoke the overridden method through the use
of the super keyword.
Note:
• You can only go back one level.

• In the constructor, if you use super(), it must be the very first code, and
you cannot access any this.xxx variables or methods to compute its
parameters.
Q: How do you prevent a method from being overridden?

A: To prevent a specific method from being overridden in a subclass, use the final
modifier on the method declaration, which means "this is the final
implementation of this method", the end of its inheritance hierarchy.
public final void exampleMethod() {
// Method statements
}
Q: What is Constructor?
A: • A constructor is a special method whose task is to initialize the object of
its class.
• It is special because its name is the same as the class name.
• They do not have return types, not even void and therefore they cannot
return values.
• They cannot be inherited, though a derived class can call the base
class constructor.
• Constructor is invoked whenever an object of its associated class is
created.
Q: How does the Java default constructor be provided?

A: If a class defined by the code does not have any constructor, compiler will
automatically provide one no-parameter-constructor (default-constructor) for
the class in the byte code. The access modifier (public/private/etc.) of the
default constructor is the same as the class itself.
Q: Can constructor be inherited?
A: No, constructor cannot be inherited, though a derived class can call the base
class constructor.
Q: How are this() and super() used with constructors?
A: • Constructors use this to refer to another constructor in the same class
with a different parameter list.
• Constructors use super to invoke the superclass's constructor. If a
constructor uses super, it must use it in the first line; otherwise, the
compiler will complain.
Q: What are Access Specifiers available in Java?

A: • Public- public classes, methods, and fields can be accessed from
everywhere.
• Protected- protected methods and fields can only be accessed within
the same class to which the methods and fields belong, within its
subclasses, and within classes of the same package.
• Default(no specifier)- If you do not set access to specific level, then
such a class, method, or field will be accessible from inside the same
package to which the class, method, or field belongs, but not from
outside this package.
• Private- private methods and fields can only be accessed within the
same class to which the methods and fields belong. private methods
and fields are not visible within subclasses and are not inherited by
subclasses.
Q: What is final modifier?

A: • final Classes- A final class cannot have subclasses.
• final Variables- A final variable cannot be changed once it is initialized.
• final Methods- A final method cannot be overridden by subclasses.
Q: What are the uses of final method?

A: • Disallowing subclasses to change the meaning of the method.
• Increasing efficiency by allowing the compiler to turn calls to the method
into inline Java code.
Q: What are static variables?

A: Variables that have only one copy per class are known as static variables.
They are not attached to a particular instance of a class but rather belong to a
class as a whole. They are declared by using the static keyword as a modifier.
static type varIdentifier;
where, the name of the variable is varIdentifier and its data type is specified by
type.
Note: Static variables that are not explicitly initialized in the code are
automatically initialized with a default value. The default value depends on the
data type of the variables.
Q: What is static block?
A: Static block which exactly executed exactly once when the class is first loaded
into JVM. Before going to the main method the static block will execute.
Q: What is the difference between static and non-static variables?
A: A static variable is associated with the class as a whole rather than with
specific instances of a class. Non-static variables take on unique values with
each object instance.
Q: What are static methods?
A: • A static method can only call other static methods.
• A static method must only access static data.
• A static method cannot reference to the current object using
keywords super or this.

Java Notes 3

Uploaded by

Java Notes 3

Uploaded by

CONTENTS

Class Definition in Java

Class Class Name [extends SuperClassName ]

[Modifier ] returnType MethodName (parameter list){

Illustration 3.1 // Encapsulation //

// A program that uses the circle class

//The following class declares an object of type Circle

Illustration 3.2 // Encapsulation //

// A program that declares two objects of the Circle class

// Declaring objects of type Circle and Box

// This class declares an object of type Point.

// assign values to mypoint's instance variables

// access the values from mypoint�s instance variable

/* Encapsulation: Defining a class with method */

// definition of another class. This is a main class

// definition of another class. This is a main class

/* Encapsulation: Utilization of objects in a program */

// definition of another class. This is a main class

System.out.println (" X1 = " + p1.x + "Y1 = " + p1.y );

Illustration 3.8 //constructor//

// A Java program to demonstrate working of constructor in Java

Illustration 3.9 // Constructor //

/* Demontration of constructor Overloading */

Student(int rollno, String name, String course, float fee){

/*Demontration of constructor Overloading */

// Program to demonstrate use of this: to invoke current class method

/* Special use of this keyword: No object creation to invoke method

/* Demontration of constructor Overloading */

Circle (double x, double y, double r){

Circle (double r){

Circle (Circle c){

Illustration 3.15 // Example of Inheritance in Java //

/* A simple example of inheritance. */

// Create a subclass by extending class A.

/* The subclass has access to all public members of its superclas

/* Inheritance example: initializing through constructor */

Box(){ // Default setting by this constructor

double volume() { // compute and return volume

// Here, Box is extended to include weight.

// constructor for BoxWeight

/* Inheritance example: initializing through constructor */

Box(){ // Default setting by this constructor

Box(double w, double h, double d) {

double volume() { // compute and return volume

// Here, Box is extended to include weight.

// Constructors for BoxWeight

BoxWeight(double w, double h, double d, double m) {

/* Example of a superclass variable referring to a subclass Object*/

Box() { // default constructor

// constructor used when all dimensions specified

double volume() { // compute and return volume

// Here, Box is extended to include weight.

// constructor for BoxWeight

// assign BoxWeight reference to Box reference

/* Simple example of super concept */

// A complete implementation of BoxWeight.

// constructor used when all dimensions specified

// compute and return volume

// BoxWeight now fully implements all constructors.

// constructor when all parameters are specified

/* Example of super to overcome name hiding */

// Create a subclass by extending class A.

/* Code sharing through super concept */

class MagicCat extends Cat { // MagicCat is another kind of Cat

/* Example of multilevel inheritance. */

// Start with Box.

// constructor used when all dimensions specified

// compute and return volume

// Add shipping costs

// constructor when all parameters are specified

/* A simple abstract class example */

abstract class Base {

class Derived extends Base {

// Uncommenting the following line will cause compiler error as the

// We can have references of Base type.

// An abstract class with constructor

/Demontration of constructor Overloading /

/M1/ float distance ( int x, int y) { // One definition of distance

/M2/ float distance (Point p) { // Overloaded definition of dist

/M4/ float distance (Point3D pt) {