CHAPTER 1

INTRODUCTION

Student Management System is software which is helpful for students as well as the school
authorities. In the current system all the activities are done manually. It is very time consuming
and costly. Our Student Management System deals with the various activities related to the
students. There are mainly 2 modules in this software

User module

Administrator Module

In the Software we can register as a user and user has of two types, student and administrator.
Administrator has the power to add new user and can edit and delete a user. A student can
register as user and can add edit and delete his profile. The administrator can add edit and delete
details of the students. All the user can see our profile.

BACKGROUND OF PROJECT
School Management System is an application which refers to management systems which are
generally small or medium in size. It is used by managment to manage the data using a
computerized system where he/she can add new user. Student maintenance modules are also
included in this system which would keep track of the student’s detailed description about the
details of student and managment. With this computerized system there will be no loss of record
which generally happens when a non computerized system is used. All these modules are able
to help management to manage the data with more convenience and in a more efficient way as
compared to managment systems which are not computerized...

REQUIREMENTS
Development tools and Programming language : Java is used to write whole code and Spring
boot is used for development and MYSQL is used for database
CHAPTER 2

LANGUAGES AND TOOLS

In these System We used Java Programming language and MYSQL for data base and Spring
boot tool is used foe backend development.

JAVA

Java is a high-level, class-based, object-oriented programming language that is designed

to have as few implementation dependencies as possible. It is a general-purpose
programming language intended to let programmers write once, run anywhere (WORA)

meaning that compiled Java code can run on all platforms that support Java without the need
to recompile

Java applications are typically compiled to bytecode that can run on any Java virtual machine
(JVM) regardless of the underlying computer architecture. The syntax of Java is similar to
C and C++, but has fewer low-level facilities than either of them. The Java runtime provides
dynamic capabilities (such as reflection and runtime code modification) that are typically not
available in traditional compiled languages. As of 2019, Java was one of the most popular
programming languages in use according to GitHub. Particularly for client–server web
applications, with a reported 9 million developers

Java was originally developed by James Gosling at Sun Microsystems and released in May
1995 as a core component of Sun Microsystems' Java platform. The original and reference
implementation Java compilers, virtual machines, and class libraries were originally
released by Sun under proprietary licenses. As of May 2007, in compliance with the
specifications of the Java Community Process, Sun had relicensed most of its Java
technologies under the GPL-2.0-only license. Oracle offers its own HotSpot Java Virtual
Machine, however the official reference implementation is the OpenJDK JVM which is free
open-source software and used by most developers and is the default JVM for almost all Linux
distributions.
As of March 2022, Java 18 is the latest version, while Java 17, 11 and 8 are the current long-
term support (LTS) versions. Oracle released the last zero-cost public update for the legacy
version Java 8 LTS in January 2019 for commercial use, although it will otherwise still support
Java 8 with public updates for personal use indefinitely. Other vendors have begun to offer
zero-cost builds of OpenJDK 8 and 11 that are still receiving security and other upgrades.
Oracle (and others) highly recommend uninstalling outdated and unsupported versions of Java,
due to unresolved security issues in older versions.[22] Oracle advises its users to immediately
transition to a supported version, such as one of the LTS versions (8, 11, 17).

There were five primary goals in the creation of the Java language:[18]
1. It must be simple, object-oriented, and familiar.
2. It must be robust and secure.
3. It must be architecture-neutral and portable.
4. It must execute with high performance.
5. It must be interpreted, threaded, and dynamic.

Java JVM and bytecode

Main articles: Java (software platform) and Java virtual machine
One design goal of Java is portability, which means that programs written for the Java platform
must run similarly on any combination of hardware and operating system with adequate run
time support. This is achieved by compiling the Java language code to an intermediate
representation called Java bytecode, instead of directly to architecture-specific machine code.
Java bytecode instructions are analogous to machine code, but they are intended to be executed
by a virtual machine (VM) written specifically for the host hardware. End-users commonly
use a Java Runtime Environment (JRE) installed on their device for standalone Java
applications or a web browser for Java applets.
Standard libraries provide a generic way to access host-specific features such as graphics,
threading, and networking.

The use of universal bytecode makes porting simple. However, the overhead of interpreting
bytecode into machine instructions made interpreted programs almost always run more slowly
than native executables. Just-in-time (JIT) compilers that compile byte-codes to machine
code during runtime were introduced from an early stage. Java's Hotspot compiler is actually
two compilers in one; and with GraalVM (included in e.g. Java 11, but removed as of Java 16)
allowing tiered compilation. Java itself is platform-independent and is adapted to the
particular platform it is to run on by a Java virtual machine (JVM) for it, which translates the
Java bytecode into the platform's machine language

Main article: Java performance

Programs written in Java have a reputation for being slower and requiring more memory than
those written in C++ However, Java programs' execution speed improved significantly with
the introduction of just-in-time compilation in 1997/1998 for Java 1.1,[51] the addition of
language features supporting better code analysis (such as inner classes, the StringBuilder class,
optional assertions, etc.), and optimizations in the Java virtual machine, such as HotSpot
becoming Sun's default JVM in 2000. With Java 1.5, the performance was improved with the
addition of the java.util.concurrent package, including lock-free implementations of the
ConcurrentMaps and other multi-core collections, and it was improved further with Java 1

CHAPTER 3

AUTOMATIC MEMORY MANAGEMENT

Java uses an automatic garbage collector to manage memory in the object lifecycle. The
programmer determines when objects are created, and the Java runtime is responsible for
recovering the memory once objects are no longer in use. Once no references to an object
remain, the unreachable memory becomes eligible to be freed automatically by the garbage
collector. Something similar to a memory leak may still occur if a programmer's code holds a
reference to an object that is no longer needed, typically when objects that are no longer needed
are stored in containers that are still in use. If methods for a non-existent object are called, a
null pointer exception is thrown
One of the ideas behind Java's automatic memory management model is that programmers can
be spared the burden of having to perform manual memory management. In some languages,
memory for the creation of objects is implicitly allocated on the stack or explicitly allocated
and deallocated from the heap. In the latter case, the responsibility of managing memory
resides with the programmer. If the program does not deallocate an object, a memory leak
occurs. If the program attempts to access or deallocate memory that has already been
deallocated, the result is undefined and difficult to predict, and the program is likely to become
unstable or crash. This can be partially remedied by the use of smart pointers, but these add
overhead and complexity. Note that garbage collection does not prevent logical memory leaks,
i.e. those where the memory is still referenced but never used.
Garbage collection may happen at any time. Ideally, it will occur when a program is idle. It is
guaranteed to be triggered if there is insufficient free memory on the heap to allocate a new
object; this can cause a program to stall momentarily. Explicit memory management is not
possible in Java.
Java does not support C/C++ style pointer arithmetic, where object addresses can be
arithmetically manipulated (e.g. by adding or subtracting an offset). This allows the garbage
collector to relocate referenced objects and ensures type safety and security.
As in C++ and some other object-oriented languages, variables of Java's primitive data types
are either stored directly in fields (for objects) or on the stack (for methods) rather than on the
heap, as is commonly true for non-primitive data types (but see escape analysis). This was a
conscious decision by Java's designers for performance reasons.
Java contains multiple types of garbage collectors. Since Java 9, HotSpot uses the Garbage
First Garbage Collector (G1GC) as the default.[55] However, there are also several other
garbage collectors that can be used to manage the heap. For most applications in Java, G1GC
is sufficient. Previously, the Parallel Garbage Collector was used in Java 8.
Having solved the memory management problem does not relieve the programmer of the
burden of handling properly other kinds of resources, like network or database connections,
file handles, etc., especially in the presence of exceptions.

he syntax of Java is largely influenced by C++ and C. Unlike C++, which combines the syntax
for structured, generic, and object-oriented programming, Java was built almost exclusively as
an object-oriented language.[18] All code is written inside classes, and every data item is an
object, with the exception of the primitive data types, (i.e. integers, floating-point numbers,
boolean values, and characters), which are not objects for performance reasons. Java reuses
some popular aspects of C++ (such as the printf method).
Unlike C++, Java does not support operator overloading[56] or multiple inheritance for
classes, though multiple inheritance is supported for interfaces.[57]
Java uses comments similar to those of C++. There are three different styles of comments: a
single line style marked with two slashes (//), a multiple line style opened with /* and closed
with */, and the Javadoc commenting style opened with /** and closed with */. The Javadoc
style of commenting allows the user to run the Javadoc executable to create documentation for
the program and can be read by some integrated development environments (IDEs) such as
Eclipse to allow developers to access documentation within the IDE.
All source files must be named after the public class they contain, appending the suffix .java,
for example, HelloWorldApp.java. It must first be compiled into bytecode, using a Java
compiler, producing a file with the .class suffix (HelloWorldApp.class, in this case). Only then
can it be executed or launched. The Java source file may only contain one public class, but it
can contain multiple classes with a non-public access modifier and any number of public inner
classes. When the source file contains multiple classes, it is necessary to make one class
(introduced by the class keyword) public (preceded by the public keyword) and name the
source file with that public class name.
A class that is not declared public may be stored in any .java file. The compiler will generate a
class file for each class defined in the source file. The name of the class file is the name of the
class, with .class appended. For class file generation, anonymous classes are treated as if
their name were the concatenation of the name of their enclosing class, a $, and an integer.
The keyword public denotes that a method can be called from code in other classes, or that a
class may be used by classes outside the class hierarchy. The class hierarchy is related to the
name of the directory in which the .java file is located. This is called an access level modifier.
Other access level modifiers include the keywords private (a method that can only be accessed
in the same class) and protected (which allows code from the same package to access). If a
piece of code attempts to access private methods or protected methods, the JVM will throw a
SecurityException
The keyword static[19] in front of a method indicates a static method, which is associated
only with the class and not with any specific instance of that class. Only static methods can be
invoked without a reference to an object. Static methods cannot access any class members that
are not also static. Methods that are not designated static are instance methods and require a
specific instance of a class to operate.
The keyword void indicates that the main method does not return any value to the caller. If a
Java program is to exit with an error code, it must call System.exit() explicitly.
The method name main is not a keyword in the Java language. It is simply the name of the
method the Java launcher calls to pass control to the program. Java classes that run in managed
environments such as applets and Enterprise JavaBeans do not use or need a main() method.
A Java program may contain multiple classes that have main methods, which means that the
VM needs to be explicitly told which class to launch from.
The main method must accept an array of String objects. By convention, it is referenced as
args although any other legal identifier name can be used. Since Java 5, the main method can
also use variable arguments, in the form of public static void main(String... args), allowing
the main method to be invoked with an arbitrary number of String arguments. The effect of this
alternate declaration is semantically identical (to the args parameter which is still an array of
String objects), but it allows an alternative syntax for creating and passing the array.
The Java launcher launches Java by loading a given class (specified on the command line or as
an attribute in a JAR) and starting its public static void main(String[]) method. Stand-alone
programs must declare this method explicitly. The String[] args parameter is an array of String
objects containing any arguments passed to the class. The parameters to main are often passed
by means of a command line.
Printing is part of a Java standard School: The System class defines a public static field called
out. The out object is an instance of the PrintStream class and provides many methods for
printing data to standard out, including println(String) which also appends a new line to the
passed string.
The string "Hello World!" is automatically converted to a String object by the compiler.

The Java language is a key pillar in Android, an open source mobile operating system.
Although Android, built on the Linux kernel, is written largely in C, the Android SDK uses the
Java language as the basis for Android applications but does not use any of its standard GUI,
SE, ME or other established Java standards.[78] The bytecode language supported by the
Android SDK is incompatible with Java bytecode and runs on its own virtual machine,
optimized for low-memory devices such as smartphones and tablet computers. Depending
on the Android version, the bytecode is either interpreted by the Dalvik virtual machine or
compiled into native code by the Android Runtime.
Android does not provide the full Java SE standard School, although the Android SDK does
include an independent implementation of a large subset of it. It supports Java 6 and some Java
7 features, offering an implementation compatible with the standard School (Apache
Harmony).

The use of Java-related technology in Android led to a legal dispute between Oracle and Google.
On May 7, 2012, a San Francisco jury found that if APIs could be copyrighted, then Google
had infringed Oracle's copyrights by the use of Java in Android devices.[79] District Judge
William Alsup ruled on May 31, 2012, that APIs cannot be copyrighted,[80] but this was
reversed by the United States Court of Appeals for the Federal Circuit in May 2014.[81] On
May 26, 2016, the district court decided in favor of Google, ruling the copyright infringement
of the Java API in Android constitutes fair use.[82] In March 2018, this ruling was overturned
by the Appeals Court, which sent down the case of determining the damages to federal court
in San Francisco.[83] Google filed a petition for writ of certiorari with the Supreme Court of
the United States in January 2019 to challenge the two rulings that were made by the Appeals
Court in Oracle's favor.[84] On April 5, 2021, the Court ruled 6-2 in Google's favor, that its
use of Java APIs should be considered fair use. However, the court refused to rule on the
copyrightability of APIs, choosing instead to determine their ruling by considering Java's API
copyrightable "purely for argument’s sake.

Oracle Corporation is the current owner of the official implementation of the Java SE platform,
following their acquisition of Sun Microsystems on January 27, 2010. This implementation
is based on the original implementation of Java by Sun. The Oracle implementation is available
for Microsoft Windows (still works for XP, while only later versions are currently officially
supported), macOS, Linux, and Solaris. Because Java lacks any formal standardization
recognized by Ecma International, ISO/IEC, ANSI, or other third-party standards
organizations, the Oracle implementation is the de facto standard.
The Oracle implementation is packaged into two different distributions: The Java Runtime
Environment (JRE) which contains the parts of the Java SE platform required to run Java
programs and is intended for end users, and the Java Development Kit (JDK), which is
intended for software developers and includes development tools such as the Java compiler,
Javadoc, Jar, and a debugger. Oracle has also released GraalVM, a high performance Java
dynamic compiler and interpreter.
OpenJDK is another notable Java SE implementation that is licensed under the GNU GPL. The
implementation started when Sun began releasing the Java source code under the GPL. As of
Java SE 7, OpenJDK is the official Java reference implementation.
The goal of Java is to make all implementations of Java compatible. Historically, Sun's
trademark license for usage of the Java brand insists that all implementations be compatible.
This resulted in a legal dispute with Microsoft after Sun claimed that the Microsoft
implementation did not support RMI or JNI and had added platform-specific features of their
own. Sun sued in 1997, and, in 2001, won a settlement of US$20 million, as well as a court
order enforcing the terms of the license from Sun.[77] As a result, Microsoft no longer ships
Java with Windows.
Platform-independent Java is essential to Java EE, and an even more rigorous validation is
required to certify an implementation. This environment enables portable server-side
applications.

In 2004, generics were added to the Java language, as part of J2SE 5.0. Prior to the introduction
of generics, each variable declaration had to be of a specific type. For container classes, for
example, this is a problem because there is no easy way to create a container that accepts only
specific types of objects. Either the container operates on all subtypes of a class or interface,
usually Object, or a different container class has to be created for each contained class. Generics
allow compile-time type checking without having to create many container classes, each
containing almost identical code. In addition to enabling more efficient code, certain runtime
exceptions are prevented from occurring, by issuing compile-time errors. If Java prevented all
runtime type errors (ClassCastExceptions) from occurring, it would be type safe.
In 2016, the type system of Java was proven unsound.[65]

CHAPTER 4

MYSQL
MYSQL- MySQL ("My S-Q-L", officially, but also called "My Sequel") is (as of July 2013)
the world's second most widely used open-source relational database management system
(RDBMS). It is named after co-founder Michael Widenius daughter, My.

The SQL phrase stands for Structured Query Language. The MySQL development project has
made its source code available under the terms of the GNU General Public License, as well as
under a variety of proprietary agreements. MySQL was owned and sponsored by a single for-
profit firm, the Swedish company MySQL AB, now owned by Oracle Corporation .MySQL is
a popular choice of database for use in web applications, and is a central component of the
widely used LAMP open source web application software stack (and other 'AMP' stacks).

LAMP is an acronym for "Linux, Apache, MySQL, and Perl/PHP/Python." Free-software-open

source projects that require a full-featured database management system often use MySQL. For
commercial use, several paid editions are available, and offer additional functionality.

Applications which use MySQL databases include:

TYPO3, MODx, Joomla, WordPress, phpBB, MyBB, Drupal and other software. MySQL is
also used in many high-profile, large-scale websites, including Wikipedia, Google (though not
for searches), Facebook, Twitter, Flickr, and YouTube.

SQL Process
When you are executing an SQL command for any RDBMS, the system determines the best
way to carry out your request and SQL engine figures out how to interpret the task.
There are various components included in this process.
These components are −
• Query Dispatcher
• Optimization Engines
• Classic Query Engine
• SQL Query Engine, etc.
A classic query engine handles all the non-SQL queries, but a SQL query engine won't handle
logical files.
Following is a simple diagram showing the SQL Architecture −