Programming language Using JAVA (COM 211)

Recap
You can recall in Java Programming I we discussed the following:
 Java and its History
 Steps in program development
 Variables and keywords
 Operators and precedence of operations in Java
 Decisions
 Looping
 Java built in functions

Page 1 of 57
 ARRAYS
Java provides a data structure, the array, which stores a fixed-size sequential collection of
elements of the same type. An array is used to store a collection of data, but it is often more
useful to think of an array as a collection of variables of the same type. It is also a collection of
similar type of elements which has contiguous memory location.
Java array is an object which contains elements of a similar data type. Additionally, the elements
of an array are stored in a contiguous memory location. It is a data structure where we store
similar elements. We can store only a fixed set of elements in a Java array.
Array in Java is index-based, the first element of the array is stored at the 0th index, 2nd element
is stored on 1st index and so on.
 In Java, all arrays are dynamically allocated.
 Arrays may be stored in contiguous memory [consecutive memory locations].
 Since arrays are objects in Java, we can find their length using the object property length.
This is different from C/C++, where we find length using sizeof.
 A Java array variable can also be declared like other variables with [] after the data type.
 The variables in the array are ordered, and each has an index beginning with 0.
 Java array can also be used as a static field, a local variable, or a method parameter.

Advantages of Arrays:
1. Code Optimization: It makes the code optimized, we can retrieve or sort the data
efficiently.
2. Data Storage and manipulation: It allows easy storage and manipulation large data sets
3. Random access: Java Arrays enable you to access any element randomly with the help of
indexes. We can get any data located at an index position.
Disadvantages:
1. Size Limit: We can store only the fixed size of elements in the array. It doesn't grow its
size at runtime.
2. Java cannot store heterogeneous data.

Types of Arrays in java

There are two types of arrays.
1. Single Dimensional or 1-Dimensional Array: A one-dimensional array (or single
dimension array) is a type of linear array. Accessing its elements involves a single
subscript which can either represent a row or column index.

Page 2 of 57
 2. Multidimensional Array: A multidimensional array is an array with more than one
dimensions. In a matrix, the two dimensions are represented by rows and columns. Each
element is defined by two subscripts, the row index and the column index.
Category of Arrays:
Array can also be grouped into two forms:
1. Primitive arrays: This array is created using the primitive data types such as int, char,
bool, etc.
2. Non-Primitive (Object) Arrays: This kind of array otherwise called an object array. It
is created from the class of the reference object.
Declaring 1-D array:
To use an array in a program, you must declare a variable to reference the array, and you must
specify the type of array the variable can reference. Here is the syntax for declaring an array
variable:
dataType[] arr; (or)
datatype arr[];
example:
double[] myList; // preferred way. Or
double myList[]; // works but not preferred way.
Creating Array:
You can create an array by using the new operator with the following syntax:
arr = new dataType[arraySize]; or
dataType[] arr = {value0, value1, ..., valuek};
The array elements are accessed through the index. Array indices are 0-based; that is, they start
from 0 to arr.length-1.
Example 1: The following statement declares an array variable, myList, creates an array of 10
elements of double type and assigns its reference to myList:
double[] myList = new double[10];

Page 3 of 57
Processing Array:
When processing array elements, we often use either for loop or for-each loop because all of the
elements in an array are of the same type and the size of the array is known.

Example 2: The example below, declares, instantiates, initializes, and traverses an array of 5
items.
//Java Program to illustrate how to declare, instantiate,
//initialize and traverse the Java array.
class Testarray{
public static void main(String args[]){
int a[]=new int[5];//declaration and instantiation
a[0]=10;//initialization
a[1]=20;
a[2]=70;
a[3]=40;
a[4]=50;
//traversing array
for(inti=0; i<a.length; i++)//length is the property of
array
System.out.println(a[i]);
}
}

Output:
10

Page 4 of 57
20
70
40
50

Example 3: Here is a complete example showing how to create, initialize, and process arrays:
public class TestArray {
public static void main(String[] args) {
double[] myList = {1.9, 2.9, 3.4, 3.5};
// Print all the array elements
for (inti = 0; i<myList.length; i++) {
System.out.println(myList[i] + " ");
}
// Summing all elements
double total = 0;
for (inti = 0; i<myList.length; i++) {
total += myList[i];
}
System.out.println("Total is " + total);
// Finding the largest element
double max = myList[0];
for (inti = 1; i<myList.length; i++) {
if (myList[i] > max) max = myList[i];
}
System.out.println("Max is " + max);
}
}
Output:
1.9
2.9
3.4

Page 5 of 57
 3.5
Total is 11.7
Max is 3.5

The foreach Loop

JDK 1.5 introduced a new for loop known as foreach loop or enhanced for loop, which enables
you to traverse the complete array sequentially without using an index variable.
Example 4:
The following code displays all the elements in the array myList:
public class TestArray {
public static void main(String[] args) {
double[] myList = {1.9, 2.9, 3.4, 3.5};
// Print all the array elements
for (double element: myList) {
System.out.println(element);
}
}
}
Output:
1.9
2.9
3.4
3.5
Passing Arrays to Methods
Just as you can pass primitive type values to methods, you can also pass arrays to methods. For
example, the following method displays the elements in an int array:
Example 5:
public static void printArray(int[] array) {
for (inti = 0; i<array.length; i++) {
System.out.print(array[i] + " ");
}
}

Page 6 of 57
You can invoke it by passing an array. For example, the following statement invokes the
printArray method to display 3, 1, 2, 6, 4, and 2:
printArray(new int[]{3, 1, 2, 6, 4, 2});

Returning an Array from a Method:

A method may also return an array. For example, the following method returns an array that is
the reversal of another array:
public static int[] reverse(int[] list) {
int[] result = new int[list.length];
for (inti = 0, j = result.length - 1; i<list.length; i++,
j--) {
result[j] = list[i];
}
return result;
}

Multidimensional Array in Java

In such case, data is stored in row and column based index (also known as matrix form).
Syntax of Declaring Multidimensional Array:
dataType[][] arrayRefVar; (or)
dataType[][]arrayRefVar; (or)
dataTypearrayRefVar[][]; (or)
dataType[]arrayRefVar[];
Example 6: Instantiate and Initialise Multidimensional Array:
int[][] arr=new int[3][3]; //3 row and 3 column
//initialise array
arr[0][0]=1;
arr[0][1]=2;
arr[0][2]=3;
arr[1][0]=4;
arr[1][1]=5;

Page 7 of 57
arr[1][2]=6;
arr[2][0]=7;
arr[2][1]=8;
arr[2][2]=9;

Example 7: This declare, instantiate, initialize and print a 2Dimensional array.

//Java Program to illustrate the use of multidimensional array
class Testarray3{
public static void main(String args[]){
//declaring and initializing 2D array
intarr[][]={{1,2,3},{2,4,5},{4,4,5}};
//printing 2D array
for(inti=0;i<3;i++){
for(int j=0;j<3;j++){
System.out.print(arr[i][j]+" ");
}
System.out.println();
}
}
}

Output:
1 2 3
2 4 5
4 4 5

Non-Primitive (Object) Arrays:

An array of objects is created like an array of primitive-type data items in the following way.
Student[] arr = new Student[5]; //student is a user-defined class
Syntax:

Page 8 of 57
-- data type[] arrName;
-- datatype arrName[];
-- datatype [] arrName;

Example of Arrays of Objects

Example:
Below is the implementation of the above-mentioned topic:
import java.io.*;
class GFG {
public static void main (String[] args) {
int [] arr=new int [4];
// 4 is the size of arr
System.out.println("Array Size:"+arr.length);
}
}
The student Array contains five memory spaces each of the size of student class in which the
address of five Student objects can be stored. The Student objects have to be instantiated using
the constructor of the Student class, and their references should be assigned to the array elements
in the following way.
Example 2:
Below is the implementation of the above mentioned topic:
// Java program to illustrate creating
// an array of objects
class Student {
public int roll_no;
public String name;
Student(int roll_no, String name)
{
this.roll_no = roll_no;
this.name = name;
}

Page 9 of 57
}
// Elements of the array are objects of a class Student.
public class GFG {
public static void main(String[] args)
{
// declares an Array of Students
Student[] arr;

// allocating memory for 5 objects of type Student.

arr = new Student[5];

// initialize the first elements of the array

arr[0] = new Student(1, "aman");

// initialize the second elements of the array

arr[1] = new Student(2, "vaibhav");

// so on...
arr[2] = new Student(3, "shikar");
arr[3] = new Student(4, "dharmesh");
arr[4] = new Student(5, "mohit");

// accessing the elements of the specified array

for (int i = 0; i < arr.length; i++)
System.out.println("Element at " + i + " : "
+ arr[i].roll_no + " "
+ arr[i].name);
}
}
Example 3
An array of objects is also created like:

Page 10 of 57
// Java program to illustrate creating
// an array of objects

class Student
{

public String name;

Student(String name)
{
this.name = name;
}
@Override
public String toString(){
return name;
}
}

// Elements of the array are objects of a class Student.

public class GFG
{
public static void main (String[] args)
{
// declares an Array and initializing the elements of
the array
Student[] myStudents = new Student[]{new
Student("Dharma"),new Student("sanvi"),new Student("Rupa"),new
Student("Ajay")};

// accessing the elements of the specified array

for(Student m:myStudents){
System.out.println(m);
}

Page 11 of 57
 }
}

List and Maps

List in Java provides the facility to maintain the ordered collection. It contains the index-based
methods to insert, update, delete and search the elements. It can have the duplicate elements also.
We can also store the null elements in the list. The List interface is found in the java.util package
and inherits the Collection interface which is a factory of list iterators.

Creating a List:
The ArrayList and LinkedList classes provide the implementation of List interface. Let's see the
examples to create the List:
//Creating a List of type String using ArrayList
List<String> list=new ArrayList<String>();

//Creating a List of type Integer using ArrayList

List<Integer> list=new ArrayList<Integer>();

//Creating a List of type Book using ArrayList

List<Book> list=new ArrayList<Book>();

//Creating a List of type String using LinkedList

List<String> list=new LinkedList<String>();

Example 8:
import java.util.*;
public class ListExample1{
public static void main(String args[]){
//Creating a List
List<String> list=new ArrayList<String>();
//Adding elements in the List
list.add("Mango");
list.add("Apple");

Page 12 of 57
 list.add("Banana");
list.add("Grapes");
//Iterating the List element using for-each loop
for(String fruit:list)
System.out.println(fruit);
}
}
Output:
Mango
Apple
Banana
Grapes

Example 9: Convert Array to List

import java.util.*;
public class ArrayToListExample{
public static void main(String args[]){
//Creating Array
String[] array={"Java","Python","PHP","C++"};
System.out.println("Printing Array:
"+Arrays.toString(array));
//Converting Array to List
List<String> list=new ArrayList<String>();
for(String lang:array){
list.add(lang);
}
System.out.println("Printing List: "+list);
}
}

Assignment:

Page 13 of 57
Given the matrices below:
1 1 1
A=2 2 2
3 3 3
1 1 1
B=2 2 2
3 3 3

1. Write a java program that:

a) Add the matrices.
b) Subtract the matrices
c) Multiply matrix A by 4
2. Write a java program that multiply matrix A and B.
3. Write a java program that copy all the element of one array to another.

Java Event Driven Program

In Java, GUI-based programs are implemented by using the classes from the standard
javax.swing andjava.awt packages. We will refer to them collectively as GUI classes. When
weneed to differentiate them, we will refer to the classes from javax.swing as Swingclasses and
those from java.awt as AWT classes.
To build an effective graphical user interface using objects from the javax.swingand java.awt
packages, we must learn a new style of program control called eventdriven programming. An
event occurs when the user interacts with a GUI object.
For example, when you move the cursor, click on a button, or select a menu choice,an event
occurs. In event-driven programs, we program objects to respond to theseevents by defining
event-handling methods.
In the older versions of Java (before Java 2 SDK 1.2), we had only AWTclasses to build GUI-
based programs. Many of the AWT classes are now supersededby their counterpart Swing
classes (e.g., AWT Button class is superseded by SwingJButton class). AWT classes are still
available, but it is generally preferable to useSwing classes. There are two main advantages in
using the Swing classes over the AWT classes:
1. The Swing classes provide greater compatibility across different operating systems
because it is implemented fully in Java. While AWT is implemented using native GUI
objects. That is why Swing classes are called light-weight classes while AWT classes are
called heavy-weight classes.

Page 14 of 57
 2. The Swing classes support many new functionalities not supported by the AWT
counterparts. Example, we can easily display an image inside a button in addition to a
text by using a Swing JButton, but only text can be displayed insidea button with an
AWT Button.

Figure 1 Various GUI Objects from the javax.swing package

Simple GUI I/O with JOptionPane

One of the easiest ways to provide a simple GUI-based input and output is by using the
JOptionPane class. For example, when we execute the statement below the dialog shown in
Figure 2 appears on the centre of the screen.
JOptionPane.showMessageDialog(null, "I Love Java");

Figure 2: A simple “message” dialog created by the showMessageDialog method by using the JOptionPane class

Example 10:
/*
Sample Program: Shows a Message Dialog
File: eg10ShowMessageDialog.java
*/

Page 15 of 57
import javax.swing.*;
class Eg10ShowMessageDialog {
public static void main(String[] args) {
JFramejFrame;
jFrame = new JFrame();
jFrame.setSize(400,300);
jFrame.setVisible(true);
JOptionPane.showMessageDialog(jFrame, "one\ntwo\
nthree");
String input;
input = JOptionPane.showInputDialog(null, "Enter
text:");}
}

Output:

Unlike the Scanner class that supports different input methods for specificdata types, that is,
nextInt and nextDouble, the JOptionPane supports only a stringinput. To input a numerical value,
we need to perform the string conversion ourselves. To input an integer value, say, age, we can
write the code as follows:

Page 16 of 57
String str= JOptionPane.showInputDialog(null, "Enter age:");
int age = Integer.parseInt(str);
If the user enters a string that cannot be converted to an int, for example, 12.34 orabc123, a
NumberFormatException error will result. We use corresponding wrapperclasses to convert the
string input to other numerical data values.
Table 1: Common wrapper classes and their conversion methods.

Page 17 of 57
 JAVA OOP

OOP stands for Object-Oriented Programming.

Procedural programming is about writing procedures or methods that perform operations on the
data, while object-oriented programming is about creating objects that contain both data and
methods.

Object-oriented programming has several advantages over procedural programming:

 OOP is faster and easier to execute

 OOP provides a clear structure for the programs
 OOP helps to keep the Java code DRY "Don't Repeat Yourself", and makes the code
easier to maintain, modify and debug
 OOP makes it possible to create full reusable applications with less code and shorter
development time

Tip: The "Don't Repeat Yourself" (DRY) principle is about reducing the repetition of code. You
should extract out the codes that are common for the application, and place them at a single place
and reuse them instead of repeating it.

Java - What are Classes and Objects?

Classes and objects are the two main aspects of object-oriented programming.

Look at the following illustration to see the difference between class and objects:

Class Objects

Fruit Apple, Banana, Mango

Car Volvo, Audi, Toyota,

So, a class is a template for objects, and an object is an instance of a class.

Page 18 of 57
When the individual objects are created, they inherit all the variables and methods from the class.

Java Classes/Objects

Java is an object-oriented programming language.

Everything in Java is associated with classes and objects, along with its attributes and methods.
For example: in real life, a car is an object. The car has attributes, such as weight and color,
and methods, such as drive and brake.

A Class is like an object constructor, or a "blueprint" for creating objects.

Create a Class

To create a class, use the keyword class:

MyClass.java

Create a class named "MyClass" with a variable x:

public class MyClass {

int x = 5;

Create an Object

In Java, an object is created from a class. We have already created the class named MyClass, so
now we can use this to create objects.

To create an object of MyClass, specify the class name, followed by the object name, and use the
keyword new:

Example

Create an object called "myObj" and print the value of x:

public class MyClass {

int x = 5;

public static void main(String[] args) {

Page 19 of 57
 MyClass myObj = new MyClass();

System.out.println(myObj.x);

Multiple Objects

You can create multiple objects of one class:

Example

Create two objects of MyClass:

public class MyClass {

int x = 5;

public static void main(String[] args) {

MyClass myObj1 = new MyClass(); // Object 1

MyClass myObj2 = new MyClass(); // Object 2

System.out.println(myObj1.x);

System.out.println(myObj2.x);

Using Multiple Classes

You can also create an object of a class and access it in another class. This is often used
for better organization of classes (one class has all the attributes and methods, while the other
class holds the main() method (code to be executed)).

Remember that the name of the java file should match the class name. In this example, we have
created two files in the same directory/folder:

 MyClass.java
 OtherClass.java

MyClass.java
Page 20 of 57
public class MyClass {

int x = 5;

OtherClass.java

class OtherClass {

public static void main(String[] args) {

MyClass myObj = new MyClass();

System.out.println(myObj.x);

When both files have been compiled:

C:\Users\Your Name>javac MyClass.java

C:\Users\Your Name>javac OtherClass.java

Run the OtherClass.java file:

C:\Users\Your Name>java OtherClass

And the output will be:

Java Class Attributes

In the previous chapter, we used the term "variable" for x in the example (as shown below). It is
actually an attribute of the class. Or you could say that class attributes are variables within a
class:

Example

Create a class called "MyClass" with two attributes: x and y:

public class MyClass {

int x = 5;

Page 21 of 57
 int y = 3;

Accessing Attributes

You can access attributes by creating an object of the class, and by using the dot syntax (.):

The following example will create an object of the MyClass class, with the name myObj. We use
the x attribute on the object to print its value:

Example

Create an object called "myObj" and print the value of x:

public class MyClass {

int x = 5;

public static void main(String[] args) {

MyClass myObj = new MyClass();

System.out.println(myObj.x);

Modify Attributes

You can also modify attribute values:

Example

Set the value of x to 40:

public class MyClass {

int x;

public static void main(String[] args) {

MyClass myObj = new MyClass();

myObj.x = 40;

System.out.println(myObj.x);

Page 22 of 57
 }

Or override existing values:

Example

Change the value of x to 25:

public class MyClass {

int x = 10;

public static void main(String[] args) {

MyClass myObj = new MyClass();

myObj.x = 25; // x is now 25

System.out.println(myObj.x);

If you don't want the ability to override existing values, declare the attribute as final:

Example

public class MyClass {

final int x = 10;

public static void main(String[] args) {

MyClass myObj = new MyClass();

myObj.x = 25; // will generate an error: cannot assign a value to a final

variable

System.out.println(myObj.x);

Multiple Objects

Page 23 of 57
If you create multiple objects of one class, you can change the attribute values in one object,
without affecting the attribute values in the other:

Example

Change the value of x to 25 in myObj2, and leave x in myObj1 unchanged:

public class MyClass {

int x = 5;

public static void main(String[] args) {

MyClass myObj1 = new MyClass(); // Object 1

MyClass myObj2 = new MyClass(); // Object 2

myObj2.x = 25;

System.out.println(myObj1.x); // Outputs 5

System.out.println(myObj2.x); // Outputs 25

Multiple Attributes

You can specify as many attributes as you want:

Example

public class Person {

String fname = "John";

String lname = "Doe";

int age = 24;

public static void main(String[] args) {

Person myObj = new Person();

System.out.println("Name: " + myObj.fname + " " + myObj.lname);

System.out.println("Age: " + myObj.age);

Page 24 of 57
}

Java Class Methods

You learned from the Java Methods chapter that methods are declared within a class, and that
they are used to perform certain actions:

Example

Create a method named myMethod() in MyClass:

public class MyClass {

static void myMethod() {

System.out.println("Hello World!");

myMethod() prints a text (the action), when it is called. To call a method, write the method's name
followed by two parentheses () and a semicolon;

Example

Inside main, call myMethod():

public class MyClass {

static void myMethod() {

System.out.println("Hello World!");

public static void main(String[] args) {

myMethod();

// Outputs "Hello World!"

Static vs. Non-Static

Page 25 of 57
You will often see Java programs that have either static or public attributes and methods.

In the example above, we created a static method, which means that it can be accessed without
creating an object of the class, unlike public, which can only be accessed by objects:

Example

An example to demonstrate the differences between static and public methods:

public class MyClass {

// Static method

static void myStaticMethod() {

System.out.println("Static methods can be called without creating

objects");

// Public method

public void myPublicMethod() {

System.out.println("Public methods must be called by creating objects");

// Main method

public static void main(String[] args) {

myStaticMethod(); // Call the static method

// myPublicMethod(); This would compile an error

MyClass myObj = new MyClass(); // Create an object of MyClass

myObj.myPublicMethod(); // Call the public method on the object

Page 26 of 57
 JAVA CONSTRUCTORS

In Java, a constructor is a block of codes similar to the method. It is called when an instance of
the class is created. At the time of calling constructor, memory for the object is allocated in the
memory. It is a special type of method which is used to initialize the object. Every time an
object is created using the new() keyword, at least one constructor is called.

It calls a default constructor if there is no constructor available in the class. In such case, Java
compiler provides a default constructor by default.

Rules for creating Java constructor

There are two rules defined for the constructor.
1. Constructor name must be the same as its class name
2. A Constructor must have no explicit return type
3. A Java constructor cannot be abstract, static, final, and synchronized

Example: Default Constructor

Create a constructor:

Page 27 of 57
// Create a MyClass class
public class MyClass {
int x; // Create a class attribute
// Create a class constructor for the MyClass class
public MyClass() {
x = 5; // Set the initial value for the class attribute x
}
public static void main(String[] args) {
MyClass myObj = new MyClass(); // Create an object of class MyClass (This
will call the constructor)
System.out.println(myObj.x); // Print the value of x
}
}

// Outputs 5

Example: Parameterized Constructor

Create a constructor:

//Java Program to demonstrate the use of the parameterized constructor.

class Student4{
int id;
String name;
//creating a parameterized constructor
Student4(int i, String n){
id = i;
name = n;
}
//method to display the values
void display(){
System.out.println(id+" "+name);
}

public static void main(String args[]){

//creating objects and passing values
Student4 s1 = new Student4(111,"Karan");
Student4 s2 = new Student4(222,"Aryan");
//calling method to display the values of object

Page 28 of 57
 s1.display();
s2.display();
}
}

OUTPUT:
111 Karan
222 Aryan

JAVA ENCAPSULATION

Encapsulation
The meaning of Encapsulation, is to make sure that "sensitive" data is hidden from users. To
achieve this, you must:
 declare class variables/attributes as private
 provide public get and set methods to access and update the value of a private variable.

Get and Set

You learned from the previous chapter that private variables can only be accessed within the
same class (an outside class has no access to it). However, it is possible to access them if we
provide public get and set methods. The get method returns the variable value, and
the set method sets the value. Syntax for both is that they start with either get or set, followed by
the name of the variable, with the first letter in upper case:

Example

public class Person {

private String name; // private = restricted access

// Getter

public String getName() {

return name;

Page 29 of 57
 // Setter

public void setName(String newName) {

this.name = newName;

Example explained

The get method returns the value of the variable name.

The set method takes a parameter (newName) and assigns it to the name variable. The this keyword
is used to refer to the current object.

However, as the name variable is declared as private, we cannot access it from outside this class:

Example

public class MyClass {

public static void main(String[] args) {

Person myObj = new Person();

myObj.name = "John"; // error

System.out.println(myObj.name); // error

If the variable was declared as public, we would expect the following output:

John

However, as we try to access a private variable, we get an error:

MyClass.java:4: error: name has private access in Person

myObj.name = "John";

Page 30 of 57
 ^
MyClass.java:5: error: name has private access in Person
System.out.println(myObj.name);
^
2 errors

Instead, we use the getName() and setName() methods to acccess and update the variable:

Example

public class MyClass {

public static void main(String[] args) {

Person myObj = new Person();

myObj.setName("John"); // Set the value of the name variable to "John"

System.out.println(myObj.getName());

// Outputs "John"

Java Packages & API

A package in Java is used to group related classes. Think of it as a folder in a file directory.
We use packages to avoid name conflicts, and to write a better maintainable code. Packages are
divided into two categories:

 Built-in Packages (packages from the Java API)

 User-defined Packages (create your own packages)

Built-in Packages

The Java API is a library of prewritten classes, that are free to use, included in the Java
Development Environment. The library contains components for managing input, database

Page 31 of 57
programming, and much more. The library is divided into packages and classes. Meaning you
can either import a single class (along with its methods and attributes), or a whole package that
contain all the classes that belong to the specified package.

To use a class or a package from the library, you need to use the import keyword:

Syntax

import package.name.Class; // Import a single class

import package.name.*; // Import the whole package

Import a Class

If you find a class you want to use, for example, the Scanner class, which is used to get user
input, write the following code:

Example

import java.util.Scanner;

In the example above, java.util is a package, while Scanner is a class of the java.util package. To
use the Scanner class, create an object of the class and use any of the available methods found in
the Scanner class documentation. In our example, we will use the nextLine() method, which is
used to read a complete line:

Example

Using the Scanner class to get user input:

import java.util.Scanner;

class MyClass {

public static void main(String[] args) {

Scanner myObj = new Scanner(System.in);

System.out.println("Enter username");

String userName = myObj.nextLine();

Page 32 of 57
 System.out.println("Username is: " + userName);

Import a Package

There are many packages to choose from. In the previous example, we used
the Scanner class from the java.util package. This package also contains date and time facilities,
random-number generator and other utility classes. To import a whole package, end the sentence
with an asterisk sign (*). The following example will import ALL the classes in the java.util package:

Example

import java.util.*;

User-defined Packages

To create your own package, you need to understand that Java uses a file system directory to
store them. Just like folders on your computer:

Example

└── root
└── mypack
└── MyPackageClass.java

To create a package, use the package keyword:

MyPackageClass.java

package mypack;

class MyPackageClass {

public static void main(String[] args) {

Page 33 of 57
 System.out.println("This is my package!");

Page 34 of 57
 JAVA INHERITANCE

Inheritance in Java is a mechanism in which one object acquires all the properties and
behaviors of a parent object. It is an important part of OOPs (Object Oriented programming
system).

The idea behind inheritance in Java is that you can create new classes that are built upon existing
classes. When you inherit from an existing class, you can reuse methods and fields of the parent
class. Moreover, you can add new methods and fields in your current class also.

Inheritance represents the IS-A relationship which is also known as a parent-child relationship.

Why use inheritance in java

o For Method Overriding (so runtime polymorphism can be achieved).

o For Code Reusability.

Terms used in Inheritance

o Class: A class is a group of objects which have common properties. It is a template or blueprint
from which objects are created.
o Sub Class/Child Class: Subclass is a class which inherits the other class. It is also called a
derived class, extended class, or child class.
o Super Class/Parent Class: Superclass is the class from where a subclass inherits the features. It
is also called a base class or a parent class.
o Reusability: As the name specifies, reusability is a mechanism which facilitates you to reuse the
fields and methods of the existing class when you create a new class. You can use the same fields
and methods already defined in the previous class.

Types of inheritance in java

1. Single Inheritance

2. Multilevel Inheritance

3. Hierarchical Inheritance

4. Multiple Inheritance

5. Hybrid Inheritance

On the basis of class, there can be three types of inheritance in java: single, multilevel and
hierarchical.

Page 35 of 57
In java programming, multiple and hybrid inheritance is supported through interface only.

To inherit from a class, use the extends keyword.

Example: Single inheritance

class Animal{
void eat(){
System.out.println("eating...");
}
}
class Dog extends Animal{
void bark(){
System.out.println("barking...");
}
}
class TestInheritance{
public static void main(String args[]){
Dog d=new Dog();
d.bark();
d.eat();
}
}

Output:
barking...
eating...

Example: Multilevel inheritance

class Animal{
void eat(){
System.out.println("eating...");
}
}
class Dog extends Animal{

Page 36 of 57
 void bark(){
System.out.println("barking...");
}
}
class BabyDog extends Dog{
void weep(){
System.out.println("weeping...");
}
}
class TestInheritance2{
public static void main(String args[]){
BabyDog d=new BabyDog();
d.weep();
d.bark();
d.eat();
}
}

Output:

Weeping...
Barking...
Eating...

Example: Hierarchical inheritance

class Animal{
void eat(){
System.out.println("eating...");
}
}
class Dog extends Animal{
void bark(){
System.out.println("barking...");
}
}
class Cat extends Animal{
void meow(){
System.out.println("meowing...");

Page 37 of 57
}
}
class TestInheritance3{
public static void main(String args[]){
Cat c=new Cat();
c.meow();
c.eat();
//c.bark();//C.T.Error
}
}

Output:

meowing...
eating...

In the example below, the Car class (subclass) inherits the attributes and methods from
the Vehicle class (superclass):

Example

class Vehicle {

protected String brand = "Ford"; // Vehicle attribute

public void honk() { // Vehicle method

System.out.println("Tuut, tuut!");

class Car extends Vehicle {

private String modelName = "Mustang"; // Car attribute

public static void main(String[] args) {

// Create a myCar object

Page 38 of 57
 Car myCar = new Car();

// Call the honk() method (from the Vehicle class) on the myCar object

myCar.honk();

// Display the value of the brand attribute (from the Vehicle class) and
the value of the modelName from the Car class

System.out.println(myCar.brand + " " + myCar.modelName);

Page 39 of 57
 JAVA POLYMORPHISM

Polymorphism in Java is a concept by which we can perform a single action in different ways.
Polymorphism is derived from 2 Greek words: poly and morphs. The word "poly" means many
and "morphs" means forms. So polymorphism means many forms.

There are two types of polymorphism in Java: compile-time polymorphism and runtime
polymorphism. We can perform polymorphism in java by method overloading and method
overriding.

If you overload a static method in Java, it is the example of compile time polymorphism. Here,
we will focus on runtime polymorphism in java.

Like we specified in the previous chapter; Inheritance lets us inherit attributes and methods
from another class. Polymorphism uses those methods to perform different tasks. This allows us
to perform a single action in different ways.

For example, think of a superclass called Animal that has a method called animalSound().
Subclasses of Animals could be Pigs, Cats, Dogs, Birds - And they also have their own
implementation of an animal sound (the pig oinks, and the cat meows, etc.):

Example

class Animal {
public void animalSound() {
System.out.println("The animal makes a sound");
}
}
class Pig extends Animal {
public void animalSound() {
System.out.println("The pig says: wee wee");
}
}
class Dog extends Animal {
public void animalSound() {
System.out.println("The dog says: bow wow");
}

Page 40 of 57
 SERVLET AND JAVASERVER PAGES

Servlet can be described in many ways, depending on the context.

o Servlet is a technology which is used to create a web application.

o Servlet is an API that provides many interfaces and classes including documentation.

o Servlet is an interface that must be implemented for creating any Servlet.

o Servlet is a class that extends the capabilities of the servers and responds to the incoming
requests. It can respond to any requests.
o Servlet is a web component that is deployed on the server to create a dynamic web page.

Web application

A web application is an application accessible from the web. A web application is

composed of web components like Servlet, JSP, Filter, etc. and other elements such as HTML,
CSS, and JavaScript. The web components typically execute in Web Server and respond to the
HTTP request.

CGI (Common Gateway Interface)

CGI technology enables the web server to call an external program and pass HTTP
request information to the external program to process the request. For each request, it starts a
new process.

Page 41 of 57
Disadvantages of CGI

There are many problems in CGI technology:

1. If the number of clients increases, it takes more time for sending the response.
2. For each request, it starts a process, and the web server is limited to start processes.
3. It uses platform dependent language e.g. C, C++, perl.

Advantages of Servlet

There are many advantages of Servlet over CGI. The web container creates threads for handling
the multiple requests to the Servlet. Threads have many benefits over the Processes such as they

Page 42 of 57
share a common memory area, lightweight, cost of communication between the threads are low.
The advantages of Servlet are as follows:

1. Better performance: because it creates a thread for each request, not process.
2. Portability: because it uses Java language.
3. Robust: JVM manages Servlets, so we don't need to worry about the memory
leak, garbage collection, etc.
4. Secure: because it uses java language.

JavaServer Pages

JavaServer Pages (JSP) is a technology for developing Webpages that supports

dynamic content. This helps developers insert java code in HTML pages by making use of
special JSP tags, most of which start with <% and end with %>.

A JavaServer Pages component is a type of Java servlet that is designed to fulfill the role of a
user interface for a Java web application. Web developers write JSPs as text files that combine
HTML or XHTML code, XML elements, and embedded JSP actions and commands.

Using JSP, you can collect input from users through Webpage forms, present records from a
database or another source, and create Webpages dynamically.

JSP tags can be used for a variety of purposes, such as retrieving information from a database or
registering user preferences, accessing JavaBeans components, passing control between pages,
and sharing information between requests, pages etc.

Why Use JSP?

JavaServer Pages often serve the same purpose as programs implemented using
the Common Gateway Interface (CGI). But JSP offers several advantages in comparison with
the CGI.

 Performance is significantly better because JSP allows embedding Dynamic Elements in

HTML Pages itself instead of having separate CGI files.
 JSP are always compiled before they are processed by the server unlike CGI/Perl which
requires the server to load an interpreter and the target script each time the page is
requested.

Page 43 of 57
  JavaServer Pages are built on top of the Java Servlets API, so like Servlets, JSP also has
access to all the powerful Enterprise Java APIs, including JDBC, JNDI, EJB,
JAXP, etc.
 JSP pages can be used in combination with servlets that handle the business logic, the
model supported by Java servlet template engines.
 JSP technology is used to create web application just like Servlet technology. It can be
thought of as an extension to Servlet because it provides more functionality than servlet
such as expression language, JSTL, etc.

 A JSP page consists of HTML tags and JSP tags. The JSP pages are easier to maintain
than Servlet because we can separate designing and development. It provides some
additional features such as Expression Language, Custom Tags, etc.

Advantages of JSP over Servlet

 There are many advantages of JSP over the Servlet. They are as follows:

 1) Extension to Servlet

 JSP technology is the extension to Servlet technology. We can use all the features of the
Servlet in JSP. In addition to, we can use implicit objects, predefined tags, expression
language and Custom tags in JSP, that makes JSP development easy.

 2) Easy to maintain

 JSP can be easily managed because we can easily separate our business logic with
presentation logic. In Servlet technology, we mix our business logic with the presentation
logic.

 3) Fast Development: No need to recompile and redeploy

 If JSP page is modified, we don't need to recompile and redeploy the project. The Servlet
code needs to be updated and recompiled if we have to change the look and feel of the
application.

Page 44 of 57
  4) Less code than Servlet

 In JSP, we can use many tags such as action tags, JSTL, custom tags, etc. that reduces the
code. Moreover, we can use EL, implicit objects, etc.

The Lifecycle of a JSP Page

The JSP pages follow these phases:

o Translation of JSP Page

o Compilation of JSP Page

o Classloading (the classloader loads class file)

o Instantiation (Object of the Generated Servlet is created).

o Initialization ( the container invokes jspInit() method).

o Request processing ( the container invokes _jspService() method).

o Destroy ( the container invokes jspDestroy() method).

As depicted in the above diagram, JSP page is translated into Servlet by the help of JSP
translator. The JSP translator is a part of the web server which is responsible for translating the
JSP page into Servlet. After that, Servlet page is compiled by the compiler and gets converted
into the class file. Moreover, all the processes that happen in Servlet are performed on JSP later
like initialization, committing response to the browser and destroy.

Creating a simple JSP Page

To create the first JSP page, write some HTML code as given below, and save it by .jsp
extension. We have saved this file as index.jsp. Put it in a folder and paste the folder in the web-
apps directory in apache tomcat to run the JSP page.

index.jsp

Let's see the simple example of JSP where we are using the scriptlet tag to put Java code in the
JSP page. We will learn scriptlet tag later.

1. <html>
2. <body>

Page 45 of 57
3. <% out.print(2*5); %>
4. </body>
5. </html>

It will print 10 on the browser.

How to run a simple JSP Page?

Follow the following steps to execute this JSP page:

o Start the server

o Put the JSP file in a folder and deploy on the server

o Visit the browser by the URL http://localhost:portno/contextRoot/jspfile, for example,

http://localhost:8888/myapplication/index.jsp

Do I need to follow the directory structure to run a simple JSP?

o No, there is no need of directory structure if you don't have class files or TLD files. For
example, put JSP files in a folder directly and deploy that folder. It will be running fine.
However, if you are using Bean class, Servlet or TLD file, the directory structure is
required.

The Directory structure of JSP

o The directory structure of JSP page is same as Servlet. We contain the JSP page outside
the WEB-INF folder or in any directory.

What is JDBC?

JDBC stands for Java Database Connectivity, which is a standard Java API for database-
independent connectivity between the Java programming language and a wide range of
databases. The JDBC library includes APIs for each of the tasks mentioned below that are
commonly associated with database usage.

 Making a connection to a database.

Page 46 of 57
  Creating SQL or MySQL statements.

 Executing SQL or MySQL queries in the database.

 Viewing & Modifying the resulting records.

Fundamentally, JDBC is a specification that provides a complete set of interfaces that allows for
portable access to an underlying database. Java can be used to write different types of
executables, such as:

 Java Applications

 Java Applets

 Java Servlets

 Java ServerPages (JSPs)

 Enterprise JavaBeans (EJBs).

All of these different executables are able to use a JDBC driver to access a database, and take
advantage of the stored data.

JDBC provides the same capabilities as ODBC, allowing Java programs to contain database-
independent code.

Pre-Requisite

Before moving further, you need to have a good understanding of the following two subjects:

 Core JAVA Programming

 SQL or MySQL Database

JDBC Architecture

The JDBC API supports both two-tier and three-tier processing models for database access
but in general, JDBC Architecture consists of two layers −

 JDBC API − This provides the application-to-JDBC Manager connection.

 JDBC Driver API − This supports the JDBC Manager-to-Driver Connection.

Page 47 of 57
The JDBC API uses a driver manager and database-specific drivers to provide transparent
connectivity to heterogeneous databases. The JDBC driver manager ensures that the correct
driver is used to access each data source. The driver manager is capable of supporting multiple
concurrent drivers connected to multiple heterogeneous databases. Following is the architectural
diagram, which shows the location of the driver manager with respect to the JDBC drivers and
the Java application

Common JDBC Components

The JDBC API provides the following interfaces and classes:

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

 Connection − This interface with all methods for contacting a database. The connection
object represents communication context, i.e., all communication with database is
through connection object only.

 Statement − You use objects created from this interface to submit the SQL statements to
the database. Some derived interfaces accept parameters in addition to executing stored
procedures.

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

 SQLException − This class handles any errors that occur in a database application.

The JDBC 4.0 Packages

Page 48 of 57
 The java.sql and javax.sql are the primary packages for JDBC 4.0. This is the latest
JDBC version at the time of writing this tutorial. It offers the main classes for interacting with
your data sources.

The new features in these packages include changes in the following areas −

 Automatic database driver loading.

 Exception handling improvements.

 Enhanced BLOB/CLOB functionality.

 Connection and statement interface enhancements.

 National character set support.

 SQL ROWID access.

 SQL 2003 XML data type support.

 Annotations.

how to create a Database using JDBC application. Before executing the following example,
make sure you have the following in place −

 You should have admin privilege to create a database in the given schema. To execute
the following example, you need to replace the username and password with your actual
user name and password.
 Your MySQL or whatever database is up and running.

Required Steps

The following steps are required to create a new Database using JDBC application −

 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.
 Open a connection − Requires using the DriverManager.getConnection() method to
create a Connection object, which represents a physical connection with the database
server.

To create a new database, you need not give any database name while preparing
database URL as mentioned in the below example.

Page 49 of 57
  Execute a query − Requires using an object of type Statement for building and
submitting an SQL statement to the database.
 Clean up the environment . try with resources automatically closes the resources.

Sample Code

Copy and paste the following example in JDBCExample.java, compile and run as follows −

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;

public class JDBCExample {

static final String DB_URL = "jdbc:mysql://localhost/";
static final String USER = "guest";
static final String PASS = "guest123";

public static void main(String[] args) {

// Open a connection
try(Connection conn = DriverManager.getConnection(DB_URL,
USER, PASS);
Statement stmt = conn.createStatement();
) {
String sql = "CREATE DATABASE STUDENTS";
stmt.executeUpdate(sql);
System.out.println("Database created successfully...");

} catch (SQLException e) {
e.printStackTrace();
}
}
}

Now let us compile the above example as follows −

C:\>javac JDBCExample.java
C:\>

Page 50 of 57
When you run JDBCExample, it produces the following result −

C:\>java JDBCExample
Database created successfully...
C:\>

ENTERPRISE SOLUTIONS

Enterprise solutions are designed to integrate multiple facets of a company’s business

through the interchange of information from various business process areas and related
databases. These solutions enable companies to retrieve and disseminate mission-critical data
throughout the organization, providing managers with real-time operating information.

Step Process for Enterprise Software Development

Developing software is not a set in stone method. There is no universal approach to it or the right
way to do it. Sometimes a development process fits the software that you are trying to make like
skin, but sometimes you have to go for unconventional methods. It all depends on your needs
and the type of software that you are developing. Over the years, enterprise software
development has evolved drastically; new methods have surfaced, making the process more
streamlined, transparent, and efficient, and older workflows have been discarded. But again, it is
an iterative process, and every few years a new development process becomes the hot trend. And
while there is no universally accepted approach to develop software, we do, however, have
Software Development Lifecycle(SDLC)- a seven-step software development approach to build,
test, and deliver quality software products. While SDLC is widely considered as the best
approach to enterprise software development still, it is not a necessity that you use it to develop
your software as well. As we said earlier, it depends on the type of software that you are
building. With that said, let’s take a look at what SDLC is and talk about its seven steps to
develop enterprise software.

What is SDLC?

Software Development Lifecycle is a systematic series of steps to develop and test high-
quality software. SDLC allows developers to not only approach software development in a
systematic way, but it also allows them to deliver it on time and in the budget. SDLC is a

Page 51 of 57
development tracking mechanism, broken into seven steps that are to be carried out in a
particular series. Following it makes it easier for the developers to plan the project and offer
near-accurate time and cost estimations. Each step in SDLC has its own subprocesses and
provides deliverables that are used as input by the next step in the process. SDLC helps in speedy
and cost-effective software development, and by increasing visibility and transparency, it helps
developers in creating better relations with their customers and decreases project risk.

7-Steps to Develop an Enterprise Software

SDLC is broken into seven steps that are to be carried out in the sequence that has been laid
down below. It is to be kept in mind that following this sequence will provide optimal outcomes
while deviating from it might not have the desired result.

 Step 1: Requirement Analysis

 Step 2: Feasibility Study
 Step 3: Design
 Step 4: Coding
 Step 5: Testing
 Step 6: Install/Deploy
 Step 7: Maintenance

Each of the above steps has been explained below:

Page 52 of 57
1. Requirement Analysis

Requirement Analysis is the first step in the SDLC process. It is where the board
members and stakeholders get together to devise a plan of action and decide what exactly is
wanted out of the software. This is where all the operations that are required from the software
are laid down. Once that is done, they can get a clear picture of the amount of effort and money
that they will have to put into this project, and a clear timeline is also decided. The scope of the
project is finalized in this stage as well, and all the issues that might be faced somewhere down
the line are identified too. Based on the requirements that are laid out in this phase, along with
the timeline and the budget, other things are thought of as well. The tools that will be required
are bought, the talent needed for this project is hired, etc. With the help of this phase, enterprises
can reduce the risk involved in software development since there are no hidden faces to it.
Everything that will be required for this project is laid out right in the beginning, and thus, the
enterprise can operate according to that plan.

2. Feasibility Study

This is the second step in SDLC, and the deliverables from the first step are used in this
step to create documents. This is also the step where the minor details about the project are
finalized as well. And once that is done, all of this data is documented so that everyone knows
the plan, and there is no barrier of knowledge.

The deliverable of this step is a Software Requirement Specification document that contains
everything that is to be designed, all the data about the software’s dependencies, every minor
detail, from the language it will be programmed in, to different use cases, all of it put in this
document.

There are five different types of feasibility checks:

 Economic Feasibility: the enterprise asks itself if the product can be finished in the
allotted budget or not.
 Legal Feasibility: the enterprise asks itself if the product will work according to the
cyber laws and other regulations or not.

Page 53 of 57
  Operation Feasibility: the enterprise asks itself if they can create operations that are
expected by the client or not.
 Technical Feasibility: the enterprise asks itself if the project is feasible with the
technology that is available currently in the market or not.
 Schedule Feasibility: the enterprise asks itself if the project will be finished in the given
time or not.

3. Design

The output of the previous phase, the SRS document, is now used to design the software.
Different modules are built and documented, software architecture is developed according to the
scope of the project. This is where the nooks and crannies of a project are defined and designed,
from the smallest of modules to the overall architecture of the software.

There are two different types of design documents created in this step:

a) High-Level Design:

 A name and a small description for each module

 Interface relationships and dependencies between modules
 Architecture diagrams with technology details
 Database tables
 The functionality of every module

b) Low-Level Design:

 Functional logic of modules

 Database tables with their type and size
 The interface is thoroughly described
 Dependency issues
 Error messages

4. Coding

Page 54 of 57
 This is the longest and most difficult phase of the project. Coding is the step in which the
deliverables of the previous step are used, and developers start to actually create them, to code
them in the language that was decided in the first step.

The software is broken into different modules in the Design step, and so, each developer is given
a module, and they have to work on it on their own while their teammates work on their own
modules individually. This can also be a process where sometimes developers need some help,
especially if it is a new language for them.

The entire team works under a project manager, and it is his responsibility to keep track of all
their works. But while tracking is crucial, a project manager must also keep in mind to not push
his team members too hard. Coding is a taxing job, and a developer needs to focus, and he
cannot do it if you are constantly pushing them to deliver their module.

Once all the modules have been developed, they are put together, and if everything goes as
planned and there are no dependency errors or conflicts, then what you have at the end of this
process is a fully functioning software, ready for the next step of SDLC.

5. Testing

Once the developed software is ready, it is deployed to the testing environment where a
team of QA engineers works with it. Their prime task is to find flaws, glitches, inconsistencies,
and bugs, functional or UI/UX, in your software.

They put your software through various testing cycles and conduct different tests to make sure
that the final deliverable of the software development process is a high-quality and bug-free
software.

Your QA engineers will put your software through different tests, some of them are as follows:

 Code Quality: This testing phase focuses on the coding of each module to make sure that
it is easily understandable. When the project is handed over to the end client, chances are

Page 55 of 57
 he will have his coders poke around in the software as well, or maybe a new coder might
be assigned to the project, and he will require a clean code to understand the project.
 Unit Testing: In this testing, individual units of the software are tested by the QA
engineers. The idea behind this testing is to make sure that each component of the
software works the way it was designed to work.
 Integration Testing: In this testing, the integrations of different software modules are
tested. Since different modules were developed by different coders and are then put
together, sometimes, it is possible that a tester might pick a bug in which two modules
might not be interacting with each other the way they were supposed to. That is why
Integration Testing is essential.
 Performance Testing: In this testing, the performance of the software is scrutinized. The
QA engineers take a look at the software’s response time, speed, resource utilization,
scalability, etc. They also make sure that the software works flawlessly and holds up to
certain performance standards even when more than one of its instances are active.
 Security Testing: In this testing, the security of the software is checked. Any backdoor
that might have been left open, any threat, vulnerabilities, etc. are all checked in this
testing.

6. Install/Deploy

Once the software is tested and free of bugs, it is ready to be deployed and make its way to the
stakeholders. If the project manager gives the go-ahead once all the bugs have been fixed, the
software is deployed. Some companies also make use of automated deployment tools as well.

7. Maintenance

Once the software has been deployed, it is time to keep it running and upgrade it
according to your client’s needs or your stakeholder’s needs. Some new additions to the
software, some tweaks in the UI, all of it after the deployment process falls into this step.
Regular upgrades and security fixes for the latest cyber threats are also necessary to keep the
software safe from outside attacks.

Even after being extra cautious, sometimes some bugs manage to slip past the QA engineers, and
they are fixed in this phase when they are flagged by the users or the stakeholders.

Page 56 of 57
Page 57 of 57