Advanced Object Oriented Programming

( AOOP - R/A/E )

Lecture Notes

( quick preparation material - Y23 updated )

Prepared By

Dr MSR PRASAD
SEC-11 Adv
 SYLLABUS

CO-1

1. Design Patterns

 Introduction to Design Patterns

 Creational Patterns

o Singleton, Factory Method, Abstract Factory

 Structural Patterns

o Decorator, Bridge, Adapter, Facade

 Behavioral Patterns

 Observer, Command, Iterator, Chain of Responsibility, Strategy, Template, Dependency Injection

2. Clean Coding Techniques

 SOLID Principles

 Code Smells

o Bloaters, Object-Oriented Abusers, Change Preventers, Dispensables, Couplers

 Refactoring Techniques

o Removing Code Smells

3. Test-Driven Development (TDD)

 Introduction to TDD, Unit Testing & JUnit5


CO-2

4. Generics & Collections Framework

 Introduction to Generics, Usage of Generics with Interfaces, Building Stacks, Queues, and
Priority Queues

 Comparator, Comparable, Cloneable & Iterator Interfaces

 Sets and Maps and Their Java API

 Functional Interfaces, Nested Classes, Lambda Expressions, and Stream API

 CO-3

5. Multi-threading & Parallel Programming

 Introduction to Multithreading and Parallel Programming, Thread Concepts & States, Creating
Tasks & Threads, Thread Classes, Thread Pools, Thread Synchronization & Locks, Cooperation
Among Threads, Case Study: Producer/Consumer, Blocking Queues, Semaphores, Deadlock
Avoidance, Synchronized Collections & Parallel Programming

CO-4

6. Java I/O and JDBC

 Java I/O and Its Limitations

 JDBC: API, Components, Architecture (2-Tier & 3-Tier), Drivers & Their Types, Packages for JDBC
Connection, Steps to Connect to Databases (PostgreSQL)

7. Servlets

 Overview, Life Cycle of a Servlet, Attributes in Servlets, Interaction Between Client & Servlet,
Servlet Demo Application Development with Sessions

8. JavaServer Pages (JSP)

 Overview & Advantages Over Servlets, Features and Syntax, Life Cycle of JSP, Environmental
Setup for JSP, Interaction Between Client, JSP & Server, JSP Demo Application Development
CO - 1
 SHORT ANSWER QUESTIONS ( from CO-1 )

1. Types of inheritance
Answer:
a) multilevel b) multiple c) Hierarchical d) hybrid inheritance

2. Multi level inheritance?

Answer:
class A , class B extends A , class C extends B is multilevel inheritance

3. Advantages of inheritance in java?

Answer:
1. Reusability 2. Better organization of the code 3. Clean coding technique 4.
Method overriding are the advantages.

4. Multiple inheritance in Java, what is the problem?

Answer:
Java supports single parent class to derive the child class, but multi inheritance
needs more than one super classes. To overcome this problem, the child class can
be derived from one class and one interface.

Eg: class Book extends Paper implements from Ink

Where
Paper is the super class
Ink is the interface.
5. Example of an abstract class
Answer:
abstract class AbsEmp {
abstract void show();
}

6. Example of abstract method in Java.

Answer:
abstract class AbsEmp {
abstract void show();
}
In this above program abstract method show() has no definition, it’s definition
must be overridden in the child class of the abstract class AbsEmp .

7. "implements" keyword in java

Answer:
“implements” keyword is used for interface .
Eg.
interface Iface {
void callMe();
}
Class Employee implements Iface {
Public void callMe() {
System.out.println(“ hello dude”);
}
}
8. “extends” keyword - in interfaces ?
Answer:
interfaces can be extended with keyword “extends”
Eg.
interface Iface1 {
void callMe();
}
interface Iface2 extends Iface1 {
void callMeToo();
}

9. Testing in software development - Explanation

Answer:
Coding and Testing are the important steps of software engineering. As per the
requirements project can be designed and developed (coded), after the coding part is
completed code should be tested for correctness of the results ie validation and
verification purposes.

10. Design patterns

Answer:
Design patterns represent the best practices used by experienced object-oriented
software developers. Design patterns are solutions to general problems that software
developers faced during software development. These solutions were obtained by
trial and error by numerous software developers over quite a substantial period of
time. Finally Design Patterns are a software engineering concept describing
recurring solutions to common problems in software design.
11. Uses of design patterns
Answer:
During the design phase of the software development design patterns are used. They
are programming language-independent strategies for solving a common problem.
That means a design pattern represents an idea, not a particular implementation. By
using design patterns, you can make your code more flexible, reusable, and
maintainable.

12. Uses of Singleton pattern.

Answer:
The Singleton pattern also supports lazy loaded and static initialization, helps in the
hiding of dependencies, and provides a single access point to a particular example.

13. List of creational design patterns?

Answer:
Singleton, Factory and abstract Factory design patterns

14. Uses of Structural Design patterns .

Answer:
In software engineering, structural design patterns are design patterns that ease the
design by identifying a simple way to realize relationships among entities.
Examples of Structural Patterns include: Adapter pattern: 'adapts' one interface for a
class into one that a client expects. Structural design patterns are blueprints for
combining objects and classes into larger structures to achieve multiple goals. They
simplify the structure by identifying relationships, such as how classes inherit from
each other and how they are composed from other classes.
15. What is the purpose and benefits of Observer Design Pattern?

Answer:

The observer design pattern is a behavioral design pattern that's useful when you
want to be notified of changes to an object's state. In this pattern, the object being
monitored is called the subject, and the object that monitors it is called the observer.

It supports the principle of loose coupling between objects that interact with each
other. It allows sending data to other objects effectively without any change in the
Subject or Observer classes. Observers can be added/removed at any point in time.

16. What is the purpose and benefits of Strategy Design Pattern?

Answer:

the strategy design pattern is a behavioral pattern that allows for the selection of an
algorithm during runtime. It provides flexibility and reusability by enabling the
calling code to choose from a set of algorithms instead of implementing a single
one.

It allows you to define a family of algorithms, encapsulate each one, and make them
interchangeable. It enables you to select and use an algorithm at runtime without
tightly coupling the client code to a specific implementation.

17. Phases of Test driven development

Answer:
1. Red Phase : planning and design stage i.e before coding
2. Green Phase : coding stage
3. Refactoring : code change
18. Refactoring of code
Answer:
To get the efficiency of the code, refactoring is required. In Refactoring the
behavior of the code is unchanged ie. Inputs is same and output is same. What
happens is the code is reorganized by changing data structures or input modes or
adding more functions or class hierarchical arrangements.

19. Characteristics of clean code

Answer:
The code that is easily readable, modifiable, testable, maintainable and is less prone
to errors is referred as "Clean Code".

20. Comments in clean coding

Answer:
Commenting is also considered as one of the best practises to make the code easily
understandable. In Java, two kinds of comments are allowed:

Documentation comments - The target audience is the users of codebase

Implementation comments - The target audience is the developers that work on the
codebase.

21. Variable - As per clean coding - Explanation

Answer:
A variable is considered as an identifier in programming languages,

Variables are used to represent data items in program. Variables are declared with
data types.

Eg . int marks;
 boolean flag;

characters to declare a variable

a) length
b) begin with small letter or underscore
c) special characters used

22. Dead code / Lazy code

Answer:
Dead code is a code available in the program but has no significance, found no
references in the usage.

When there is no significance of a particular code segment, it is called dead code or

lazy code.

23. Relate a method call?

Answer:
In java methods are declared as class methods and instance methods.

Class methods: they are static methods called by its class or by any object.

Instance method : they are non static methods , called by only object of the class.

Eg.
Class Hamper{
Static void show(){
}
Void display(){
}
Public static void main(String[] args){
Hamper h1 = new Hamper();
Hamper. Show(); // static method call
h1.dispaly(); // non static method call
}
}
 LONG ANSWER QUESTIONS ( from CO-1 )

1. Inheritance - Example program

Program:
class Animal {
void eat(){
System.out.println("Animals eat food");
}
void sleep(){
System.out.println("Animals sleep at night");
}
}

class Monkey extends Animal{

void jump(){
System.out.println("Monkeys easily jumps on trees");
}
void eat(){
System.out.println("Monkeys eat vegitarian food");
}
}
class Human extends Monkey{
void study(){
System.out.println("Humans study in great
universities");
}
void eat(){
System.out.println("Human eat cooked food and junk
food");
}
}

class DemoInh1{
public static void main(String[] args){
Animal aa = new Animal();
Human hh = new Human();
Monkey mm = new Monkey();
aa.eat();
aa.sleep();
mm.eat();
mm.jump();
hh.study();
hh.eat();
hh.sleep();
}
}

2. Inheritance – Example program -2 (method overriding)

(What is method overriding in java, Explain how runtime polymorphism is
achieved in java? Use at least two classes inheritance is the relationship between
them. Child class must override at least one method from the parent class.)

Answer:
Method Overriding: redefining a method from its super class. method overriding,
is an example of runtime polymorphism where as method over loading is the
example for compile time polymorphism.

Program:
class Monkey implements Animal{
public void eat(){
System.out.println("Monkeys eat vegitarian food");
}
public void sleep(){
System.out.println("Monkeys sleep on trees");
}
void jump(){
System.out.println("Monkeys jumps from tree to tree");
}
}

class Human extends Monkey{

@override from parent class
void eat(){
System.out.println("Human eat cooked food and junk
food");
}
void study(){
System.out.println("Humans study in great
universities");
}
}
class DemoInh1{
public static void main(String[] args){
Human hh = new Human();
Monkey mm = new Monkey();

mm.eat();
mm.jump();
hh.study();
hh.eat();
hh.sleep();
}
}

3.Abstract class – Example program -1

(Java program to create abstract class Car, with abstract methods steering() and
braking(). Create a subclass Maruthi to implements abstract methods in it.)

Program:
abstract class Car {
abstract void steering();
abstract void breaking();
}
Class Maruthi extends Car{
@override
void steering(){
System.out.println(“ steering helps in turning the car
towards right and left”);
}
void breaking(){
System.out.println(“ breaks helps in slow down/stopping
the car”);
}
}

Class Demo{
Public static void main(String[] args){
Car c1 = new Maruthi();
c1. Steering();
c1.breaking();
}
}

4.Abstract class – Example program -2

(Java program with an abstract class Brazo in which callMe() method is an abstract
method. Write another java class that should implement callMe() method of Brazo
class, so that callMe() method can be called.)

Program:
abstract class Brazo {
abstract void callMe();
}
Class Carzo extends Brazo{
@override
void callMe(){
System.out.println(“ overriding callMe method from Brazo
calss”);
 }
}
Class Demo{
Public static void main(String[] args){
Brazo b1 = new Carzo();
b1. callMe();
}
}

5. Interface –abstract class - Example program -1

(Java program interface Animal having atleast two methods in it, write a Monkey
class as abstract class, atleast one abstract method in it, Write Human class with
one method in it, test how the methods of Animal and Monkey are executed?)

Program:
interface Animal {
void eat();
void sleep();
}

abstract class Monkey implements Animal{

abstract void jump();
public void eat(){
System.out.println("Monkeys eat vegitarian food");
}
public void sleep(){
System.out.println("Monkeys sleep on trees");
 }
}
class Human extends Monkey{
void study(){
System.out.println("Humans study in great
universities");
}
void eat(){
System.out.println("Human eat cooked food and junk
food");
}
}

class DemoInh1{
public static void main(String[] args){
Human hh = new Human();
Monkey mm = new Monkey();

mm.eat();
mm.jump();
hh.study();
hh.eat();
hh.sleep();
}
}
6. Interface - Example program -2
Answer:
overridden methods of interface are public only, demonstration of the statement is
the following statement.

Program :
interface One {
void callMe();
}

class IntImpl implements One {

public void callMe(){
System.out.println("callme: output");
}

void show(){
System.out.println(" Today is Sunny day ");
}
}

class DemoIntf1 {
public static void main(String[] args){
IntImpl if1 = new IntImpl();
if1.callMe();
if1.show();
}
}
7. Interface –Example program -3 ( Extends key word)
Answer:
Interfaces can be extended, as they follow inheritance of OOP concept.
Program :
interface One {
void callMe();
}
interface Two extends One {
void callMeToo();
}
// concrete class
class IntImpl implements Two {
public void callMe(){
System.out.println("callme: output");
}
public void callMeToo(){
System.out.println("callmeToo: output");
}
void show(){
System.out.println(" Today is wednesday");
}
}

class DemoIntf3 {
public static void main(String[] args){
IntImpl if1 = new IntImpl();
 if1.callMe();
if1.callMeToo();
if1.show();
}
}

8. Multiple inheritance - Example program

Answer:
Java does not support multiple inheritance ie child class having two parent classes,
but it can be achieved through one parent as class and another as interface. The
following program demonstrates this feature.

Program :
interface One{
void callMe();
}

class Hello{
void greet(){
System.out.println("Hello world");
}
}

class HelloOne extends Hello implements One {

public void callMe(){
System.out.println("callme: output");
}
 void show(){
System.out.println("today is wednes day");
}
}

class DemoIntf5{
public static void main(String[] args){
HelloOne ho1 = new HelloOne();
ho1.callMe();
ho1.greet();
ho1.show();
}
}

9. Differentiate interface with abstract class in java

Abstract class Interface

1) Abstract class can have abstract Interface can have only abstract methods.
and non-abstract methods.

2) Abstract class doesn't support multiple Interface supports multiple inheritance.

inheritance.

3) Abstract class can have final, non-final, Interface has only static and final variables.
static and non-static variables.

4) Abstract class can have static methods, Interface can't have static methods, main
main method and constructor. method or constructor.

5) Abstract class can provide the Interface can't provide the implementation of
implementation of interface. abstract class.
 6) The abstract keyword is used to declare The interface keyword is used to declare
abstract class. interface.

7) Example: Example:
public abstract class Shape{ public interface Drawable{
public abstract void draw(); void draw();
} }

10. Singleton design pattern – Example program

Answer;
Singleton pattern involves a single class which is responsible to create an object
while making sure that only single object gets created. This class provides a way to
access its only object which can be accessed directly without need to instantiate the
object of the class. It's useful when you need to control access to shared resources
or maintain a single point of control, such as in logging systems, database
connections, caches, and thread pools.

Important points:
1. Private default constructor
2. Static object
3. Static method to return the object to the caller.
4. Number of utility methods to be used by the object

Program :
class Hello{
private Hello(){
}
static Hello obj = new Hello();

static Hello getObject(){

return obj;
}

void show(){
System.out.println("Hello World");
}
}

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

Hello h1 = Hello.getObject();
h1.show();
}
}

11. Factory design pattern Example Program-1 with Block diagram

Answer:
It's used when a superclass has multiple subclasses and the client program needs to
return one of the subclasses based on input. The pattern moves the responsibility of
instantiating a class from the client program to the factory class.

The pattern encapsulates object creation logic in a separate class, making the code
more flexible and maintainable. It also promotes loose coupling by eliminating the
need to bind application-specific classes into the code. This means the code only
interacts with the abstract class or resultant interface, so it can work with any
classes that extend or implement that interface.

Factory design pattern – bock diagram

Program:
import java.util.Scanner;
interface Shape{
void draw();
}

class Circle implements Shape{

public void draw(){
System.out.println(" circle has no sides");
}
}
class Square implements Shape{
public void draw(){
System.out.println(" square has all equal sides");
}
}

class Rectangle implements Shape{

public void draw(){
System.out.println(" rectangle has two sides equal");
}
}

class ShapeFactory {
Shape getShape(int x){
if (x==1)
return new Circle();
else if(x==2)
return new Square();
else if(x==3)
return new Rectangle();
else
return null;
}
}
class DemoFact1 {
public static void main(String[] args){
Shape sh;
int x;
ShapeFactory shft= new ShapeFactory();
Scanner in = new Scanner(System.in);
System.out.println("Enter 1/2/3 for circle/square/rect
:");
x=in.nextInt();
sh= shft.getShape(x);
sh.draw();
}
}

12. Factory design pattern - Example program – 2

Program:
import java.util.Scanner;
interface Service{
void loanPayment();
}

class SBI implements Service{

public void loanPayment() {
System.out.println(" Loan paid in SBI with roi 7.5%");
}
}
class HDFC implements Service{
public void loanPayment() {
System.out.println(" Loan paid in HDFC bank with roi
7.9%");
}
}

class ICICI implements Service{

public void loanPayment(){
System.out.println(" Loan paid in ICICI bank with roi
7.8%");
}
}

class BankFactory {
Service getService(int x){
if (x==1)
return new SBI();
else if(x==2)
return new HDFC();
else if(x==3)
return new ICICI();
else return null;
}
}
class FactoryDemo{
public static void main(String[] args){
Service sh;
int bank;
Scanner in = new Scanner(System.in);
System.out.println(" Enter 1/2/3 for SBI/HDFC/ICICI
banks”);
bank= in.nextInt();
BankFactory bf = new BankFactory();
sh= bf.getService(bank);
sh.loanPayment();
}
}

13. Abstract Factory design pattern program with Block Diagram

Answer:
The purpose of the Abstract Factory is to provide an interface for creating families
of related objects, without specifying concrete classes.

Factory Method Pattern allows the sub-classes to choose the type of objects to
create. It promotes the loose-coupling by eliminating the need to bind application-
specific classes into the code.
 Abstract Factory design – block diagram

Program:
interface Shape{
void draw();
}

class Rectangle implements Shape{

public void draw(){
System.out.println(" I am a Rectangle");
}
}

class Square implements Shape{

public void draw(){
System.out.println(" I am a Square");
}
}

class RoundedRectangle implements Shape{

public void draw(){
System.out.println(" I am a rounded Rectangle");
}
}

class RoundedSquare implements Shape{

public void draw(){
System.out.println(" I am a rounded Square");
}
}

abstract class AbsFactory {

abstract Shape getShape(int x);
}

class ShapeFactory extends AbsFactory {

Shape getShape(int x){
if (x==1)
return new Rectangle();
else if(x==2)
return new Square();
else return null;
}
}

class RoundedShapeFactory extends AbsFactory {

Shape getShape(int x){
if (x==1)
return new RoundedRectangle();
else if(x==2)
return new RoundedSquare();
else return null;
}
}

class FactoryProducer{
static AbsFactory getFactory(int x){
if (x==1)
return new ShapeFactory();
else if (x==2)
return new RoundedShapeFactory();
else return null;
}
}

class AbsFactDemo1{
public static void main(String[] args){
AbsFactory abf;
Shape sh;
abf = FactoryProducer.getFactory(2);
sh= abf.getShape(2);
sh.draw();
}
}

14. Aggregation - Example program

Answer:
Aggregation is HAS-A type relation among java objects.
Class contains object of another class as it’s instance variable or as a local variable
so that all the members of the class can be accessed.

Program :
// Agrigation program – object as a instance variable (through constructor)

class Address {
String d_no;
String city;

Address( String d, String c){

d_no=d;
city=c;
}

void show_details(){
System.out.println("Door no -> "+d_no);
System.out.println("city -> "+ city);
}
}

class Employee {
String name;
String emp_no;
Address ad;

Employee( String n, String e, Address a){

name=n;
emp_no=e;
ad=a;
}

void show_details(){
ad.show_details();
System.out.println("name -> "+ name);
System.out.println("emp no -> "+emp_no);
}
}

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

Address aa= new Address("100", "Delhi");

Employee ee=new Employee("Rahul G", "CSE-255",aa);
ee.show_details();
}
}

15. Structural Design Patterns - Explanation

Answer:
There are many structural design patterns available, most popular among them are

1. Adopter design pattern

2. Bridge design pattern
3. Decorator design pattern
4. Façade design pattern

All of them use aggregation concept of oop.

Aggregation:

Aggregation is HAS-A type relation among java objects.

Class contains object of another class as it’s instance variable or as a local variable
so that all the members of the class can be accessed.

Advantages:

Structural patterns explain how to assemble objects and classes into larger
structures while keeping these structures flexible and efficient. These patterns help
make it easier to identify a simple way to realize relationships between entities.

The purpose of design patterns is simple - to provide structure. By giving you a

basic framework for problem-solving, they can speed up the development process.
Generally speaking, using design patterns will make your code more flexible,
reusable, and maintainable.

They are reusable in multiple projects.

They provide the solutions that help to define the system architecture.
They capture the software engineering experiences.
They provide transparency to the design of an application.

16. Adopter design pattern - Example program -1

Answer:
The adapter design pattern acts as a bridge between incompatible interfaces,
enabling them to collaborate without modifying their source code. It's a structural
design pattern that promotes code reusability and interoperability.

The following program demonstrates two incompatible interfaces, where CricPlayer

class and HockPlayer class are good to access their own methods. But

SpCrikPlayer class is acting like a connector to get methods from both of the
interfaces.

Program :
interface Cricket{
void playCricket();
}

interface Hockey{
void playHockey();
}
class CricPlayer implements Cricket{
public void playCricket(){
System.out.println(" playing cricket is my passion");
}
}

class HockPlayer implements Hockey{

public void playHockey(){
System.out.println(" playing hockey is my passion");
}
}

class SpCrikPlayer implements Cricket{

public void playCricket(){
Hockey hh = new HockPlayer();
hh.playHockey();
System.out.println(" playing cricket is my passion");
}
}

class AdoptDemo1 {
public static void main(String[] args){
Cricket ck, sck;
Hockey hk;
hk= new HockPlayer();
hk.playHockey();
ck = new CricPlayer();
sck = new SpCrikPlayer();
ck.playCricket();
sck.playCricket();
}
}

17. Adopter design pattern - Example program-2

Program:
interface Parrot{
void talk();
}

interface Duck{
void kwack();
}

class GreenParrot implements Parrot {

public void talk(){
System.out.println(" it talks good words");
}
}

class KDuck implements Duck {

public void kwack(){
System.out.println(" it makes sound kwack.. kwack");
}
}

class SpecDuck implements Duck{

Parrot p;
SpecDuck(Parrot pt){
p=pt;
}

public void kwack(){

System.out.println(" it makes sound kwack.. kwack");
p.talk();
}
}

class AdoptDemo2 {
public static void main(String[] raga){
Parrot p1;
Duck d1;

p1= new GreenParrot();

p1.talk();

d1= new KDuck();

d1.kwack();

d1= new SpecDuck(p1);

d1.kwack();
}
}
18. Decorator design pattern – Example program with Block Diagram
Answer:
The Decorator Design pattern extend the functionality of an existing object without
changing its code or breaking its clients. The decorator pattern also allows you to
compose different decorators at runtime, creating flexible and dynamic
combinations of behaviors.

Decorator design pattern - block diagram

Program:
interface Shape{
void draw();
}

class Circle implements Shape{

public void draw(){
System.out.println(" I am a circle");
}
}
class Rectangle implements Shape{
public void draw(){
System.out.println(" I am a rectangle");
}
}

class ShapeDecorator implements Shape{

Shape sh;
ShapeDecorator(Shape s){
sh=s;
}
public void draw(){
sh.draw();
System.out.println(" i have silver lining");
}
}

class RedShapeDecorator implements Shape{

Shape sh;
RedShapeDecorator(Shape s){
sh=s;
}
public void draw(){
sh.draw();
setRedBorder();
}
void setRedBorder(){
System.out.println(" i have red border");
}
}
class DecoDemo1{
public static void main(String[] args){
Shape s = new Circle();
Shape s1 = new ShapeDecorator(s);
RedShapeDecorator s2 = new RedShapeDecorator(s1);
s2.draw();

Shape s3 = new Rectangle();

Shape s4 = new ShapeDecorator(s3);
s4.draw();

}
}

19. Bridge design Pattern (Example-1)

Answer:
The Bridge design pattern separates an abstraction from its implementation,
allowing both to change independently. This structural pattern increases flexibility
and maintainability in complex systems.
Program:
interface Shape{
void show();
}

interface Deco{
void display();
}

class Circle implements Shape{

public void show(){
System.out.println(" i am a circle");
}
}

class Rectangle implements Shape{

public void show(){
System.out.println(" i am a Rectangle");
}
}

class Deco1 implements Deco{

Shape sh;
Deco1(Shape s1){
sh=s1;
}
public void display(){
sh.show();
System.out.println(" filled with Red color");
}
}

class Deco2 implements Deco{

Shape sh;
Deco2(Shape s1){
sh=s1;
}
public void display(){
sh.show();
System.out.println(" border color is blue");
}
}

class BridgeDemo1{
public static void main(String[] msr){
Shape sh;
Deco dc;
sh = new Rectangle();
dc = new Deco1(sh);
dc.display();
}
}
20. Bridge design Pattern (Example-2)
Answer:
The Bridge design pattern separates an abstraction from its implementation,
allowing both to change independently. This structural pattern increases flexibility
and maintainability in complex systems.

Program:
interface Bank{
void show();
}

interface Account{
void openAcc();
}

class SBI implements Bank{

Account ac;
SBI(Account ac1){
ac=ac1;
}
public void show(){
System.out.println(" welcome to SBI");
ac.openAcc();
}
}
class Axis implements Bank{
Account ac;
Axis(Account ac1){
ac=ac1;
}
public void show(){
System.out.println(" welcome to Axis Bank");
ac.openAcc();
}
}

class SavingAcc implements Account{

public void openAcc(){
System.out.println(" Your savings account opened successfully...");
}
}
class CurrentAcc implements Account{
public void openAcc(){
System.out.println(" Your current account opened successfully...");
}
}

class BridgeDemo2{
public static void main(String[] msr){
Bank bnk;
Account acc;
acc = new SavingAcc();
bnk = new Axis(acc);
bnk.show();

acc = new CurrentAcc();

bnk = new Axis(acc);
bnk.show();
}
}

21. Façade design pattern(Example-1)

Answer:
The Facade Design Pattern is a structural pattern that simplifies a system's interface,
making it easier to use and understand. It's often used for complex systems with
many classes or unavailable source code. The pattern provides a single interface
that hides the system's intricacies and shields clients from the implementation
details.

The Facade pattern offers the following benefits: It shields clients from subsystem
components, thereby reducing the number of objects that clients deal with and
making the subsystem easier to use. It promotes weak coupling between the
subsystem and its clients. Often the components in a subsystem are strongly
coupled.

Program:

// Facade design pattern is to hide the details of the subsystem...

 interface Shape {

void draw();

class Rectangle implements Shape {

public void draw() {

System.out.println(" I am a Rectangle");

class Square implements Shape {

public void draw() {

System.out.println(" I am a square");

class Circle implements Shape {

public void draw() {

System.out.println(" I am a circle");

}
 class ShapeMaker {

private Shape circle;

private Shape rectangle;

private Shape square;

public ShapeMaker() {

circle = new Circle();

rectangle = new Rectangle();

square = new Square();

void drawCircle(){

circle.draw();

void drawRectangle(){

rectangle.draw();

void drawSquare(){

square.draw();

}
class DemoFacadePattern1 {

public static void main(String[] args) {

ShapeMaker shapeMaker = new ShapeMaker();

shapeMaker.drawCircle();

shapeMaker.drawRectangle();

shapeMaker.drawSquare();

22. Façade Design Pattern (Example-2)

Program:
// This pattern is to hide the internal subsystem details to the user..

interface MobilePhone {
void modelNo();
void price();
}

class Iphone implements MobilePhone {

public void modelNo() {

System.out.println(" Iphone 6 ");
}
 public void price() {
System.out.println(" Rs 65000.00 ");
}
}

class Samsung implements MobilePhone {

public void modelNo() {
System.out.println(" Samsung galaxy tab 3 ");
}

public void price() {

System.out.println(" Rs 45000.00 ");
}
}

class Blackberry implements MobilePhone {

public void modelNo() {

System.out.println(" Blackberry Z10 ");
}

public void price() {

System.out.println(" Rs 55000.00 ");
}
}
 class ShopKeeper {
private MobilePhone iphone;
private MobilePhone samsung;
private MobilePhone blackberry;

ShopKeeper(){
iphone= new Iphone();
samsung=new Samsung();
blackberry=new Blackberry();
}
void iphoneSale(){
iphone.modelNo();
iphone.price();
}
void samsungSale(){
samsung.modelNo();
samsung.price();
}

void blackberrySale(){
blackberry.modelNo();
blackberry.price();
}
}
 class DemoFacade2 {
public static void main(String args[]) {

ShopKeeper sk=new ShopKeeper();

sk.iphoneSale();
sk.samsungSale();
sk.blackberrySale();
}
}

23. Behavioral Design Patterns

Ans:
These design patterns are specifically concerned with communication between
objects.
1. Template DP
2. Iterator DP
3. Command DP
4. Chain of Responsibility
5. Dependency Injection

23. Template Pattern - Explanation

Answer:
Template pattern, This pattern comes under behavior pattern category. An abstract
class exposes defined way(s)/template(s) to execute its methods. Its subclasses can
override the method implementation as per need but the invocation is to be in the
same way as defined by an abstract class.
The Template Method design pattern allows subclasses to change the steps of an
algorithm without modifying its structure. This leads to more reusable and flexible
code. It's particularly beneficial when a part of an algorithm can vary, but the
structure of the algorithm is to be preserved.

Advantages:

1. Encourages Code Reusability: The Template Design Pattern promotes code

reuse by providing a common template or algorithm structure in the abstract
class.
2. Defines a Consistent Algorithm Structure: The pattern enforces a consistent
algorithm structure across multiple subclasses.
3. Easy to Use.
4. Time and Cost-efficient.
5. Proven through testing.

Model diagram:
24. Template design pattern for “making Tea” – Example program
Program:
abstract class Drink{
abstract void boilWater();
abstract void addTeaPowder();
abstract void addSugar();
abstract void serveTea();

final void makeTea(){

boilWater();
addTeaPowder();
addSugar();
serveTea();
}
}

class Tea extends Drink{

void boilWater(){
System.out.println(" boil water until we get fumes");
}

void addTeaPowder(){
System.out.println("add TEA powder and milk ");
}
void addSugar(){
System.out.println("add sugar as per your taste ");
}
void serveTea(){
System.out.println("Serve Tea in cups");
}
}

class TempDemo2{
public static void main(String[] args){
Drink gg;
gg= new Tea();
gg.makeTea();
}
}

25. Iterator design pattern - Explanation

Answer:
The iterator design pattern is a behavioral pattern that offers a sequential way to
access elements in an aggregate object without revealing its underlying structure.

The most important two methods are

1. public boolean hasNext();

2. public Object next();

hasNext() method will check whether next element is there in the list or not,
accordingly returns true if available otherwise returns false.

next() method will return the next element from the list if available.

Both these methods are made available through a interface, any class implementing
this interface can use both of these methods.
The implemented class must take care of objects of any type may be String or any
user defined type.

Example program can be written..

interface Iterator {
public boolean hasNext();
public Object next();
}

26. Iterator design pattern for “String objects” – Example program

Program:

interface Iterator {
Object next();
boolean hasNext();
}

class NameIterator implements Iterator{

String[] str = {"one","two","three","four","five"};
int index = 0;

public boolean hasNext(){

if (index < str.length)
return true;
else
return false;
}
public Object next(){
if(hasNext() == true)
return str[index++];
else
return null;
}
}

class IteratorDemo1{
public static void main(String[] msr){
NameIterator ni = new NameIterator();
while(ni.hasNext())
System.out.println((String) ni.next());
}
}

27. Iterator design pattern for Integer objects – Example program

Program:

interface Iterator {
Object next();
boolean hasNext();
}

class NumIterator implements Iterator{

int[] str = {30,35,40,45,50};
int index = 0;

public boolean hasNext(){

if (index < str.length)
return true;
else
return false;
}

public Object next(){

if(hasNext() == true)
return str[index++];
else
return null;
}
}

class IteratorDemo2{
public static void main(String[] msr){
NumIterator ni = new NumIterator();
while(ni.hasNext())
System.out.println((Integer) ni.next());
}
}
28. Command Design Pattern (Example program-1)
Answer:
The Command design pattern is a behavioral pattern that transforms a request into a
stand-alone object. It focuses on separating the sender of a request from the
receiver.

class WatchSon{
void bringVeg(){
System.out.println(" brought vegitables");
}
}

class WatchMan{
WatchSon ws;
WatchMan(WatchSon ws1){
ws = ws1;
}

void bringVeg(){
ws.bringVeg();
}
}

class Husband{
WatchMan wm;
Husband(WatchMan wm1){
wm = wm1;
}
void bringVeg(){
wm.bringVeg();
}
}

class CommandDemo1{
public static void main(String[] msr){
WatchSon w1 = new WatchSon();
WatchMan w2 = new WatchMan(w1);
Husband w3 = new Husband(w2);
w3.bringVeg();
}
}

29. Command Design Pattern (Example program-2)

Answer:
interface Bank{
void openAcc(int x);
}

class Account {
void savings(){
System.out.println(" your savings account opened");
}
void current(){
System.out.println(" your current account opened");
}
}

class SBI implements Bank{

Account ac;
SBI(Account ac1){
ac = ac1;
System.out.println(" welcome to SBI");
}

public void openAcc(int x){

if( x==1)
ac.savings();
else
ac.current();
}
}

class BankBazar{
Bank bk;
BankBazar( Bank bk1){
bk=bk1;
}
void service(int x){
bk.openAcc(x);
}
}

class CommandDemo2{
public static void main(String[] msr){
Account acc = new Account();
SBI sb = new SBI(acc);
BankBazar bz = new BankBazar(sb);
bz.service(2);
}
}

30. Dependency Injection Design Pattern ( program-1)

Answer:

Dependency injection (DI) is a design pattern that allows objects to receive

dependencies from an external source, instead of creating them internally. The main
purpose is to decouple objects from their dependencies, resulting in loosely coupled
classes. This makes code easier to maintain, read, and test.

Program-1:

interface Mobile{

void model();
void price();

class Iphone implements Mobile{

public void model(){

System.out.println(" model no = 15 pro max");

public void price(){

System.out.println(" this iphone mrp = Rs.1,40,000");

class Samsung implements Mobile{

public void model(){

System.out.println(" model no = fold 6");

public void price(){

System.out.println(" this phone mrp = Rs.1,30,000");

}
class SalesMan{

Mobile mb;

SalesMan(Mobile mb1){

mb=mb1;

void showDetails(){

mb.model();

mb.price();

class DepInj1{

public static void main(String[] args){

Mobile mb;

mb = new Samsung();

SalesMan sm = new SalesMan(mb);

sm.showDetails();

31. Dependency Injection Design Pattern ( program-1)

Program:

interface Shape{
void area(int x, int y);

class Triangle implements Shape{

public void area(int l, int b){

System.out.println(" Area of the triangle = "+ l*b/2);

class Rectangle implements Shape{

public void area(int l, int b){

System.out.println(" Area of the recangle = "+ l*b);

class ShapeMaker{

Shape sh;

ShapeMaker(Shape sh1){

sh = sh1;

}
void ShapeArea(int x, int y){

sh.area(x,y);

class DepInj2{

public static void main(String[] args){

//Shape ss = new Triangle();

Shape ss = new Rectangle();

ShapeMaker sm = new ShapeMaker(ss);

sm.ShapeArea(5,10);

32. What is the purpose and benefits of Chain of Responsibility Design

Pattern? (Program-1)
Answer:

The Chain of Responsibility (CoR) pattern in object-oriented design is a behavioral

pattern that passes requests through a chain of handlers until one handles
it. It's useful when you need to process different types of requests or change the
order of handlers at runtime.
The Chain of Responsibility pattern is a behavioral design pattern that allows you to
create a chain of loosely coupled objects that can handle a request. Each object in
the chain can either process the request or pass it to the next object.

Program:

import java.util.Scanner;

interface DChain{

void setNextChain(DChain dc);

void dispense(int x);

class L1Regd implements DChain{

DChain chain;

public void setNextChain(DChain dc){

chain = dc;

public void dispense(int x){

System.out.println("you registered for exams");

if (x>1) chain.dispense(x);

}
}

class L2Fee implements DChain{

DChain chain;

public void setNextChain(DChain dc){

chain = dc;

public void dispense(int x){

System.out.println("we received your fee");

if (x>2) chain.dispense(x);

class L3HallTkt implements DChain{

DChain chain;

public void setNextChain(DChain dc){

chain = dc;

public void dispense(int x){

System.out.println("you can download hall ticket");

class DemoChainExams{

public static void main(String[] msr){

DChain c1 = new L1Regd();

DChain c2 = new L2Fee();

DChain c3 = new L3HallTkt();

Scanner in = new Scanner(System.in);

int n;

c1.setNextChain(c2);

c2.setNextChain(c3);

System.out.println("Enter your choice 1/2/3");

n= in.nextInt();

c1.dispense(n);

33. Chain of Responsibility Design Pattern? (Program-2)

Program:

import java.util.Scanner;
interface DispenseChain {

void setNextChain(DispenseChain nextChain);

void dispense(int cur);

class Rs50Dispenser implements DispenseChain {

DispenseChain chain;

public void setNextChain(DispenseChain nextChain) {

chain=nextChain;

public void dispense(int cur) {

if(cur >= 50){

int num = cur/50;

int remainder = cur % 50;

System.out.println("Dispensing "+num+" X 50Rs. note");

if(remainder !=0) chain.dispense(remainder);

} else chain.dispense(cur);

}
class Rs20Dispenser implements DispenseChain{

DispenseChain chain;

public void setNextChain(DispenseChain nextChain) {

chain=nextChain;

public void dispense(int cur) {

if(cur >= 20){

int num = cur / 20;

int remainder = cur % 20;

System.out.println("Dispensing "+num+" X 20Rs. note");

if(remainder !=0) chain.dispense(remainder);

} else chain.dispense(cur);

class Rs10Dispenser implements DispenseChain {

DispenseChain chain;

public void setNextChain(DispenseChain nextChain) {

 chain=nextChain;

public void dispense(int cur) {

if(cur >= 10){

int num = cur/10;

int remainder = cur % 10;

System.out.println("Dispensing "+num+" X 10Rs. note");

class DemoChainATM {

public static void main(String[] args) {

DispenseChain c1 = new Rs50Dispenser();

DispenseChain c2 = new Rs20Dispenser();

DispenseChain c3 = new Rs10Dispenser();

// set the chain of responsibility

c1.setNextChain(c2);

c2.setNextChain(c3);

while (true) {
 int amount = 0;

System.out.println("Enter amount to dispense");

Scanner input = new Scanner(System.in);

amount = input.nextInt();

if (amount % 10 != 0) {

System.out.println("Amount should be in multiple of 10s.");

return;

// process the request

c1.dispense(amount);

34. Techniques / Characteristics of clean code.

Answer:
The code that is easily readable, modifiable, scalable(in some cases), maintainable
and is less prone to errors is referred as "Clean Code". Less prone to errors means
that there will be very less chances of getting bugs in that code.

Characteristics of Clean Code:

 Simple:

 Maintainable:

 Testable:
 Readable:

 Techniques of clean code:

1. All the resources must be placed in the respective folders for pro use and
maintenance
2. Proper Naming : all variables, constants, class names, method names,
Enum names must follow the conventions used in the industry
3. Anatomy of java program : as per the industry standards

4. White spaces and Indentation:

To increase the readability include white spaces wherever they are
appropriate. Indentation must be followed to understand the block of
statements ie group of logically related statements.
5. Method parameters : avoid too many parameters or arguments to be
passed in a method call, to achieve this think of data classes.
6. Hard coding : Data may be needed in different ways when project is
executed in real time, so while developing program use appropriate source
but always not from the key board.
7. Code comments : comments are required for every code component to
express its relevance in the project useful in the maintenance phase.
8. Log file : It is important to understand the execution of the code
9. SOLID properties : Simple , open/closed principle, Liskov substitution
principle, Interface segregation principle, Dependency inversion principle.
10. keep it simple and stupid whether it is design or code.
35. Clean coding techniques – Example program
Answer:
One important point in clean coding technique is to build a method with minimum
number of arguments.

a) Method parameters : avoid too many parameters or arguments to be passed in

a method call, to achieve this think of data classes.
b) Naming conventions
c) Comments :

I am going to illustrate a java program for the above concepts of clean coding,

Program:
// clean code program
// method's long parameter list reduced
// Address data class, collection of variables
class Address{
int house_no;
int road_no;
String city;
// constructor for data class
Address(int h, int r, String c){
house_no = h;
road_no = r;
city = c;
}
}
// main class
class StudentX{
// this method is getting more data from address object
void show(String name, Address ad1){
System.out.println( name );
System.out.println( ad1.house_no );
System.out.println( ad1.road_no );
System.out.println( ad1.city );
}

// driver method
public static void main(String[] args){
Address ad = new Address(100, 22, "vja");
StudentX st1 = new StudentX();
st1.show("Rahul",ad);
}
}

36. code smells - Explanation

Answer:
There are many known code smells that have been categorized as follows:

Bloaters: Bloaters are code, methods and classes that have increased to such
gargantuan proportions that they are hard to work with. Usually these smells do not
crop up right away, rather they accumulate over time as the program evolves (and
especially when nobody makes an effort to eradicate them). Long Method, Large
Class, Primitive Obsession, Long Parameter List and Data Clumps are famous in
this category.
Object-Orientation Abusers: All these smells are incomplete or incorrect application
of object-oriented programming principles. Switch Statements, Temporary Field,
Refused Request and Alternative Classes with Different Interface are known as
object-orientation abusers code smells.

Change Preventers: These smells mean that if you need to change something in one
place in your code, you have to make many changes in other places too. Program
development becomes much more complicated and expensive as a result. Code
smells like Divergent Change, Shotgun Surgery and Parallel Inheritance Hierarchies
are in this category.

Dispensable: A dispensable is something pointless and unneeded whose absence

would make the code cleaner, more efficient and easier to understand like
Comments, Duplicate Code, Lazy Class, Data Class, Dead Code and Speculative
Generality.

Couplers: All the smells in this group contribute to excessive coupling between
classes or show what happens if coupling is replaced by excessive delegation. Some
examples would be Feature Envy, Inappropriate Intimacy, Message Chains, Middle
Man and Incomplete Library Class

37. code smells within classes - Explanation

Answer:
Code Smells Within Classes
1. Comments: Yes, Comments are code smells too. It is like deodorant to the
code. If comments explain a few lines of complex code or a complex
expression, it should be made as a complete another function/ sub-expression
respectively.

2. Long Method: A long method contains too many lines of code. Any code
with more than 25 lines of code should make you question. It could be solved
 using refactoring techniques like changing expression into sub-expression,
complex codes into a new function in order to make a function or method a
small and easy to read without changing its functionality.
3. Long Parameter List: Any function with more parameters is obviously more
complex. One of the thumb rules is to use a maximum of 3 to 4 parameters in
a function.
4. Large Classes: A class contains many methods/lines of code/fields is
considered a code smell. Refactoring techniques could be done like, extract
class, extract subclass, extract interface, duplicate observed data.
5. Duplicate Code: When a code is repeated for more than two times, merge it
into a function or a method of the class. If the same code is found in two or
more classes, using the extract method we can refactor the code smell.
6. Dead Code: The code that is not being used. A function with no calls or the
condition that never occurs. Delete unused code and unnecessary files.

38. code smells with in classes – Example Program

Answer:
One of the code smells within the class is
Long Parameter List: Any function with more parameters is obviously more
complex. One of the thumb rules is to use a maximum of 3 to 4 parameters in
a function.
I am going present a program to avoid above code smell.

Program:
// clean code program
// method's long parameter list reduced
// Address data class, collection of variables
class Address{
int house_no;
int road_no;
String city;

// constructor for data class

Address(int h, int r, String c){
house_no = h;
road_no = r;
city = c;
}
}

// main class
class StudentX{

// this method is getting more data from address object

void show(String name, Address ad1){
System.out.println( name );
System.out.println( ad1.house_no );
System.out.println( ad1.road_no );
System.out.println( ad1.city );
}

// driver method
public static void main(String[] args){
Address ad = new Address(100, 22, "vja");
StudentX st1 = new StudentX();
st1.show("Rahul",ad);
 }
}

39. Demonstrate a code segment to represent duplicate.

Answer:
In the following code segment method1() and method2() methods are exactly the
same. This is an example of duplicate code.

public class MyClass {

public void method1() {
int a = 1;
int b = 2;
int c = a + b;
System.out.println(c);
}

public void method2() {

int a = 1;
int b = 2;
int c = a + b;
System.out.println(c);
}
}

40. Build a java program to remove duplicate code in Q.39

Answer :
By removing the duplicate code ie method2 from the above program, I am giving
the fully implemented program as follows.
class MyClass {
public void method1() {
int a = 1;
int b = 2;
int c = a + b;
System.out.println(c);
}

public static void main(String[] args){

MyClass mc1 = new MyClass();
Mc1.method1();
}
}

41. Program on Liskov substitution principle (clean coding)

Program:

class Parent {
String name;
String ph;

Parent(){
}

Parent (String n1, String p1){

name = n1;
ph = p1;
}
void display(){
System.out.println(" name ="+ name);
System.out.println(" phone ="+ ph);
}
}

class Derived extends Parent{

String branch;
String clg;
Derived(String n1, String p1, String b1, String c1){
name=n1;
ph=p1;
branch = b1;
clg = c1;
}

void show(){
System.out.println(" name ="+ name);
System.out.println(" phone ="+ ph);
System.out.println(" branch ="+ branch);
System.out.println(" college ="+ clg);
}
}

class DemoLiskov{
public static void main(String[] args){
Parent obj = new Derived("Rahul","99999","CSE","KLEF");
// Liskov substitution goes here...
Derived doj = new Derived("Rani","88888","CSE","KLEF");
doj.show();
doj.display();
}
}
42. Dependency Inversion – program (clean coding)
Program:
class Parent {
Parent(){
}
void show(){
System.out.println("show method parent class");
}
}
class Derived extends Parent{
void show(){
System.out.println("show method child class");
}
void display(){
System.out.println("display method of child class");
}
}

class DemoDepInversion{
public static void main(String[] args){
//Parent obj = new Parent();
Derived obj = new Derived();
obj.show();
obj.display();
}
}

43. Interface segregation – program (clean coding)

Program:
interface Iface1{
void show();
}

interface Iface2 extends Iface1{

void display();
}

class One implements Iface2{

public void show(){
System.out.println("Show method of One class");
}

public void display(){

System.out.println(" display method of One class");
}

void hello(){
System.out.println(" Hello from one class");
}
}

class Two implements Iface1{

public void show(){
System.out.println("Show method of Two class");
}

void borrow(){
System.out.println(" borrow from Two class");
}
}

class InterfaceSegre{
public static void main(String[] args){
Iface1 oo;

oo = new One();
oo.show();

oo = new Two();
oo.show();
}
}
44. Usage of Data class – program ((clean coding)
Program:
class Data {
int x;
int y;
Data (int x1 , int y1){
x = x1;
y = y1;
}
}

class Compute{
Data dt;
Compute(Data dt1){
dt = dt1;
}

int sum(){
return dt.x + dt.y;
}
int subtract(){
return dt.x - dt.y;
}
}

class DataClass1{
public static void main(String[] msr){
Data dd = new Data(20,10);
Compute cp = new Compute(dd);
System.out.println("sum ="+ cp.sum());
System.out.println("difference ="+ cp.subtract());
}
}
45. Refactoring techniques - Example program.
Answer:
• Refactoring encompasses a number of specific code hygiene practices. When
it comes to eliminating code smells, however, there are three particularly
effective techniques: one that focuses on methods, another that focuses on the
method calls and a third that focuses on classes.

-------------------------------------
Program before refactoring:
-------------------------------------
class StudentY{
void show(String name, int house_no, int road_no, String
city){
System.out.println(name);
System.out.println(house_no);
System.out.println(road_no);
System.out.println(city);
}

public static void main(String[] args){

StudentY st1 = new StudentY();
st1.show("Rahul",100, 22, "vja");
}
}
-----------------------------------
Program after Refactoring:
-----------------------------------
// clean code program
// method's long parameter list reduced
// Address data class, collection of variables
class Address{
int house_no;
int road_no;
String city;
// constructor for data class
Address(int h, int r, String c){
house_no = h;
road_no = r;
city = c;
}
}

// main class
class StudentX{

// this method is getting more data from address object

void show(String name, Address ad1){
System.out.println( name );
System.out.println( ad1.house_no );
System.out.println( ad1.road_no );
System.out.println( ad1.city );
}

// driver method
public static void main(String[] args){
Address ad = new Address(100, 22, "vja");
StudentX st1 = new StudentX();
st1.show("Rahul",ad);
}
}

46. Extract Method - declare a method for reuse of code ( Refactoring )

Program:
class Employee{
int empId;
String empName;
int hno;
String city;
int pin;
Employee(int id, String en, int h, String c, int p){
empId =id;
empName =en;
hno=h;
city = c;
pin = p;
}
// normal way
void show(){
System.out.println(empId);
System.out.println(empName);
System.out.println(hno);
System.out.println(city);
System.out.println(pin);
}
// refactored way
void show(){
System.out.println(empId);
System.out.println(empName);
showAddress();
}

// method developed for refactoring...

void showAddress(){
System.out.println(hno);
System.out.println(city);
System.out.println(pin);
}
}
47. Replace Method with Method Object ( Refactoring )
Program:
class PrintHelloMethod {
String name;

PrintHelloMethod(String name) {
this.name = name;
}

// normal method
public void print() {
System.out.println("Hello, " + name);
}

// normal method from another class

public void printHello() {
PrintHelloMethod phm = new
PrintHelloMethod("World");
phm.print();
}
// refactored method
public void printHello() {
new PrintHelloMethod("World").print();
}

}
class Refactor2{
public static void main(String[] args){
PrintHelloMethod phm = new PrintHelloMethod("world");
phm.printHello();
}
}

48. Replace Temp with Query ( Refactoring )

Program:
public class Customer {
private double basePrice;

public double getDiscountedPrice() {

double discount = 0.1; // Normal way
double discountedPrice = basePrice * discount;
return discountedPrice;
}
}
public class Customer {
private double basePrice;
public double getDiscountedPrice() {
return basePrice * getDiscount(); //
Refactored way
}

private double getDiscount() {

 return 0.1;
}
}
49. Hide Delegate – example ( Refactoring )
Program:
// Before refactoring
class MyClass {
MyDelegate delegate;
MyClass(MyDelegate delegate) {
this.delegate = delegate;
}
void doSomething() {
delegate.doSomething();
}
}

// After refactoring
interface MyDelegate {
void doSomething();
}
class MyClass {
MyDelegate delegate;
MyClass() {
this.delegate = new MyDelegate();
}
public void doSomething() {
delegate.doSomething();
 }
}
50. Remove MiddleMan - java example ( Refacoring )
Program:
// Normal way...
class Boss1 {
private Worker w1;
Boss1( Worker ww){
w1 = ww;
}

public void doSomething() {

w1.doSomething() ;
}
}

class Worker{
void doSomething(){
System.out.println(" brought 1 kg chillies");
}
}

class Refactor5 {
public static void main(String[] args){
Worker w10 = new Worker();
Boss1 bb1 = new Boss1(w10);
bb1.doSomething();
 }
}

// refactored way...
class Boss1 {
public void doSomething() {
System.out.println(" brought 1 kg chillies");
}
}

class Refactor51 {
public static void main(String[] args){
Boss1 bb1 = new Boss1();
bb1.doSomething();
}
}

51. Replace conditional with Polymorphism ( Refactoring )

Program:
// Before refactoring
class Bird {
private String type;
private int numberOfCoconuts;
private boolean isNailed;
private int voltage;

public String getSpeed() {

 switch (type) {
case "EUROPEAN":
return "average";
case "AFRICAN":
return (numberOfCoconuts > 2) ? "tired" :
"average";
case "NORWEGIAN_BLUE":
return (isNailed) ? "0" : "beautiful";
default:
return "unknown";
}
}
}

// After refactoring
abstract class Bird {
private String type;

public Bird(String type) {

this.type = type;
}

public abstract String getSpeed();

}
class EuropeanSwallow extends Bird {
public EuropeanSwallow() {
super("EUROPEAN");
}

@Override
public String getSpeed() {
return "average";
}
}

class AfricanSwallow extends Bird {

private int numberOfCoconuts;

public AfricanSwallow(int numberOfCoconuts) {

super("AFRICAN");
this.numberOfCoconuts = numberOfCoconuts;
}

@Override
public String getSpeed() {
return (numberOfCoconuts > 2) ? "tired" : "average";
}
}
class NorwegianBlueParrot extends Bird {
private boolean isNailed;
private int voltage;

//Replace conditional with Polymorphism - example

public NorwegianBlueParrot(boolean isNailed, int

voltage) {
super("NORWEGIAN_BLUE");
this.isNailed = isNailed;
this.voltage = voltage;
}

@Override
public String getSpeed() {
return (isNailed) ? "0" : "beautiful";
}
}
// Usage example
Bird bird = new EuropeanSwallow();
System.out.println(bird.getSpeed()); // "average"

bird = new AfricanSwallow(3);

System.out.println(bird.getSpeed()); // "tired"
bird = new NorwegianBlueParrot(true, 110);
System.out.println(bird.getSpeed()); // "0"
CO - 2
 SHORT ANSWER QUESTIONS ( from CO-2 )

1. Uses of Generics in Java?

Answer:
Java Generics allows us to create a single class, interface, and method that can be
used with different types of data (objects).

Generics does not work with primitive types (int, float, char, etc).

Code reusability is an advantage

2. Comparable interface - Explanation

Answer:
Java Comparable interface is used to order the objects of the user-defined class.
This interface is found in java.lang package and contains only one method named
compareTo(Object).

Syntax :

public int compareTo(Object obj): It is used to compare the current object with
the specified object. It returns

o positive integer, if the current object is greater than the specified object.
o negative integer, if the current object is less than the specified object.
o zero, if the current object is equal to the specified object.

3. comparable and comparator interfaces - Differences.

Answer:
Comparable interface :
available in java.lang package
 it’s method is compareTo( Object o1)
Comparator interface
available in java.util package
it’s method is compare( Object o1, Object o2)

4. HashSet – Explanation
Answer:
HashSet is commonly used if we have to access elements randomly. It is because

elements in a hash table are accessed using hash codes. The hashcode of an

element is a unique identity that helps to identify the element in a hash table.

HashSet cannot contain duplicate elements. Hence, each hash set element has a

unique hashcode.

Add(), remove(), size(), addAll(), retainAll(), removeAll(), clear() are the main

methods of the Hashset.

5. collection framework - Explanation

Answer:
Collection framework has three major interfaces List, Queue and Set

List has been implemented by arrayList, LinkedList and Vector classes

Queue is implemented by PriorityQueue class

Set is implemented by HashSet, LinkedHashSet and TreeSet

Collection framework classes are used to store and manage variety of Objects.
6. Map - Explanation
Answer:
Map interface is implemented by Hashmap, LinkedHashMap and TreeMap

A map contains values on the basis of key, i.e. key and value pair. Each key and
value pair is known as an entry. A Map contains unique keys.

A Map is useful if you have to search, update or delete elements on the basis of a
key.

put(), remove(), getKey(), getValue(), entrySet() are the major methods of the Map.

7. iterator interface - Explanation

Answer:
Iterator interface provides the facility of iterating the elements in a forward
direction only, it is used along with many collection framework classes.

There are 3 methods in an iterator interface only.

Public Boolean hasNext() – returns true if element/s are available otherwise false.

Public Object next() – returns object if available

Public void remove() – last element returned by the iterator will be removed
 LONG ANSWER QUESTIONS ( from CO-2 )

1. Generics / Generic method - Example program - 1

Answer:

Java Generics allows us to create a single class, interface, and method that can be
used with different types of data (objects).

Generics does not work with primitive types (int, float, char, etc).

Advantages:

1) Type-safety: We can hold only a single type of objects in generics. It doesn’t

allow to store other objects.
2) 2) Type casting is not required: There is no need to typecast the object.
3) 3) Compile-Time Checking: It is checked at compile time so problem will not
occur at runtime.
4) Code Reusability

Type Parameters :

The type parameters naming conventions are important to learn generics thoroughly.
The common type parameters are

1. T – Type 2. E – Element 3. K – Key 4. N – Number 5. V – Value

Program : whether the given number is Zero/Non-zero (Integer and Double types)

class Gen10{

<T> void check(T data1){

int i;
double d;

String s;

if(data1 instanceof Integer){

if( (Integer)data1 == 0)

System.out.println("ZERO");

else

System.out.println("non ZERO");

else if(data1 instanceof Double){

if( (Double)data1 == 0)

System.out.println("ZERO");

else

System.out.println("non ZERO");

public static void main(String[] args){

Gen10 g1 = new Gen10();

g1.<Integer>check(200);

g1.<Integer>check(0);

g1.<Double>check(12.6);

g1.<Double>check(0.0);

}
}

2. Generics class - Example program

Program: whether the given number is even/odd (Integer and Double types)

class Gen10 <T>{

T data1;

Gen10(T data1){

this.data1 = data1;

void check(){

int i;

double d;

String s;

if(data1 instanceof Integer){

if( (Integer)data1 == 0)

System.out.println("ZERO");

else

System.out.println("non ZERO");

else if(data1 instanceof Double){

if( (Double)data1 == 0)

System.out.println("ZERO");
 else

System.out.println("non ZERO");

public static void main(String[] args){

Gen10<Integer> g1 = new Gen10<>(200);

g1.check();

Gen10<Integer> g2 = new Gen10<>(0);

g2.check();

Gen10<Double> g3 = new Gen10<>(200.99);

G3.check();

Gen10<Double> g4 = new Gen10<>(0.0);

g4.check();

3. Generic method - Example program- 2

Program: whether the given number is even/odd (Integer and Double types)

class Even {
<T> void checkOddEven (T number) {
if (number instanceof Integer) {
if ((Integer)number % 2 == 0)
 System.out.println((Integer)number + "
is even number");
else
System.out.println((Integer)number + "
is odd number");

} else
if (number instanceof Double) {
if ((Double)number % 2 == 0)
System.out.println((Double)number + "
is even number");
else
System.out.println((Double)number + "
is odd number");
}
}
}
public class EvenDemo {
public static void main(String[] args) {
Even e = new Even();
e.<Integer>checkOddEven(11);
e.<Double> checkOddEven(13.0);
}
}

4 . Comparable interface – Example program.

Program: ( Find out the best object depends on cgpa of the student )
class Student implements Comparable<Student>{
String name;
int rank;
double cgpa;
double salarypak;

Student(String n, int r, double cg, double sp){

name=n;
rank=r;
cgpa=cg;
salarypak=sp;
}

public int compareTo(Student s){

if(cgpa > s.cgpa)
return 1;
else if(cgpa < s.cgpa)
return -1;
else return 0;
}
}

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

Student s1 = new Student("Raman",100,9.9,12.5);

Student s2 = new Student("Kishore",40000,7.9,25.9);
int i = s1.compareTo(s2);
if(i==1)
System.out.println("Raman is best");
else if(i==-1)
System.out.println("Kishore is best");
else
System.out.println("Both are best");
}
}

5. comparable and comparator interfaces – Differences

Answer:

Comparable Comparator

1) Comparable provides compareTo() Comparator provides compare()

method to sort elements method to sort elements.

2) Comparable affects the original class, Comparator doesn't affect the original
i.e., the actual class is modified. class, i.e., the actual class is not
modified.

3). Comparable is present A Comparator is present in

in java.lang package. the java.util package.

4) Comparable provides a single sorting The Comparator provides multiple

sequence. sorting sequences.
 5) We can sort the list elements of We can sort the list elements of
Comparable type Comparator type
by Collections.sort(List) method. by Collections.sort(List,
Comparator) method.

6. Clonable Interface

Method : public Object clone()

Program:
class Student implements Cloneable {
int id;
String name;
Student(int id, String name){
this.id = id;
this.name = name;
}
@Override
Public Object clone() throws CloneNotSupportedException
{
return super.clone();
}
}

class ClonableInterface{
public static void main(String[] args) {
Student s = new Student(101, "Rahul");
System.out.println(s.id + " " + s.name);
try {
Student s1 = (Student) s.clone();
System.out.println(s1.id + " " + s1.name);
}catch (Exception e) {
System.out.println(e);
}
}
}

7. Block diagram of collection Framework

Answer:
 8. ArrayList / LinkedList - Example Program-1 ( Integer objects )
Program:
import java.util.*;
class List1 {
public static void main(String[] args){
// create ArrayList or LinkedList as per the question
//LinkedList<Integer> numbers = new LinkedList<>();
ArrayList<Integer> numbers = new ArrayList<>();
// Add elements to ArrayList
numbers.add(10);
numbers.add(20);
numbers.add(30);
numbers.add(40);
numbers.add(50);
System.out.println("ArrayList: " + numbers);
numbers.set(3,35);
System.out.println("size"+ numbers.size());
System.out.println(" ");
numbers.remove(3);
Iterator itr= numbers.iterator();
while(itr.hasNext()) {
System.out.print(itr.next());
System.out.print(" , ");
}
System.out.println("size"+ numbers.size());
}
}
9. ArrayList / LinkedList - Example Program-1 ( String objects )
Program:
import java.util.*;
class List2 {
public static void main(String[] args){

// create ArrayList or LinkedList as per the

question
//LinkedList<String> countries = new LinkedList<String>();
ArrayList< String > countries = new ArrayList< String >();
// Add elements to List
countries.add(“India”);
countries.add(“Australia”);
countries.add(“USA”);
countries.add(“Nepal”);
countries.add(“Russia”);
System.out.println("ArrayList: " + countries);

numbers.set(3,”Malaysia” );

System.out.println("size"+ countries.size());
System.out.println(" ");

countries.remove(2);
Iterator itr= countries.iterator();
while(itr.hasNext()) {
 System.out.print(itr.next());
System.out.print(" , ");
}
System.out.println("size"+ countries.size());
}
}

10. Stack program

Program:

import java.util.Stack;
public class Stack1
{
public static void main(String[] args)
{
//creating an instance of Stack class
Stack<Integer> stk= new Stack<>();
// checking stack is empty or not
boolean result = stk.empty();
System.out.println("Is the stack empty? " + result);
// pushing elements into stack
stk.push(78);
stk.push(113);
stk.push(90);
stk.push(120);
//prints elements of the stack
System.out.println("Elements in Stack: " + stk);
result = stk.empty();
System.out.println("Is the stack empty? " + result);
System.out.println("top of the stack ="+ stk.pop());
}
}

11. Dequeue/ ArrayDequeue Program

Program:
import java.util.ArrayDeque;
import java.util.Deque;

public class DequeExample {

public static void main(String[] args) {
// Create a Deque using ArrayDeque
implementation
Deque<String> deque = new ArrayDeque<>();

// Add elements to the front

deque.addFirst("Element 1");
deque.offerFirst("Element 2");

// Add elements to the back

deque.addLast("Element 3");
deque.offerLast("Element 4");

// Print the Deque

System.out.println("Deque: " + deque);
 // Remove elements from the front
String firstElement = deque.removeFirst();
System.out.println("Removed from front: " +
firstElement);

// Remove elements from the back

String lastElement = deque.removeLast();
System.out.println("Removed from back: " +
lastElement);

// Peek at the first element

String peekFirst = deque.peekFirst();
System.out.println("Peek first: " + peekFirst);

// Peek at the last element

String peekLast = deque.peekLast();
System.out.println("Peek last: " + peekLast);
}
}

12. Priority Queue – program

Program:
import java.util.PriorityQueue;

class PriorityQueue1 {
public static void main(String[] args) {
 // Create a PriorityQueue using the natural
ordering (ascending)
PriorityQueue<Integer> pq = new
PriorityQueue<>();

// Add elements to the queue

pq.add(5);
pq.add(2);
pq.add(8);
pq.add(1);

// Print the queue (not necessarily in order)

System.out.println("PriorityQueue: " + pq);

// Remove and print elements in priority order

System.out.print("Elements in priority order:
");
while (!pq.isEmpty()) {
System.out.print(pq.poll() + " ");
}
}
}

13. HashSet / LinkedHashSet / TreeSet program with ( Integer Objects )

( Any four methods on Set )
Program:

import java.util.*;
class Set1 {
public static void main(String[] klu){

// declare set as per the question from the

following
// HashSet <Integer> list = new
HashSet<Integer>();
// LinkedHashSet <Integer> list = new
LinkedHashSet<Integer>();
TreeSet <Integer> list = new
TreeSet<Integer>();

// add() method ...

list.add(40);
list.add(20);
list.add(30);
list.add(70);
list.add(50);

System.out.println(list);

// contains() method ...

boolean x = list.contains(20);
System.out.println(x);
System.out.println(list.size());

// remove() method ...

list.remove(4);
System.out.println(list);
System.out.println(list.size());

// iterator() method ...

Iterator itr = list.iterator();
while(itr.hasNext()){
int i = (Integer) itr.next();
System.out.println(i);
}
}
}
14. HashSet / LinkedHashSet / TreeSet program with ( String Objects )
( Any four methods on Set )
Program:
import java.util.*;
class Set2 {
public static void main(String[] klu){

// declare set as per the question from the

following
TreeSet <String> list = new TreeSet<String>();
//LinkedHashSet <String> list = new LinkedHashSet<>();
//HashSet <String> list = new HashSet<String>();

// add() method ...

list.add("India");
list.add("canada");
list.add("Egypt");
list.add("Malaysia");
list.add("singapore");

System.out.println(list);

// contains() method ...

boolean x = list.contains("malaysia");
System.out.println(x);
System.out.println(list.size());

// remove() method ...

list.remove("Egypt");
System.out.println(list);
System.out.println(list.size());

// iterator() method ...

Iterator itr = list.iterator();
while(itr.hasNext()){
 String i = (String) itr.next();
System.out.println(i);
}
}
}

15. HashSet / LinkedHashSet / TreeSet program ( Operations on Sets)

Answer:
Major Operations on Sets are performed with the following methods

1. Union - addAll() method

2. Intersection - retainAll() method
3. Difference - removeAll() method
Program:
import java.util.*;
class SetExample {
public static void main(String args[])
{
// declare set as per the question from the following
Set <Integer> list = new LinkedHashSet <>();

a.addAll(Arrays.asList(
new Integer[] { 1, 3, 2, 4, 8, 9, 0 }));

Set<Integer> b = new LinkedHashSet<Integer>();

b.addAll(Arrays.asList(
new Integer[] { 1, 3, 7, 5, 4, 0, 7, 5 }));
 Set<Integer> union = new LinkedHashSet<>(a);
union.addAll(b);
System.out.print("Union of the two Set");
System.out.println(union);

Set<Integer> intersection = new HashSet<>(a);

intersection.retainAll(b);
System.out.print("Intersection of the two Set");
System.out.println(intersection);

Set<Integer> difference = new TreeSet<>(a);

difference.removeAll(b);
System.out.print("Difference of the two Set");
System.out.println(difference);
}
}
 16. Block diagram of Map interface and Explanation
Answer:

Map in Java is an interface available in java. util package and it stores the data in
key and value pairs. It does not allow duplicate keys.

TreeMap, HashMap and LinkedHashMap are the classes that are implementing
Map interface.

SortedMap is another interface extending Map.

TreeMap class implements both SortedMap and Map interfaces

The map() operation in Java 8 streams transforms the elements of a collection based
on a specified function. It takes a Function<T, R> as input, where T is the type of
the input element and R is the type of the output element.

Operations using Map Interface and HashMap/ LinkedHashMap /TreeMap

Adding Elements :
hm1.put(1, "Geeks");
hm2.put(new Integer(1), "Geeks");

Changing Element:
hm1.put(new Integer(2), "For");

Removing Elements:
hm1.remove(new Integer(4));

Iterating through the Map:

for (Map.Entry<String, Integer> e : map.entrySet())
System.out.println(e.getKey() + " "+
e.getValue());

By using the for-each loop, we get an entrySet() which provides an automated

“view” of the data in the map, in the form of key-value pairs. Each entrySet
contains a key and corresponding values.

17. HashMap/TreeMap/LinkedHashMap program with ( Integer Objects )

( Any Five methods of Map)
Program:
import java.util.*;
class MapDemo11{
public static void main(String[] args){
// use the following map declaration as per the question
//Map<String,Integer> mp = new HashMap<>();
//Map<String,Integer> mp = new LinkedHashMap<>();
Map<String,Integer> mp = new TreeMap<>();
// load elements
mp.put("one", 181);
mp.put("two", 275 );
mp.put("three",356);
mp.put("four", 499);
mp.put("five", 598);
System.out.println(" No of element in the map (before) :"+mp.size());

// removing an element
mp.remove("four");

// getting element from map

int str =(Integer) mp.get("five");
System.out.println(str);

// checking the size of the map

System.out.println(" No of element in the map (after) :"+mp.size());

// traversing through map (entrySet() method)

for(Map.Entry<String,Integer> myMap: mp.entrySet())
{
System.out.print(myMap.getKey()+" : ");
System.out.println(myMap.getValue());
}
}
}

18. HashMap/ LinkedHashMap /TreeMap program with ( String Objects )

( Any Five methods of Map )
Program:
import java.util.*;
class MapDemo1{
public static void main(String[] args){
// use the following map declaration as per the question

//Map<Integer,String> mp = new HashMap<>();

//Map<Integer,String> mp = new LinkedHashMap<>();
Map<Integer,String> mp = new TreeMap<>();

// load elements
mp.put(5,"India");
mp.put(2,"Srilanka");
mp.put(3,"USA");
mp.put(4,"Russia");
mp.put(1,"China");
System.out.println(" No of element in the map (before) :"+mp.size());

// removing an element
mp.remove(4);

// getting element from map

String str =(String) mp.get(5);
System.out.println(str);

// checking the size of the map

System.out.println(" No of element in the map (after) :"+mp.size());
// traversing through map (entrySet() method)
for(Map.Entry<Integer,String> myMap: mp.entrySet())
{
System.out.print(myMap.getKey()+" : ");
System.out.println(myMap.getValue());
}
}
}
19. Functional Interfaces and Lambda Expression
Answer:
A functional interface is an interface that contains only one abstract method. They
can have only one functionality to exhibit, it works for Abstract classes and
Interfaces.
Lambda Expression is used along with functional expression without any method
name, it works for only interfaces.
Variations in using Functional interfaces are shown in the following programs.
Program: ( Ordinary program without any Functional Interface)

interface Eatable{
void eat();
}

class One implements Eatable{

public void eat(){
System.out.println(" eating .. fruits");
System.out.println(" eating .. sweets");
}
}
class NoFuncInterface{
public static void main(String[] args){
Eatable eb = new One();
eb.eat();
}
}
Program 2: ( Method developed with its name -pure functional interface)
@FunctionalInterface
interface Eatable{
void eat();
}

class FuncInterface1 {
public static void main(String[] args){
Eatable eb = new Eatable(){
public void eat(){
System.out.println(" eating .. fruits");
System.out.println(" eating .. sweets");
}
};
eb.eat();
}
}

Program 3: ( Lambda expression without arguments )

@FunctionalInterface
interface Eatable{
void eat();
}
class Lamba1 {
public static void main(String[] args){
Eatable eb =()->{
System.out.println(" eating .. fruits");
System.out.println(" eating .. sweets");
};
eb.eat();
}
}

Program 4: ( Lambda Expression with two arguments )

@FunctionalInterface
interface Eatable{
void eat(String x, String y);
}

class Lamba2 {
public static void main(String[] args){
Eatable eb =(String a, String b)->{
System.out.println(" eating .. "+a);
System.out.println(" eating .. "+b);
};
eb.eat("fruits","sweets");
}
}
20. Nested classes

a) Inner class : The purpose of nested classes is to group classes that belong
together, which makes your code more readable and maintainable.

Program 1: ( Demo of Inner class )

class Outer
{
int outer_x=100;
void test()
{
Inner inner = new Inner();
inner.display();
inner.showy();
}

class Inner
{
int y=10;
void display()
{
System.out.println("dispaly: outer_x =" + outer_x);
}

void showy()
{
 System.out.println(y);
}
}
}

class InnerClass
{
public static void main(String args[])
{
Outer outer = new Outer();
outer.test();
}
}

b) Local class : A class i.e., created inside a method, is called local inner class in java. Local
Inner Classes are the inner classes that are defined inside a block. Generally, this block is a
method body.

Program 1:

class JLInner1{
private int data=30;
void display(){
class Local{
void msg(){
System.out.println(data);
}
}
Local l=new Local();
 l.msg();
}
public static void main(String args[]){
JLInner1 obj=new JLInner1();
obj.display();
}
}

Program 2:
class JLInner2{
private int data=30;//instance variable
void display(){
int value=50;
class Local{
void msg(){
System.out.println("local variable: "+value);
System.out.println("instance variable: "+data);
}
}
Local l=new Local();
l.msg();
}
public static void main(String args[]){
JLInner2 obj=new JLInner2();
obj.display();
}
}

c) Anonymous class : a class that has no name is known as an anonymous inner class in Java.
It should be used if you have to override a method of class or interface.

Program 1:
abstract class Person{
abstract void eat();
}
class JAInner1{
public static void main(String args[]){
Person p=new Person(){
void eat(){
System.out.println("nice fruits");
}
};
p.eat();
}
}

Program 2:
interface Eatable{
void eat();
}
class JAInner2{
public static void main(String args[]){
Eatable e=new Eatable(){
 public void eat(){
System.out.println("nice fruits");
}
};
e.eat();
}
}
CO – 3
 SHORT ANSWER QUESTIONS ( from CO-3 )

1. What is parallel programming?

Answer:
Parallel programming can also be called as Multitasking

Multitasking is a process of executing multiple tasks simultaneously. We use

multitasking to utilize the CPU. Multitasking can be achieved by two ways:

o Process-based Multitasking (Multiprocessing)

o Thread-based Multitasking (Multithreading)

2. Identify the differences between Multithreading and Multitasking

Answer:

Process-based Thread-based
Multitasking Multitasking
Address space Each process have its own Threads share the same
address in memory i.e. address space.
each process allocates
separate memory area.

weight Process is heavyweight. Thread is lightweight.

Cost of communication Cost of communication Cost of communication

between the process is between the thread is low.
high.
3. Threads and Thread states?
Answer:

Thread is basically a lightweight sub-process, a smallest unit of processing.

Multiprocessing and multithreading, both are used to achieve multitasking.
But we use multithreading than multiprocessing because threads share a common
memory area.
The life cycle of the thread with thread states are as follows:
1. New : The thread is in new state if you create an instance of Thread class but
before the invocation of start() method.
2. Runnable : The thread is in runnable state after invocation of start() method,
but the thread scheduler has not selected it to be the running thread.
3. Running: The thread is in running state if the thread scheduler has selected it.
4. Non-Runnable (Blocked): This is the state when the thread is still alive, but is
currently not eligible to run.
5. Terminated: A thread is in terminated or dead state when its run() method
exits.
4. List the ways, threads can be declared in Java?
Answer:
Threads in Java can be declared in two ways.
1. Extends Thread

Class Thr1 extends Thread{

Public void run(){
}
}

2. Implements Runnable
Class Thr2 implements Runnable{
Public void run(){
}
}

5.Illustrate Thread class with fully written constructor.

Answer:

Class MyThread extends Thread {

String str;
MyThread(String s){
Str=s;
}
}
6.Discuss the importance of run() method?
Answer:
public void run() is used to perform action for a thread.

Run() is the main method of java thread program, thread behavior declared in this
method. After creating the thread object,
Thread o1 = new Thread();
o1.start(); Would call the run() method.

7.Explain sleep() method in threads.

Answer:

The sleep() method of Thread class is used to sleep a thread for the specified
amount of time.

Eg:
public static void sleep(long miliseconds) throws InterruptedException

8. What is the purpose of join()?

Answer:
The join() method waits for a thread to die. In other words, it causes the currently
running threads to stop executing until the thread it joins with completes its task.

9.Judge the relevance of priority in threads?

Answer:

Each thread have a priority. Priorities are represented by a number between 1 and
10. In most cases, thread schedular schedules the threads according to their priority
(known as preemptive scheduling). But it is not guaranteed because it depends on
JVM specification that which scheduling it chooses.
Eg:
Thread t1 = new Thread();
t1.setPriority(6);
Int g = t1.getPriority();
the above two methods available.

10.Types of Synchronization in java.

Answer:
It is to maintain the critical section among threads.
Key word: synchronized
1. Synchronized method()
Eg. synchronized void add(){

2. Synchronized block - from any method

Eg. synchronized(this){
}
11. Differentiate synchronized block and method
Answer:

Synchronized method Synchronized block

Lock Object/class level Only object level
scope Entire method Limited to few statements
Performance low high
Waiting time high low
Null pointer no yes
exception
 LONG ANSWER QUESTIONS ( from CO-3 )

1. Java Thread program for displaying “HelloWorld”.

Answer:
Classs MyThr implements Runnable {
public void run(){
System.out.println(“Hello World”);
}
public static void main(String[] args){
MyThr m1 = new MyThr();
Thread t1 = newThread(m1);
t1.start();
}
}

2. Java thread to print 1 to 10 numbers…

Answer:
Classs MyThr implements Runnable {
public void run(){
for(int I = 1; i<=10; i++)
System.out.println(i);
}
public static void main(String[] args){
MyThr m1 = new MyThr();
Thread t1 = newThread(m1);
t1.start();
} }
3. Sleep() method -extended from Thread .
Answer:
classs MyThr extends Thread {
public void run(){
try{
for(int I = 1; i<=10; i++)
Thread.sleep();
System.out.println(i);
} catch(Exception e){
System.out.println(e);
}
}
public static void main(String[] args){
MyThr t1 = new MyThr();
MyThr t2 = new MyThr();

t1.start();
t2.start();
}
}
4. Java program- thread1 is derived from Thread class which should produce
numbers from 1 to 10, thread2 is drawn from Runnable interface to
produce numbers from 10 to 1. Demo class to output both threads created.
Answer:
classs MyThr1 extends Thread {
public void run(){
try{
for(int I = 1; i<=10; i++)
Thread.sleep();
System.out.println(i);
} catch(Exception e){
System.out.println(e);
}
}
}
Class MyThr2 implements Runnable {
public void run(){
try{
for(int i = 10; i>=1; i--)
Thread.sleep();
System.out.println(i);
} catch(Exception e){
System.out.println(e);
}
}
}
Class Demo {
public static void main(String[] args){
MyThr1 t1 = new MyThr1();
MyThr2 m2 = new MyThr2();
Thread t2 = new Thread(m2);
t1.start();
t2.start();
}
}

5. Java thread program –Runnable interface - to print Fibonacci sequence

numbers / even odd numbers
Note: This program is good for any three/five thread methods of thread ( sleep(),
start(), isAlive(), join() and run() methods )
Answer:
class FiboSeq{
void fibo(){
int a,b,f;
a=0;
b=1;
System.out.println(a);
System.out.println(b);
try{
for(int i=0; i< 8; i++){
f=a+b;
System.out.println(f);
Thread.sleep(500);
a=b;
b=f;
}
}
catch(Exception e){
System.out.println(e);
}
}

void evenOdd(){
int[] ar = {10,23,45,20,24,99};
for(int i=0; i<ar.length; i++){
if ((ar[i] % 2) == 0)
System.out.println(ar[i]+ " "+ " is Even number");
else
System.out.println(ar[i]+ " "+ " is ODD number");
}
}
}

class ThrN implements Runnable{

FiboSeq fs;
ThrN(FiboSeq f1){
fs=f1;
}
public void run(){
fs.fibo();
}
}

class ThrM implements Runnable{

FiboSeq fs;
ThrM(FiboSeq f1){
fs=f1;
}

public void run(){

fs.evenOdd();
}
}
class ThrFibo1 {
public static void main(String[] args){
FiboSeq ff = new FiboSeq();

ThrN tt = new ThrN(ff);

Thread t1 = new Thread(tt);

ThrM tk = new ThrM(ff);

Thread t2 = new Thread(tk);

t1.start();
t2.start();
System.out.println(" t1 is existing? "+ t1.isAlive());
System.out.println(" t2 is existing? "+ t1.isAlive());
try{
t1.join();
t2.join();
}catch(Exception e){
System.out.println(e);
}

System.out.println(" t1 is existing? "+ t1.isAlive());

System.out.println(" t2 is existing? "+ t1.isAlive());
}
}

6. Develop a java program, your program should have two threads with two
different purposes to demonstrate start(), run(), sleep(), getPriority(),
setPriority() methods.
( Count of even/odd numbers and count of zeroes/Non-zeroes are possible in this
program )
Answer:
class Thr1 extends Thread {
String str;
Thr1( String str){
this.str =str;
}

public void run(){

int ectr=0;
int octr=0;

int ar[] = {12,97,87,54,78,32,9,91,53,75};

for(int i=0; i<ar.length; i++){
if((ar[i] % 2) == 0) {
System.out.println(str +": "+ ar[i] + " is an EVEN
number");
ectr++;
}
else {
System.out.println(str + " : "+ar[i] + " is an ODD
number");
octr++;
}
}
System.out.println(str +": count of EVEN numbers =
"+ectr);
System.out.println(str +": count of ODD numbers =
"+octr);
}
}

class Thr2 implements Runnable {

String str;
Thr2( String str){
this.str =str;
}
public void run(){
int zctr=0;
int nzctr=0;
try{
int ar[] = {12,0,87,54,0,32,9,91,53,0};
for(int i=0; i<ar.length; i++){
if(ar[i] == 0) {
System.out.println(str +": "+ ar[i] + " is a ZERO");
zctr++;
}
else {
System.out.println(str + ": "+ar[i] + " is NON ZERO");
nzctr++;
}
Thread.sleep(500);
}
} catch(Exception e){
System.out.println(e);
}
System.out.println(str +" count of ZERO numbers =
"+zctr);
System.out.println(str +" count of NonZero numbers =
"+nzctr);
}
}
class ThrDemo5 {
public static void main(String[] args){
String s1 = "FIRST";
String s2 = "SECOND";

Thr1 t1 = new Thr1(s1);

Thr1 t3 = new Thr1(s1);

Thr2 gg = new Thr2(s2);

Thread t2 = new Thread(gg,s2);

t1.start();
t2.start();
t3.start();

System.out.println(" Name of Thread1 ="+ t1.getName());

System.out.println(" Name of Thread2 ="+ t2.getName());

t1.setPriority(9);
t3.setPriority(2);
System.out.println(t1.getName() + " priority : " +
t1.getPriority());
System.out.println(t3.getName() + " priority : " +
t3.getPriority());

System.out.println(" BEFORE calling join() method");

System.out.println(t1.getName() + " is exists? " +
t1.isAlive());
System.out.println(t2.getName() + " is exists? " +
t2.isAlive());
System.out.println(t3.getName() + " is exists? " +
t3.isAlive());

try{
t1.join();
t2.join();

t3.java();
}catch(Exception er){
System.out.println(er);
}
System.out.println(" AFTER calling join() method");
System.out.println(t1.getName() + " is exists? " +
t1.isAlive());
System.out.println(t2.getName() + " is exists? " +
t2.isAlive());
System.out.println(t3.getName() + " is exists? " +
t3.isAlive());

}
}
7. Describe synchronization in java threads, write a java program that
included a synchronized block in a particular method for a genuine reason.
Answer:
Synchronization in Java is the capability to control the access of multiple threads to
any shared resource.

Mutual Exclusive helps keep threads from interfering with one another while sharing
data. It can be achieved by using the following three ways:

1. By Using Synchronized Method

2. By Using Synchronized Block
3. By Using Static Synchronization

Program:
class Bangee{
void doit(String str){
// synchronized block
synchronized(this){
try{
System.out.print("[ "+str);
Thread.sleep(1000);
}
catch(Exception e){
System.out.println(e);
}

System.out.println("]");
 }
}
}

class Thr1 implements Runnable {

Bangee bg;
String str;
Thr1(Bangee bb, String str1){
bg=bb;
str = str1;
}
public void run(){
bg.doit(str);
}
}

class TsyncDemo1{
public static void main(String[] args){
Bangee bg1 = new Bangee();
Thr1 tt1 = new Thr1(bg1,"raja");
Thr1 tt2 = new Thr1(bg1,"Kaja");
Thread t1 = new Thread(tt1);
Thread t2 = new Thread(tt2);
t1.start();
t2.start();
}
}
8. A java program to implement synchronized method
Answer:
class Bangee{
// synchronized method…
synchronized void doit(String str){
try{
System.out.print("[ "+str);
Thread.sleep(1000);
}
catch(Exception e){
System.out.println(e);
}

System.out.println("]");
}
}

class Thr1 implements Runnable {

Bangee bg;
String str;
Thr1(Bangee bb, String str1){
bg=bb;
str = str1;
}
public void run(){
bg.doit(str);
} }
class TsyncDemo1{
public static void main(String[] args){
Bangee bg1 = new Bangee();
Thr1 tt1 = new Thr1(bg1,"raja");
Thr1 tt2 = new Thr1(bg1,"Kaja");
Thread t1 = new Thread(tt1);
Thread t2 = new Thread(tt2);
t1.start();
t2.start();
}
}

9. Lock Interface and Rentrant Lock

Program 1:
// Lock and ReentrantLock - synchronization program...
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class TableX{
Lock qLock = new ReentrantLock();
void printX(int n){
qLock.lock();
try{
for (int i= 1; i<=10; i++){
System.out.println( n +" X "+ i +" = "+n*i);
Thread.sleep(1000);
}
}catch(Exception e){
System.out.println(e);
}
qLock.unlock();
}
}

class ThrTable extends Thread {

TableX tbl;
int n;
ThrTable(TableX tbl1, int n1){
tbl=tbl1;
n=n1;
}

public void run(){

tbl.printX(n);
}
}

class Thr12Lock1{
public static void main(String[] args){
TableX tx = new TableX();
ThrTable t1 = new ThrTable(tx, 5);
ThrTable t2 = new ThrTable(tx, 10);
t1.start();
t2.start();
}
}

Program 2:
// Lock and ReentrantLock - synchronization program...

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
class StrX{
Lock qLock = new ReentrantLock();
void printX(String str){
qLock.lock();
try{
System.out.print("[ "+ str);
Thread.sleep(500);
System.out.println(" ]");
}catch(Exception e){
System.out.println(e);
}finally{
qLock.unlock();
}
}
}
class ThrStr extends Thread{
StrX sx;
String s;
ThrStr( StrX sx1, String s1){
sx = sx1;
s = s1;
}

public void run(){

sx.printX(s);
}
}

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

StrX sx = new StrX();

ThrStr t1 = new ThrStr(sx, "KLEF is");
ThrStr t2 = new ThrStr(sx, "world class");
ThrStr t3 = new ThrStr(sx, "University");
t1.start();
t2.start();
t3.start();
}
}
10. Semaphore – programs
Program 1:
import java.util.concurrent.*;
// Thread coodination - with semaphore
class TableX{
Semaphore sem = new Semaphore(1);

void printX(int n){

try{
sem.acquire();
System.out.println( " ");
for (int i= 1; i<=10; i++){
System.out.println( n +" X "+ i +" = "+n*i);
Thread.sleep(1000);
}
}catch(Exception e){
System.out.println(e);
}
sem.release();
}
}

class ThrTable extends Thread {

TableX tbl;
int n;
ThrTable(TableX tbl1 , int n1)
 {
tbl = tbl1;
n=n1;
}

public void run(){

tbl.printX(n);
}
}

class Thr14Semaphore1{
public static void main(String[] args){
TableX tx = new TableX();
ThrTable t1 = new ThrTable(tx, 5);
ThrTable t2 = new ThrTable(tx, 10);
t1.start();
t2.start();
}
}
Program 2:
import java.util.concurrent.*;
// Thread coodination - with semaphore
class StrX{
Semaphore sem = new Semaphore(1);
void printX(String str){

try{
sem.acquire();
System.out.print("[ "+ str);
Thread.sleep(500);
System.out.println(" ]");
}catch(Exception e){
System.out.println(e);
}
sem.release();

}
}

class ThrStr extends Thread{

StrX sx;
String s;
ThrStr( StrX sx1, String s1){
sx = sx1;
s = s1;
}

public void run(){

sx.printX(s);
}
}

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

StrX sx = new StrX();

ThrStr t1 = new ThrStr(sx, "KLEF is");
ThrStr t2 = new ThrStr(sx, "world class");
ThrStr t3 = new ThrStr(sx, "University");
t1.start();
t2.start();
t3.start();
}
}
11. Examine the process of inter-thread communication (communication
between threads) with a neat diagram, explain wait() and notify() methods in
this context.
Answer:

Wait() - The wait() method causes the current thread to wait indefinitely until
another thread either invokes notify() for this object .

Notify() - For all threads waiting on this object’s monitor (by using any one of
the wait() methods), the method notify() notifies any one of them to wake up
arbitrarily.

Program:
// wait() and notify() demo program...

class Data {
boolean sig = false;
synchronized void part1() {
System.out.println("Welcome to KLEF");
sig = true;
notify();
}
 synchronized void part2() {
try {
if (!sig)
wait();
} catch (Exception e) {
System.out.println(e);
}
System.out.println("Join in any one Tech
club");
}
}

class Thr1 extends Thread {

Data dt;
Thr1(Data dt1){
dt = dt1;
}

public void run() {

dt.part1();
}
}

class Thr2 extends Thread {

Data dt;
Thr2(Data dt1) {
dt = dt1;
}

public void run() {

dt.part2();
}
}

class Thr16WtNtf1{
public static void main(String[] args) {
Data dt = new Data();

Thr1 t1 = new Thr1(dt);

Thr2 t2 = new Thr2(dt);

// Start t2 and then t1

t2.start();
t1.start();

}
}

Program 2:
class Bank{
boolean sig = false;

synchronized void deposit(){

System.out.println(" your deposit is successful");
System.out.println(" you can withdraw any time");
System.out.println(" ");
sig = true;
notify();
}

synchronized void withdraw(){

try{
if (!sig)
wait();
} catch(Exception e){
System.out.println(e);
}
System.out.println(" Thank you for withdrawing your
money");
}
}

class Thr1 extends Thread{

Bank bk;
Thr1(Bank bk1){
bk=bk1;
}
public void run(){
bk.deposit();
}
}

class Thr2 extends Thread{

Bank bk;
Thr2(Bank bk1){
bk=bk1;
}
public void run(){
bk.withdraw();
}
}

class Thr17WtNtf2{
public static void main(String[] args){
Bank bkk = new Bank();
Thr1 t1 = new Thr1(bkk);
Thr2 t2 = new Thr2(bkk);

t2.start();
t1.start();
}
}
12. Deadlock program (situation how deadlock occurs)
Program:
class BookTkt extends Thread {
Object train, comp;
BookTkt(Object t1, Object c1){
train = t1;
comp=c1;
}

public void run(){

synchronized(train){
System.out.println(" Book ticket locked on train");
try{
Thread.sleep(150);
}catch(Exception e){
System.out.println(e);
}
System.out.println(" Book ticket now waiting to lock on
compartment");
synchronized(comp){
System.out.println(" Book ticket locked on
compartment");
}
}
}
}
class CancelTkt extends Thread{
Object train, comp;
CancelTkt(Object t1, Object c1){
train = t1;
comp=c1;
}
public void run(){
synchronized(comp){
System.out.println(" cancel ticket locked on
compartment");
try{
Thread.sleep(200);
}catch(Exception e){
System.out.println(e);
}
System.out.println(" cancel ticket now waiting to lock
on train");
synchronized(train){
System.out.println(" cancel ticket locked on train");
}
}
}
}

class Thr19DeadLock{
public static void main(String[] args){
Object train = new Object();
Object compartment = new Object();
BookTkt obj1 = new BookTkt(train, compartment);
CancelTkt obj2 = new CancelTkt(train, compartment);

Thread t1 = new Thread(obj1);

Thread t2 = new Thread(obj2);
t1.start();
t2.start();
}
}

13. Avoiding Deadlock ( program to handle deadlock)

Program:
class BookTkt extends Thread {
Object train, comp;
BookTkt(Object t1, Object c1){
train = t1;
comp=c1;
}

public void run(){

synchronized(train){
System.out.println(" Book ticket locked on train");
try{
Thread.sleep(150);
}catch(Exception e){
System.out.println(e);
}
System.out.println(" Book ticket now waiting to lock on
compartment");
synchronized(comp){
System.out.println(" Book ticket locked on
compartment");
}
}
}
}

class CancelTkt extends Thread{

Object train, comp;
CancelTkt(Object t1, Object c1){
train = t1;
comp=c1;
}
public void run(){
synchronized(train){
System.out.println(" cancel ticket locked on train");
try{
Thread.sleep(150);
}catch(Exception e){
System.out.println(e);
}
System.out.println(" cancel ticket now waiting to lock
on compartment");
synchronized(comp){
 System.out.println(" cancel ticket locked on
compartment");
}
}
}
}

class Thr20DeadLockAvoid{
public static void main(String[] args){
Object train = new Object();
Object compartment = new Object();
BookTkt obj1 = new BookTkt(train, compartment);
CancelTkt obj2 = new CancelTkt(train, compartment);

Thread t1 = new Thread(obj1);

Thread t2 = new Thread(obj2);
t1.start();
t2.start();
}
}
14. A classical Producer and Consumer java threads to demonstrate inter
thread communication.
Program :
class Data {
int n;
boolean sig=false;

synchronized void put(int n1) {

try {
if(sig)
wait();
}catch(Exception e) {
System.out.println(e);
}

n=n1;
System.out.println("put= "+n);
sig=true;
notify();
}

synchronized void get() {

try {
if(!sig)
wait();
}catch(Exception e) {
System.out.println(e);
 }
System.out.println("Got= "+n);
sig=false;
notify();
}
}

class Producer extends Thread {

Data dt;
Producer(Data dt1){
dt=dt1;
}

public void run() {

int i=1;
for(int lp=0; lp<20; lp++)
dt.put(i++);
}
}

class Consumer extends Thread {

Data dt;
Consumer(Data dt1) {
dt=dt1;
}

public void run() {

for(int lp=0; lp<20; lp++)
dt.get();
}
}

class Thr18ProdConsumer {
public static void main(String args[]) {
Data dt= new Data();
Producer p1 = new Producer(dt);
Consumer c1 = new Consumer(dt);
p1.start();
c1.start();
}
}
CO – 4
 SHORT ANSWER QUESTIONS ( from CO-4 )

1. List DML commands in SQL?

Answer:

DML – stands for Data Manipulation Language commands,

they are usually called CRUD operations.
C – Create ie INSERT SQL
R – Read ie SELECT SQL
U – Update ie UPDATE SQL
D – Delete ie DELETE SQL

2. which java package must be imported for jdbc?

Answer :
Java.sql.* pkg must be imported to work with JDBC operations in Java, it
contains classes like

Connection, Statement, PreparedStatement, CallableStatement, ResultSet,

DatabaseMetaData, ResultSetMetaData etc..

These classes are useful for JDBC applications development.

3. Which SQL command is used for querying a table?

Answer :
SELECT SQL command is used for the querying a table.
Eg.
SELECT * from PRODUCT;
SELECT PID, PNAME from PRODUCT;
SELECT PID, PNAME from PRODUCT where PID>115;
4. Express the role of a driver and Driver Manager in JDBC?
Answer :

From the above architecture, JDBC Driver manager and JDBC Driver plays a
major role in making JDBC application programs.

DriverManager: This class manages a list of database drivers. Matches connection

requests from the java application with the proper database driver using
communication sub protocol. The first driver that recognizes a certain subprotocol
under JDBC will be used to establish a database Connection.

Driver: This interface handles the communications with the database server. You
will interact directly with Driver objects very rarely. Instead, you use
DriverManager objects, which manages objects of this type. It also abstracts the
details associated with working with Driver objects.
 5. Explain JDBC ResultSet?
Answer :

ResultSet: These objects hold data retrieved from a database after you execute an
SQL query using Statement objects. It acts as an iterator to allow you to move
through its data.

Eg.
ResultSet rs=stmt.executeQuery("select PCOST, PNAME from product");
Where stmt is the Statement class object.

6. Database is the heart of any programming application, in this context

how java programs are designed to connect to any commercial
databases available in the market? Write the procedure that you know
to connect java program to a Oracle database.

Answer:
Six steps of JDBC application development with Oacle/any database

 Import the packages: Requires that you include the packages containing the
JDBC classes needed for database programming. Most often, using import
java.sql.* will suffice.

 Register the JDBC driver: Requires that you initialize a driver so you can
open a communication channel with the database.

 Open a connection: Requires using the DriverManager.getConnection()

method to create a Connection object, which represents a physical connection
with the database.

 Execute a query /Execute update: Requires using an object of type

Statement for building and submitting an SQL statement to the database.
 Extract data from result set: Requires that you use the appropriate
ResultSet.getXXX() method to retrieve the data from the result set.

 Clean up the environment: Requires explicitly closing all database

resources versus relying on the JVM's garbage collection.

7. Explain HTTP ?
Answer:

The Hyper Text Transfer Protocol (HTTP) is the foundation of the World
Wide Web, and is used to load webpages using hypertext links. HTTP is an
application layer protocol designed to transfer information between
networked devices and runs on top of other layers of the network protocol
stack.

8. Explain the benefits of web programming

Answer:

Web programming is the process of creating web pages, developing web

pages to creating intricate web applications.

Multiple users can access the same version of an application. Users don't
need to install the app. Users can access the app through various platforms
such as a desktop, laptop or mobile. Users can access the app through
multiple browsers.
9. Give any two examples of web client?
Answer:

web browsers like

Google chrome
Mozilla Firefox
Microsoft Internet Explorer are the few examples of web clients.

10. Give example of web server?

Answer:

Apache Tomcat
Microsoft IIS
Oracle IPlanet
are the few web servers examples.

11.Define Servlet ?
Answer:
a servlet is a Java programming language class that extends the capabilities
of web server applications. Servlets can respond to any type of request, and
are commonly used to design and deploy dynamic web pages.

12.Difference between HTML and JSP programs

Answer:

HTML is statically typed and is parsed at browser i.e. client side and hence
would be evaluated at client side which exposes your page and would allow
client to do several manipulations. But JSPs are server side and hence are
more secure and safe as client can only access html in last.
13.List the phases in Lifecycle of a JSP Page.
Answer:

14.List the Advantages of JSP over Servlets.

Answer:

1. Easy maintenance: JSP is easy to maintain since separating business

logic with presentation logic is simple.
2. Servlet extension: Being the extension of Servlet technology, it can use
all the features of Servlet.
3. Require less coding: It allows custom tags that reduces the code and
makes coding flexible.
 LONG ANSWER QUESTIONS ( from CO-4 )

1. Programs on Buffered Reader :

Program 1: ( Reading data from a file )
import java.io.*;
public class BufferedReader1 {
public static void main(String args[])throws Exception{
FileReader fr=new FileReader("D:\\Demo111.java");
BufferedReader br=new BufferedReader(fr);

int i;
while((i=br.read())!=-1){
System.out.print((char)i);
}
br.close();
fr.close();
}
}

Program 2: ( Reading string from key board) )

import java.io.*;
class BufferedReader2{
public static void main(String args[])throws Exception{
InputStreamReader r=new InputStreamReader(System.in);
BufferedReader br=new BufferedReader(r);
System.out.println("Enter your name");
 String name=br.readLine();
System.out.println("Welcome "+name);
}
}

Program 3 : ( Reading string from keyboard until you enter “stop”)

import java.io.*;
class BufferedReader3{
public static void main(String args[])throws Exception{
InputStreamReader r=new InputStreamReader(System.in);
BufferedReader br=new BufferedReader(r);
String name="";
while(!name.equals("stop")){
System.out.println("Enter data: ");
name=br.readLine();
System.out.println("data is: "+name);
}
br.close();
r.close();
}
}

Program 4: ( Reading data from Key board )

import java.io.*;
class BufferedReader4{
public static void main(String args[])throws Exception{
 InputStreamReader r=new InputStreamReader(System.in);
BufferedReader br=new BufferedReader(r);
//System.out.println("Enter your name");
//String name=br.readLine();
System.out.println("Enter first number");
String s1 = br.readLine();
System.out.println("Enter second number");
String s2 = br.readLine();
int a1 = Integer.parseInt(s1);
double a2 = Double.parseDouble(s2);
double c = a1+a2;
System.out.println("sum = "+c);
}
}
Program 5: ( writing data into a file )
import java.io.*;
class BufferedWriter1 {
public static void main(String[] args) throws Exception {
FileWriter writer = new FileWriter("D:\\testout.txt");
BufferedWriter buffer = new BufferedWriter(writer);
buffer.write("Welcome to KLEF, world class University.");
buffer.close();
System.out.println("Success");
}
}
2. JDBC Drivers Types

Answer:

JDBC driver implementations vary because of the wide variety of operating systems
and hardware platforms in which Java operates. Sun has divided the implementation
types into four categories, Types 1, 2, 3, and 4, which is explained below −

Type 1: JDBC-ODBC Bridge Driver

In a Type 1 driver, a JDBC bridge is used to access ODBC drivers installed on each
client machine. Using ODBC, requires configuring on your system a Data Source
Name (DSN) that represents the target database.

When Java first came out, this was a useful driver because most databases only
supported ODBC access but now this type of driver is recommended only for
experimental use or when no other alternative is available.

The JDBC-ODBC Bridge that comes with JDK 1.2 is a good example of this kind
of driver.
Type 2: JDBC-Native API

In a Type 2 driver, JDBC API calls are converted into native C/C++ API calls,
which are unique to the database. These drivers are typically provided by the
database vendors and used in the same manner as the JDBC-ODBC Bridge. The
vendor-specific driver must be installed on each client machine.

If we change the Database, we have to change the native API, as it is specific to a

database and they are mostly obsolete now, but you may realize some speed
increase with a Type 2 driver, because it eliminates ODBC's overhead.

The Oracle Call Interface (OCI) driver is an example of a Type 2 driver.

Type 3: JDBC-Net pure Java

In a Type 3 driver, a three-tier approach is used to access databases. The JDBC

clients use standard network sockets to communicate with a middleware application
server. The socket information is then translated by the middleware application
server into the call format required by the DBMS, and forwarded to the database
server.

This kind of driver is extremely flexible, since it requires no code installed on the
client and a single driver can actually provide access to multiple databases.

You can think of the application server as a JDBC "proxy," meaning that it makes
calls for the client application. As a result, you need some knowledge of the
application server's configuration in order to effectively use this driver type.

Your application server might use a Type 1, 2, or 4 driver to communicate with the
database, understanding the nuances will prove helpful.
Type 4: 100% Pure Java

In a Type 4 driver, a pure Java-based driver communicates directly with the

vendor's database through socket connection. This is the highest performance driver
available for the database and is usually provided by the vendor itself.

This kind of driver is extremely flexible, you don't need to install special software
on the client or server. Further, these drivers can be downloaded dynamically.

3. Identify difference between INSERT and UPDATE SQL statements in

JDBC?
Answer:
INSERT SQL UPDATE SQL
1 New record is added to table NO new record is added
2 Row count will be increased Row count remains same
3 Applied on a single row Multiple rows can be affected
4 Clauses can not be used Clauses can be used
4. Program on CRUD operations for PRODUCT table..
Answer:
PRODUCT table description:
PID – number(3) field
PNAME – varchar2(30) field
PCOST – number(5,2) field

Program :
import java.sql.*;
class DBCRUD_PRODUCT{
public static void main(String args[])throws
Exception{

Class.forName("oracle.jdbc.driver.OracleDriver");
Connection con =
DriverManager.getConnection("jdbc:oracle:thin:@localhost
:1521:xe","system","admin");
// code segment to verify Connection is
successfully established or not
if( con != null )
System.out.println("connected");
else
System.out.println("not connected");

Statement stmt = con.createStatement();

// depends on the question use the following strings
appropriately
// String s1="INSERT into product
values(118,'pen drive',97.98)";
 //String s1 = "DELETE FROM PRODUCT WHERE PID= 115";
String s1 = "UPDATE product SET PCOST =
48.90 WHERE PID=110";

int n = stmt.executeUpdate(s1);
System.out.println("Records effected:" + n);
con.commit();
// use of reultset to get all rows from
the product table
ResultSet rs=stmt.executeQuery("select
* from product");
// use of reultset to get all rows from the
product table with a condition

ResultSet rs=stmt.executeQuery("select * from product

where PID > 115");
// use any one of the above statements depending on the
question
while(rs.next())
{
//
System.out.println(rs.getInt(1)+" "+rs.getString(2)+"
"+rs.getDouble(3));
}
con.close();
stmt.close();
}
}
5. Program on CRUD operations for EMPLOYEE table..
Answer:
EMPLOYEE table description:
EID – number(4) field
ENAME – varchar2(20) field
ESAL – number(8,2) field
Program:
import java.sql.*;
class DBCRUD_EMPLOYEE{
public static void main(String args[])throws
Exception{

Class.forName("oracle.jdbc.driver.OracleDriver");
Connection con =
DriverManager.getConnection("jdbc:oracle:thin:@localhost
:1521:xe","system","admin");
// code segment to verify Connection is
successfully established or not
if( con != null )
System.out.println("connected");
else
System.out.println("not connected");
// Statement object code segment in this
program
Statement stmt = con.createStatement();
// depends on the question use the following strings
appropriately
// String s1="INSERT into EMPLOYEE
values(1118,'sundar’,33333.98)";
 //String s1 = "DELETE FROM EMPLOYEE WHERE EID=
115";
String s1 = "UPDATE product SET ESAL =
44444.90 WHERE EID=1110";

int n = stmt.executeUpdate(s1);
System.out.println("Records effected:" + n);
con.commit();
// use of reultset to get all rows from
the product table
ResultSet rs=stmt.executeQuery("select
* from EMPLOYEE");
// use of reultset to get all rows from the
product table with a condition

ResultSet rs=stmt.executeQuery("select * from EMPLOYEE

where EID > 1115");
// use any one of the above statements depending on the
question
while(rs.next())
{
//
System.out.println(rs.getInt(1)+" "+rs.getString(2)+"
"+rs.getDouble(3));
}
con.close();
stmt.close();

}
}
6. Program to update the third record and delete the fourth record and finally
display available records using ResultSet object that uses SELECT sql
statement.
Answer :
PRODUCT table description:
PID – number(3) field
PNAME – varchar2(30) field
PCOST – number(5,2) field
Assuming there are 5 record available in the table with PIDs are 101, 102, 103, 104
and 105 sequentially .
Program :
import java.sql.*;
class DBCRUD_PRODUCT{
public static void main(String args[])throws
Exception{

Class.forName("oracle.jdbc.driver.OracleDriver");
Connection con =
DriverManager.getConnection("jdbc:oracle:thin:@localhost
:1521:xe","system","admin");
// code segment to verify Connection is
successfully established or not
if( con != null )
System.out.println("connected");
else
System.out.println("not connected");

Statement stmt = con.createStatement();

// depends on the question use the following strings
appropriately

// updating Third record where its PID = 103

String s1 = "UPDATE product SET PCOST =
48.90 WHERE PID=103";

int n1 = stmt.executeUpdate(s1);
System.out.println("Records effected:" + n1);
con.commit();

// Deleting fourth record where its PID = 104

String s2 = "DELETE FROM PRODUCT WHERE PID= 104";
int n2 = stmt.executeUpdate(s1);
System.out.println("Records effected:" + n2);

// printing all the records after performing above two

tasks.
ResultSet rs=stmt.executeQuery("select
* from product");
while(rs.next()){
System.out.println(rs.getInt(1)+" "+rs.getString(2)+"
"+rs.getDouble(3));
}
con.close();
stmt.close();
} }
7. Program on scrollable result set.
Answer:
import java.sql.*;

public class ScrollableResultSet1 {

public static void main(String[] args) throws

Exception {

Class.forName("oracle.jdbc.driver.OracleDriver");

Connection
con=DriverManager.getConnection("jdbc:oracle:thin:@local
host:1521:xe","system","admin");

Statement st =
con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_READ_ONLY);

ResultSet rs = st.executeQuery("select * from

product");
System.out.println("RECORDS IN THE TABLE...");
while (rs.next()) {
System.out.println(rs.getInt(1) + " -> " +
rs.getString(2)+" -> "+rs.getDouble(3));
}
rs.first();
System.out.println("FIRST RECORD...");
 System.out.println(rs.getInt(1) + " -> " +
rs.getString(2)+" -> "+rs.getDouble(3));
rs.absolute(3);
System.out.println("THIRD RECORD...");
System.out.println(rs.getInt(1) + " -> " +
rs.getString(2)+" -> "+rs.getDouble(3));
rs.last();
System.out.println("LAST RECORD...");
System.out.println(rs.getInt(1) + " -> " +
rs.getString(2)+" -> "+rs.getDouble(3));
System.out.println("LAST BUT ONE RECORD...");
rs.previous();
System.out.println(rs.getInt(1) + " -> " +
rs.getString(2)+" -> "+rs.getDouble(3));
rs.relative(-2);
System.out.println(rs.getInt(1) + " -> " +
rs.getString(2)+" -> "+rs.getDouble(3));

//System.out.println(rs.getInt(1) + " -> " +

rs.getString(2)+" -> "+rs.getDouble(3));
con.close();
}
}
8. Write a java code segment to use PreparedStatement object to insert a
record into product table.
Program :
import java.sql.*;
class InsertPrepared{
public static void main(String args[]){
try{
Class.forName("oracle.jdbc.driver.OracleDriver");

Connection
con=DriverManager.getConnection("jdbc:oracle:thin:@local
host:1521:xe","system","admin");

Statement stmt = con.createStatement();

PreparedStatement pstmt=con.prepareStatement("insert
into product values(?,?,?)");

pstmt.setInt(1,115);//1 specifies the first parameter in

the query
pstmt.setString(2,"MARKER");
pstmt.setDouble(3,19.00);

int i=pstmt.executeUpdate();
System.out.println(i+" records inserted");

ResultSet rs=stmt.executeQuery("select * from product");

while(rs.next())
{
System.out.println(rs.getInt(1)+" "+rs.getString(2)+"
"+rs.getDouble(3));
//
System.out.println(rs.getInt("PID")+"
"+rs.getString("PNAME")+" "+rs.getDouble("PCOST"));
}
con.commit();
con.close();

}catch(Exception e){ System.out.println(e);}

}
}

9. Differentiate Statement and PreparedStatement objects

Statement PreparedStatement
1 createStatement() method is used prepareStatement() method is used
2 SQL command contains absolute SQL command will have ‘?’ marks
data
3 Do not have setXXX() methods This has setXXX() methods
4 Useful only at compile time Useful at both compile time and
database operations runtime database operations
Notes On servlets:
10. Life Cycle of a Servlet (Servlet Life Cycle)

Answer:
1. Life Cycle of a Servlet
1. Servlet class is loaded
2. Servlet instance is created
3. init method is invoked
4. service method is invoked
5. destroy method is invoked

The web container maintains the life cycle of a servlet instance. Let's see the life
cycle of the servlet:

1. Servlet class is loaded.

2. Servlet instance is created.
3. init method is invoked.
4. service method is invoked.
5. destroy method is invoked.
As displayed in the above diagram, there are three states of a servlet: new, ready
and end. The servlet is in new state if servlet instance is created. After invoking the
init() method, Servlet comes in the ready state. In the ready state, servlet performs
all the tasks. When the web container invokes the destroy() method, it shifts to the
end state.
11. Architecture of Servlet ?
Answer:

Servlet Architecture

Execution of Servlets :

Execution of Servlets involves the six basic steps:

1. The clients send the request to the web server.
2. The web server receives the request.
3. The web server passes the request to the corresponding servlet.
4. The servlet processes the request and generate the response in the form of
output.
5. The servlet send the response back to the web server.
6. The web server sends the response back to the client and the client browser
displays it on the screen.
12. Why servlets are important ?
Answer:
Today we all are aware of the need of creating dynamic web pages i.e the ones
which have the capability to change the site contents according to the time or are
able to generate the contents according to the request received by the client. If you
like coding in Java, then you will be happy to know that using Java there also exists
a way to generate dynamic web pages and that way is Java Servlet, the need for
server-side extensions.
Servlets are the Java programs that runs on the Java-enabled web server or
application server. They are used to handle the request obtained from the web
server, process the request, produce the response, then send response back to the
web server.

Properties of Servlets :

 Servlets work on the server-side.

 Servlets capable of handling complex request obtained from web server.

13. Differences between GET and POST methods

Answer:
Get vs. Post

There are many differences between the Get and Post request. Let's see these
differences:
GET POST

1) In case of Get request, only limited amount of data can be In case of post request, large amount of data can
sent because data is sent in header. be sent because data is sent in body.

2) Get request is not secured because data is exposed in URL Post request is secured because data is not exposed
bar. in URL bar.

3) Get request can be bookmarked. Post request cannot be bookmarked.

4) Get request is idempotent . It means second request will Post request is non-idempotent.
be ignored until response of first request is delivered

5) Get request is more efficient and used more than Post. Post request is less efficient and used less than
get.

14. Servlet program to display “ Hello servlet world “ in the browser.

Program:
import java.io.*;
import javax.servlet.*;

public class First implements Servlet{

ServletConfig config=null;

public void init(ServletConfig config){

this.config=config;
System.out.println("servlet is initialized");
}

public void service(ServletRequest req,ServletResponse

res)
throws IOException,ServletException{
res.setContentType("text/html");

PrintWriter out=res.getWriter();
out.print("<html><body>");
out.print("<b> Hello servlet world </b>");
out.print("</body></html>");

}
public void destroy(){System.out.println("servlet is
destroyed");}
public ServletConfig getServletConfig(){return config;}
public String getServletInfo(){return "copyright 2007-
1010";}

15. Web technology deals with many types of methodologies and technologies,
Java server pages is one among them. JSP adopts a particular process to make
the web page dynamic. Explain JSP processing with a neat diagram.
Answer:
JSP Architecture
JSP Processing
The following steps explain how the web server creates the Webpage using JSP −

 As with a normal page, your browser sends an HTTP request to the web
server.
 The web server recognizes that the HTTP request is for a JSP page and
forwards it to a JSP engine. This is done by using the URL or JSP page
which ends with .jsp instead of .html.
 The JSP engine loads the JSP page from disk and converts it into a servlet
content. This conversion is very simple in which all template text is
converted to println( ) statements and all JSP elements are converted to Java
code. This code implements the corresponding dynamic behavior of the page.
 The JSP engine compiles the servlet into an executable class and forwards the
original request to a servlet engine.
 A part of the web server called the servlet engine loads the Servlet class and
executes it. During execution, the servlet produces an output in HTML
format. The output is furthur passed on to the web server by the servlet
engine inside an HTTP response.
 The web server forwards the HTTP response to your browser in terms of
static HTML content.
 Finally, the web browser handles the dynamically-generated HTML page
inside the HTTP response exactly as if it were a static page.

All the above mentioned steps can be seen in the following diagram −
Typically, the JSP engine checks to see whether a servlet for a JSP file already
exists and whether the modification date on the JSP is older than the servlet. If the
JSP is older than its generated servlet, the JSP container assumes that the JSP hasn't
changed and that the generated servlet still matches the JSP's contents. This makes
the process more efficient than with the other scripting languages (such as PHP) and
therefore faster.

So in a way, a JSP page is really just another way to write a servlet without having
to be a Java programming wiz. Except for the translation phase, a JSP page is
handled exactly like a regular servlet.

1. Explain JSP elements like JSP scriplet, declaration, expression,

comment, directive to develop a dynamic web page.
Answer:
16. Elements of JSP

The elements of JSP have been described below −

The Scriptlet

A scriptlet can contain any number of JAVA language statements, variable or

method declarations, or expressions that are valid in the page scripting language.

Following is the syntax of Scriptlet −

<% code fragment %>

Eg.
<html>
<head><title>Hello World</title></head>

<body>
Hello World!<br/>
<%
out.println("Your IP address is " +
request.getRemoteAddr());
%>
</body>
</html>

JSP Declarations

A declaration declares one or more variables or methods that you can use in Java
code later in the JSP file. You must declare the variable or method before you use it
in the JSP file.

Following is the syntax for JSP Declarations −

<%! declaration; [ declaration; ]+ ... %>

Eg.
<%! int i = 0; %>
<%! int a, b, c; %>
<%! Circle a = new Circle(2.0); %>

JSP Expression

A JSP expression element contains a scripting language expression that is

evaluated, converted to a String, and inserted where the expression appears in the
JSP file.

Eg.
<html>
<head><title>A Comment Test</title></head>

<body>
<p>Today's date: <%= (new
java.util.Date()).toLocaleString()%></p>
</body>
</html>

JSP Comments

JSP comment marks text or statements that the JSP container should ignore. A JSP
comment is useful when you want to hide or "comment out", a part of your JSP
page.

Following is the syntax of the JSP comments −

<%-- This is JSP comment --%>

Following example shows the JSP Comments −

<html>
 <head><title>A Comment Test</title></head>

<body>
<h2>A Test of Comments</h2>
<%-- This comment will not be visible in the page
source --%>
</body>
</html>

JSP Directives

A JSP directive affects the overall structure of the servlet class. It usually has the
following form −

<%@ directive attribute="value" %>

Eg.

<%@ page ... %>

2. Program on JSP elements ?

Answer:
The following program illustrates some of the JSP Elements to insert a row into
the product table of Oracle database.

Program:
<html>
<body>
<%@ page import ="java.sql.*" %>
<%@ page import ="javax.sql.*" %>
<%
String id;
int iid;
double dcost;
id=request.getParameter("pid");
String name=request.getParameter("pname");
String cost=request.getParameter("pcost");
iid=Integer.parseInt(id);
dcost=Double.parseDouble(cost);
try{
<%--comment – for Registering the driver --%>
Class.forName("oracle.jdbc.driver.OracleDriver");

<%--comment – getting the Connection object --%>

Connection con =
DriverManager.getConnection("jdbc:oracle:thin:@localho
st:1521:xe","system","admin");

PreparedStatement pstmt=con.prepareStatement("insert
into product values(?,?,?)");

pstmt.setInt(1,iid);
pstmt.setString(2,name);
pstmt.setDouble(3,dcost);

int i=pstmt.executeUpdate();

out.print(i+ "Insertion Successful");

}catch(Exception e)
{
System.out.println(e);
 }
%>
</body>
</html>

17. Develop a JSP application that accepting two numbers from the client
.html program and sending to a .jsp file in the server that responding to the
input arrived on request object and computing the sum of the two numbers
sending the output back to the client over response object.
Answer:
This question requires two programs 1. HTML program to initiate the process from
browser 2. JSP program in the server to accept the request from HTML program.

Programs:
sum.html program
<html>
<body>
<h2>Compute the sum of two numbers</h2>
<form name="testForm" method="GET"
action="computesum.jsp">

Enter num1: <input type="text" name="num1" /><br>

Enter num2: <input type="text" name="num2" /><br><br>

<input type="submit" value="SumJSP" name="Compute"/>

</form>

</body>
</html>

Computesum.jsp
<html>
<head>
<title>sum of two numbers with jsp</title>
</head>

<body>
<%
String value1, value2;
double n1, n2, sum;
value1=request.getParameter("num1");
value2=request.getParameter("num2");

n1=Double.parseDouble(value1);
n2=Double.parseDouble(value2);

sum=n1+n2;

out.println("The sum is:" + sum);

%>

</body>
</html>
18. A JSP program to connect to Oracle database and to get data from the
PRODUCT table and publish the record sets in a HTML table in the browser.
Programs:
First program : Product.html
<html>
<body>
<form action="prod.jsp" method="post">
<input type="submit" value="dispaly products" />
</form>
</body>
</html>

Second program : prod.jsp

<HTML>
<HEAD>
<TITLE>Selecting products From a
Database</TITLE>
</HEAD>

<BODY>
<H1>Showing Products From a product table</H1>

<%
Connection con =
DriverManager.getConnection("jdbc:oracle:thin:@localhost
:1521:xe","system","admin");
 Statement stat = con.createStatement() ;
ResultSet resultset =
stat.executeQuery("select * from Product") ;
%>

<TABLE BORDER="1">
<TR>
<TH>ID</TH>
<TH>NAME</TH>
<TH>COST</TH>
</TR>
<% while(resultset.next()){ %>
<TR>
<TD> <%= resultset.getInt(1) %></td>
<TD> <%= resultset.getString(2) %></TD>
<TD> <%= resultset.getDouble(3) %></TD>
</TR>
<% } %>
</TABLE>
</BODY>
</HTML>
Team AOOP wishes you

***** END OF NOTES *****