lOMoAR cPSD| 34421130

Contents
• Introduction to web
• Introduction to Java
• Java Language Fundamentals
• OOP implementation
• Packages
• Arrays
• Exception handling
• Working with String
• Multithreading
• SQL
• JDBC
• HTML/CSS
• Javascript
• AJAX
• Servlets and JSP
• Hibernate
• Spring boot
• Conclusion

Downloaded by Indukuri Yeswanth Varma (indukuriyeswanthvarma@gmail.com)

 lOMoAR cPSD| 34421130

Java Full Stack:

A full-stack developer is a person who can develop application's backend
and frontend. Java full-stack is basically a term used for a web developer that
uses Java to develop the entire technology stack is referred to as Java full stack
developer.

Introduction to Java:
• Java is a popular programming language, created in 1995.
• It is owned by Oracle, and more than 3 billion devices run Java.
• Java works on different platforms (Windows, Mac, Linux, Raspberry Pi,
etc.).
• It is easy to learn and simple to use.

• It is open source and free.

• It is secure, fast and powerful.

• Java is an object oriented language which gives a clear structure to

programs and allows code to be reused, lowering development costs.

• It is used for:

Mobile applications (specially Android apps)

Desktop applications
Web applications
Web servers and application servers
Games

Syntax:
public class Main{
public static void main(String[] args){
System.out.println(“Hello World”);
}
}

Downloaded by Indukuri Yeswanth Varma (indukuriyeswanthvarma@gmail.com)

 lOMoAR cPSD| 34421130

• Every line of code that runs in Java must be inside a class. In our example,
we named the class Main. A class should always start with an uppercase
first letter.

• Java is case-sensitive: "MyClass" and "myclass" has different meaning.

• The name of the java file must match the class name. When saving the
file, save it using the class name and add ".java" to the end of the
filename.

• Any code inside the main() method will be executed.

• Inside the main() method, we can use the println() method to print a line of
text to the screen.

IDENTIFIERS:

• Java identifiers are names given to variables, methods, classes, and

other program elements in Java programming language.

• Java identifiers must start with a letter, a currency character "$", or an

underscore "_". The first character cannot be a digit.

• Java identifiers can contain letters, digits, underscores, and currency

characters. The name can be of any length.

• Java is case-sensitive, which means that "name" and "Name" are two
different identifiers.

• Identifiers should not be a Java keyword, which are reserved words in

Java that have a specific meaning and cannot be used as an identifier.

• Examples of valid identifiers in Java are "myVariable", "_count",

"MAX_VALUE", "calculateSum", "MyClass".

Downloaded by Indukuri Yeswanth Varma (indukuriyeswanthvarma@gmail.com)

 lOMoAR cPSD| 34421130

Variables:
• Variables are containers for storing data values.

• In Java, there are different types of variables, for example:

String - stores text, such as "Hello". String values are surrounded by

double quotes
int - stores integers (whole numbers), without decimals, such as
123 or -123
float - stores floating point numbers, with decimals, such as 19.99 or -
19.99
char - stores single characters, such as 'a' or 'B'. Char values are
surrounded by single quotes
boolean - stores values with two states: true or false.

• To create a variable, you must specify the type and assign it a value.

Syntax: type variableName = value;

• All Java variables must be identified with unique names.

• These unique names are called identifiers.
• Identifiers can be short names (like x and y) or more descriptive
names (age, sum, totalVolume).
• The general rules for naming variables are:
Names can contain letters, digits, underscores, and dollar signs
Names must begin with a letter
Names should start with a lowercase letter and it cannot
contain whitespace
Names can also begin with $ and _ .

Names are case sensitive ("myVar" and "myvar" are different

variables).

Downloaded by Indukuri Yeswanth Varma (indukuriyeswanthvarma@gmail.com)

 lOMoAR cPSD| 34421130

Reserved words (like Java keywords, such as int or boolean)

cannot be used as names.

Data Types:
• Data types are divided into two groups:

Primitive data types -

includes byte, short, int, long, float, double, boolean and char.

Non-primitive data types - such as String, Arrays and Classes.

• Primitive number types are divided into two groups:

Integer types stores whole numbers, positive or negative (such
as 123 or -456), without decimals. Valid types
are byte, short, int and long. Which type you should use, depends on the
numeric value.
Floating point types represents numbers with a fractional part,
containing one or more decimals. There are two
types: float and double.
• Integer Types:
The byte data type can store whole numbers from -128 to 127. This
can be used instead of int or other integer types to save memory
when you are certain that the value will be within -128 and 127.
The short data type can store whole numbers from -32768 to
32767.
The int data type can store whole numbers from -2147483648 to
2147483647. In general, the int data type is the preferred data type when
we create variables with a numeric value.
The long data type can store whole numbers from -
9223372036854775808 to 9223372036854775807. This is used
when int is not large enough to store the value. Note that you
should end the value with an "L".
• Floating Point Types:

Downloaded by Indukuri Yeswanth Varma (indukuriyeswanthvarma@gmail.com)

 lOMoAR cPSD| 34421130

The float and double data types can store fractional numbers. Note
that you should end the value with an "f" for floats and "d" for
doubles.
A floating point number can also be a scientific number with an "e"
to indicate the power of 10.

• Type casting is when you assign a value of one primitive data type
to another type.
• In Java, there are two types of casting:
Widening Casting (automatically) - converting a smaller type to a
larger type size
byte -> short -> char -> int -> long -> float -> double

Example:
int myInt = 9;
double myDouble = myInt;

Narrowing Casting (manually) - converting a larger type to a

smaller size type
double -> float -> long -> int -> char -> short -> byte

Example:
double myDouble = 9.78d;
int myInt = (int) myDouble;

Operators:
• Operators are used to perform operations on variables and values.

• Java divides the operators into the following groups:

Arithmetic operators
Assignment operators
Comparison operators
Logical operators
Bitwise operators

Downloaded by Indukuri Yeswanth Varma (indukuriyeswanthvarma@gmail.com)

 lOMoAR cPSD| 34421130

Conditional Statements:
• Java has the following conditional statements:

Use if to specify a block of code to be executed, if a specified

condition is true.

Syntax:
if (condition) {
// block of code to be executed if the condition is true
}

Use else to specify a block of code to be executed, if the same

condition is false.

Syntax:
if (condition) {
// block of code to be executed if the condition is true
} else {
// block of code to be executed if the condition is false
}

Use else if to specify a new condition to test, if the first condition is

false.

if (condition1) {
// block of code to be executed if condition1 is true
} else if (condition2) {
// block of code to be executed if the condition1 is false and
condition2 is true
} else {
// block of code to be executed if the condition1 is false and
condition2 is false

Downloaded by Indukuri Yeswanth Varma (indukuriyeswanthvarma@gmail.com)

 lOMoAR cPSD| 34421130

}
Use switch to specify many alternative blocks of code to be
executed.

Syntax:
switch(expression) { case
x:
// code block
break;
case y:
// code block
break;
default:
// code block
}
The switch expression is evaluated once.

The value of the expression is compared with the values of

each case.

If there is a match, the associated block of code is executed.

The break and default keywords are optional.

Loops:
• Loops can execute a block of code as long as a specified condition is
reached.
• Loops are handy because they save time, reduce errors, and they make
code more readable.
While Loop:
The while loop loops through a block of code as long as a specified condition
is true.
Syntax:
while (condition) {
// code block to be executed
}
Do/While Loop:

Downloaded by Indukuri Yeswanth Varma (indukuriyeswanthvarma@gmail.com)

 lOMoAR cPSD| 34421130

The do/while loop is a variant of the while loop. This loop will execute the
code block once, before checking if the condition is true, then it will repeat the
loop as long as the condition is true.
Syntax:
do {
// code block to be executed
}
while (condition);
For Loop:
When you know exactly how many times you want to loop through a block of
code, use the for loop instead of a while loop.
Syntax:
for (statement 1; statement 2; statement 3)
{ // code block to be executed
}
Statement 1 is executed (one time) before the execution of the code
block.
Statement 2 defines the condition for executing the code block.
Statement 3 is executed (every time) after the code block has been
executed.
Arrays:
• Arrays are used to store multiple values in a single variable, instead of
declaring separate variables for each value.
• To declare an array, define the variable type with square brackets:
Example: String[]
cars;
• You can access an array element by referring to the index number.
• This statement accesses the value of the first element in cars:
Example:
String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};

// Outputs Volvo
Multidimensional Arrays:
• A multidimensional array is an array of arrays.
• Multidimensional arrays are useful when you want to store data as a
tabular form, like a table with rows and columns.

Downloaded by Indukuri Yeswanth Varma (indukuriyeswanthvarma@gmail.com)

 lOMoAR cPSD| 34421130

• To create a two-dimensional array, add each array within its own set of
curly braces.
Example:
int[][] myNumbers = { {1, 2, 3, 4}, {5, 6, 7} };
System.out.println(myNumbers[1][2]); // Outputs 7

Methods:
• A method is a block of code which only runs when it is called.
• You can pass data, known as parameters, into a method.
• Methods are used to perform certain actions, and they are also known as
functions.
• Why use methods? To reuse code: define the code once, and use it
many times.
• A method must be declared within a class. It is defined with the name of
the method, followed by parentheses ( ).
Example:
public class Main {
static void myMethod() {
// code to be executed
}}
myMethod() is the name of the method.

static means that the method belongs to the Main class and not an object
of the Main class. You will learn more about objects and how to access
methods through objects.
void means that this method does not have a return value.

• To call a method in Java, write the method's name followed by two

parentheses () and a semicolon;

• Information can be passed to methods as parameter. Parameters act as

variables inside the method.
• Parameters are specified after the method name, inside the
parentheses. You can add as many parameters as you want, just
separate them with a comma.

12

Downloaded by Indukuri Yeswanth Varma (indukuriyeswanthvarma@gmail.com)

 lOMoAR cPSD| 34421130

• The following example has a method that takes a String called fname as
parameter. When the method is called, we pass along a first name, which
is used inside the method to print the full name:
public class Main {
static void myMethod(String fname) {
System.out.println(fname + " Refsnes");
}

public static void main(String[] args) {

myMethod("Liam");
myMethod("Jenny");
myMethod("Anja");
}
}
Return Values:
The void keyword, used in the examples above, indicates that the method
should not return a value. If you want the method to return a value, you can use a
primitive data type (such as int, char, etc.) instead of void, and use the return
keyword inside the method:
public class Main {
static int myMethod(int x) {
return 5 + x;
}
public static void main(String[] args) {
System.out.println(myMethod(3));
}
}

Java OOP(Object Oriented Programing):

• 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:

Downloaded by Indukuri Yeswanth Varma (indukuriyeswanthvarma@gmail.com)

 lOMoAR cPSD| 34421130

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
Object:
Any entity that has state and behavior is known as an object. For example, a
chair, pen, table, keyboard, bike, etc. It can be physical or logical.
An Object can be defined as an instance of a class. An object contains an address
and takes up some space in memory. Objects can communicate without knowing
the details of each other's data or code. The only necessary thing is the type of
message accepted and the type of response returned by the objects. Example: A
dog is an object because it has states like color, name, breed, etc. as well as
behaviors like wagging the tail, barking, eating, etc.
Class:
Collection of objects is called class. It is a logical entity.
A class can also be defined as a blueprint from which you can create an individual
object. Class doesn't consume any space. Inheritance:

When one object acquires all the properties and behaviors of a parent object, it is
known as inheritance. It provides code reusability. It is used to achieve runtime
polymorphism.
Polymorphism:
If one task is performed in different ways, it is known as polymorphism. For
example: to convince the customer differently, to draw something, for example,
shape, triangle, rectangle, etc.
In Java, we use method overloading and method overriding to achieve
polymorphism.
Another example can be to speak something; for example, a cat speaks meow, dog
barks woof, etc.

Downloaded by Indukuri Yeswanth Varma (indukuriyeswanthvarma@gmail.com)

 lOMoAR cPSD| 34421130

Abstraction:
Hiding internal details and showing functionality is known as abstraction. For
example phone call, we don't know the internal processing.
In Java, we use abstract class and interface to achieve abstraction. Encapsulation
Binding (or wrapping) code and data together into a single unit are known as
encapsulation. For example, a capsule, it is wrapped with different medicines. A
java class is the example of encapsulation. Java bean is the fully encapsulated class
because all the data members are private here.
Inheritance in Java:
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.
• Class: A class is a group of objects which have common properties. It is a
template or blueprint from which objects are created.

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

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

• 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.
Syntax:
class Subclass-name extends Superclass-name
{
//methods and fields
}

Downloaded by Indukuri Yeswanth Varma (indukuriyeswanthvarma@gmail.com)

 lOMoAR cPSD| 34421130

Types of Inheritance:
• Single Inheritance
• Multiple Inheritance
• Multi-Level Inheritance
• Hierarchical Inheritance
• Hybrid Inheritance

Abstraction in Java
Abstraction is a process of hiding the implementation details and showing only
functionality to the user.
Another way, it shows only essential things to the user and hides the internal
details, for example, sending SMS where you type the text and send the message.
You don't know the internal processing about the message delivery. Abstraction
lets you focus on what the object does instead of how it does it.
Ways to achieve Abstraction
There are two ways to achieve abstraction in java
1. Abstract class (0 to 100%)
2. Interface (100%)
Abstract class in Java
A class which is declared as abstract is known as an abstract class. It can have
abstract and non-abstract methods. It needs to be extended and its method
implemented. It cannot be instantiated.
• An abstract class must be declared with an abstract keyword.
• It can have abstract and non-abstract methods.
• It cannot be instantiated.
• It can have constructors and static methods also.
• It can have final methods which will force the subclass not to change the
body of the method.
Example: abstract
class Bike{
abstract void run();
}
class Honda4 extends Bike{
void run(){System.out.println("running safely..");}
public static void main(String args[]){
Bike obj = new
Honda4(); obj.run();

Downloaded by Indukuri Yeswanth Varma (indukuriyeswanthvarma@gmail.com)

 lOMoAR cPSD| 34421130

}
}
Interface in Java:
• An interface in Java is a blueprint of a class. It has static constants and
abstract methods.
• The interface in Java is a mechanism to achieve abstraction. There can be
only abstract methods in the Java interface, not method body. It is used
to achieve abstraction and multiple inheritance in Java.
• In other words, you can say that interfaces can have abstract methods
and variables. It cannot have a method body.
• Java Interface also represents the IS-A relationship.
• It cannot be instantiated just like the abstract class.
• Since Java 8, we can have default and static methods in an interface.
• Since Java 9, we can have private methods in an interface.
• There are mainly three reasons to use interface. They are given below.
It is used to achieve abstraction.
By interface, we can support the functionality of multiple
inheritance.
It can be used to achieve loose coupling.
• An interface is declared by using the interface keyword. It provides total
abstraction; means all the methods in an interface are declared with the
empty body, and all the fields are public, static and final by default. A class
that implements an interface must implement all the methods declared in the
interface.

Syntax:

interface <interface_name>{

// declare constant fields

// declare methods that abstract
// by default.
}
Polymorphism:
Polymorphism means "many forms", and it occurs when we have many classes
that are related to each other by inheritance.

Downloaded by Indukuri Yeswanth Varma (indukuriyeswanthvarma@gmail.com)

 lOMoAR cPSD| 34421130

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");
}
}
Method Overloading:
If a class has multiple methods having same name but different in parameters, it is
known as Method Overloading.
If we have to perform only one operation, having same name of the methods
increases the readability of the program.
Suppose you have to perform addition of the given numbers but there can be any
number of arguments, if you write the method such as a(int,int) for two
parameters, and b(int,int,int) for three parameters then it may be difficult for you
as well as other programmers to understand the behavior of the method because its
name differs.
So, we perform method overloading to figure out the program quickly.

Downloaded by Indukuri Yeswanth Varma (indukuriyeswanthvarma@gmail.com)

 lOMoAR cPSD| 34421130

Advantage of method overloading

Method overloading increases the readability of the program.
Different ways to overload the method
There are two ways to overload the method in java
1. By changing number of arguments
2. By changing the data type
Example:
class Adder{
static int add(int a,int b){return a+b;}
static int add(int a,int b,int c){return a+b+c;}
}
class TestOverloading1{
public static void main(String[] args){
System.out.println(Adder.add(11,11));
System.out.println(Adder.add(11,11,11));
}}
Method Overriding:
If subclass (child class) has the same method as declared in the parent class, it is
known as method overriding in Java.
In other words, If a subclass provides the specific implementation of the method
that has been declared by one of its parent class, it is known as method overriding.
Usage of Java Method Overriding
oMethod overriding is used to provide the specific implementation of a
method which is already provided by its superclass.
oMethod overriding is used for runtime polymorphism
Rules for Java Method Overriding
1. The method must have the same name as in the parent class
2. The method must have the same parameter as in the parent class.
3. There must be an IS-A relationship (inheritance).
Example:
class Vehicle{
void run(){System.out.println("Vehicle is running");}
}
class Bike extends Vehicle{

public static void main(String args[]){

Bike obj = new Bike();

Downloaded by Indukuri Yeswanth Varma (indukuriyeswanthvarma@gmail.com)

 lOMoAR cPSD| 34421130

obj.run();
}
}
Encapsulation:
Encapsulation in Java is a process of wrapping code and data together into a
single unit, for example, a capsule which is mixed of several medicines.
We can create a fully encapsulated class in Java by making all the data members of
the class private. Now we can use setter and getter methods to set and get the data
in it.
The Java Bean class is the example of a fully encapsulated class.
Advantage of Encapsulation in Java
By providing only a setter or getter method, you can make the class read-only or
write-only. In other words, you can skip the getter or setter methods.
It provides you the control over the data. Suppose you want to set the value of id
which should be greater than 100 only, you can write the logic inside the setter
method. You can write the logic not to store the negative numbers in the setter
methods.
It is a way to achieve data hiding in Java because other class will not be able to
access the data through the private data members.
The encapsulate class is easy to test. So, it is better for unit testing.
The standard IDE's are providing the facility to generate the getters and setters.
So, it is easy and fast to create an encapsulated class in Java.
Java Package:
A java package is a group of similar types of classes, interfaces and sub- packages.
Package in java can be categorized in two form, built-in package and user-
defined package.
There are many built-in packages such as java, lang, awt, javax, swing, net, io, util,
sql etc.
Here, we will have the detailed learning of creating and using user-defined
packages.
Advantage of Java Package:
1) Java package is used to categorize the classes and interfaces so that they
can be easily maintained.
2) Java package provides access protection.
3) Java package removes naming collision.
There are three ways to access the package from outside the package.

Downloaded by Indukuri Yeswanth Varma (indukuriyeswanthvarma@gmail.com)

 lOMoAR cPSD| 34421130

1. import package.*;
2. import package.classname;
3. fully qualified name.
Access Modifiers in
Java:
There are two types of modifiers in Java: access modifiers and non-access
modifiers.
The access modifiers in Java specifies the accessibility or scope of a field,
method, constructor, or class. We can change the access level of fields,
constructors, methods, and class by applying the access modifier on it. There are
four types of Java access modifiers:
1. Private: The access level of a private modifier is only within the class. It
cannot be accessed from outside the class.
2. Default: The access level of a default modifier is only within the package. It
cannot be accessed from outside the package. If you do not specify any
access level, it will be the default.
3. Protected: The access level of a protected modifier is within the package
and outside the package through child class. If you do not make the child
class, it cannot be accessed from outside the package.
4. Public: The access level of a public modifier is everywhere. It can be
accessed from within the class, outside the class, within the package and
outside the package.
There are many non-access modifiers, such as static, abstract,
synchronized, native, volatile, transient, etc
Exception Handling in Java
The Exception Handling in Java is one of the powerful mechanism to handle the
runtime errors so that the normal flow of the application can be maintained. What
is Exception in Java?
In Java, an exception is an event that disrupts the normal flow of the program. It
is an object which is thrown at runtime.
What is Exception Handling?
Exception Handling is a mechanism to handle runtime errors such as
ClassNotFoundException, IOException, SQLException, RemoteException, etc. The
core advantage of exception handling is to maintain the normal flow of the
application. An exception normally disrupts the normal flow of the application; that
is why we need to handle exceptions.

Downloaded by Indukuri Yeswanth Varma (indukuriyeswanthvarma@gmail.com)

 lOMoAR cPSD| 34421130

Types of Java Exceptions

There are mainly two types of exceptions: checked and unchecked. An error is
considered as the unchecked exception. However, according to Oracle, there are
three types of exceptions namely:
1. Checked Exception
2. Unchecked Exception
3. Error

The classes that directly inherit the Throwable class except RuntimeException and
Error are known as checked exceptions. For example, IOException, SQLException,
etc. Checked exceptions are checked at compile-time.

The classes that inherit the RuntimeException are known as unchecked

exceptions. For example, ArithmeticException, NullPointerException,
ArrayIndexOutOfBoundsException, etc. Unchecked exceptions are not checked at
compile-time, but they are checked at runtime.

Error is irrecoverable. Some example of errors are OutOfMemoryError,

VirtualMachineError, AssertionError etc.

Java provides five keywords that are used to handle the exception.
• The "try" keyword is used to specify a block where we should place an
exception code. It means we can't use try block alone. The try block must be
followed by either catch or finally.
• The “catch” block is used to handle the exception. It must be preceded
by try block which means we can’t use catch block alone.
• The "finally" block is used to execute the necessary code of the
program. It is executed whether an exception is handled or not.
• The “throw” keyword is used to throw an exception.
• The "throws" keyword is used to declare exceptions. It specifies that
there may occur an exception in the method. It doesn't throw an
exception. It is always used with method signature.
Example:
public class JavaExceptionExample{

public static void main(String args[]){

Downloaded by Indukuri Yeswanth Varma (indukuriyeswanthvarma@gmail.com)

 lOMoAR cPSD| 34421130

try{
int data=100/0;

}catch(ArithmeticException e){System.out.println(e);
}
System.out.println("rest of the code...");
}}
Multithreading in Java:
Multithreading in Java is a process of executing multiple threads
simultaneously.
A thread is a lightweight sub-process, the smallest unit of processing.
Multiprocessing and multithreading, both are used to achieve multitasking.
However, we use multithreading than multiprocessing because threads use a shared
memory area. They don't allocate separate memory area so saves memory, and
context-switching between the threads takes less time than process. Java
Multithreading is mostly used in games, animation, etc.

Advantages of Java Multithreading

1) It doesn't block the user because threads are independent and you can
perform multiple operations at the same time.
2) You can perform many operations together, so it saves time.
3) Threads are independent, so it doesn't affect other threads if an exception
occurs in a single thread.

Relational database concepts

A relational database management system (RDBMS) stores and retrieves data
that is represented in tables. A relational database consists of a collection of
tables that store interrelated data.
This section introduces some of the terms and concepts that are important in talking
about relational databases.
Database tables
In a relational database, all data is held in tables, which are made up
of rows and columns.
Each table has one or more columns, and each column is assigned a specific
datatype, such as an integer number, a sequence of characters (for text), or a
date. Each row in the table has a value for each column.

Downloaded by Indukuri Yeswanth Varma (indukuriyeswanthvarma@gmail.com)

 lOMoAR cPSD| 34421130

A typical fragment of a table containing employee information may look as

follows:
emp_ID emp_lname emp_fname emp_phone

10057 Huong Zhang 1096

10693 Donaldson Anne 7821

The tables of a relational database have some important characteristics:
• There is no significance to the order of the columns or rows.
• Each row contains one and only one value for each column.
• Each value for a given column has the same type.
The following table lists some of the formal and informal relational database
terms describing tables and their contents, together with their equivalent in other
nonrelational databases. This manual uses the informal terms.
Formal relational Informal relational Equivalent nonrelational
term term term

Relation Table File

Attribute Column Field

Tuple Row Record

When you are designing your database, make sure that each table in the database
holds information about a specific thing, such as employees, products, or
customers.
By designing a database this way, you can set up a structure that eliminates
redundancy and inconsistencies. For example, both the sales and accounts
payable departments may look up information about customers. In a relational
database, the information about customers is entered only once, in a table that
both departments can access.
A relational database is a set of related tables. You use primary and foreign keys
to describe relationships between the information in different tables. Primary
and foreign keys
Primary and foreign keys define the relational structure of a database. These keys
enable each row in the database tables to be identified, and define the relationships
between the tables.

Downloaded by Indukuri Yeswanth Varma (indukuriyeswanthvarma@gmail.com)

 lOMoAR cPSD| 34421130

Tables have a primary key

All tables in a relational database should have a primary key. The primary key is
a column, or set of columns, that allows each row in the table to be uniquely
identified. No two rows in a table with a primary key can have the same primary
key value.
If no primary key is assigned, all the columns together become the primary key. It
is good practice to keep your primary key for each table as compact as possible.
Examples
In a table holding information about employees, the primary key may be an ID
number assigned to each employee.
In the sample database, the table of sales order items has the
following columns:
• An order number, identifying the order the item is part of
• A line number, identifying each item on any order
• A product ID, identifying the product being ordered
• A quantity, showing how many items were ordered
• A ship date, showing when the order was shipped
To find the name of a particular employee's department, there is no need to put the
name of the employee's department into the employee table. Instead, the
employee table contains a column holding the department ID of the employee's
department. This is called a foreign key to the department table. A foreign key
references a particular row in the table containing the corresponding primary key.
In this example, the employee table (which contains the foreign key in the
relationship) is called the foreign table or referencing table. The department
table (which contains the referenced primary key) is called the primary table or
the referenced table.

Queries
Retrieve data from a database using the SELECT statement. The basic query
operations in a relational system are projection, restriction, and join. The
SELECT statement implements all of these operations.
A projection is a subset of the columns in a table. A restriction (also
called selection) is a subset of the rows in a table, based on some conditions. For
example, the following SELECT statement retrieves the names and prices of all
products that cost more than $15:

Downloaded by Indukuri Yeswanth Varma (indukuriyeswanthvarma@gmail.com)

 lOMoAR cPSD| 34421130

SELECT name,

unit_price FROM product

WHERE unit_price > 15

This query uses both a restriction (WHERE unit_price > 15) and a
projection (SELECT name, unit_price)
A JOIN links the rows in two or more tables by comparing the values in key
columns and returning rows that have matching values. For example, you may
want to select the item identification numbers and product names for all items
for which more than a dozen has been shipped: SELECT sales_order_items.id,
product.name

FROM product KEY JOIN

sales_order_items WHERE

sales_order_items.quantity > 12
The product table and the sales_order_items table are joined together
based on the foreign key relationships between them.

SQL

SQL is a standard database language used to access and manipulate data in

databases. SQL stands for Structured Query Language. SQL was developed by IBM
Computer Scientists in the 1970s. By executing queries SQL can create, update,
delete, and retrieve data in databases like MySQL, Oracle, PostgreSQL, etc. Overall
SQL is a query language that communicates with databases.

What is a Database?
Data is the new fuel of this world but only data is unorganized information, so to
organize that data we make a database. A database is the organized collection of
structured data which is usually controlled by a database management system
(DBMS). Databases help us with easily storing, accessing, and manipulating data
held on a computer.

Why to learn SQL?

▪ SQL helps you to easily get information from data at high efficiency. To
manipulate the data in databases like Create, Read, Edit, and delete we use
SQL queries. Users can interact with data stored in relational database
Downloaded by Indukuri Yeswanth Varma (indukuriyeswanthvarma@gmail.com)
 lOMoAR cPSD| 34421130

management systems. Anyone who knows the English language can easily
write SQL queries. Some of the key features of SQL are given below:
▪ Without a lot of coding knowledge we can manage a database with SQL.
▪ SQL works with database systems from Oracle, IBM, Microsoft, etc.
▪ Simple and easy to learn.
▪ SQL is ANSI and ISO standard language for database manipulations.
▪ SQL retrieves large amounts of data very fast.

Applications of SQL
In data-driven industries where managing databases is very important in regular,
Here are some important SQL applications.
• To support client/server architecture, software engineers use SQL to establish the
connection between back-end and front-end.
• SQL can also be used in the 3-tier architecture of a client, an application server, and a
database.
• SQL is used as a Data Definition Language(DDL) in which we can independently
create a database, define the structure, use it, and discard it when its work is done.
• SQL is used as a Data Manipulation Language(DML) in which we can enter data,
modify data, extracting data.
• SQL is used as a Data Control Language(DCL) it specifies how we can protect our
database against corruption and misuse.

JDBC
JDBC stands for Java Database Connectivity. JDBC is a Java API to connect and
execute the query with the database. It is a part of JavaSE (Java Standard Edition).
JDBC API uses JDBC drivers to connect with the database. There are four types of
JDBC drivers:

• JDBC-ODBC Bridge Driver,

• Native Driver,
• Network Protocol Driver, and
• Thin Driver
• We have discussed the above four drivers in the next chapter.
• We can use JDBC API to access tabular data stored in any relational database. By
the help of JDBC API, we can save, update, delete and fetch data from the
database. It is like Open Database Connectivity (ODBC) provided by Microsoft.

Downloaded by Indukuri Yeswanth Varma (indukuriyeswanthvarma@gmail.com)

 lOMoAR cPSD| 34421130

The current version of JDBC is 4.3. It is the stable release since 21st September,
2017. It is based on the X/Open SQL Call Level Interface. The java.sql package
contains classes and interfaces for JDBC API. A list of popular interfaces of JDBC
API are given below:

▪ Driver interface
▪ Connection interface
▪ Statement interface
▪ PreparedStatement interface
▪ CallableStatement interface
▪ ResultSet interface
▪ ResultSetMetaData interface
▪ DatabaseMetaData interface
▪ RowSet interface
▪ AD

A list of popular classes of JDBC API are given below:

▪ DriverManager class
▪ Blob class
▪ Clob class
▪ Types class

Why Should We Use JDBC

▪ Before JDBC, ODBC API was the database API to connect and execute the query
with the database. But, ODBC API uses ODBC driver which is written in C
language (i.e. platform dependent and unsecured). That is why Java has defined its
own API (JDBC API) that uses JDBC drivers (written in Java language).
▪ We can use JDBC API to handle database using Java program and can perform the
following activities:
▪ Connect to the database

Downloaded by Indukuri Yeswanth Varma (indukuriyeswanthvarma@gmail.com)

 lOMoAR cPSD| 34421130

▪ Execute queries and update statements to the database

▪ Retrieve the result received from the database.

HTML
▪ HTML is an acronym which stands for Hyper Text Markup Language which is used
for creating web pages and web applications. Let's see what is meant by Hypertext
Markup Language, and Web page.
▪ Hyper Text: HyperText simply means "Text within Text." A text has a link within it, is a
hypertext. Whenever you click on a link which brings you to a new webpage, you have
clicked on a hypertext. HyperText is a way to link two or more web pages (HTML
documents) with each other.
▪ Markup language: A markup language is a computer language that is used to apply
layout and formatting conventions to a text document. Markup language makes text more
interactive and dynamic. It can turn text into images, tables, links, etc.
▪ Web Page: A web page is a document which is commonly written in HTML and
translated by a web browser. A web page can be identified by entering an URL. A Web
page can be of the static or dynamic type. With the help of HTML only, we can create
static web pages.
▪ Hence, HTML is a markup language which is used for creating attractive web pages with
the help of styling, and which looks in a nice format on a web browser. An HTML
document is made of many HTML tags and each HTML tag contains different content .

Java script
▪ JavaScript (js) is a light-weight object-oriented programming language which is used by
several websites for scripting the webpages. It is an interpreted, full-fledged programming
language that enables dynamic interactivity on websites when applied to an HTML
document. It was introduced in the year 1995 for adding programs to the webpages in the
Netscape Navigator browser. Since then, it has been adopted by all other graphical web
browsers. With JavaScript, users can build modern web applications to interact directly
without reloading the page every time. The traditional website uses js to provide several
forms of interactivity and simplicity.
▪ Although, JavaScript has no connectivity with Java programming language. The name
was suggested and provided in the times when Java was gaining popularity in the market.
In addition to web browsers, databases such as CouchDB and MongoDB uses JavaScript
as their scripting and query language.

Application of JavaScript
▪ JavaScript is used to create interactive websites. It is mainly used for:
▪ Client-side validation,
▪ Dynamic drop-down menus,
▪ Displaying date and time,
Downloaded by Indukuri Yeswanth Varma (indukuriyeswanthvarma@gmail.com)
 lOMoAR cPSD| 34421130

▪ Displaying pop-up windows and dialog boxes (like an alert dialog box, confirm dialog
box and prompt dialog box),
▪ Displaying clocks etc.
▪ JavaScript is used to create interactive websites. It is mainly used for:
▪ Client-side validation,
▪ Dynamic drop-down menus,
▪ Displaying date and time,
▪ Displaying pop-up windows and dialog boxes (like an alert dialog box, confirm dialog
box and prompt dialog box),
▪ Displaying clocks etc.

Ajax Tutorial
▪ AJAX tutorial covers concepts and examples of AJAX technology for beginners and professionals.
▪ AJAX is an acronym for Asynchronous JavaScript and XML. It is a group of inter-related
technologies like JavaScript, DOM, XML, HTML/XHTML, CSS, XMLHttpRequest etc.
▪ AJAX allows you to send and receive data asynchronously without reloading the web page. So it is fast.
▪ AJAX allows you to send only important information to the server not the entire page. So only valuable
data from the client side is routed to the server side. It makes your application interactive and faster.
▪ here are too many web applications running on the web that are using ajax technology
like gmail, facebook,twitter, google map, youtube etc.

How AJAX Works?

▪ AJAX communicates with the server using XMLHttpRequest object. Let's try to understand the flow of
ajax or how ajax works by the image displayed below.

Downloaded by Indukuri Yeswanth Varma (indukuriyeswanthvarma@gmail.com)

 lOMoAR cPSD| 34421130

▪ As you can see in the above example, XMLHttpRequest object plays a important role.
▪ User sends a request from the UI and a javascript call goes to XMLHttpRequest object.
▪ HTTP Request is sent to the server by XMLHttpRequest object.
▪ Server interacts with the database using JSP, PHP, Servlet, ASP.net etc.
▪ Data is retrieved.
▪ Server sends XML data or JSON data to the XMLHttpRequest callback function.
▪ HTML and CSS data is displayed on the browser.

Servlets
▪ Servlet technology is used to create a web application (resides at server side and
generates a dynamic web page).
▪ Servlet technology is robust and scalable because of java language. Before Servlet, CGI
(Common Gateway Interface) scripting language was common as a server-side
programming language. However, there were many disadvantages to this technology. We
have discussed these disadvantages below.
▪ There are many interfaces and classes in the Servlet API such as Servlet, GenericServlet,
HttpServlet, ServletRequest, ServletResponse, etc.

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

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

▪ Servlet is an API that provides many interfaces and classes including documentation.
▪ Servlet is an interface that must be implemented for creating any Servlet.

Downloaded by Indukuri Yeswanth Varma (indukuriyeswanthvarma@gmail.com)

 lOMoAR cPSD| 34421130

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

Hibernate
▪ Hibernate is a Java framework that simplifies the development of Java application to
interact with the database. It is an open source, lightweight, ORM (Object Relational
Mapping) tool. Hibernate implements the specifications of JPA (Java Persistence API) for
data persistence.

ORM Tool

▪ An ORM tool simplifies the data creation, data manipulation and data access. It is a
programming technique that maps the object to the data stored in the database.

▪
▪ The ORM tool internally uses the JDBC API to interact with the database.

What is JPA?

Downloaded by Indukuri Yeswanth Varma (indukuriyeswanthvarma@gmail.com)

 lOMoAR cPSD| 34421130

▪ Java Persistence API (JPA) is a Java specification that provides certain functionality and
standard to ORM tools. The javax.persistence package contains the JPA classes and
interfaces.

Advantages of Hibernate Framework

▪ Following are the advantages of hibernate framework:

Open Source and Lightweight

▪ Hibernate framework is open source under the LGPL license and lightweight.

Fast Performance

▪ The performance of hibernate framework is fast because cache is internally used in

hibernate framework. There are two types of cache in hibernate framework first level
cache and second level cache. First level cache is enabled by default.

Database Independent Query

▪ HQL (Hibernate Query Language) is the object-oriented version of SQL. It generates the
database independent queries. So you don't need to write database specific queries. Before
Hibernate, if database is changed for the project, we need to change the SQL query as
well that leads to the maintenance problem.

Automatic Table Creation

▪ Hibernate framework provides the facility to create the tables of the database
automatically. So there is no need to create tables in the database manually.

Simplifies Complex Join

▪ Fetching data from multiple tables is easy in hibernate framework.

Provides Query Statistics and Database Status

▪ Hibernate supports Query cache and provide statistics about query and database status.

Spring Boot
▪ Spring Boot Tutorial provides basic and advanced concepts of Spring Framework. Our
Spring Boot Tutorial is designed for beginners and professionals both.
▪ Spring Boot is a Spring module that provides the RAD (Rapid Application Development)
feature to the Spring framework.
▪ Our Spring Boot Tutorial includes all topics of Spring Boot such, as features, project,
maven project, starter project wizard, Spring Initializr, CLI, applications, annotations,
dependency management, properties, starters, Actuator, JPA, JDBC, etc.

Downloaded by Indukuri Yeswanth Varma (indukuriyeswanthvarma@gmail.com)

 lOMoAR cPSD| 34421130

▪ Spring Boot is a project that is built on the top of the Spring Framework. It provides an
easier and faster way to set up, configure, and run both simple and web-based
applications.
▪ It is a Spring module that provides the RAD (Rapid Application Development) feature
to the Spring Framework. It is used to create a stand-alone Spring-based application that
you can just run because it needs minimal Spring configuration.

▪
▪ In short, Spring Boot is the combination of Spring Framework and Embedded Servers.
▪ In Spring Boot, there is no requirement for XML configuration (deployment descriptor). It
uses convention over configuration software design paradigm that means it decreases the
effort of the developer.
▪ We can use Spring STS IDE or Spring Initializr to develop Spring Boot Java
applications.
▪ Why should we use Spring Boot Framework?
▪ We should use Spring Boot Framework because:
▪ The dependency injection approach is used in Spring Boot.
▪ It contains powerful database transaction management capabilities.
▪ It simplifies integration with other Java frameworks like JPA/Hibernate ORM, Struts, etc.
▪ It reduces the cost and development time of the application.
▪ Along with the Spring Boot Framework, many other Spring sister projects help to build
applications addressing modern business needs. There are the following Spring sister
projects are as follows:
▪ Spring Data: It simplifies data access from the relational and NoSQL databases.
▪ Spring Batch: It provides powerful batch processing.
▪ Spring Security: It is a security framework that provides robust security to applications.
▪ Spring Social: It supports integration with social networking like LinkedIn.
▪ Spring Integration: It is an implementation of Enterprise Integration Patterns. It
facilitates integration with other enterprise applications using lightweight messaging and
declarative adapters.

Conclusion
In conclusion, a Java Full Stack Developer requires a diverse range of technical and soft
skills to develop and maintain web-based applications. They need to be proficient in both
front-end and back-end development, understand security protocols, testing and
debugging methodologies, design patterns, cloud technologies, and be customer-focused.
Downloaded by Indukuri Yeswanth Varma (indukuriyeswanthvarma@gmail.com)