AYESHa Seminar

Visvesvaraya Technological University
Belagavi, Karnataka
An Internship Report
On
“Professional Practice of Java, SQL, Hibernate and Springs”
An internship report Submitted to the Department of Electrical & Electronics Engineering of

Visvesvaraya Technological University in partial fulfilment for the award of the Degree of
Bachelor of Engineering.
Submitted by:
GOUSIA BEE 3BR20EE022

Under the Guidance of:
Mrs. Arathi P B B. E, M.Tech
Assistant professor,
BITM, Ballari.
Mr. Gagana V
Trainer, QSpiders
Bengaluru.
DEPARTMENT OF ELECTRICAL & ELECTRONICS ENGINEERING
BALLARI INSTITUTE OF TECHNOLOGY AND MANAGEMENT

(Recognized by Govt. of Karnataka, approved by AICTE, New Delhi & Affiliated to
Visvesvaraya Technological University, Belagavi)
“JnanaGangotri” Campus, No.873/2, Ballari-Hosapete Road, Allipur,
Ballari-583104, Karnataka, India
2023-2024
Basavarajeswari Group of Institutions
BALLARI INSTITUTE OF TECHNOLOGY AND MANAGEMENT

(Recognized by Govt. of Karnataka, approved by AICTE, New Delhi & Affiliated to
Visvesvaraya Technological University, Belagavi)
“JnanaGangotri” Campus, No.873/2, Ballari-Hosapete Road, Allipur, Ballari-583104,
Karnataka, India
DEPARTMENT OF ELECTRICAL & ELECTRONICS ENGINEERING
CERTIFICATE
This is to certify that the Internship entitled “Professional Practice of Java, SQL, Hibernate
and Springs” has been successfully completed by GOUSIA BEE bearing USN:
3BR20EE022, a student of VIII semester, for the partial fulfilment of the requirements for the
Bachelor Degree in Electrical & Electronics Engineering of the Visvesvaraya Technological
University, Belagavi during the academic year 2023-2024.
Signature of the Internship Guide Signature of the HOD
Prof. Arathi P B B.E., M. Tech Dr. Sharanareddy M. Tech, Ph. D
Signature of the Principal
Dr. Yadavalli Basavaraj M. Tech, Ph. D
External Viva
Name of the Examiners Signature and Date
1).......................................... ........................................
2).......................................... ........................................
DECLARATION
This is to declare that Internship entitled “Professional Practice of Java, SQL,

Hibernate and Springs” is a part of work/Internship Training carried out by meat “J/Q
Spiders Testing Training Institute (Bengaluru)” in partial fulfillment of the
requirements for the award of the degree, Bachelor of Engineering in Electrical &
Electronics Engineering of the Visvesvaraya Technological University, Belagavi. Under
the Guidance of Prof. Arathi P B.
Signature of Student
Date: GOUSIA BEE
Place: Ballari 3BR20EE022
ACKNOWLEDGEMENT
The satisfaction that I feel at the successful completion of Internship on “Professional Practice
of Java, SQL, Hibernate and Springs” it would be incomplete if I did not mention the names
of people, whose noble gesture, affection, guidance, encouragement, and support crowned my
efforts with success.
I express my deep sense of gratitude to the Management of BITM, Ballari, for providing me
the congenial environment in the college for successful completion of my internship.
I am extremely grateful to respective Guide Prof. Arathi P B B.E., M. Tech and coordinator Prof.
Farzana Begum K B.E., M. Tech and Prof. Arathi P B B.E., M. Tech. for their noble gesture,support,
co-ordination, and valuable suggestions given to me in completing the Internship. I also thank
Dr. Sharanareddy M. Tech, Ph.D., H.O.D. Dept. of EEE, Dr. Yadavalli Basavaraj M. Tech, Ph.D.,
Principal, BITM and Management of BITM for extending their support and encouragement in
completion of my internship.
I extended sincere thanks to all the teaching and non-teaching staff members of, Electrical and
Electronics Engineering Department of B I T M, Ballari for constant support and help during
the internship seminar.
My heartful thanks to our parents, family members and friends whose patience and kind
cooperation at all the stages enable us to complete this internship seminar successfully.
GOUSIA BEE
3BR20EE022
Table of Contents
Sl. No Title Page No.
Cover Page I
Inner Cover Page II
College Certificate III
Certificate IV
Declaration by the Student V
Acknowledgement VI
Executive Summary VII
Table of Contents VIII
Chapter 1 Company Profile 1
1.1 Company Caption 1
1.2 Company Logo 1
1.3 Company Name 1
1.4 Address 1
1.5 Phone number and fax number 1
1.6 Website URL 1
1.7 Email address 1
1.8 Company Headquarters 1
1.9 Competitive performance 1
1.10 Major organization Milestones 2
Chapter 2 About The Company 3
2.1 History of the Organization 3
2.2 Organization Structure, Products, Services Offered by the 3
Company
2.3 Number of Employees in the Organization 4
2.4 Employees Structure of the Organization 4
2.5 Financial Details 4
2.5 Process Adopted 4
2.7 Introduction about the Department 4
2.8 Roles and Responsibilities of Individuals in the Department 5
2.9 Number of systems and Their specifications 5
2.10 organization structure of the Department 5
2.11 My Role in the Company 6
Chapter 3 Tasks Performed 7
3.1 Introduction about the Concepts 7
3.1.1 Java 7-12
3.1.2 SQL 13-18
3.1.3 Hibernate 18-21
3.1.4 Spring 21-29
3.2 Assessments Solved 30
3.2.1 Java Example 30
3.2.2 SQL Example 31
Chapter 4 Reflection (Specific Outcomes) 32
4.1 Experience in the Organization 32
4.2 Technical Outcomes of the Project 32
4.3 Non- Technical Outcomes of the Project 32
4.3.1 Verbal and Writing Communication 32
4.3.2 Oral Communication Skills 33
4.3.3 Time Management 33
4.3.4 Personality development 33
4.3.5 Resource Utilization Skills 34
Conclusion 35
References 36
List Of Figures
Figure No Figure Name Page No
2.1 Employee Structure of the Organization 4
2.2 Organization Structure of the Department 5
Professional Practice Of JAVA, SQL, Hibernate, Springs 2022-23
CHAPTER 1
COMPANY PROFILE
1.1 Company Caption
“QSpiders is a place where businesses find talent and dreams take flight.”
1.2 Company Logo
1.3 Company Name “QSpiders”
1.4 Address
No.01, 3rd cross Basappa Layout, Gavi Puram Extn, Kempe Gowda Nagar,
Bengaluru, Karnataka 560019.
1.5 Phone number

+91-9845687781
1.6 Website URL

http://www.qspiders.com
1.7 Email Address

onlineenq@qspiders.com
1.8 Headquarters
Bangalore, Karnataka
1.9 Competitive Performance
Ranked 2nd among 126 competitors
Dept of EEE, BITM, Ballari. Page 1

1.10 Major Organization Milestones

➢ Established in 2003.
➢ Led by Industry Experts.
➢ Global Presence in 4 Countries.
➢ Spread Across 21 Centers in India.
➢ Presence in 8 States.
➢ Training Centers are in 9 major Cities in India.
➢ Placement activities of the students
➢ Industrial level internship opportunities

CHAPTER 2
ABOUT THE COMPANY
2.1 History of the Organization
QSpiders is a best-in-class learning solutions organization headquartered in
India’s IT capital, Bangalore. It offers a wide range of courses in the area of software testing and
are official partners of the ISTQB®. A “finishing school” in many ways, the institute provides
young job aspirants the perfect launch-pad to build a rewarding career in the growing IT sector.
From its humble beginnings, QSpiders has exponentially grown to be the world’s largest software
testing training organization spread across countries. At QSpiders, we ensure training is imparted
by specialists with proven subject matter expertise and who have spent over a decade intheir area
of specialization. Our faculty are highly competent, skilled and dedicated to giving their best
towards the professional development of our students. Besides training, QSpiders also provide
placement assistance to their students and most of the big corporates in the corporate world hire
our trained talent. It is indeed their pleasure to have placed over thousands of job- seekers in various
IT firms across India over the years with an aim to place thousands more! Building competency
into over 5000 students a month, QSpiders is where talent meets opportunity and it believe search
for the dream job or the dream professional ends here.
2.2 Organization Structure, Products, Services offered by the Company

2.2.1 Organization Structure
QSpiders has 21 centers across India, along with this, there are 4 different unitsworking
parallel - altogether the total space used is 2,81,500Sqrft.
2.3 Products and Services
➢ Specialized in Software testing & Automation Tools Training.
➢ Specialized in Software Development Training.
➢ Services offered are:
▪ Graduate Internships.
▪ Incubation – CSR Activity.
▪ Campus Recruitment Training.
▪ Corporate Training.

▪ Post Graduate Internship.

▪ Project Guidance.
▪ Placements.
2.4 Number of Employees in the Organization

Altogether QSpiders has 470 Employees & 112 Trainers in their Organization.
2.5 Employee Structure of the Organization
Founder & Managing Director
Vice President
Operations Head
Branch Heads
Counsellors & HR’s
Fig 2.1 Employee Structure of the Organization.
2.6 Financial Details-Operational cost of the organization

50 Crores Overall Turnover.
2.7 Process Adopted
Agile Methodology.
2.8 Introduction about the Department
• Train on Mobile Application Technologies.
• Train on QA Technologies.
• Train on Full Stack Development.

• Guidance on Internship & Project Implementation.

2.9 Roles and Responsibilities of Individuals in the Department
• Mentoring the team.
• Preparing Syllabus.
• Solving intern’s Technical Problem.
• Nurturing them in building code.
2.10 Number of Systems and Their Specifications

o DESKTOP: 20 Dell Desktops.
Specifications:
a. LED Monitor 15 inches wide Screen.
b. Dell CPU.
c. Intel i3 core processor
d. 8GB RAM & 1TB HDD.
o INTERNET ACCESS: LAN Connection.
2.11 Organization Structure of the Department
Manager
Lead
Sr. Member
Associates
Fig 2.2 Organization Structure of the Department.

2.12 My Role in the company
The roles and responsibilities assigned to me during the internship are:
1. The first task that must be performed by an application developer is to collect the
requirements.
2. The intern must be able to understand and visualize the requirements collected in order to
frame the objectives required for developing the application.
3. Further the intern must identify the tools that are required for the development.
4. Develop a plan in order to carry out the tasks assigned to them on a step-by-step basis.
5. Break down the program specifications into simplest elements and translate the logic into
a programming language.
6. Combine all the logics of the program design by integrating the logics.
7. Debugging the program and minimize the errors present in the logic.
8. Perform testing to check whether that the output works as intended.
9. Generate a report by writing a detailed documentation for the operation of the program.

CHAPTER 3
TASKS PERFORMED
3.1 INTRODUCTION ABOUT THE CONCEPTS:

3.1.1 JAVA:
In 1995, Java, which originally went by the name Oak and then Green, was created by a
team led by James Gosling for Sun Microsystems, a company now owned by Oracle. Java was
originally designed for use on digital mobile devices, such as cell phones. However, when Java
1.0 was released to the public in 1996, its main focus had shifted to use on the internet, providing
interactivity with users by giving developers a way to produce animated web pages.
Java is a high-level object-oriented programming language developed by Sun Microsystems. It
came into existence as a part of web application, web services and a platform independent
programming language in 1990s.
a) Features of JAVA:
1. Simple: We wanted to build a system that could be programmed easily without a lot of
esoteric training and which leveraged today’s standard practice.
2. Object Oriented: Simply stated, object-oriented design is a technique for programming
that focuses on the data (objects) and on the interfaces to that object.
3. Robust: Java is intended for writing programs that must be reliable in a variety ofways.
The single biggest difference between Java and C/C++ is that java has a pointer model that
eliminates the possibility of overwriting memory and corrupting data.
4. Secure: Java is intended to be used in networked/distributed environments. Toward that
end, a lot of emphasis has been placed on security. Java enables the construction of virus-
free, tamper-free systems.
5. Portable: Unlike C and C++, there are no “implementation-dependent” aspects ofthe
specification. The sizes of the primitive data types are specified, as is the behavior
of arithmetic on them.

6. Interpreted: The Java interpreter can execute Java byte codes directly on any
machine to which the interpreter has been ported.
7. High Performance: While the performance of interpreted byte codes is usuallymore
than Adequate, there are situations where higher performer is required.
8. Multithreaded: The benefits of multithreading are better interactive responsiveness and
real-time behavior.
9. Dynamic: In a number of ways, Java is a more dynamic language than C or C++.It was
designed to adapt to an evolving environment.
b) Object-Oriented Programming Concepts:

The Java language is object oriented. This section is an introduction to OOPlanguage
concepts, using structured programming as a point of contrast.
i) CLASS: A class is the template or blueprint from which objects are made. Thinking about classes
as cookie cutters. Objects are the cookies themselves. When you construct an object from a class,
you are said to have created an instance of the class.
• General form of a class: A class is declared by use of the class keyword. The general form
of a class definition is shown as:
Class class_name{
type instance-variable1;type
instance-variable2;
type method-name(parameter-list)
{
//body of method

ii) OBJECTS: Objects are the basic run time entity or in other words object is an instance of a class.
Each object made from a class can have its values for the instance variables of that class.
• Syntax for the Object: class_nameobject_name= newclass_name();
Example: Class Dog{
int size;
String breed;
String name;void
bark(){
System.out.println(“Ruff! Ruff!”);
}
Class DogTestDrive{
Public static void main (String[] args){Dog
d=new Dog();
d.size=40;
d.bark();
}
}
iii) METHODS:
A class has one or more methods. Methods must be declared inside the class. Within
the curly braces of a method, write the instructions for how that method should be
performed. Method code is basically a set of statements, and you can think of a method
kind of like a function or procedure.
public class class_name{
returntypemethod_name(){
//statements;
}
}

iv) INHERITANCE:
● When one class inherits from another, it is called Inheritance.
● The class which is inherited is called superclass and the class which inherits iscalled
subclass.
Example: Public class Doctor{ Boolean
worksAtHospital;void
treatPatient( ) {
//Perform a checkup
}
}
Public class FamilyDoctor extends Doctor{
Boolean makesHouseCalls;
voidgiveAdvice( ) {
//give homespun advice
}
}
Public class Surgeon extends Doctor{void
treatPatient( ) {
//perform surgery
}
void makeIncision( ) {
//make incision(yikes!)
}
}
v) ABSTRACTION:
The process of abstraction in Java is used to hide certain details and only show the
essential features of the object. Through the process of abstraction, a programmer hides
all but the relevant data about an object in order to reduce complexity and increase
efficiency.

• An abstract class has no use, no value, and no purpose in life unless it is

extended.
• An abstract class means that nobody can ever make a new instance of that class.
Syntax: abstract public class canine extends Animal{
Public void roam( ){ }
}
vi) ENCAPSULATION
Encapsulation is the concept of hiding the implementation details of a class and

allowing access to the class through a public interface. For this, we need to declare the instance
variables of the class as private or protected. The client code should access only the public
methods rather than accessing the data directly.
For Example: public class Employee {

private float salary; public
float getSalary(){
return salary;
}
public void setSalary(float salary){
this.salary = salary;
}
}
vii) CONSTRUCTORS
A class contains constructors that are invoked to create objects from the class blueprint.
Constructor declarations look like method declarations-except that they use the name of the
class and have no return type.
For Example: Bicycle has one constructor:
Public Bicycle (intstartCadence, intstartSpeed, intstartGear) {gear =
startGear;
cadence = startCadence;
speed = startSpeed;
}

To create a new Bicycle object called myBike, a constructor is called by the newoperator:
Bicycle myBike = new Bicycle(30, 0, 8);
viii) THIS KEYWORD

● When we declare the name of instance variable and local variables same, This
keyword helps us to avoid name conflicts.
● In the example, this.length and this.breadth refers to the instance variable length and
breadth while length and breadth refers to the arguments passed in themethod.
Example: class Rectangle{
intlength,breadth;
void show(intlength,int breadth){
this.length=length;
this.breadth=breadth;
}
Intcalculate(){
return(length*breadth);
}
}
public classUseOfThisOperator{
public static void main(String[] args){
Rectangle rectangle = newRectangle();rectangle.show(5,6);
int area = rectangle.calculate();
System.out.println(“The area of a Rectangle is : “+ area);
}
}
Output:C:\java>java UseOfThisOperatorThe
area of a Rectangle is: 30

3.1.2 STRUCTURED QUERY LANGUAGE (SQL):

SQL is the only language which is used to interact with the relational database system.
SQL was developed by IVM. Previously SQL was also called as SEQL (Simple/StructuredEnglish
Query Language). SQL helps us to maintain data consistency and integrity i.e., helps us to maintain
correctness of data.
Data integrity and consistency is maintained with the help of:
1. Data types.
2. Constraints.
1. DATATYPES:
These include character (n), varchar (n), number (n), date (dd-mm-yy), Boolean,BLOB
(Binary Large Object), CLOB, Integer (n), Float (p,s), Number(n,s).
2. CONSTRAINTS
a) Unique: Unique constraints helps us to eliminate duplicate values from a columni.e., storage of
duplicate values is not allowed.
Examples: phone number, aadhar card number, USN, PAN card number etc.
b) Not Null: A not Null constraint when applied on the column does not allow nullstorage.
c) Check: Check constraint is used to apply some additional business scenarios.
d) Default: Default constraint is used to declare a default value to a column if a value is not specified.
By default, in SQL, the default value for all the columns is NULL.
e) Primary Key: Primary key is used to uniquely identify a record from the table. The column which
is made as primary key is both unique as well as “NOTNULL”. The column which is unique
as well as not null is eligible to become primary key.
f) Foreign key: Foreign key is used to create a relationship across multiple tables. Foreign key
is also called ass referral integrity constraint. A foreign key is also called as “REFERAL
INTEGRITY CONSTRAINT”.

3.1.2.1 SUB LANGUAGES OF SQL

There are five sub languages in SQL. They are as follows:
1. Data Query Language.
2. Data Manipulation Language.
3. Transaction Control Language.
4. Data Definition Language.
5. Data Control Language.
1. DATA QUERY LANGUAGE (DQL):

DQL is used to fetch the records from the database based on certain requirements.
The records are fetched using “SELECT” statements. “SELECT” statement is capable of
performing three tasks:
a) Projection: This means selecting columns from the table.
b) Selection: This is used to select rows from the table.
c) Joins: This is used to select rows and columns from multiple tables and displaying itas
one single table.
a) PROJECTION:
Selecting columns from the table is called projection.
Syntax: select */Distinct [column list]/express as [Alias] from tablename;
Examples:
• Display all the employee names along with their salary and thedepartment
numbers.
SELECT ename, sal, deptno FROM emp;
b) SELECTION:
Here we limit the number of rows in the table.
Syntax: SELECT * / {Distinct [column] / Expression (Alias)}
FROM tablename WHERE condition (?);
“WHERE” clause restricts the number of records in the table and returns the records only for
the specified condition. “WHERE” clause checks condition for each and every record once.
Example: SELECT * FROM emp WHERE deptno=10;

c) JOINS:
Join is one of the capabilities of SELECT clause. It is used to display rows and columns
from different tables. According to joins, there are two types:
a) Inner join.
b) Outer join.
INNER JOIN OUTER JOIN
Joint condition which returns Joint condition which returns both

only the matching records ofthe matching and un-matching records of
table is known as “InnerJoin”. the table based on join condition is
known as “Outer Join”.
2. DATA MANIPULATION LANGUAGE:

DML involves three types of SQL commands. They are:
a) Insert.
b) Update.
c) Delete.
a) Insert: This command is used to insert the values into the existing table. When we try
to insert the values into a table that does not exist, then we get an error as “TABLE OR
VIEW DOES NOT EXISTS”.
Syntax: INSERT INTO tablename (column1, column2 …) VALUES (value1,
value2…);
Example: INSERT INTO emp (empno, ename, job, sal) VALUES (1234, ‘Arnav’,
‘artist’, 20000);
b) Update: This command is used to update one record, multiple records or all records of
the table. Without “WHERE” clause, the expression in the “SET” clause is appliedto
all the columns of the table i.e., all the columns are updated.
Syntax: UPDATE tablename SET expression WHERE condition;
Example: UPDATE emp SET sal=50000 WHERE empno=1234;

c) Delete: This command is used to delete one record, multiple records or all records from
the table.
Syntax: DELETE FROM tablename WHERE condition;
Example: DELETE FROM emp WHERE empno=1234;
3. TRANSACTION CONTROL STATEMENTS:

There are three transaction control statements that are used in SQL. They are:
a) Commit.
b) Roll back.
c) Save point.
a) Commit: Commit statement is used to make the changes made by the transactions
(SQL statements) permanent.
b) Roll Back: Roll back is used to reverse the changes made by the transactions up to
previous commit point or specified save point.
c) Save point: Save point helps us to create temporary intermediate points to which we
can roll back.
4. DATA DEFINATION LANGUAGE:

The concept of the data definition language used to refer to a subset of Structured
Query Language (SQL) for declaring tables, columns, data types and constraints.
This includes the following statements (or commands):
a) CREATE statement:
A commonly used CREATE command is the CREATE TABLE command. The
typical usage is:
Syntax: CREATE TABLE [table name] ([column definitions]) [table parameters];
The column definitions are:

• A comma-separated list consisting of any of the following

• Column definition: [column name] [data type] {NULL | NOT
NULL} {column options}
• Primary Key definition: PRIMARY KEY ( [comma separated column list] )
• Constraints: {CONSTRAINT} [constraint definition]
Example: CREATE TABLE products
(P_id number (4) primary key, man_date date NOT NULL,
Price number (5) NOT NULL, p_name varchar2 (10));
b) DROP statement:
The DROP statement destroys an existing database, table, index, or view.
A DROP statement in SQL removes a component from a relational database
management system(RDBMS).
Syntax: DROP TABLE tablename;
A table to be dropped should not have any primary key which are used as references
by the other table.
c) ALTER statement:
The ALTER statement modifies an existing database object.
• ALTER statement to add a column:
Syntax: ALTER TABLE tablename
ADD column_name datatype constraint;
Example: ALTER TABLE emp ADD phone number (10) unique;
• ALTER statement to drop a column:
Syntax: ALTER TABLE tablename DROP column column_name;
Example: ALTER TABLE emp DROP column phone;
d) TRUNCATE statement:
The TRUNCATE statement is used to delete all data from a table. It's much faster
than DELETE.
Syntax: TRUNCATE TABLE tablename;
When we use TRUNCATE statement, only the data is deleted permanently but it does
not delete the structure i.e., it retains the structure.

5. DATA CONTROL LANGUAGE:

A data control language (DCL) is syntax similar to a computer programming language used
to control access to data stored in a database (Authorization). Examples of DCL commands
include:
a) GRANT to allow specified users to perform specified tasks.
b) REVOKE to cancel previously granted or denied permissions.
3.1.3 HIBERNATE
Hibernate (Framework):
Hibernate ORM (or simply Hibernate) is an object–relational mapping tool for the Java
programming language. It provides a framework for mapping an object-oriented domain model
to a relational database. Hibernate handles object–relational impedance mismatch problems by
replacing direct, persistent database accesses with high-level object handling functions.
Hibernate is free software that is distributed under the GNU Lesser General Public License 2.1.
Hibernates primary feature is mapping from Java classes to database tables, and mapping from
Java data types to SQL data types. Hibernate also provides data query and retrieval facilities. It
generates SQL calls and relieves the developer from the manual handling and object conversion
of the result set.
Mapping
The mapping of Java classes to database tables is implemented by the configuration of an XML
file or by using Java Annotations. When using an XML file, hibernate can generate skeleton
source code for the persistence classes. This is auxiliary when annotations are used. Hibernate
can use the XML file or the Java annotations to maintain the database schema.
There are provided facilities to arrange one-to-many and many-to-many relationships between
classes. In addition to managing associations between objects, hibernate can also manage
reflexive associations wherein an object has a one-to-many relationship with other instances of
the class type. Hibernate supports the mapping of custom value types. This makes the following
scenarios possible:
Overriding the default SQL type when mapping a column to a property. Mapping Java Enums
to columns as though they were regular properties. Mapping a single property to multiple
columns. Objects in an object-oriented application follow OOP principles, while objects in the
back end follow database normalization principles, resulting in different representation

requirements. This problem is called "object–relational impedance mismatch". Mapping is a

way of resolving the object–relational impedance mismatch problem. Mapping informs the
ORM tool of what Java class object to store in which database table.
Hibernate Query Language (HQL)
Hibernate provides a SQL inspired language called Hibernate Query Language (HQL) for
writing SQL-like queries against Hibernate's data objects. Criteria Queries are provided as an
object-oriented alternative to HQL. Criteria Query is used to modify the objects and provide the
restriction for the objects. HQL (Hibernate Query Language) is the object-oriented version of
SQL. It generates database independent queries so that there is no need to write database-
specific queries. Without this capability, changing the database would require individual SQL
queries to be changed as well, leading to maintenance issues.
Persistence
Hibernate provides transparent persistence for Plain Old Java Objects (POJOs). The only strict
requirement for a persistent class is a no-argument constructor, though not necessarily public.
Proper behavior in some applications also requires special attention to the equals() and
hashCode() methods in the object classes.[2] Hibernate recommends providing an identifier
attribute, and this is planned to be a mandatory requirement in a future release.
Collections of data objects are typically stored in Java collection classes, such as
implementations of the Set and List interfaces. Java generics, introduced in Java 5, are also
supported. Hibernate can be configured to lazy load associated collections. Lazy loading is the
default as of Hibernate 3.
Related objects can be configured to cascade operations from one object to the other. For
example, a parent Album class object can be configured to cascade its save and delete operations
to its child Track class objects.
Integration
Hibernate can be used both in standalone Java applications and in Java EE applications using
servlets, EJB session beans, and JBI service components. It can also be included as a feature in
other programming languages. For example, Adobe integrated Hibernate into version 9 of
ColdFusion (which runs on J2EE app servers) with an abstraction layer of new functions and
syntax added into CFML.

Entities and components
In Hibernate jargon, an entity is a stand-alone object in Hibernate's persistent mechanism which

can be manipulated independently of other objects. In contrast, a component is subordinate to
an entity and can be manipulated only with respect to that entity. For example, an Album object
may represent an entity; but the Tracks object associated with the Album objects would
represent a component of the Album entity, if it is assumed that Tracks can only be saved or
retrieved from the database through the Album object. Unlike J2EE, hibernate can switch
databases.
Steps In Hibernate
1. Create the Persistent class.
2. Create the mapping file for Persistent class.
3. Create the Configuration file.
4. Create the class that retrieves or stores the persistent object.
5. Load the jar file.
6. Run the first hibernate application by using command prompt.
Example for Hibernates

package com.javatpoint.mypackage;
public class Employee {

private int id;
private String firstName,lastName;
public int getId() {

return id;
}
public void setId(int id) {
this.id = id;
}
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}

public String getLastName() {

return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
3.1.4 SPRING
Spring Framework
The Spring Framework is an application framework and inversion of control container for the
Java platform. The framework's core features can be used by any Java application, but there are
extensions for building web applications on top of the Java EE (Enterprise Edition) platform.
Although the framework does not impose any specific programming model, it has become
popular in the Java community as an addition to the Enterprise JavaBeans (EJB) model. The
Spring Framework is open source.
The first version was written by Rod Johnson, who released the framework with the publication
of his book Expert One-on-One J2EE Design and Development in October 2002. The
framework was first released under the Apache 2.0 license in June 2003. The first production
release, 1.0, was released in March 2004. The Spring 1.2.6 framework won a Jolt productivity
award and a JAX Innovation Award in 2006. Spring 2.0 was released in October 2006, Spring
2.5 in November 2007, Spring 3.0 in December 2009, Spring 3.1 in December 2011, and Spring
3.2.5 in November 2013. Spring Framework 4.0 was released in December 2013. Notable
improvements in Spring 4.0 included support for Java SE (Standard Edition) 8, Groovy 2, some
aspects of Java EE 7, and WebSocket. Spring Boot 1.0 was released in April 2014.
Spring Framework 4.2.0 was released on 31 July 2015 and was immediately upgraded to version
4.2.1, which was released on 01 Sept 2015. It is "compatible with Java 6, 7 and 8, with a focus
on core refinements and modern web capabilities". Spring Framework 4.3 has been released on
10 June 2016 and will be supported until 2020.[10] It "will be the final generation within the
general Spring 4 system requirements (Java 6+, Servlet 2.5+), [...]" Spring 5 is announced to be
built upon Reactive Streams compatible Reactor Core.

Spring Framework 6.0 has been released on 16 November 2022 and came with a Java 17+
baseline and a move to Jakarta EE 9+ (in the Jakarta namespace), with a focus on the recently
released Jakarta EE 10 APIs such as Servlet 6.0 and JPA 3.1.
Modules
• The Spring Framework includes several modules that provide a range of services:
• Spring Core Container: this is the base module of Spring and provides spring containers (Bean
Factory and Application Context).[13]
• Aspect-oriented programming enables implementing cross-cutting concerns.
• Authentication and authorization: configurable security processes that support a range of
standards, protocols, tools, and practices via the Spring Security sub-project (formerly Acegi
Security System for Spring).
• Convention over configuration: a rapid application development solution for Spring-based
enterprise applications is offered in the Spring Roo module.
• Data access: working with relational database management systems on the Java platform using
Java Database Connectivity (JDBC) and object-relational mapping tools and with NoSQL
databases.
• Inversion of control container: configuration of application components and lifecycle
management of Java objects, done mainly via dependency injection
• Messaging: declarative registration of message listener objects for transparent message-
consumption from message queues via Java Message Service (JMS), improvement of message
sending over standard JMS APIs
• Model–view–controller: an HTTP- and servlet-based framework providing hooks for extension
and customization for web applications and RESTful (representational state transfer) Web
services.
• Remote access framework: declarative remote procedure call (RPC)-style marshalling of Java
objects over networks supporting Java remote method invocation (RMI), CORBA (Common
Object Request Broker Architecture) and HTTP-based protocols including Web services (SOAP
(Simple Object Access Protocol))
• Transaction management: unifies several transaction management APIs and coordinates
transactions for Java objects.

• Remote management: declarative exposure and management of Java objects for local or remote
configuration via Java Management Extensions (JMX)
• Testing: support classes for writing unit tests and integration tests
• Inversion of control container (dependency injection)
• Central to the Spring Framework is its inversion of control (IoC) container, which provides a
consistent means of configuring and managing Java objects using reflection. The container is
responsible for managing object lifecycles of specific objects: creating these objects, calling
their initialization methods, and configuring these objects by wiring them together.
• Objects created by the container are also called managed objects or beans. The container can be
configured by loading XML (Extensible Markup Language) files or detecting specific Java
annotations on configuration classes. These data sources contain the bean definitions that
provide the information required to create the beans.
• Objects can be obtained by means of either dependency lookup or dependency injection.[14]
Dependency lookup is a pattern where a caller asks the container object for an object with a
specific name or of a specific type. Dependency injection is a pattern where the container passes
objects by name to other objects, via either constructors, properties, or factory methods.
• In many cases one need not use the container when using other parts of the Spring Framework,
although using it will likely make an application easier to configure and customize. The Spring
container provides a consistent mechanism to configure applications and integrates with almost
all Java environments, from small-scale applications to large enterprise applications.
• The container can be turned into a partially compliant EJB (Enterprise JavaBeans) 3.0 container
by means of the Pitchfork project. Some[who?] criticize the Spring Framework for not
complying with standards.[15] However, Spring Source doesn't see EJB 3 compliance as a
major goal, and claims that the Spring Framework and the container allow for more powerful
programming models.[16] The programmer does not directly create an object, but describes
how it should be created, by defining it in the Spring configuration file. Similarly, services and
components are not called directly; instead, a Spring configuration file defines which services
and components must be called. This IoC is intended to increase the ease of maintenance and
testing.

Aspect-oriented programming framework
The Spring Framework has its own Aspect-oriented programming (AOP) framework that
modularizes cross-cutting concerns in aspects. The motivation for creating a separate AOP
framework comes from the belief that it should be possible to provide basic AOP features
without too much complexity in either design, implementation, or configuration. The Spring
AOP framework also takes full advantage of the Spring container.
The Spring AOP framework is proxy pattern-based and is configured at run time. This removes
the need for a compilation step or load-time weaving. On the other hand, interception only
allows for public method-execution on existing objects at a join point.
Compared to the AspectJ framework, Spring AOP is less powerful, but also less complicated.
Spring 1.2 includes support to configure AspectJ aspects in the container. Spring 2.0 added more
integration with AspectJ; for example, the pointcut language is reused and can be mixed with
Spring AOP-based aspects. Further, Spring 2.0 added a Spring Aspects library that uses AspectJ
to offer common Spring features such as declarative transaction management and dependency
injection via AspectJ compile-time or load-time weaving. Spring Source also usesAspectJ AOP
in other Spring projects such as Spring Roo and Spring Insight, with Spring Security also
offering an AspectJ-based aspect library.
Spring AOP has been designed to make it able to work with cross-cutting concerns inside the
Spring Framework. Any object which is created and configured by the container can be enriched
using Spring AOP.
The Spring Framework uses Spring AOP internally for transaction management, security,
remote access, and JMX.
Since version 2.0 of the framework, Spring provides two approaches to the AOP configuration:
schema-based approach and

@AspectJ-based annotation style.
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
The Spring team decided not to introduce new AOP-related terminology; therefore, in the
Spring reference documentation and API, terms such as aspect, join point, advice, pointcut,
introduction, target object (advised object), AOP proxy, and weaving all have the same
meanings as in most other AOP frameworks (particularly AspectJ).
Data access framework

Spring's data access framework addresses common difficulties developers face when working
with databases in applications. Support is provided for all popular data access frameworks in
Java: JDBC, iBatis/MyBatis, Hibernate, Java Data Objects (JDO, discontinued since 5.x),
Jakarta Persistence API (JPA), Oracle TopLink, Apache OJB, and Apache Cayenne, among
others.
For all these supported frameworks, Spring provides these features.
o Resource management – automatically acquiring and releasing database resources.

o Exception handling – translating data access related exception to a Spring data access
hierarchy.
o Transaction participation – transparent participation in ongoing transactions
o Resource unwrapping – retrieving database objects from connection pool wrappers.
o Abstraction for binary large object (BLOB) and character large object (CLOB) handling
All these features become available when using template classes provided by Spring for each
supported framework. Critics have said these template classes are intrusive and offer no
advantage over using (for example) the Hibernate API directly. [failed verification] In response,
the Spring developers have made it possible to use the Hibernate and JPA APIs directly. This
however requires transparent transaction management, as application code no longer assumes
the responsibility to obtain and close database resources and does not support exception
translation.

Together with Spring's transaction management, its data access framework offers a flexible
abstraction for working with data access frameworks. The Spring Framework does not offer a
common data access API; instead, the full power of the supported APIs is kept intact. The Spring
Framework is the only framework available in Java that offers managed data access
environments outside of an application server or container.[20]
Transaction management
Spring's transaction management framework brings an abstraction mechanism to the Java
platform. Its abstraction is capable of:
working with local and global transactions (local transaction does not require an application
server)
working with nested transactions
working with save points.
working in almost all environments of the Java platform
In comparison, Java Transaction API (JTA) only supports nested transactions and global
transactions and requires an application server (and in some cases also deployment of
applications in an application server).
The Spring Framework ships a Platform Transaction Manager for several transaction
management strategies:
Transactions managed on a JDBC Connection

Transactions managed on Object-relational mapping Units of Work
Transactions managed via the JTA Transaction Manager and User Transaction
Transactions managed on other resources, like object databases.
Next to this abstraction mechanism the framework also provides two ways of adding transaction
management to applications:
Procedurally, by using Spring's Transaction Template

Declaratively, by using metadata like XML or Java annotations (@Transactional, etc.)
Together with Spring's data access framework – which integrates the transaction management
framework – it is possible to set up a transactional system through configuration without having
to rely on JTA or EJB. The transactional framework also integrates with messaging and caching
engines.
Model–view–controller framework
Spring MVC/Web Reactive presentation given by Jürgen Höller

The Spring Framework features its own model–view–controller (MVC) web application framework,
which was not originally planned.

The Spring developers decided to write their own Web framework as a reaction to what they
perceived as the poor design of the (then) popular Jakarta Struts Web framework,[21] as well
as deficiencies in other available frameworks. In particular, they felt there was insufficient
separation between the presentation and request handling layers, and between the request
handling layer and the model.[22]
Like Struts, Spring MVC is a request-based framework. The framework defines strategy
interfaces for all of the responsibilities that must be handled by a modern request-based
framework. The goal of each interface is to be simple and clear so that it's easy for Spring MVC
users to write their own implementations, if they so choose. MVC paves the way for cleaner
front end code. All interfaces are tightly coupled to the Servlet API. This tight coupling to the
Servlet API is seen by some as a failure on the part of the Spring developers to offer a high-
level abstraction for Web-based applications[citation needed]. However, this coupling makes
sure that the features of the Servlet API remain available to developers while also offering a
high abstraction framework to ease working with it.
The DispatcherServlet class is the front controller[23] of the framework and is responsible for
delegating control to the various interfaces during the execution phases of an HTTP request.
The most important interfaces defined by Spring MVC, and their responsibilities, are listed
below:
• Controller: comes between Model and View to manage incoming requests and redirect
to proper response. Controller will map the http request to corresponding methods. It
acts as a gate that directs the incoming information. It switches between going into
model or view.
• HandlerAdapter: execution of objects that handle incoming requests
• HandlerInterceptor: interception of incoming requests comparable, but not equal to
Servlet filters (use is optional and not controlled by DispatcherServlet).
• HandlerMapping: selecting objects that handle incoming requests (handlers) based on
any attribute or condition internal or external to those requests
• LocaleResolver: resolving and optionally saving of the locale of an individual user
• MultipartResolver: facilitate working with file uploads by wrapping incoming requests
• View: responsible for returning a response to the client. Some requests may go straight
to view without going to the model part; others may go through all three.
• ViewResolver: selecting a View based on a logical name for the view (use is not strictly
required).
Each strategy interface above has an important responsibility in the overall framework. The
abstractions offered by these interfaces are powerful, so to allow for a set of variations in their
implementations, Spring MVC ships with implementations of all these interfaces and together
offers a feature set on top of the Servlet API. However, developers and vendors are free to write
other implementations. Spring MVC uses the Java java.util.Map interface as a data-oriented
abstraction for the Model where keys are expected to be string values.
The ease of testing the implementations of these interfaces seems one important advantage of
the high level of abstraction offered by Spring MVC. DispatcherServlet is tightly coupled to the
Spring inversion of control container for configuring the web layers of applications. However,
web applications can use other parts of the Spring Framework—including the container—and
choose not to use Spring MVC.
A workflow of Spring MVC
When a user clicks a link or submits a form in their web-browser, the request goes to Spring
DispatcherServlet. DispatcherServlet is a front-controller in spring MVC. It consults one or
more handler mappings. DispatcherServlet chooses an appropriate controller and forwards the
request to it. The Controller processes the particular request and generates a result. It is known
as Model. This information needs to be formatted in html or any front-end technology like JSP.
This is the View of an application. All of the information is in the MODEL And VIEW object.
When the controller is not coupled to a particular view, DispatcherServlet finds the actual JSP
with the help of ViewResolver.
Configuration of DispatcherServlet
DispatcherServlet must be configured in web.xml
<servlet>
<servlet-name>MyServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>MyServlet</servlet-name>
<url-pattern>/<url-pattern>
</servlet-mapping>
Spring Boot
Spring Boot Extension is Spring's convention-over-configuration solution for creating stand-
alone, production-grade Spring-based Applications that you can "just run".[24] It is
preconfigured with the Spring team's "opinionated view" of the best configuration and use of
the Spring platform and third-party libraries so you can get started with minimum fuss.
Most Spring Boot applications need very little Spring configuration.

Key Features:
• Create stand-alone Spring applications.

• Embed Tomcat or Jetty directly (no need to deploy WAR files)
• Provide opinionated 'starter' Project Object Models (POMs) to simplify your
Maven/Gradle configuration.
• Automatically configure Spring whenever possible
• Provide production-ready features such as metrics, health checks and externalized
configuration.
• Absolutely no code generation and no requirement for XML configuration.
• Smooth Integration and supports all Enterprise Integration Patterns.
Spring Roo
Spring Roo is a community project which provides an alternative, code-generation based

approach at using convention-over-configuration to rapidly build applications in Java. It
currently supports Spring Framework, Spring Security and Spring Web Flow. Roo differs from
other rapid application development frameworks by focusing on:
• Extensibility (via add-ons)

• Java platform productivity (as opposed to other languages)
• Lock-in avoidance (Roo can be removed within a few minutes from any application)
• Runtime avoidance (with associated deployment advantages)
• Usability (particularly via the shell features and usage patterns)
Batch framework
Spring Batch is a framework for batch processing that provides reusable functions that are
essential in processing large volumes of records, including:
• logging/tracing
• transaction management
• job processing statistics
• job restart

3.2 Assessments Solved

3.2.1 Java Example: -
Statement: Write a Java Program to Find the Average Marks & percentage of a student
import java.util.*;
public class Result {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println(“Enter the number of subjects:”);
int n=sc.nextint();
int sum=0;
Int arr[]=new int[n];
System.out.println(“Enter the scores:”);
for(int i=0;i<n;i++){
arr.append(sc.nextdouble());
}
double sum = 0.0;
for (double num: arr) {
sum += num;
}
System.out.println("The sum is: %.2f", sum);
double percentage = (sum / (n*100))*100;
System.out.println("The percentage is: %.2f", percentage);
}
}
Output: -
Enter the number of subjects:

8
Enter the scores:
67
75
80
84
78
82
79
89
The sum is: 634
The percentage is: 79.25

3.2.2 SQL Example: -
Statement: write a SQL Query to select customers details who belongs to Mexico country
Customer Table:
CustomerId CustomerName ContactName Address City PostalCode Country

1 Alfreds Maria Obre str.57 Berlin 12209 Germany
2 Ana Ana Avda.de la Mexico 05021 Mexico
3 Antonio Moreno Mataderos London 95875 UK
2312
4 Harley Thomas 120 Hanover Mexico 05078 Mexico
sq.
5 Berglunds Christina Berguvage Luela 45321 Sweden
Code:
SELECT *FROM Customers
WHERE Country= ‘Mexico’;
Result:
CustomerId CustomerName ContactName Address City PostalCode Country

2 Ana Ana Avda.de la Mexico 05021 Mexico
4 Harley Thomas 120 Hanover Mexico 05078 Mexico
sq.

CHAPTER 4
REFLECTION NOTES (OUTCOMES)
4.1 EXPERIENCE IN THE ORGANIZATION
This report is about the internship, worked at QSpiders. It was a good time to practice and
to improve the knowledge we had learnt into real environment. The internship report has four
chapters. The first chapter is about the company profile. The second chapter writes about the
company and department in the organization. The third chapter says about the concepts
learned and the last part in this reflection notes is the conclusion of the internship and future
work. The job description and motivation do it.
4.2 TECHNICAL OUTCOMES OF THE PROJECT
Internship position
The internship started from 10th Jan 2020 to 10th Feb 2020. The Concepts learned
namely are “Java, SQL and JDBC”.
Work Experience
The internship was quite satisfactorily in terms of work environment. The team we
have worked with was very friendly and helped a lot in all our problems. New experiences
include teamwork, responsibility and commitments.
4.3 NON-TECHNICAL OUTCOMES OF THE PROJECT

4.3.1 Verbal and writing communication.
Strong verbal communication skills are important for everyone. They are extremely
valuable in both our personal and professional life. When speaking clearly, confidently
and with poise, we are much more likely to commend the respect of others and build
rapport. This is particularly important in business interactions. We have improved a lot
in oral and written communication. The team was very good, co- operative and they gave
valuables ideas and suggestions.

4.3.2 Oral communication
Making a speech or presentation before a large group of people such as manager,

customer or peers is now part of the job. The need is to effectively communication technical
information about our discipline to others.
Ways to develop oral communication skills

• Participate in oral presentation in classes.
• Join the debate team.
• Volunteer to work in on-campus activities that require public speaking.
• Give a speech.
• Chair a meeting or discussion group.
4.3.3 Personality Development
Personality development as in personal growth involves being conscious of one’s

thoughts, feelings, prejudices and judgments and using this personal knowledge to act
with mindfulness and in greater accordance with one’s values and potential. Internship
is a period of intense physical and emotional stress. Most studies have focused on the
negative effects of residency training. Cynicism, anger, depression, and burnout occur
at high rates during residency and may be associated with substance abuse, marital
discord, poor job satisfaction, isolation, and professional reprimand.
4.3.4 Time management
Time management is one of the most important skills one can have in the workplace.
Deadlines are important, and while one might not meet all of them, they teach us valuable
professional lessons that we will carry with us throughout our career.

4.3.5 Resource utilization management

Resource utilization refers to the process of making the most of the resources available
to one in order to achieve the objective that one wants to. Or, on a personal front, one’s
individual project and the utilization of one’s resources for the same could also be called
resource utilization. The internship period has inculcated resource utilization factor by
helping us to utilize all the resources such as time, computing systems, internet connectivity
and many more in the most effective manner.

CONCLUSION
Overall, this internship was a useful experience. I have gained new knowledge and skills. I
achieved several of my learning goals. The things that they thought in our internship were core
Java, SQL, Web Technology and J2EE. At the end of the course, we are able to manage the data
using SQL queries and connect database and java using JDBC. Internship helped us in
overcoming the difficulties faced in the project related to JDBC. Undergoing Internship in
QSpiders was good experience which enhanced our skills and made able to increase our
knowledge in implementing the project.

REFERENCES
[1] hhtps://www.javatpoint.com/dbms-sql-command
[2] https://data-flair.training/blogs/sql-date-functions
[3] https://www.javatpoint.com/java-tutorial
[4] https://www.tutorialspoint.com/hibernate/index.htm
[5] https://www.baeldung.cvom/spring-tutorial

AYESHa Seminar

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

AYESHa Seminar

Uploaded by

Copyright:

Available Formats

Visvesvaraya Technological University

An internship report Submitted to the Department of Electrical & Electronics Engineering of

GOUSIA BEE 3BR20EE022

DEPARTMENT OF ELECTRICAL & ELECTRONICS ENGINEERING

BALLARI INSTITUTE OF TECHNOLOGY AND MANAGEMENT

BALLARI INSTITUTE OF TECHNOLOGY AND MANAGEMENT

DEPARTMENT OF ELECTRICAL & ELECTRONICS ENGINEERING

Signature of the Internship Guide Signature of the HOD

Prof. Arathi P B B.E., M. Tech Dr. Sharanareddy M. Tech, Ph. D

Signature of the Principal

Dr. Yadavalli Basavaraj M. Tech, Ph. D

Name of the Examiners Signature and Date

This is to declare that Internship entitled “Professional Practice of Java, SQL,

1.2 Company Logo

1.3 Company Name “QSpiders”

1.5 Phone number

1.6 Website URL

1.7 Email Address

Dept of EEE, BITM, Ballari. Page 1

1.10 Major Organization Milestones

Dept of EEE, BITM, Ballari. Page 2

2.2 Organization Structure, Products, Services offered by the Company

Dept of EEE, BITM, Ballari. Page 3

▪ Post Graduate Internship.

2.4 Number of Employees in the Organization

2.5 Employee Structure of the Organization

Founder & Managing Director

Counsellors & HR’s

Fig 2.1 Employee Structure of the Organization.

2.6 Financial Details-Operational cost of the organization

2.7 Process Adopted

Dept of EEE, BITM, Ballari. Page 4

• Guidance on Internship & Project Implementation.

2.10 Number of Systems and Their Specifications

Fig 2.2 Organization Structure of the Department.

Dept of EEE, BITM, Ballari. Page 5

2.12 My Role in the company

The roles and responsibilities assigned to me during the internship are:

8. Perform testing to check whether that the output works as intended.

Dept of EEE, BITM, Ballari. Page 6

3.1 INTRODUCTION ABOUT THE CONCEPTS:

Dept of EEE, BITM, Ballari. Page 7

b) Object-Oriented Programming Concepts:

Dept of EEE, BITM, Ballari. Page 8

Dept of EEE, BITM, Ballari. Page 9

Dept of EEE, BITM, Ballari. Page 10

• An abstract class has no use, no value, and no purpose in life unless it is

Encapsulation is the concept of hiding the implementation details of a class and

For Example: public class Employee {

Dept of EEE, BITM, Ballari. Page 11

viii) THIS KEYWORD

Dept of EEE, BITM, Ballari. Page 12

3.1.2 STRUCTURED QUERY LANGUAGE (SQL):

c) Check: Check constraint is used to apply some additional business scenarios.

Dept of EEE, BITM, Ballari. Page 13

3.1.2.1 SUB LANGUAGES OF SQL

1. DATA QUERY LANGUAGE (DQL):

Example: SELECT * FROM emp WHERE deptno=10;

Dept of EEE, BITM, Ballari. Page 14

Joint condition which returns Joint condition which returns both

2. DATA MANIPULATION LANGUAGE:

Dept of EEE, BITM, Ballari. Page 15

3. TRANSACTION CONTROL STATEMENTS: