Java is one of the most fundamental
programming languages that anybody can learn
despite being so simple. It is a Marvel what can be achieved
with the use of java? Hi everyone. I welcome you all to this Java
full court session by Edureka, but before we begin, let's look
at our agenda for today. So we're going to start out by
talking about Java, what it is, and why do we need it? Then we're going
to discuss a few basic concepts like variables and data types in Java followed
by which we are going to talk about operators control
statements and methods. We are also going to discuss
the meat and potatoes of this session classes objects and object oriented
programming Concepts in Java followed by which
we are going to talk about exception handling then we're going to discuss
Java collection Frameworks and finally close this Action
by discussing the Dom parser in Java also do click on the Subscribe button
to never miss an update on the hottest Technologies by
the Edureka YouTube channel. Okay, before we start off
let me introduce myself. I am vinoth and I have been with this industry
IT industry specifically into Java development
for last 12 years. Alright, so the first topic is
about introduction to Java. So what are we going to cover
in this particular topic? So it's going to be
introduction to Java what Java is all about will have
Java installation done as well. So that you guys
can use it in future. You guys can try your hands
on we'll talk about modifiers and variables in Java. This is pretty much similar to what we have in other
programming languages will talk about Java data types as well, which is nothing but data type as we have the it's a storage
for different data types, right or the data that is store whatever
you want to process. Song is first put into memory and that is what
data type is all about. So you have different storage is like for character you
have something else and for float you will have
something else for long. We will have something else sort of data type
conversion in Java. So so you could convert
from one data type to other data type in Java. There are implicit
conversions done. We're in the programmer
need not take care about it. Java programming by itself would
take care about converting it which is implicit conversion
and there are few conversions, which programmers have
to take care about they have to explicitly mention that you have to convert
from this data type to this data type. And if you don't do it you would end up in
compilation errors or something. We'll talk about operators
operators are nothing but the operators that work upon this data type and which is nothing
but transformation. So you kind of use
this operators to add up for say for example Of two integers
you want to add it up. So you would have
this operators used. We'll talk about control
statements in Java as well control statements. Like you have if else and for loops
and stuff like that, so we'll talk about it. So Java is pretty much similar to other programming
languages thing is it has some unique features which makes it really important in the current industry
the IT industry when it comes to Big Data
and stuff like that. So we'll touch base on all
this important features of java, which would help
you to understand. Why do we really use it? Alright. So the first
topic is Introduction. So what is Java so Java as we
said the programming language which has object-oriented
programming model. So when I say object-oriented
programming model everything in Java is taken as an object. So object is nothing but something that has got State
and behavior say for example, you have chair, right? Jed has got a particular State and it has got
a particular Behavior. If you do something
if you move it, it would go this way and that way
and stuff like that. So basically any object if we think about
in reality realm any object for that matter would have
some kind of state and it would have
some kind of behavior which incorporates on its own. Right? So basically similar to that
Java is programming language, which is based on object
oriented programming model. So everything Java
could be thought of as an object or you define a class. So say for example
you have house right? So house could be thought of as an object or class
rather a house has a class and it would have
certain attributes right like number of rooms
or stuff like that. So that is nothing
but the state of the house. So this was actually brought
in by Sun Microsystems in 1995, and basically Java is nothing but we have jvm but jvm
is nothing but you kind of kind of can say it's
a specification right Sun Microsystems has said
that this is how it should be so that any company tomorrow I can go and create
my own version of java, but it has to be aligned
to this particular specification that is given
by Sun Microsystems. So Java is nothing
but reference implementation of java is provided
by Sun Microsystems, but nevertheless as I said give him
itself is a specification which anyone can Implement
actually but we will talk about Sun Microsystems talk about
the reference implementation that is nothing but one
created by Sun Microsystems. So everything in Java
would have a state and behavior and
which would be defined by class. Again, it was started off by
a team led by James Gosling and we know it's open source, which doesn't stop anyone
from putting in whatever code. I want to still we have lot
of versions coming in Java. So it's not that you
just have one version created by Sun Microsystems and it's been used
across the industry. You have like find
some issues or if they want to have
some kind of enhancement in the open a particular
module the keep doing it. So right now we have
like Java is at version 12, which is like we have lot
of enhancements coming in. It's a evolving thing
it's ever evolving thing. And as I said,
this is open source tomorrow. If you become a good
programmer in Java, you could go and actually
write something for Java and which would be
moderated by someone and which would be put
as open source. And anyone can use it
other thing is Java the very important feature
why we use Java or why Java is so widely used is
right once and run everywhere. So you write a class
or you write program once and you compile it and this particular
compiled version of class. Be run anywhere on any machine
or you could transport this particular compiled
version of java, which is nothing but classify we
call it as a class file again, you did not get into
what is class file. But just to say that you compile it you get
a compiled version of it and this compiled version of class could be transported
anywhere in the network or you could put it
anywhere and just run it so you could take it
on your pen drive as well and go anywhere and plug your pendrive get this class path
download this class path or download this class rather and just run it so it right
once and run everywhere and the magic part is it
could be run on any environment. It could be run on any platform. That's why it's
platform independent. So I could write a program today
on Windows compile it and tomorrow I can just take it
on my pen drive and run it on Linux as well. So you don't have
to take care about it. Java by itself has a feature
to make it platform independent. So As you could imagine this
is one of the reasons why it's been widely used because since we
are getting into a phase of distributed computing, we cannot have everything run
on same platform. You don't know
where your so you as a programmer write something but you don't know where this particular program
is going to run. It could be on any platform. So this is why
it is more important. So unlike dotnet, right? You need to have Microsoft just to give you
this thing comparison with dotnet so for.net
you need to have Microsoft stack implemented, but for this you need
not could be run everywhere. So Java can be used
to create complete applications that may run
on a single computer or can be distributed among servers and clients
in the network. As I said, this is more
about the application of platform-independent
programming language. So it could be used on any machine you
need not take care about which machine
your program is going to run on. All right, so let's
talk about Java. Earth so what features
do we have in Java? First thing is Java is
pretty much simple when it comes to SDK or when it comes
to API application interface. It's pretty much simple. It's kept as simple as possible. It's pretty much similar
to other programming languages and it's verbose. So anyone can just read
through it and understand what it is trying to do so they have kept it
to that level so similar to any high-level languages, right the coach
should be such that as you read through it. You should understand what it is doing and that's
what they have tried to do. Its high-performance. One of the things that I
already mentioned about. It's an evolving system. It's not that it's been
just done once and been used throughout its evolving system. So as and when this continuous
Improvement done, right, so as then when if I as
the application programmer if I find something not working as expected I can raise a ticket and they could go
through the ticket or there's a Java development. Which has been driven by Oracle. Now, they would look
at the priority of this particular stuff. And if there are a lot of tickets been raised by
other companies as well. And if something could be done on the aspect
on the particular aspect that you raised they
would surely Incorporated and notify you in a particular release
the enhancement is coming up and stuff like that. So it's a evolving system
and you know, the performance is always if there's some drawback or
if there's something not working as expected they would surely Rectify it
in the future releases. So that way it keep it up
to the mark the keep the high-performance thing
going it is secured. So Java basically runs
in virtual machine sandbox, and no one can get
into this particular space. So no one can intrude it. I would say so that keeps it free from virus
and stuff like that or untrusted process. And other thing that is important is
unlike C. Java doesn't expose pointers so in see There
could be malicious user who could get into the memory
location through pointers and can manipulate the contents
of a particular memory. Right? Whereas in Java. It doesn't expose the pointer. It doesn't give you the pointer
to a memory location. So you can't actually go
and change the content of a memory location
when you are using Java so that keeps it secure. So it's robust. So Java checks the code during
compilation time and runtime. So basically what happens is as I said when you compile
it you get a class file and whenever you try
to run this class file on any of the machines, it will ensure
that it's properly done or if there's some issue
with the class file. It would say that it's
a correctly classify. So basically you have
some kind of checks done during the compilation as well compilation is nothing but if you have something
tactical error say, for example, if you miss the semicolon at the
end of a particular statement or an end of any statement, It would prompt you
during the compilation time that this is not
what is expected or it would ask you to correct it once you have everything as
for the expectation, it would compile it
and create a class file and when you put this glass file
to any of the machines during the runtime
it checks as well. And the other thing is about you don't have to take
care about memory allocation and releasing unlike
in other programming languages. Java by itself does garbage collection
garbage collection is nothing but when a particular memory
is not being utilized by your program of goes out of scope it
would Java by itself has a thread I don't want
to get into threads and stuff like that. But Java would enough
the memory contains by itself. You don't have to explicitly
write a code to clean it and see you have
to write a code to clean. It errors in Java. It's done by itself. So that makes it robust
other thing is it's portable as we already spoke. You can write
a programming windows. You can run the same program
or you can write a program in Windows compile
it get a class file or the compiled version
of the class and just put it on any platform. It could be Windows. It could be you run it
on Unix or Linux or Mac or anywhere so you don't have
to take care about it. So Java by itself does it and that's where jvm comes
into picture which we'll talk about in the the further slides. So other thing is it's Dynamic which means that it has
runtime polymorphism. So all the objects
are evaluated during runtime. It's not just that it's done
during the compile time. There. Is this something done
during the runtime as well. So basically it's called
as runtime polymorphism. But just to keep in mind
not everything is linked up during the compile time
is something done during the runtime as well. So it could be
distributed as well. You don't have to have
all the code put into one machine and run
it from my machine. I could run something written
on your machine as well. If into net in the same network
or if if they are exposed to a network we could run
programs on different machines. So that's what distributed
is all about. So you could think of big data. So this is one of the major features why
Java is been widely used in big data, right? So big data is nothing
but you have chunks of data you have like petabytes of information coming
in every minute or every hour or every day, right and you want
to process it. So it cannot be done
in one machine if you want to run
everything on one machine as we had earlier, right? Everything was monolithic
everything was done on one machine sort of so that's where you would want
to have servers right. Now. The server thing is it's not being used that much
since there's a lot of English. Intense stuff like that. So distributed computing
is nothing but we have like pure computers
or normal computers that we have and programs
are actually done on this machines
rather than rather than having a high-end machines. So basically this feature is what helps Java
to be used in big data. And as I said, it's run on commodity Hardware
as against server Hardware which needs a lot
of investment for companies. Java is multi threaded
so multi-threaded is nothing but so you have
multiple cores on your machine, right? You have like four cores
and stuff like that. So you could utilize all this
for course say for example, you want to do addition
of two numbers and multiplication of two
numbers right different numbers. So you don't have to run
everything on One Core. So this could since you have four processors
right for course, you could have
addition run on one core and you could have
this multiplication going on at the same time
at the same instance, right? You could have this
multiplication going on as well. You could run them
as a thread right? You don't have to have
one waiting for other. You don't have to do it
in a sequential manner when you're operating
on different variables, right? So that's what multi-threaded
is all about. As I said you could have
this operations carried out on different course
in the same instance of time. Object-oriented again
as I spoke earlier, everything is performed
using objects and Java can be easily extended since it is based
on object model. Now, let's talk
about which sectors or which industry sectors
actually use Java. So you have Android apps. So Android apps Cal
could be written on Java. So basically the underneath
is Android API, which is similar
to jdk so jdk is nothing but Java development kit. It's widely used
in financial services industry. If if you would have
some idea about it. You could see that mostly all Financial
companies use Java. So the Legacy systems that we have in financial
companies is mostly developed on Java. So one of the aspects
for this is more about it's pretty secure. So that's why it's
been written on Java lots of global investment Banks. Like Citigroup Barclays Standard
Chartered and other Banks use Java for writing front and back office
electronic trading system. So one of the main features
why it's been used in financial industry
is about security. It provides high
level of security as we spoke earlier
Java web applications. So basically you have
web servers on which your application would be hosted and you could request
for a particular JSP or JSP is nothing but
a dynamic HTML page right there in the contents could change
basically you could request for some particular JSP and you could get it
so say for example, you are trying to log on to a particular application
you get a login page that is nothing but a JSP. So basically a mini
of the web applications is developed on Java as well. One of the main features why
web applications are developed because you have a lot
of web servers supporting, Java you Have
to deploy application on a particular web server and could access it
from anywhere across glue. You should be
on internet though. Embedded system when it comes
to embedded system. It has to be lightweight, right. So Java it I remember
Java version 8 had lot of feature making it pretty much
light weight when it comes to embedded systems. So basically you have
Micro addition j2me. What we are talking here
is j2se and the thing that we so there are
three flavors of java. So one is j2se, which is nothing
but standard edition and which is standard edition, which you have like all
the data types and stuff like that all four loops
and stuff like that. Right that is about j2se. You have G to EE
which is Enterprise Edition, which is nothing but the web application that
we spoke about and we have j2me which is micro Edition, which is nothing
but for embedded systems as its name suggests,
it is micro Edition, which is light in weight. And as we can imagine
that in embedded system, it has to be lighter
since it is burnt into a chip, right and you cannot have
a big application. So that's why
we have lightweight when it comes to j2me. So again as I touch base
on this it's about web servers and application servers which makes Java compatible
for web applications. So we have Apache Tomcat which is pretty much widely used
which was a web server earlier. Now, they have Apache Tom e
or which is Tom double e which is nothing but application
server version of it. So basically when it
comes to web servers or application servers, what you do is you as a client could send
a request to our web server and web server or the application server
would just process this particular request and send the response
the way the It's written. So basically it would serve
the expected result out. So you have
Enterprise applications. Again, this is
Java Enterprise Edition, which makes it favorable
for web applications. So all these
specifications j2me. J2w. J2se, this are nothing but
specifications exposed by Java. So if you as a developer
wants to do something or if you want to write your own
version of it you can do it. So where is Java used
again scientific applications? So I as you could imagine
in scientific applications, you need to have
high level of accuracy and precision rather. They could be
mathematical equations and mathematical computations
which needs lot of CPU time because it's very
CPU intensive right? When you do a very
precise calculation with high level of high degree. It needs lot of CPU time, right? So that's where Java is good at. So basically this is about as
a spoke about multi-threading utilizing all the course
to the fullest suppose. You have four core processor
using all these four cores is been done by
Java Java has feature or through threads you
could actually read through or actually utilize this for course to the fullest
Big Data Technologies again, big data is nothing. But as I said, it's distributed you cannot have
everything run on one machine, which was the case earlier. You would have one server put up and everything is done
on that particular server. Now, it cannot be the case. That's where Big Data comes
into picture wherein you have distributed architecture and you have this data being processed across Network
rather than just on one machine and mind you as I said, this machines are
commodity hardware and not server level Hardware or the Enterprise level Hardware which makes Cheaper Internet
of Things So Internet of Things is coming up the booming thing wherein you
could connect things together. Say, for example,
you have cars, right? So you could
connect cars together so you could have
sensors in your car which could emit data and you
could connect them together. So basically it's all connecting
things together or say, for example, let me talk
about internet itself. So earlier if you remember
computers were not connected it were all pure right. It could just be used
for your own purpose. Now internet has started wherein you have all
these computers connected and if you are connected
to the internet, you could go onto Google
and search something or whatever you want to sort of So basically this is what
internet of things is all about. So consider this
instead of computer. It could be any other objects
a car for example, as I said so consider
car has sensor and it is emitting
this sensor data every minute and we could utilize
this sensor data and do something
with it or one car can know where the other car is. So that's what internet of thing is about all about
connecting things together. Let's start off
with the setup setup for Java. So basically you could go
to this particular site and just download the SDK
based on this jdk, right? So basically based
on whatever platform you are at. If you are using Windows, you have to select Windows
if you are using something else if you have mac,
you can select Mac. So this is pretty much similar to other softwares you get
an exe file download it and you just have
to run that exe file. So basically I can show you
what gets downloaded. So I have downloaded
version 12 for Java as you could see here
and and since its Windows, it is mentioned as Windows. So this is nothing
but an exe file that you get which you could run and you would have
Java installed on your machine. So it's pretty simple. It's pretty much similar to other software's you
have say for example, or I could just show
you the location where it is installed. So if you get into
the program files, you can see javabean
installed here, right? And it says jdk 12. So once you install Java, once you download
this particular stuff jdk and once you install this
this executable you should be able to see
this Java folder in your program files. So it shows here. It's for you can select whatever
you want to see you have as you could see here. This line X there
is Windows Mac OS and stuff like that. You have to select
the platform you are on and should be good to go. This is done. You could see you get a exe
which you have to run. So basically to run Java
what you have to do is yeah. So you go to the system you have
control panel system you go here and you have to click
on Advanced system settings. Basically, what we are trying
to do is we are going to set an environment variable right and what we are going to set
is this path variable. So you have if you want to put it specific
to a particular user you can put it here put it
in the upper space or you want it
across the system. You could basically put
the path variable here in the system variables. So once you install it
you have to make sure that you have this particular path being put in
your path environment variable. So basically tells the OS that you have executables within
this particular directory. So once that is done, once you have
this properly setup, let me open a partial. So partial is nothing but it's pretty much simpler
to command prompt but it's a Linux flavor of it. So basically you could run
Linux commands as well. Okay, so I will I
will once this is done. Give me a second. Okay. So with partial you can do LS which would give you a listing
unlike in command prompt. You have to give dir. So it's basically
good for programming. So once you have
this properly set once you have
this path properly set if you write Java here, if you write Java
on your command prompt, you should be able to see
this help coming up here. So if it's not properly set up, you won't see this it would give
you unrecognized command. Yeah, open command prompt
and type Java. So once the path is properly set
you should be able to see this. So let's set up Eclipse as well. So it could be eclipse or IntelliJ whatever
you are comfortable with so you could use
either of them since IntelliJ has
much more features. You could use IntelliJ as well. So you go to Eclipse download and whatever flavor you
can take the latest one Whatever flavor you
want to install if you if you want
a simple one you can do it. If you're trying to do
something on web. You can download
that one as well. So basically for simple purpose for whatever we are going
to do you can have normal ones. So let me quickly open
up my so this is nothing but the IDE integrated
development environment that I use with just IntelliJ all the IDS are
pretty much similar. So IntelliJ similar to Eclipse,
so it's coming up. So basically what you do is you have to select a workspace
first workspace is nothing but all your program all the class files all
the class and everything that you write would be put
into this particular Works piece and you can create
a new class and start off. So when we get
to the hello world program, which is the first program
that we are going to talk about it would give
you a clear idea on what we are talking about. So let's talk
about Java internals how it looks like and all the features
that we spoke about. So basically so far what we have covered is more
about Java is object oriented program or it uses
object-oriented programming. Paradigm which is nothing but everything is thought of as
a class with a particular State and behavior right
is platform independent. That's why it's been widely used
it secured as well. That's why it's been used in
banking applications and stuff. It's good for
distributed computing since its platform independent. You don't you just
have to write it once and you can run it everywhere. So basically this platform
independent aspect is what helps it to be widely used
in Big Data applications. So let's talk
about the internals. So what is jvm jvm is nothing. But again, it's
a specification right? You could have your own jvm son by itself gives
specification for a jvm. This is what the GBM
should be all about so I could create my own jvm. But we usually we use
the reference implementation of sun Microsystems Oracle now. Right, so jvm is
a virtual machine that runs the bytecode. So basically there has to be
some level of compilation done before give him
can understand it. So that's where you
have Java compiler. And so what this does is nothing
but it takes your source code. It takes the class files as
or it takes the class that you write as is so Java compiler
would consume it and kind of compile it
into a DOT class file so dot class file is nothing
but compressed version of it and compiled version
of it as well. And this dot class file is nothing but it's also known
as bytecode and this is what a jvm could understand. So once you have
this class file, it could be sent to the jvm and jvm could understand
it and run the applications. So what makes Java
platform independent is this Java compiler is platform. Pendant you don't have
to take care about it. You just have
to run the compiler. And whenever you want to run
this particular byte code on any of the machines, you just have to have jvm
for that particular machine. Right? So basically if you
want to have online X, right if you want
to run it on Windows, you would have jvm
installed on Windows or you would download
the jvm for Windows. And if you want to run it
on Ubuntu or the Linux or Mac would just have
to have the jvm downloaded for that particular platform and it should be able to sense
this particular byte code. So basically this is what makes
it platform-independent. Right? As I said,
once you have this bytecode once you compile it this
bytecode could be transported or ported into any of the machines
in operating systems and you should be able to run it that is what it is all about. It's right ones
and run anywhere. So as I earlier
mentioned you could As get this class file
into your pen drive and take it anywhere and you could just
plug your pen drive and just run through that's how simple it is. So, this is Java
runtime environment where in you have set of jvm plus you
have libraries libraries, it does nothing but you know, although programs put together
all the programs source code for Java put together. So our T dot jar is
one of the libraries which would have
most of the classes or you have you till classes
maybe string class string is a class itself, which is exposed by Java. So this particular jar file or it's a Java archive jar
is nothing but Java archive which is set of java classes
or the class files rather which would have lot
of class files within so in our T dot jar you would have
something like string class and stuff like that a lot
of other classes, which is been used by the sea. Some are which has been
used by Java itself? So basically in JRE this is what you have jvm
plus set of libraries plus other additional files. So as spoke jvm is nothing
but specific to environment, but all these things
like Artie dot jar and stuff like that
would be independent GRE does not contain tools and utilities such as compilers or debuggers for developing
applets and application. So GRE by itself
the runtime environment, so it doesn't have compilers
and stuff like that. So jdk is nothing
but it specifically for development you
could see here. It's JRE plus development tools
you have compilers and stuff like that as well. So to run a class file, you just need the JRE but
if you are a developer, you would need jdk so
what we downloaded earlier if you remember that was jdk right jdk
for Windows or jdk for liners. So basically if you see
this one could see here as jdk. So essentially you need jdk only
if you are a programmer if you just want to run
the class file GRE would suffice so why is jdk GRE and jvm as we spoke about you
could see jdk is a superset. It has everything right GDK
would have your jvm. Plus it would have
as we spoke here. It's JRE plus your
development tools as well. As you could see here details
it has everything here. It would be really
confusing right now. If you directly get
into what all this is all about, but basically you
could imagine jdk is a superset and Jerry is nothing but
it's your runtime environment which has jvm
and some additional files or RT dot jar as we said which is nothing but set
of files set of class files that is exposed by Java which could be used
like string for example, right? Let's see how it works. So basically you have
your source file. So this is what a developer
would typically right would create a DOT Java file. So whatever you write
you create a class. You just create a new class
and write something to it. What you get is dot Java you
get the extension dot Tower. So basically this
is your source code, whatever you write you as a developer would
write this class. Is would be sent for compilation
or whenever you are good enough done with your coding
you would compile it. And once the compilation
is done once everything looks good enough. Once the compiler doesn't Mark anything and
doesn't flag anything rather, which means everything
is syntactically, right? You will get Java bytecode. Just nothing but dot class 5. Now. This dot class file
could be moved across Network or you could as I said, you could just put it
in your pen drive and can take it anywhere and you could run it
on any of the environments. You just have to have jvm. So basically you
could run this class file, which is compiled on Windows. You could run it on any of the environment
any of the platform's. So this is something that we
spoke about during runtime. There's a verification as well. So so when classloader would
load this particular class file, it would ensure that it is up to the Mark
or it's not manipulated sort of so if it all it
sees something wrong, then it would flag it off as you know corrupted
file or something. So this is nothing but Java class file libraries
are T dot jar that we spoke about Java archive. So this is what is happening. When you run a particular
class five, right? So you have this class loaded
and then you have this compilers just-in-time compiler
actually running it for you. So basically the part of jvm so
jvm is remember jvm is nothing but it's a platform. It is specific to platform. So basically for Windows you
would have a different jvm. And for line X you
would have a different jvm. So yeah, you get this class you load this class
using class loader and you run through
the application or run through the class files. So typically this is how Java operates so just
to give a just on this one. So you have a source code you
have dot Java file written you compile it you
get our class file and you can put
this class file anywhere. You can run this class file
anywhere on your network or wherever you want to you just
have to take this class file and on the machine
on which you run. What would happen is you load this class file
first using class loader and with jvm jvm would
have just-in-time compiler which would run
a particular class for you. Right? So what we are trying to do
here is you're running the source code that's written on any
environment you are running it on any other environment. So basically you
could write this on Windows. You could write
source code on Windows, but you could run it
on say for example line X. So that is what makes
it platform independent. So here let's create one class and as we created I
will More about it so that you could open
up your eclipse and could create something
like a new project so it could be a bit different
for you the look and feel might not be
exactly the same as mine, but you just have to create
a new project select Java. So basically I could
a project name. So whatever you want
to so basic nomenclature is like it has to start
with uppercase letter, which is camel casing right? So you should follow
camel casing venue. That's one of the best practices it won't flag you as
some error or something, but that's a normal
industrial practice that whenever you create
a Java project. It has to use camel casing
created record, Java. So it's creating
a project for me. And as you can see here, I have this particular project
being created right now. What I do is
I create Java class. So basically as we said everything could
be seen as a class, right that's what
object-oriented is all about. So basically what I would do
is I would create a class here. So this is my source folder where enormous Source class
would be there. So as you can see here
new Java class so say I create calm dot Ed u-- Rica. So this is nothing
but your name space or the package, right? So you could give whatever
you want to basically this is to avoid collisions, right? If we don't have a name space
there would be lot of collisions within the class. So there are a lot
of people working on the same project right so I
could create a class with name. Class A and the other person
might read classy as well. So when this is club together
into one particular application there would be Collision
So to avoid this basically what you have is you have a namespace. So I would write as calm
down dear a card dot Class A. The other person
would write something else and that would avoid class name
collisions Applause collisions. So this is compounded
Eureka is my package or namespace and hello
world is my Java class name. So as you could see here, there's a package calm
down Ed Eureka, which is again a namespace and there's a class by name
hello world that's been created. Right? And if you want to see
you could actually go and so you can see
a folder structure created here in the source. So this is your Source folder
right within your project. There was a source folder
where in we created the class. So if you go to the source folder you
could see a packet structure or you could see a directory
structure being created which starts with calm and within calm you
would have at Eureka and here you can see
Hello World dot Java. So remember we said that your source code
would have all the Java files. So basically this is
what I was referring to. This is a method that the default method
that's been called. So when you run
this particular class file jvm would actually look out
for this particular method. So you need to have
the same signature as has so you would have a main method wherein your program
execution would start, right? So as then when you compile
it and run the class file, so basically when you compile
it you would get a class file, right and when you run this class file jvm would check
out for this main or a method that has the same
signature as this one. That's a main method and your program execution
would start running from here. So basically it's a entry point
for your execution, right? So this would be a simple program wherein we
would just print hello world. So basically you have like system system is
a class and this is how you print in Java. So I don't want to confuse
right away by saying what is system
worries out and println, but basically what you
have is a system is a class as I said everything
Could Be Imagined as a class. So in Java everything
is a class. So basically you
could just click here and you could see
the source code of it, right? This is the source code
and this is coming from our T dot jar
remember in jvm. We spoke about in GRE. We had our DDOT jar. We had Jerry we had jvm
plus plus class files. So all this has been written
by Java by the Java community. So basically you can see here. This system itself is a class. So out is instance variable and println is nothing
but a method within out so what this statement
particular thing is going as nothing but writing
it on to your console. So let's print hello world. So basically when you build
a project it's compiling it as you could see here. It's saying it's building it. So once it has built it you
could see a class file here. Right? So you could see here
hello world dot class. This is because we built it
when you build it. Your Java file would be
compiled by your compiler and it would create
a DOT class file. And remember as I said, this class file dot class file
could be run on any machine. So this is Windows machine that have written
this file Java file and compiled on now. This dot class file could run
on Linux or any platform that you want to run it on. So, let me talk
about this class. Right? So you have a public key word, which is nothing
but access modifier which gives visibility. So basically what we are trying
to say here is hello world is publicly could be publicly seen so it could be seen anywhere
within the application. So basically for class level
you have public which as the name suggests. As the name gives out it
could be seen anywhere within your application that the visibility
key access modifier. All right, so you have
the keyword class here, which is for the class. You need to have
it mentioned as class. If you write something else, then it would give you
a compilation error. So it has to be
exactly the same. All right, that's
the syntax of it. Hello is nothing
but the name of your class, then you have this public
static void main, which is nothing but as I said, this is the entry point
for your application or your class file. So when you run
this particular class, it would start off from here. You have a static keyword
static keyword is nothing but it's at the class level. So basically you
need not create instance. We haven't reached
that point yet. So basically hello is a class and you could create
instance of hello, which is nothing
but object right? So when you have
a static keyword here You need not create object
of hello to run it if it's not static, then you need to have
object of hello created. So basically what I'm trying to say is see you have
one more method here, which is test. Now this doesn't have
a static keyword here. So basically what we
can do is we can print So yeah, this is a non-static
method right now. We cannot call it directly. If it's a non-static. You need to have a instance
of Hello World created. So basically how you
create instance is nothing but hello world. That's your hello world object. So when I say
instance I'm talking about creating object, right and you could create
new hello world. So object of hello world is
created using new keyword right? When you do this you
would get object of it or now. What I do is so basically what I was trying to say is
you cannot call test as is if you do it you would get
a compilation error saying that non static method test
cannot be referenced from a static context, right? You cannot call it
without having your object. So basically I can call it on Hello World object DOT test
Now I can call it now. It doesn't give
me compilation error. I'll create one
more static method which would give you some idea. So I will rename this
as non static test and this would be static test. Right and we are printing
your static method and here we are printing
non static method. So hello world
dot nonstatictest. Now, whereas the static test
did not be called using object so we could directly
call static test. Sorry, I haven't
written static here. So this is a static method. Okay, so now you could see here. It compiles fine. Right? So what I was trying to say is when you have a static
method you do not have object to call it. Whereas non-static method
you need to have object. That's what the static
is all about. Then you have void is nothing
but the return type it's not returning
anything from here. So that's why it's void. You have main method. That's the key word that the entry point
for your application. You have this arguments. You can see string
array of strings which are arguments provided
to a particular program. So you could pass
on as many arguments as you want or
if your program is say, for example, you want to pass your name as
an argument you can do that. So this is arguments then we have main which represents
the Above the program which I already mentioned then we have system dot out
dot println is nothing but the print statement so as I mentioned system is nothing everything
could be thought of as a class system is a class
out is instance variable and println is
a method within out. So basically you don't have
to think much about it just to understand the structure
of it just to understand how a particular class
is been written. This is what we have. This is how we write
a class right again, just to brief on this
you have access modifier which denotes the visibility
of a particular class. You have the class name you have
the main method which is nothing but the entry point for your class you
have a static method, which says whether you need an object to call
a particular method or could be called
directly from a class. You have a return type here. So this is how typically
any method would be written and you can write whatever statements you want to
within this particular method. This case we have printed
out hello world. So basically you
could follow this when you do it on Eclipse, so it might be a bit different
based on the eclipse version that you would have but it should be
pretty much similar. All right, so you create
a new Java project. So I showed this
already on IntelliJ, which is also widely used IDE. But yeah, you could use
Eclipse as well. So basically you could see the project name
being written as hello world, right and here it mentions
the JRE to be used. So here you can see class class
being created and let's see how we can run this. So we compiled it and we saw
that dot class file was created. Now we can run this. So as I said main
is the entry point so it would start
running from here. So your program control
would come here. And the first thing that it would see is you
have printed hello world, so it should print this one
then I would keep it simple. I don't want to let's see
what's been printed here, right? So you could see here. Hello world being
printed first, right? This is where the program
execution started from. So it came to mean so
hello world it printed out hello world. Then you give a call to
this non static method. So it printed non-static method which is been printed
in this particular method and then it gave
a call to static method and you could see static method
being printed here. So one thing to remember is
the program execution starts from Maine and it just you
know executes this main method. So whatever content
you want to write you would basically write it
in the main method so you could see here hello
world being printed out. Let's see how easy it is
to coat the same in the J shell. So J shell is nothing
but shell prompt that was created in Java version 9 since nine
you would have gesture. So since I have
Java version 12, I should have J shell as well. So yeah, J shell is
nothing but a prompt so it's nothing but
instead of writing into integrated workspace. You could have J shell and you could pry
out something here. It's not something
for production use as such it's basically to test something right
you as a developer could if you want to see what it does instead of writing
everything into the main. So if you write a class you would have to write
things into the main and then run it and stuff
like that with J. Shell. It's just a kind of interpreter
wherein we could write something some command and see
what the output is. So basically you could say for
example we printed hello world, right so system dot
out Dot println. Hello world, right
if you remember this is what we typed into
our main method plate. So if you want to run
this you have to have all this artifacts created as is right to have a class
you need to have main method and then build the class and then run it basically
initial you could run it just to see what's output. As I said, this is not application
as such this is just for the developer to test what the output for
a particular command would be and what a modifiers in Java. So one thing that we saw in the program
was access modifier. We already saw about actually
this one right public and these are public
here as well. So these are nothing
but modifiers right public as I said this public means
the access modifier which shows that hello world could be accessed anywhere
throughout your application. So here we can see as a board
or the fries changes. Meaning of other phase
in some so basically it just trying to say that one
of the aspects are one thing that access modifier
could be used is to control the visibility
of a particular class or a method as well. We have access modifier
for your methods as well. So this is just one of the things right we
would see other modifiers as well modifies in general has
some other things as well. But when it comes to access
modifiers it basically controls the visibility
of a class visibility of a class or a method or so. Yeah modifiers here as you could see there is access
and on access modifiers, let's see access modifiers. So we use public already. So this one is nothing
but a access modifier which is public which says that it could be used
throughout the application so visible to the world as it says public is nothing
but visible to the world. If we talked about
in a logical order if we talk about the visibility so default is visible
to the package. So default is nothing but within the package
it would be visible. So basically you could default is without any keyword
without any access multi-faith. That's a default scope So within the package it
would be accessible only within the package. So you have like
calm down Eureka. That's your package. Right? So this hello world
would be accessible if it has a default scope. It would be accessible only
within calm down Ed Eureka. If you try to access it from some other package
you would get an error. So that's the default
visibility:visible to the package private is nothing
but it is visible to the class. It is only visible to the class. So this is the lowest visibility
only visible to the class. If you try to access it
from outside class even within the same package
you would get an error because You won't be able
to access it is accessible only within the class public
is accessible to the world. It could be accessed from
anywhere within your application or anywhere within your wherever
your class file. So basically if you
if you have a jar file, but what I'm trying to say
is public is accessible anywhere right protected is
again visible to the package and all the sub classes. So we will talk
about sub classes. So subclasses is nothing
but in C we have inheritance, right say for example integer integer is a class as I said in object-oriented
Paradigm or in Java everything could be visualized as a class. So integer itself is
a class, right? So there's a number
there is a super class which is number which has all
the common state and behavior that a particular number
would have right so number is a super class and you have subclasses like Teacher float
would be a subclass of number long would be
a subclass of number. Basically. This is inheritance, right you are inheriting integer
float long double and everything from number class. So number is a super class
and all this integer float and everything is
a subclass of number. So when it comes to protect it, it says that it is visible
to the package and of the sub classes, so just to keep
in mind as of now, you can think of access
modifier as visibility of a particular component or could be visibility
of a class or visibility of a method or instance
variable as well. This is what drives
the encapsulation factor of object-oriented Paradigm. So basically we control the
access or all this components or we control the access of class variables
methods and everything which makes it encapsulated
cannot be breached. Sort of as you could see this is like I could make this one
as default as well. All right, so this
is default scope. It would still run
because it's within the class. Right now suppose I make
this one as private, right? Just to show you what
this encapsulation is all about or what this access modifier
is all about suppose. I make this one private right
still this one runs because it within the class
you are trying to access it within the class now. I create a new class
say for example, we say axis modified test. So I create a main class
here again main method. Now suppose if I try
to run this, right? So basically I create
the same stuff here. See I create
a hello world object. Okay. Now this one is
private right now. If I try to access it from here, what I was trying
to say is if I SEC as you could see here it says that nonstatictest has
a private axis to hello world. So you cannot use
it from outside. That's what I was trying to say. So basically since it
has got a private scope you cannot access it
from other class. And if I remove this private now
with gives it default scope and as we said default is nothing but it has got access within package you could see
this error going off here now it is accessible, right? So that's what is it is all about when you have
a private scope. It's within a class. There is default is within a package public
is accessible anywhere and protected is visible
to the package and just the subclasses. So let's talk about
non access modifiers. This is not controlling the axis
of class method or variable when it static you did
not create object of a class. So basically for static
test you could see that we didn't create
object of a class. We didn't call static test
on a particular object of class. It could be called directly. That's what static is all
about the static modifier for calling methods and variables without an object
to which it belongs as we saw we
didn't create object of our fellow world we directly
cause the static method final is nothing but you
can't change it final as the name suggests. You can't change it
once it is created. So finalizing
the implementations of classes methods and so this is nothing
but instance variable which we would be talking about the slides to come just to tell you this is
an instance variable which we have assigned
the value 10 now suppose within this particular method I
try to change the value to 11. You would get an error saying that cannot assign a value
to final variable. So final is like its final
can't change it once you have created it. You can't change it. But if I remove this final you could see
this error would go off. You don't see
this error anymore. Whereas by putting final
you would see this error. So that's what
final is all about. So basically this is good enough
for constants, right? So if you have constants within your class you
would make it final so that no one can change
it abstract is nothing but you could mention it as abstract when it doesn't
have implementation of all the methods. So what I am trying to say
is abstract modifier is again a non access modifier
and what it tries to say is say, for example, you have a shape class
cheap class is abstract class because shape doesn't say
you want to calculate area of shapes. So basically shape class by itself wouldn't know what
the area of the ship would be. Is a class where in the generic
class it doesn't know what the implementation
of area would be 4 Square. It would be Side Square for rectangle its length
into breadth or Circle. It's pie R square. So basically shaped by
itself wouldn't know what it's area would be but now shape is a super class
and say you have subclasses of it like Square you
would have Circle and so on. So now basically
you want to ensure that when you create a subclass of the shape class
you want to ensure that that particular class
implements the area that's when you create it as abstract. So the shape method would have of the shape class would have
area method as abstract which would be implemented
by the subclasses which has to be ensured
its kind of ensuring or if the subclasses
don't actually implement it you would get a error. So basically Circle would have
its own implementation of areas in pie R square square. Would have its
own implementation saying Side Square. So basically what I'm trying to
say is area is abstract method for shape class. And when you have
abstract method the class itself is abstract. So you have like shape calm
down Eddie record dot shape. I'm creating a class now. I'm creating a abstract method
So when you say abstract, you don't have
to provide implementation. It's just a chain break
this thing you don't have implementation of it. You just have
the signature of it. So basically as I said, when you have an abstract
method the class itself should be abstract. So we'll have to make
this abstract as well. So you created a shape class which would have a area and
which would give you this thing. So basically we want to have
subclass and want to show how the sub classes
are created at this point. But basically this is
what abstract is all about. You don't have
the implementation of it, but you are ensuring
that subclass is implemented. So here you can see
Just a signature. You don't have implementation unlike this implementation
is nothing but if you write something
within this braces, this is an implementation
for this particular method, whereas in shape class. You just provided
the method signature, but we don't have
limitation of it. So that's what abstract
is all about synchronized and volatile is much about using threads
synchronized is we are saying that only one thread could get
a control at one point. So as we said threads are
nothing but parallel execution you could have
thread say for example, you could have read
one calling a method. So we have as non
static method test right say this is a method. So what we are trying
to say here is if it's synchronized we can make this a synchronized
private synchronized. So this is what id is all about. So when you have this integrated
development environment, you don't have
to type everything when you type S why you could
see synchronized coming up here. Put selected. So when you put
a synchronized here, what we are trying to say is
only one thread could access it at a given point only
one thread at one point. So if multiple threads
are trying to access it one thread has to wait for it. So only one thread
would get entry to this and the other thread
should wait for it. So that's what synchronized is
all about and volatile. It's basically for
memory visibility or what we are trying to say is
so basically every processor has got its own cache. So what we are trying to say is when you use a volatile access
specifier don't store it in Cash Store it directly
into the main memory so that all the threats would get the most
recent value being assigned to a variable also
volatile is not needed when you have using synchronized as such so it's
mutually exclusive. So let's talk about variable. So variables are nothing
but it's a holder, right? Holds value and variables are
nothing but it's reference to that particular meal or it's a dress or something that is pointing to a memory
location a memory location where the squirrel use
are being stored and you could access it using
this particular variable name or you could access
the memory location where the value is stored
using a variable name what I'm trying to say here is so this is a variable
and you could access so this 10 is stored
somewhere in the memory and you could access this part
of memory location where this 10 is stored
using this variable or you can manipulate it
as well can change the vat. So basically there are
three types of variables in Java this local instance class
or static local is nothing but local to your method
whenever you have a method or you kind of create
a variable within a method that is nothing
but local scope which is like it has the axis
its visibility only within that. Particular method once control
goes out of this method you can no longer access
is particular variable that is local. So if I Define something
here say, for example, I Define something here. So this is a local variable since its defined
within a method. So once the control you
would have this only within this particular method, once the control goes
out of this method. This is no longer accessible. Basically, this is where garbage collection
for Java is useful. Once you control goes out of this particular method
garbage collector would kick in and were dean of this variable or clean of this particular
memory location or would make it available for use. So that's the local scope. The next one is instance instance is
nothing but something that is defined
at the instance level. So this is instance variable. So since it's
at the class level, right this is you could see
it at the mid-level. This is at the class level. This is nothing but
an instance variable now there is static variable as well. So this is how you define
a static variable. So instance variable is
nothing but it's per instance so you could go and change
this instance variable to something else suppose. I assign a value for T here now. I could have one more object
created suppose I call this object one and I have Hello World object. So I create
one more object here. So what we are trying
to do is we are trying to change the instance
variable through objects. So basically this is
what it is when you have an instance variable
normal instance variable, which is non static
you could access it through objects, right? So throughout object one you assign for object one you
assign instance variable value to 44 object to rinse
you change the instance variable value to 50. I won't say Changed it. But you assigned it. This is how you deal
with instance variable. It's at the instance level. It's at the object level. Whereas for static. It's at the class level. It's one per class. It's not one per instance. It's one per class. So basically what you can do
is you could do something of this sort where in its
at the class level. It's not at the object level. You are assigning value hundred
to a static variable. So as you could see here, it's not a particular instance that you're operating
on its the class directly just to give you a just
we have local variable which is within a particular
method and scope remains within a method. Once the program control moves out of this particular method
Java would or jvm would come in and kick in garbage collector to
clean this off Sony accessible within this menu you
have instance variable, which is at the class level, but it's non-static
and which means that it has copy. Per object when you
have multiple objects, you could change
the values the way you want per object static is nothing but 1 per class and
as you could see here, we change the value of
the static variable 202 class. So that's about variables. We have an instance. So instance variables
are declared in a class when the space is allocated. I will just read
through this one. So when a space is allocated
for an object in the Heap slot for each instance variable
is values created. We had a your instance variable and whenever you create
but basically an instance of a class is created
in a part of a memory, which is called Heap. So whenever hello
world object is created a slot for this instance variable would be treated as well
instance variables are created when an object is created with the use of keyword
new and destroyed when the object is destroyed. So unlike local variables, which is within
the method scope. Variable is within
the class scope. So basically whenever
you create an instance of a particular class, your memory would be allocated for that particular
instance variable. And whenever it's done whenever it's destroyed
by the garbage collector, it would go off access modifiers can be given
two instance variables. You could have like
private public protected default all the access modifiers. We assign to students variable. So basically you could have it as private private is just
within this class. You cannot access it outside this class you
could have public as well, which is like would be accessed
anywhere within this application you could have protected which is like within the package or the subclass and you can have
the default one which is nothing but package axis, which would be accessible just
within this package that is calm dotted Eureka. So instance variable
have default values for numbers the default value
zero for Boolean it is false for all. Big references it is null so values can be assigned
during the Declaration or within the Constructor you
could assign values directly while declaring it something like this instead of 0 is
the default one for integer as they have mentioned. But yeah, you could assign if you put it as 10 here it would be taken
as a default value zero zero Constructor
is nothing but a method which constricts an object of a class values can be
assigned during the Declaration or within the Constructor
instance variables can be accessed directly
by calling the variable name inside the class. However, with static methods when instance variables
are given access ability. They should be using
fully qualified name. So what we are trying to say
here is this is a static method from which we are trying
to access instance variable in this particular
static method you need to have object reference. This is Object
that we created so object reference dot instance
variable you need to have as we have mentioned here. So here as we can
see object reference to a variable name. You need to have
fully qualified name. When you try to access it
within the static method. You need to have
fully qualified name. Whereas here within a method
which is non static. This is non-static here. I can access instance variable
without object reference. So here as we can see it
could be accessed without but if I do it here it
would throw me an error. It's not accessible here at all. Non-static Fields instance
variable cannot be referenced from static context
instance variables are not accessible directly here. It has to have fully
qualified this thing, which is object reference
dot instance variable. Whereas when it's called within non static method you
could use the direct so static as we spoke about
it's one per class, so it's declared. Using static keyword. So static variables
are stored in static memory. It is rare to use
static variables other than declared final and used as either public
or private constants as we said, it's mostly used for constants
and static variables are created when program starts and destroyed when
the program stops. So one thing to remember
is it's one per class. It's not one per object
instance is one per object. We have a copy of that
particular instance variable one per object case of instance, whereas case of static
it is one per class. So the scope remains are
the life cycle remains right when the class is loaded
in the program is stopped in the class is unloaded static
variables are declared public since they must be available
for users of the class. It's not mandatory though, but usually if it's
a constant it is declared as public static variables
can be accessed by A calling with the class name. So we saw here last name
dot static variable. So how do we decide what amount
of memory is to be allocated? So these are the data types
that we have. So each variable in Java
has a specific type which determines the size
of memory the range of values that can be stored
and the set of operations that can be applied to the variable data types
can be categorized into two major types
primitive and non primitive. So basically primitive
is not object primitive is supported by language itself, which is kind of it
has got 8 primitive or its pre defined
by the language and named as keywords and it
has 8 primitive data types that is byte short integer. Then you have long float
double character and Boolean. This is pretty much similar
to other programming languages that you have by it
consumes one one bite. These are 8 primitive data type
set of predefined non-primitive. It's nothing but string string
is object itself. So that's something that is non pyramid
or if we Define your own class C student
for that matter here, right? We have defined student class
that's non primitive. So this student class has non
primitive you have strings for storing string, which is again kind
of non primitive. We have arrays or basically it's all
as reference variables since referencing
a particular memory location through variable name. This is where we have table
showing white consumes one bite and it's range is from - 128127 short is like two bites
and you could imagine that it would be
from - 32768232767. So it's pretty much similar
to other programming languages that you have like in C as well
we have similar to this thing. One thing is characteristics
to bite in C takes one bite. I believe though. It doesn't use all
the two bites every time it. On encoding type. So Boolean is one
which is true of all since it has to store 1 or 0. So it's pretty much similar. So just to talk on the bytes
required by test 1 byte short is 2 bytes integer is 4 bytes long
is 8 bytes float is nothing but it has decimal values
stored signed decimal values. So it again concerns for bites double is sign
again float values or sign decimal values which consumes 8 bytes
character is 2 bytes and bullion is one bit. So basically so decide whether to use float
or double depends on the nature of the application. So if you want to have
more Precision or if you want to have more range
you could go with double so non primitive or reference
data type is a variable that holds a particular
object or holds bit that represents a way
to access an object the pointer to a memory location baisakhi. So as we spoke Java doesn't
expose the pointer directly. It doesn't give you directly
pointed to the memory location, but it gives you
the reference variable. So you cannot manipulate
memory location directly. You cannot add some values to the memory location
through pointers or something but through reference variable
you can access it and assign someone so yeah, it does not hold
the object itself, but it holds a reference address to the object reference type
does not have size or bit range. So here we can see string Str
is equal to Ed Eureka. So the one shown in red is actually the memory
we're dead Eureka is stored. You have a reference
and Str is the reference to it. So here we can see
variables and data types. So we have a main method again
and we have bite. We declare a bite
here by D is equal to 10 short s is equal to 20, so, I think it's
pretty straightforward. You kind of have this data types
created you just have to assign values to it. These are all Primitives
as you could see till here. It's primitive so you could see
that values are being assigned and it's been printed out here. So I think it's
pretty straightforward. You can assign a value
to a variable n just print. So again, we use system
dot out dot println for printing it you
could try it out on your own. You could try it out
this data type program. You could just assign something
and just try to print it out. We are talking about
data type conversions. So we have implicit and explicit conversion in some case programmers
don't have to actually write explicit conversions
from one data type to other but in many
cases programmers need so the arrow in the diagram shows the possible
implicit type casting that a permissible bit
primitive data types. It's just with primitive data
types right as the diagrams. Those int can be converted
implicitly to Long float double since int X likes less space. It could be applied to any
of the numbers for vice versa. They have to be
converted explicitly. Whereas if you want
to convert long to integer, you have to
mention it explicitly. So basically we are talking
about when you're trying to store integer into long
integer takes less space and long takes more space. So it should can
be easily accommodated since long takes more space. If it is more than the range
of the integer. It wouldn't know
how to assign it to an integer. So that's why it has
to be explicitly convert implicit conversions. We can on the J shell
you could type this. So here what we are trying is we
have a character C is equal to a and you could see see is assigned a now
integer K is equal to C. Which could be done
you could assign character to an integer. So basically it's
a ASCII code for it. So 97 is the ASCII code for see
which would be assigned to K. So now when you
assign see to float, which works as well, so you get ninety seven point
zero you could assign character to long as well, which is in bytes integer, you could assign
double as well, which is 8 bytes float
and you could see but it cannot be done
the other way around as we spoke. So you cannot have integer or you cannot have double
assigned to character. So it would
give you incompatible our possible lossy conversion
from double to character. It has to be explicitly done. If you want to do that need
of type conversions. So here we have integer
a full 200 initiated a variable with type Teacher then
you have a string B, which is assigned value. Hello. So basically here you
can see string being used which is a reference variable
and you have string s is equal to a plus b as equal to a plus
b then it adds up like hundred plus since hello is a string
it would concatenated so you could see hundred and hello being concatenated
and you could see hundred. Hello the data type of both
the variables are different but to perform any operation we
need both the variables to be of same type here integer value
is converted into string and gets concatenated
with other string. So basically had we
been an integer you would have got edition of it say for example integer B is equal
to 200 and if you hundred plus 200 you would get 300 but since it's a string in this case
hundred is converted into string and it is concatenated. Hello explicit type conversions. We saw the previous case where an double was being
assigned to character which prompted us
with lossy conversion. So this is similar to that. So basically here what we are trying to do
is we are trying to assign double to integer. So you have double D
is equal to 45 B, which is 45 right again
double is 8 bytes decimal signed decimal number so you assign 45 to it. And now we are trying to assign
this double value to integer. So it's possible
lossy conversion, but you have a provision
to type Custer. So basically what we're trying
to do here is you're trying to assign again double
to integer which is possible if you type casted so when I say typecasting it's
nothing but opening parenthesis, then the destination data type
then your data. To a table. So basically to the right
side you could see that through explicit
type casting we can assign double to integer. So costing may lose information. For example, floating
Point values are truncated when they are cast two integers
example the value of D. That is 45.5 when converted
to integer gives 45 so we could see here
the bottom like the double we assigned the value
of 45.5 to double but when we convert
it into integer, we got 45.5 Force truncated
since double since integer since the destination data type that's integer dozens
to decimal values. Now, this is like
type conversion methods which is there
any wrapper classes? What we are trying to do here
is we are trying to convert 23, which is string into integer. So you have a string. As is equal to 23 you
assign the value 23 so mind you this is this
is string right now. We have integer dot parse int
and we pass the string which would be
converted into integer. So this integer class that you see here
right here is nothing but butter wrapper class you
have string into an integer, which is nothing
but integer dot value of string which converts it
into digital data type itself. So the you could see
the destination is is integer. Now integer to string
you have integer. We have a tostring method which with converts
integer into string. So basically you have integer I
which is been assigned 23. Now you have
integer dot tostring I which would convert
this integer into string. We have one more method which is string dot value
of which would also convert. Integer into string. Let's talk about
operators operators are nothing but it operate
on this data types. So you have unary which is kind of pretty
much similar to what you have C C++ you have post fix
and you have prefix post fixes. I plus plus or expression plus plus and the operator is
after the variable which means that it would be assigned value and then it would be added
prefix is before the operator which would be added first and then assign or the operation
would be done first and then assign that's
prefix arithmetic is pretty much similar
like multiplicative you have like multiplication division and
mod you have additive which is plus and minus you
have shifting operation, which is bits shifting
to the left and bit shifting to the right you have
relational operators less than greater than less
than equal to greater than equal to. Instance of Quality
quality of two data types or two variables which check whether they are equal
and not equal. We have a bitwise and bitwise xor bit
wise inclusive or which is happening
at the bit level. We have logical
and logical or so. Basically, this is
for conditions, right? If you want to have
like two conditions, like if int I is greater than 0 and int J is greater
than zero sort of you add or you have logical anding between two conditions
logical conditions or illogical or
pretty much similar to other programming languages. Like it's or
between two conditions. We say that either this or
that we have a ternary operator, which says that if the condition matches we
would have a condition followed by a question mark
followed by colon, and we would have some value Followed by colon followed
by some other value. So what we are trying
to say here is if the condition is
true assign value 1 if the condition is false
then assign value to so instead of having it written in if else you try to put it
within turn your printer. So basically this is when you
have simple assignment operator, if you have a logic if you have some particular
logic been written it would be a better practice to have if else so that
it's readable right because ternary operator it would be very
difficult to actually through we have
assignment operator which is equal to which is
plus equal to is nothing but adds the value
on the right hand side to the left hand side
and assigns it to the left hand side table - equal to does the same thing. It kind of subtracts value to the the left hand side from
the value to the right hand side and assigns it
to the left hand side. So I believe this is pretty much
similar to other programming. Languages there's nothing different in this we
might have used it somewhere or the else should be pretty
much simpler for you guys. So let's see
unary operator example when X is equal to 10, so you could see X
been assigned value 10, you have X plus plus as we said it assigns first
and then increments it so you could see
value 10 here again. So now if you after this
if you print the value of x, you should see
the incremented value. That's 11. So that's post-increment. So, let's see pre-decrement. So you have a been assigned
the value of 10. All right. Now, you do - - A which is pre-decrement you
would see the value 9 directly. And now if you print the value
of a it would be nine again. So basically this is like decrement and then assign
this is like a sign and then operate this is
like operate and then assign Let's see the negation operation
like a has a value of true now, we negate it and assign it to the variable D
and you could see that it's changed to false. Now. Let's see the
arithmetic operator. You have B
which has value of 20. We have D which has value of 30. So when you add
it gives you value of 50 when you multiply it gives
you the value of 613 220 which is 600 when you divide it 30
by 20 you get value 1 and when you have mod, which is like remainder, which gives you
value 30 by 20, which is equal
to 10 shift operators are so it shifts to the left
so shift left shift, right? So basically you have
integer value of 20 and if you convert this into binary if you convert the 22 binary which comes out
five digits, right? So when you convert this binary
and when you shift, To the left you would get
the value of 80. So you have value 20, which is nothing but if you
convert this 20 into binary, which would give you
one zero one zero zero right. Now, what we're doing here
is kind of Shifting it to the left by 2. This is what you do and this is
what it shows up as value of DT. So this is nothing
but 64 plus 16. So that's what this
left shift does. Basically it shifting
to the left by 2. Again, you could have shifting
to the right by 2 by 3, which would give the value
of to just shifting to the right by 3 would be
something like this. Right? So you're basically it shifts it
and you could see that. Yeah, basically it
would end up to 2. So now we have
like relational operators, which is pretty much simple
like a less than b. It gives false a greater
than b equals equals P. Since you have a is equal to B. In this case. We have a equal to B. That's why we have a
less than b as false and a greater than b as false. But whereas a equal to equal
to B is equal to 2, we have arithmetic operators
pretty much similar. Basically you have ad you have multiplication you have
division you have mod. So here we have
a is equal to 20. So what we are trying to do
is assignment so a is equal to 20 now B is equal
to 40 a plus equal to B, which is nothing but as I said, your left hand side would be
added up to the right hand side and would be assigned
to the left hand side, which is nothing but 20 plus 40
would be assigned to a so when you print a it would print
60 ternary operator, which is nothing but if a is
less than b here we can see that if a is less
than b then the value of Should be assigned to tr
or the value 200 in this case. The value 200 is been
assigned is greater than b logical operators
is nothing but anding and o-ring of conditions. Yeah, here we are saying that a is less than B and D is less than b
then return false and it's like kind of
ending logical conditions. Now, let's talk about
the control statement in Java. Now again, this one
is pretty much similar to other programming languages nothing different nothing
different in Java. So you have control statements
you have I treat if statements you
have jump statements. So one is selection
or decision making statements, which is like if else
if else ladder you have if if this particular condition
satisfies do some things do some execute group of statements and if it doesn't then execute
other group of statements that is about if else Which is nothing but
based on the value of a variable like you to execute
different step of statements like say for example, you have you write a switch on Integer value
integer variable X. Now when X is 1 you do
something or if x is 0 you do something or you can have
a default statement as well when X is either 0
or 1 do something else that supports which I tradition is you repeat the same set
of statements again, and again till the condition till a particular condition
is met that's a titration. So you have four Loops, which is like after every
iteration the value of variable or the iterating variables
would be changed and would be checked
against a condition and if it meets it would come out or if it made it
would execute it again, and if it doesn't mean
then it would come out. So yeah, this is pretty
much similar to other. Other programming languages. So for for INT I is equal
to Z 0 is less than 10. I plus plus and you write
something within it. So this Loop would go on
for 10 times from 029. It would break it would come out when eyes greater than 9
which is 10 when it goes to 10. It would come out while is again pretty
much similar to that. You have do while construct which is guaranteed
to be executed once because the condition is checked after the execution is done once so basically no matter
what the condition is. It has to be executed
once for sure. That's when if that's
the behavior you want to put into your program you would use to Y is equal to once for sure jump statements
you have like break which come out of for
Loop Komodo for Loop or any attractive statements
you have continued which would again continue
and return is again coming out. Of a method or are mostly from the methods
you written something so the control leaves
the method now just to give you what if Wells is
if if the condition is true, then then execute
the conditional code. If the condition is false come out of the execution or come
out of the conditional code. Skip the conditional code. That's what if else is
so here you have int I is equal to 10 and
int b equal to 20 if I is less than b so it's pretty much similar to
the ternary operator that we had so you could see here TR is equal to a plus b
so basically the value if a is less than b
which is in this case a is equal to 10 and B is equal
to 20 in that case. You would have PR as
30 since it is true. So basically it checks
the condition and if the condition is true it
executes the code with now let's talk about If else if it if else construct is nothing but you have a is a set
of statements to be executed when the condition is
in satisfy succeed. So in this case if a is less than b TR is equal
to a plus b else TR is equal to B minus a so in this case
it was less than a is less than b so you
got the value of 30 whereas if a is greater
than b we have again changed it. So if a is greater
than b then TR is equal to a plus b else TR
is equal to B minus a so in this case a is less than b so which means CR
should be B minus a which goes into the
else condition statement and here you have
20 be as 20 and a as 10 which is 20 minus 10. So you should have PR as 10. So here it's pretty much same. It does the same thing
nested if-else now, we are talking about
the switch statement. So you have switch expression
and you would have case written against it whatever case
you want to execute. So basically you
would have for Value 1. So yeah, what we are trying to say here
is we have a switch expression and we have a value for Value 1 as its value then
execute this piece of code and then break out and if it has value to then
execute this piece of code and then break it doesn't match with value 1 and value to then
executes the default cases. So one thing to note here is
it's mutually exclusive only one of it would be executed
out of the cases. Make sure you break out of all the the conditions so
to the right hand side you could see integer
CH has a value of 40 now. We have a switch for 40 now. Is when the value of CH
is 20 it would print case 20 executor when its value is 30 then we
would have case 30 executed when its value is 40 then we would have
case 40 executed and then break out and if it's neither 20 30 or 40
we would have a default case is executed with says that 20 30 40 not executed. So in this case since it has a value
of 40 you would see that case 40 executed as
output I'd frisson is nothing but it is basically
I treating code if a condition is met
the the code would be executed until the condition is true. The code would be executed
and once once it is false, it would come out of the loop. So basically it's
a looping statement. So after every Loop
the condition would be checked and if the condition
is true it would loop again. And if not,
then it would come out. There are three types
of for Loop in Java simple for Loop similar. See like for INT I is equal to 0 I is less than 10. I plus plus would be
a simple for Loop for each or an enhanced for Loop
and labeled for Loop for each is basically I treating on array list suppose
you have some collection or suppose you have a re right? You don't have to
manipulate the indexes since the typical scenario with arraylist is I treating
through all the elements within the list. So we have an enhanced for Loop wherein we don't have
to actually deal with indexes. Java has come up
with a enhanced for Loop where and what each iteration
it would assign the value of each element
within the array to a variable which could be used
within the loop. So we don't have
to deal with indexes like we don't have
to Loop through till the sizes met in the loop through in the size
of an array is Matt, basically it Done
by Java itself. We have an example
which would clarify it. So simple for Loop is as I mentioned you have
for INT I is equal to 10 is greater than 1 I minus minus so it
would print from 10 to 2. That's a simple for Loop. Now. What's the Syntax for it is
for then open up round brackets. Then you have initialization. Then you have a condition
and you have increment or decrement whatever
you want to do or you could even add up like I plus equal to 2 even
that is good enough. It's like for each even number
not even I would say it's like incrementing by 2. Now. This is what I
was talking about. So this is for each Loop
or enhanced for loop. We're in a typical
scenario with array. You kind of eye to it
through each element within the array and then do something
within the loop, right? So this is what Java
has made it easier for us. So basically you don't have
to deal with indexes here if we wouldn't have had
for each Loop. What you would do is
you would tell the size of the array is Matthew
would I trade through and read from each indexes right? But in this case as you could see
there's an array and for each Loop the value within the array would be
assigned to this variable and you could use this variable within makes it pretty
much simpler for us. And as I said, this is typical thing that we do with arrays now labeled for loop it's not
recommended to use this often but still we have
this construct here. So basically it's like go
to we can have a label of each for Loop. It is useful we
have nested for Loop so that we can break
or continue a specific for Loop normally break and continue keywords continues
the innermost Loop innermost for the loop only to give
Behind why I mentioned that this should
be used often is because it becomes
very difficult to debug right? If you dry run it
if you use this labels, it becomes very difficult
to actually understand what's happening within so
so we should avoid it and all this could be done
by writing a proper construct. Sorry using simple
for loop as well. So we should avoid it
somehow so basically as per my experience is
not a good practice to use them. So type of while loop we have SIMPLE while loop
we have do-while Loop. All right. So simple wire Loop is first
the condition is checked if it meets then the looping
statements are executed whereas do-while Loop is kind of
the statement is executed once for sure and then
the condition is checked if it is met then
it is looped again. If not, then comes out. So this is a simple while loop so you have conditioned
as you could see here while a is greater than 1 you print the value
of a and you increase decremented Within Here
it's a do while loop so no matter what you
would have this to printer and it would be incremented. So it's 2 to 9. So no matter what some value
would be printed for sure when you use do I now
we have jump statements, which is breaking slyke
coming out of a loop. So as we mentioned
it's the innermost Loop that it comes out of
so that's what Brave does if a particular thing is met
or you could write a condition for a particular Loop
to be broken rather than continuing it. So basically you could have
like this would be more or less like you could have infinite Loop say for example
running through and if a particular condition
is met you could break out of it a typical scenario where it would be used. So here you could see
that you have a loop from 10, which I traits from where I is equal to 10 and
where I is greater than V i- - which we are
decrementing each Loop. Whereas you're saying that if I is equal to equal
to 7 we should break out. So here you can see though eyes greater than 5 you can see the
loop has broken out after 8:00 since the value
has reached seven. It's not printing
the other indexes because it broke
out of the loop. So basically this is like if a particular condition is met and you don't want the loop
to go ahead you can break out of the loop
continue is similar when you write continue, it goes to start
of the loop again, it starts the loop again and it skips the messages
or it skips the code that you have after continue. So in this case you could see that we have I equal to in case
when I is equal to equal to 5 We are continuing the loop which means the print statement for I when I is equal
to Phi wouldn't get executed since you're continuing it. So basically as you could see
the News being printed here. You can see the 01234 and there's no 5 here
then we have 6789. So basically what we
are saying here is when I is equal to 5 don't execute
the statement within the loop. Just continue. Just keep it. Okay. So what a methods
in Java So method is if you would have written function or if you would have
used any programming languages if you want to
perform some operation if you want to do something or if you want to do something
on some particular data, you would write a method. So basically in Java methods
are defines the behavior of a class. So remember I told
you a class is all about State and behavior. So methods are nothing but it
defines the behavior of a class. So what are methods or method
has a group of statements? Of course, as I said, since it defines the behavior
of a class you need to have some operations done, right? So you define the operations
through group of statements. It is much more used to have
reusability of a block of code that minimize redundancy. So imagine if you
didn't have methods then you have written the same piece
of code again and again, Say for example, you have a method
which adds to number right? And if we write the piece of code to add two numbers
directly into the main method if you want to write it again, or if you want to again
add two numbers, you will have to write
the same piece of code again in the main method. Whereas if you have a method what you would do is
you would refactor and take this add
method or functionality which adds two numbers into a method and this method
could be invoked from anywhere within the application which is nothing
but re usability right rather than writing
the same piece of code. Now, what you are doing is you
are defining this add method into some other method which could be called
anywhere within the code. So that's about redundancy that minimizes redundancy
and increases the reusability of a code a class
can have multiple methods as you could imagine. You could have
multiple behaviors introduced into a class which means that you would potentially have
multiple methods within a class. A method returns a null or a value using
the written statement. So basically the intent of the method is to perform
some operation, right? So what method would take
is it would take parameters and do some operations
on these parameters and it may or may not return something back
to the calling program. So if you don't want
written anything you have to return null or if you want to return some value
you could have say for example, you want to return string
you would return a string of a method you
could have void as well, which means that the method
is not returning anything back to the calling program. It is doing something
within itself and just the control would be back
to the calling program, but it won't return anything
out of the method that's about method. So let's talk about so
what the syntax of method So the first one that you see so this is a method which is public int
at Eureka integer a GB and it is just concatenating
the two strings or two numbers that we have sent a cross. So basically let's
an itemized it so what is public
so public is nothing but again access modifier so public means
this particular method could be accessed from anywhere
within the application. So that's what public
means similarly you could have private. You could have default scope or
you could have protected scope. So public is accessible anywhere
within the program private is within the class default is
within the package and the protected is
within the subclass and the package. Okay. What is this int it is nothing
but the return type so this particular method
is going to take two. Arguments and do something
and written integer, right name of the method
is you can see ID Rekha. That's the name of the method. Okay. So what do you see
within the parentheses after the method name is
nothing but the arguments that this method takes so what this particular method is doing is it
is taking two arguments which it is acting upon right? So it takes integer
a and integer B, that's the parameter list. So whenever you want to invoke
this particular method you have to pass arguments in this order. Now, what do you see within
this curly braces is nothing but the behavior or this is how you introduce a behavior
to the class or this is how you add functionality
to a method. So what you are doing
here is kind of adding these two numbers. So what is
the written statement? What does it do? So written statement is nothing but you do something
you take the arguments whenever controlled comes
into a particular method. It does something and you return it back
to the calling program. So the written statement
is a control flow statement that terminates the execution of method and written
control to its caller. So when return type
of any method is void, then the method does not return
anything if it is void, you won't return anything out. But if it is written in string or something you
would return string or null if you land
not to return anything, it could be null as well. So here we can see
a method by the name work which is returning void. So you can see
that it is not taking any arguments as
such or parameters, but it is just
printing out saying that I do recall welcomes you in the second case you
can see it is written integer. So it's taking int A
and B. Okay, and then it is printing out and it's returning
integer as well. So let's write a program sample
program to add two numbers and we would be writing all
this logic within a method. So let's start off
by defining a class. All right. So we define a class
say calm dot edu, Rica Dot and a typical name for
all arithmetic operation glass with all arithmetic operation
would be calculator, right? So I would write
it as calculator. For example. Alright, so here you can see
the naming convention again. There's a package
which is calm down at Eureka and you have
a class has calculator and it follows camel casing so it starts with upper case
followed by lower case. So you can see the class
is being created here. Okay. Now what we are trying to do is
you are going to have a method which takes to number. Okay. So say I Define
let's keep it public. All right. So this is access modifier. We want to keep it public. So you want to access this particular method from
anywhere within the application. So I'm keeping this public. So typically addition
would return results, right? You would add two numbers and return results
of two numbers. So that's your written type
which is integer. So you could either write
the return type as primitive or you could write it
as a wrapper class. So basically wrapper class
is nothing but integer has its own everything
in Java could has to be realized in terms of classes. So integer has its own class int
is a primitive data type and integer that you see here. Is a class corresponding int
so let's put the return type as integer and add is
a method name. Okay. Now this takes two arguments
integer arguments, which is arg1 and let's put
the second one as arg2. All right, so we start
and ended by curly brace. Okay. Now we have to write
logic within here. So what you see here, it's throwing an error
saying that you are not returning integer out. There is a missing
written statement because in the signature this is known as method signature
this particular thing that we have defined
here is Method signature. So in the method signature
you have mentioned that this particular add method
is intended to return integer out of the body, but still you
haven't written integer. So basically to get rid
of this I could put written null which means it's doing
nothing now you can see that Got rid of the error. So let's do one thing just
to make it more verbose. I will write integer result
is equal to ARG 1 plus ARG 2. So this is a method body
that you are defining here. So you are adding
a behavior, right? You're giving Behavior
to the calculator class. So by defining add method
this certain behavior that you are introducing now, you could have
a multiplier method as well which would take two numbers
and would multiply it which is again giving some sort
of behavior to calculator. So that's the reason we say that methods add
Behavior to the plus. Okay. So here it is taken two
arguments arg1 arg2 adding it and we will return
the result from here. All right. So this is a method
that you have defined. But so far we are not invoking
this method right? We are not calling
this method you want to call and check whether
it's running as expected. So that's where we
would have main method right? When you type mean it should
give you suggestions saying that are you trying
to write main method? So if once you click
on it it would this is done by IDE by the IntelliJ
similarly in Eclipse. You would get an option, you know, it would give
you suggestions saying that we want to
introduce main method. All right, so we have
a main method here. So again, it's
public static void Main and it's taking arguments here. All right. So remember I said
static and non-static Method you can see
here add is non static method when it's a non static method
you have to create instance of this class to invoke it. So basically first thing that I do is I create
instance of Later, so how do you create
instance of calculator? It's with new keyword. All right, you create new and it would create
an instance of calculator. Now I give a call to add method and suppose I want
to add like 10 and 30. Okay. So these are the arguments and it has to be
in order in this case since both are integer. It doesn't matter but had
it been some other data type. You have to ensure
that say for example, I write string here what this would return
is typically a result right addition of two numbers. Now, let's print it out
system dot out dot println. This is for printing result of addition is flits
print out the result that we get here. All right, and let's end
it by semicolon. So basically you have
a package defined here within the package
you have calculator and actually it's my bad. I should have defined
it right here. So it gives my it gives
the right package name here. So earlier I had defined calculator with income
dot Ed u-- Rica again. I defined a package computed
Eureka which is not required. So yeah, you can see here
packages calm down said Eureka which is nothing
but the namespace we have public class calculator. So public is nothing
but the access specifier for this class plus is the keyword used
for defining class and calculator is
the name of your class. Also one thing
to note is the name of the Java file should be same
as the name of the class. So that is something that IDE or IntelliJ
would do it for you. You just have to create class
and it would create class. So basically if you go
to the source folder you would have something
like calculator dot Java right? Then you have public method
which is again, here's the method that we have defined public
is the access modifier for this method integer is the return type add is
the name of the method. It's taken two arguments
arg1 arg2 within the body you are adding two numbers
and you are returning result which is integer which aligns to the signature
that you have put here. All right in the main
method just to check whether this add method
is functioning properly. What you do is you create
the instance of calculator. You add two numbers you
pass two numbers to it then and 30 and we are going
to print the results and see if it returns as expected. So here basically it
should print the result as 40 since adding 10 and 30. So remember while it
builds it it would compile into a class file. Okay, the dot Java file
would be compiled if it's properly written
if it's in tactically, correct, it would read dot class file. All right, let's wait
for it to run. Okay, so it's
prompting me errors that we have an other methods. So let me do one thing. Let me delete other classes
that we defined yesterday. So I get go to the
source folder Comdata. Directa. I So I am just
deleting this classes that we defend yesterday. So that we don't spend time in
actually correcting it, right? So put it into a backup folder. All right, so Okay, so we have only
this calculator class now I run this. So yeah, you can see here. It has been tested result
of addition is 40. So basically what it
has done is adding these two numbers 10 and 30. All right, so that's
what we have here. So we are adding two numbers. So let's talk about the sequence
of how all this is being carried out by Java right when you run
a particular program how things work out
when you run a class. The first thing that's been called
is the main method. Okay jvm is nothing
but Java virtual machine which runs the program for you which is part of JRE
Java runtime environment. When you run a particular class, it would search for a main method and
if it doesn't have a main method then it
would give you an error saying that a class can't be run. So it's pretty much similar
to executable file, right? So if you're trying to run a class it has
to have a main method or you won't be able
to run the class directly. So that's where
the execution starts from. That's the entry point
for your program. Okay. So once it encounters Main and everything is good
your jvm would start executing the statement. That are there
within your main method. Okay. So in the edition case that we saw within the main
method we invoked we created the instance of calculator
and we invoked add method right? So when we ran that particular
class you could see that the addition was done. So basically what's happening
behind the scenes is, you know jvm would execute
the sequence of statements that you have with a name. So again coming back
to the example add example So within the main you
invoke the add method right when you invoke add
method the control would go to the add numbers method and it would again
execute whatever functionality you have put within
that particular method this case it was addition of two numbers. So it would execute
once the execution is done. It would return whatever
is been written out. So in this case, I was was addition
of two numbers, so it would return addition of
two numbers back to the calling. Program so you're calling method was the main method wherein you
called this add numbers from? Okay, so it would come back
to the main method and that's how it prints it out. So following the invocation
of add numbers you could see that we have printed
out the visual that comes out of
this add numbers and that's how it gets printed
onto your console so that the sequence of execution
that happens behind the scenes. Now what are the ways in which
you could call a method? There's call-by-value call by value is nothing but instead
of passing the memory location, it passes the value
of a particular variable. Okay. So this is similar to call-by-value and
call-by-name reference that we have in see okay, instead of passing the memory reference or instead
of passing the reference. It's just a value
that's been passed. So if you change something
within the method or if we change the value that's been passed within the method only
the local copy would change whereas the main copy
would remain as is but basically call by value
is just passing the value but not the actual reference. All right, so to understand
call-by-value you could so this would give you some idea. So say for example, I have integer ARG
1 which is equal to 10 integer ARG 2
which is equal to 30. Okay. Now I pass ARG 1 comma arg2. So what's happening here
is it's passed by value. So suppose you change. What I'm trying to say is here if you change arg1
to something else 300. Okay. So what we are trying
to do here is we are trying to pass this to arguments
arg1 arg2 to add method and within the add method we
are changing this arg1 200. Basically we would check whether this hundred
is been reflected in arg1 here. Okay. Arg1 here would
change 200 as well. Let's see what happens here. Okay, so I print it. Okay before passing it by value. So I print arg1 here. Okay, and after I give a call I would again printed
printing arg1 after busting it a value to a method
add Method All right, so let's run this so basically since its passed by
value arg1 would remain as 10. Okay, so that's what pass
by value is all over. So here you can see arg1
before passing was 10 and arg1 after passing was again 10. Alright, so the change that you made here
doesn't reflect here. So that's pass by value. All right. So this one more concept of
method overloading with in Java. You could have same methods with different number
of parameters same method when I say same method
it has The same method name which would take variable
number of parameters. Okay, the overloading happens
at the compile time itself. So during compile-time jvm
understands to which method you are actually giving a call based on the actual parameters you
pass on so just to give you a fair idea about this I
Define one more method. C ad which takes
say integer arg1, let's keep this adders. So I defend
three parameters here. So instead of two I Define
three parameters here. This is nothing
but method overloading. All right. So here I Define ARG
1 plus ARG 2 plus arg3. All right, so we sum it up here and we return it back
to the calling program. So one thing to note here
is it's not giving you compile time error, right? So you can see that it has accepted
this add method as well. So you can see here. The signature is
pretty much same only thing is we have
one more extra parameter, which is a RG3. So it is treating this true
methods as a different method. That's what method
overloading is all about suppose I Define
one more ARG pee I say 40. Alright, so we have
three parameters here. I am giving a call
to add arg1 arg2. If I put arg1 arg2 the first
add method would be called if I have one more ARG 3 now
the second add parameter or the second add method
would be called. So let's define result
from new add method, right? So here we say. Okay. So as I said, we have overloaded the add method overloading is
nothing but same method name but different arguments
or different number of arguments or it could be
different types as well. You could have only
two arguments but one is integer and one is something else if for example string that also works so basically
different data types A number of arguments but different data types or
different number of arguments. Alright, so here we are adding three numbers
and let's run this. So it's going
to add 10 30 and 40, which is nothing but a tea. So this is done
at the compile time. As I said this linking is done
by GBM at the compile time. So here you can see results from new add methods
80 during runtime. You can see that it invoked
this particular method and not this one. Alright now, let's start off
with arrays, right? What is the concept of arrays? So again, this is similar
to other programming languages arrays are nothing
but grouping data or grouping values
of same data-type. Okay. So arrays are used
to solve the problem of storing multiple elements
of the same data type. Okay, an array is group
of like typed variables that are referred
to by a common name. So you define a name
for the array and in the future you can use
this name to access it. Okay specific element in an
array is accessed by its index as you could imagine since we are grouping you
would have multiple elements, right you could add
something to it or you could delete something or you could add it to the end insert it
in the between of the array or just so something or just search by index rate
you would give some specific index and get element
from that particular index. So we would be looking
at the Which would give you a clear idea about this but basically array
is nothing but group of or its multiple elements of the same data type
array type is fixed and cannot be changed. So in Java when you define an array you either give
the number of elements that you can store in the array, which is nothing
but the array size or you have to give the values that a particular array
would contain right when you define it. Okay, but all in all
you have to make sure that when you define an array
you give the size as well which cannot be changed
the feature the size of the array has to be mentioned
during the Declaration itself. So here's an example
of array this array has around for which has four subjects
with stores marks of four subjects for a student. Okay? Here you could see indexes
in the white box, which says 0123 it's
always in sequence. It starts with 0
and it ends with n minus 1. So basically this array is
of size for which starts from index ranges from 0 to 3. All right the value
that is stored is nothing but the that's a marks
in a particular subject which is like 87 60 70 and 80. That's the value that when stored
into this array. Okay, we can access any of this indexes suppose
you want to access at index 1 you could do it. Do you need to define a front
you need to Define on the size of the array of front? This is how it's been done. Okay. So this is
how you declare array. So we saw how we
usually declare an integer and stuff like that in Java. But here we are
declaring an array. All right. So this is an integer array and you can see
square brackets here. Alright, this tells jvm that we are trying
to Define array of type integer. Alright. So again, we use
the same keyword which is nothing but Nu new keyword is used
to create a particular array. All right, and here we are defining
an array of size five. So this is one way
of declaring an array. The other one would be
who initializer itself when you declare it
you give what are the values that particular array
is holding up the first case you're not giving the values
you are just defining an array which Those some some amount of memory right jvm would
reserve some amount of memory or in this case. It's four bytes right array. So for integer,
it takes four bytes. So it would Reserve 20 bytes
for array of size five. All right. So in the second case as I said, it's directly initializing the array it's putting
these values directly into the memory location still
it would be consuming 20 bytes, but the second variant
would have values directly initialized. So when you declare an array
of size 5 the range of indexes would be from 0 to 4. If you try to access index 5 you would get this exception
exception is nothing but a anomalies situation
right which or something which is not expected as occurred in your program and Java expresses such event
by throwing out an exception. You can't access index fi. So different ways
of declaring an array. We saw that it's
with new keyword. All right, so you have new int
10 which would declare array of size 10 again. You could either have
the square bracket at the end of the variable or you could have it
in between the type and the variable name. So behind the scenes it
everything is the same. It doesn't do anything
different for both but these are different ways in
which erase could be declared. All right, the third one
is similar to the last one where in we have
BR initializing it directly. Alright, we are putting
this value 12345 into this array. This one is again same you are
so within the square brackets, you can see that you are not defining
the size of the array, but you have an initializer
at the end by which you express that you want to put in
1 2 3 4 5 into this array. So basically one and two That
you see here does the same thing it declares the array of size. The first case is 10
the second case is five though, but behind the scenes
it's doing the same thing. It's nothing different
when it comes to actual preserving memory
and stuff like that. It's doing the same stuff and three and four
does the same stuff only thing is syntactically it's varying but
what I'm trying to say is GBM doesn't do anything
different to actually executed. So the length
of the array is set when it is declared and when an array is declared
array index gets initialized. All right, so if you define an array and
if you try to print the length of it you could see
that it prints out in this case. We have declared
an array of size 20 and when you do x dot length, when you print it out you
could see that it prints 20. All right. So what are different types
of arrays that we have again similar to what we have
in Programming languages, we have single dimensional array and multi-dimensional array
single dimensional array is what we saw earlier
like you define array of integer of size 5 that is
a single dimensional array. So in this case, you could see a array
been initialized with value 2 4 6 8 and 10 that's
a single dimensional array since we have just
one dimension one row right? Say for example, you want to store marks
scored by a student or marks towed by a particular
student just one student. That would be
a single dimensional array. All right. So say for example, the first one is
the marks code in math. The second one is the sign
and so on and so forth. All right, so
that single dimensional array. So now what's multi-dimensional
array so taking the same example of storing marks code
by a student. So by a particular
student it would be a single dimensional array, but suppose you want
to show your marks code by all the students
in all the subjects. If you want to store it, it would be
multi-dimensional array. So one particular row that you see here would be
a mosque secured by a student by just one student
in all the subjects. The first row would be
by student won. The second row would be
by student to the third row would be by student
3 and so on right? So that's where you
have this application of multi-dimensional array. So how you access it is nothing but you want to access
the first element the first index it
would be a of 0 0 and this would be of 0 1
and so on so as I said if the First Column is for math if it's a marks secured in math
this entire The First Column that you see would be marks secured by all
the students in math. That would be the First Column whereas the first row is
the Mach secured by student a in all the subjects. So basically This
Could Be Imagined as a table in a database, right you have a table
where in you have rows and columns so
columns are nothing but you have Fields
within a table and the rows that you have
our different entries that you have within a table. So This Could Be Imagined
in the same way. So you could see
how the index is you could see how the indexes
are aligned so X increases when you go down and Y increases as you go to the right
the memory allocation of array, so for single dimensional array
of type integer, 1 integer value takes
four bytes, right? So now when you declare
an array of size 5, you would have 20 bytes Reserve. That's how memories
been allocated right if you have a character
array of size 5, it would be ten bites since each character
takes two bites in Java. So you would have
10 bytes reserved up front. All right, so that's about memory location a location
in single dimensional array and when it goes
to multi-dimensional array this case you have
like five elements, right you have array of 55, which means that you have
25 elements stored within the array right 25 integer element
stored within the array and each integer value takes
four bytes for storage. So it would be a hundred bytes. All right, so if you have array of if you
define a multi-dimensional array of 5 into 5, you would have basically a
hundred bytes allocated for it. Let's write some programs and understand more about
how this arrays operate. So we have an array
of five elements. All right, as you could see here 2 4 6 8
and 10 write a program to access element at a specific index. Okay, so you have an array
of five elements 2 4 6 8 and 10 and we want to access it. We want to access
particular element. All right, so let's write
so I create a class. All right, I Define
this as our a demo, so I don't give
a package name here because I am defining
a class within a package so you could see here
the package came directly because I right
clicked here right and then created a new class. So yeah, you get
this particular class here. I Define a main method as a type main it
would give me a suggestion. So this is the entry point again
for this particular class and suppose I Define the jar. Ray and suppose
I Define 2 4 6 8 and 10, right so you could see here. We have an array
defined of size five. Okay, and you have
initialized it as well. So what I was trying to say
is you need to have length of the array given
up front right? If you don't do that, it would show you an error so you can do something like
array of integers is equal to Nu so you could see here
array initializer expected. All right. So either you will have
to initialize it or give some value to it. So if you put here
10 you could see that it compiled right? So either you will have
to mention some indexes here or the length size of the array or the ways
to initialize this okay. Now you could see
the compilation error as gone. So what I'm trying
to say is it jvm has to know about the size
of the array of And if it doesn't know then it
would flag you with an error. All right, so we have defined
this array of let me keep it as is okay. So now we have defined
an array of size here five and we have initialized
values as well. Now, let's try to print
out values, right? So just to keep
it simple suppose. It ranges the index
would range from 0 to 5, in this case. So this value to is stored at index 0 value for is stored
at index 1 value 6 is stored at index 2 value
8 is stored at index 3 and then is to that index
for all right. So let's try to print
0 by the way. I want to copy it. Yeah, so I'm just sprinting
0 1 and 4 and let's see what it gives up. Right so it should print
2 4 and 10, right? So you could see
here to 4 and 10. Now. The other thing
that I wanted to show is if you try to access
so let me show you what happens there. All right, so if you try to access at index
5 which doesn't exist at all. No, it should give
you a exception So in Java exceptions could be nothing but God and you
could do something with it. So here you could see that it gives it gave you array
index out of bounds exception since five doesn't exist at all. The index five doesn't exist
at all for this array. Okay. Now let's define
multi-dimensional a write code to find the length
of rho 0 right. So let's define
a multi-dimensional array. Alright, so we have
a multi-dimensional array here. So how you define
multi-dimensional array is something like 1 2 3 4 Alright, so this is a multi-dimensional
array that you have. Okay, so we have defined
a multi-dimensional array the size of this array
would be 2 by 2. Right 2 by 2 is
the size of this array since you have two elements here or let me put it
to remove the confusion. Let me put it this way. So right now we
have like 2 by 3, right so you have like
two columns and 3 rows. All right. So now let's print actually
it has to be 3 by 2 rather. Okay. Now, let's print the size
of this array 0 right. So how we do it is again println now you
have multi-dimensional array and you have 0 so 0 to 1 refers
to this 0 1 and 2, okay. Dot length, so as you could see
here that individual row that you have
within multi-dimensional array itself is an array is
a single dimensional array. So multi-dimensional array
is nothing but it's a array of single dimensional array. Okay. So let me print here
size of first array. I miss Plus. So as you could see here, there was an exception
and since there was an exception you won't have this
particular statement executed since there was exception here. So basically to execute
this particular statement, you should handle
this particular exception, but we are not talking
about handing the exception yet. So I'll have to comment
this to pass through. So now you could see that it has printed out to which
is your size of first array. So this is a program that we actually did right
now create an array having many characters write
a program to copy elements from created array
to another array and also write a program to
delete an element from an array. Okay, so I will just talk
about this right here. So we have an array here
of characters, right? So basically when you want to
delete something from my array, what you will have to do is you will have to shift
the indexes, right? You can't delete something
directly from an array. So what you will have to do is if you want to remove
something then you will have to shift the indexes what happens is suppose you have
an array of five integers and suppose you are deleting
the second element right. Now. What you would do
is you would shift if you are deleting
the second element within the array you
would shift all the elements that follows the second element
to the left, right? So the third element
would become the second element. What would become third and the fifth one
would become the fourth. So basically you shift it. That's how you delete
something from an array. All right. So other thing is about copying
elements from the array, we have a utility class which is nothing but
system system is a class itself. So as you could have seen that when I'm printing out
something I do system dot out dot println, right? So this system it's
a utility class in Java where an IT exposes lot of functions within a lot
of methods utility methods. So one of them being our a copy, so here you have to give source and the starting index
and the destination and what we are trying
to do here is copy 5, so this is how we copy from one array into
another starting from index 0. So this is copying
and the other one that you see here
is about delete. So as I said deleting is nothing but we have A logic
written here to shift the indexes to the left. So here we are trying
to delete one at index 3 and we are just shifting elements
after this index 3 to the left. That's how we delete
something from an array. Now. Let's see what our strings
so string is nothing. But again the data type
with in Java. So why do we have strings at? All? Right. We have array of characters then
why do we have string at all? So here's an example where in you have lot
of loads of data? So you could imagine
a role of a data analyst who has to analyze through lot
of data coming in right? So nowadays, it's like petabytes of information being processed
throughout a day, right which would be
very difficult to handle if you had to deal
with character array. So that's where that's where Java has come
up with strings, which is nothing
but a group of characters, but you don't have
to deal with it Java by Itself has a class which would take care
of this strings and since strings are widely used within a program you could
imagine that name or anything that any identify that we have is mostly we have
to store it as the string. So one of the data types that widely used within industry
or which is widely used in programming is string, right. So Java has some kind of string management
as well to make sure that programs run or make
effective use of strings. Okay. So here what's been mentioned
is James is a data analyst and he's finding is really
difficult to actually deal with character array to store
patients names every time so that's where we have string. So string a solving the problem of actually dealing
with character array. So Java is actually having character array
is touring characters or the characters in the string
in a form of character array, but It doesn't expose it
to the outside world. You can just use
this class to deal with it, but you don't have to deal
with character arrays. So Java string is nothing
but sequence of characters, they are objects
of type string class. Once the string
object is created. It cannot be changed. This is the immutability
functionality of java. We're in once you write to it. You can change the value. So this is specifically
important when it comes to multi-threading when you have multiple threads
accessing a particular string or same string. So that's when immutability helps us to make sure
that you know, multi-threading is it's thread-safe we call
it as thread safe because multiple threads
can access the same string just because it is immutable. All right. So what are different ways
in which you declare a string? So you have string Str
is equal to new string which we are not initializing
the value of the string here which could Any value and you
have string str1 is equal to Ed Eureka wherein you
are initializing the value of the string right away. The other one is
the character array similar to the integer array
that we discussed. We have character array as well. So immutability of the string. So why do we have immutability
one is for security. So string stores lot
of useful information, like even the credentials
and stuff like that, which shouldn't be accessed
by external users. So this immutability factor of string helps us
to keep it secure so that no one else
can see it synchronization. So this is what I spoke about when you have multiple threads
accessing the same string, you don't have to synchronize
it Java by itself through its immutability
feature would ensure that multiple threads
can access the same string without hampering it
or it would run as it's expected. Shing so caching is nothing
but you have a string pool. So basically if you have
two strings with the same value, it won't store it. It won't store
redundant copy of it. There would be just one copy
in the string pool and both this references
would be pointing to that value. If you happen to change one of
these references it would point or it would create a new value
in the swimming pool and point the other reference
to it sort of so basically what we do is why
caching is required is as you could
imagine in application, as I said string is
widely used data type and you could have
multiple references pointing to the same value of a string. So we don't want to have
duplicate values stored. That's where this caching comes
into picture to utilize memory efficiently. So what is shrinking pool as I said string pool is
all the constants that you define
within the string within the application
would be stored in the string pull string tool
used in Java is a spool of string stored
in Java Heap memory. So we have heat memory. We're in the objects
are created and that's where string pool
resides as well. String pool is Possible only
because strings are immutable. You can't change
once it is defined. You can change it. If you change it, then you can change
that particular memory location. It creates one more entry
in your string pool and the reference would point
to the new entry. So the actual memory location
is not getting changed. That's what immutability is all
about string pool helps in Saving lot of space
for Java runtime. We are breaking
on the redundancy Factor here. So if you have multiple strings or if you have multiple strings
holding up the same value, it won't create. People copies of it there
would be just one value in the string pool, which would be accessed
by all the references. So basically string pool as we discussed is
or resides in Heap memory. So string is not a
primitive data type unlike character character CH AR is a primitive
data type string is not a primitive data type is the wrapper class
to array of characters and this is specifically done so that Java has a mechanism
to manage strings. Well, which is widely
used it arrived within any application or any programming language
for that matter. Della strings are stored
in string to love Heap area which we already discussed
so we can see a string pool. So we have stack memory
and Heap memory. So when you have
a local variable when you define something locally, the reference is created
in the stack. All right, and it points to the actual object
is created in the Heap, but the reference
is created in the stand so you could see as pointing
to hello in string pool. Okay, so s is nothing but a reference reference
to this ring. Okay, so here we can see
that we are concatenating. Right? So this would give you
fair amount of idea. What immutability is
all about, right? So here we have string S1
is equal to happy. All right, and what we are printing
out the original string that is happy, right? So you could see here
S one is a reference that's been created
in the stack. You have a string pool
within your HEAP memory which would store all
the strings all the constants or literals that you
have defined here. So you could see happy
been stored in the string pool and S1 pointing to it. Now you are trying
to concatenate S1 with learning, right? So it's happy learning. So you could see that the memory location
that s one is pointing to is not changed right
still pointing to happy. But this one more constant
that's been created in the string pool
that second category. The nation of happy and learning so you could see
happy learning also created but what's important
to note here is s 1 is still pointing to happy. It's not pointing
to happy learning. All right, so if you want S1 to actually point
to happy learning this is how you do so you have S 1
which has the value happy. All right. So you do S1 dot concat learning
and you assign it to S 1. All right. So you are assigning
to the same reference as S1 and you are printing
out s 1 in this case, what would happen is
unlike the previous example that we saw there in S1 is still
pointing to happy you would see that as one is pointing
to happy learning. So here you could see that this one is pointing
to happy learning. So basically you move the reference
from happy to have Peter. All right. So, let's see what our strings
how do we operate on strings? Right? So let me create
a new class here. Just ring demo. I create a main
main method again. All right. Now what we do is string
s is equal to and Eureka. All right. So let's first print
the length of the string. All right. So this is how this
utility class or this is how this wrapper class helps us. So it has all these utility
methods right you just have to do else dot length. It would give you length
of the string so had we not had strings and if you want to deal
with the character arrays, you would have to print
the size of the array here. Alright, so when we run it, it should print
it it is the size of the string at Eureka. Let's have substring. So it's a beginning index. So suppose we give to so it would give you
substring from index 2. So basically we
are getting substring. We are getting part
of the string substring is nothing but part
of a string right from from a particular index. So since we have given
to hear it starts from index to so you have 0 he's at 0 and x 0 D is at index 1 and U is
at index 2 so it starts from you till the end of the string
you have compared to you. Could Define two strings and you could actually
compare them and see the value so basically So you could have one more
string defined here something of this sort. Alright, so here we compare it. So we are doing s 1 dot
compared to To him, it's true. So we are comparing S1 with S2. So it compares the given string
with current string. So here you can see it
as shown minus 1 right since B is one ahead of a so if you have same string
it would show you zero. So if it's exactly the same
it would give you zero. You have he's empty suppose. You don't have anything
within your spring. You could check it
whether it's empty. He's empty returns
a Boolean variable which means if it's true it is empty
and if it is false, it has some value then we have to lower case
we have to upper case in this case suppose you want
to have could be scenario in which you want to change or you want to
change the casing. So I'll just take one
of that I make it to uppercase. Okay, so s 1 is nothing but we have Ed Eureka stored
within and we are so when I run this you should have said
Eureka printed in uppercase. So here we have written camel
casing and let's see the output. So here you can see
the string was converted or translated into upper case. So similarly you
could do lowercase which would print
string in lowercase. Now we have value of is nothing
but the value of a string value of some of the data type so you could pass integer
and you could do value of and it would give you
a convert integer into string, right so value of is
a method within string which takes different data type
and converts it into a string. So just to give you
an example you could have like teacher I is equal to a hundred String dot value of and you give I it
converting this I into string. So it would print
the same value hundred but it's converting
it into spring you could replace something
within the string. If you want to replace particular character
within the string which could be done
with replace method. So replace method takes two parameters replaces
a method within string which takes two parameters. First one is the character that you want to change
and the second one is the new character that you
want to change replace to. Okay so here to show S1 dot replace I could replace
e Within a be alright, so we are making it lowercase
and as you can see here, it's printed in uppercase E
was changed to lowercase e so that's about replace. We have contains which again gives you
Boolean type result, which says whether
a particular value of particular character
is present in a string. All right. So in this case we check whether we have
a stew with a TLD. Oh and you
replace t with L, which becomes hello, and now we are checking with
the replaced string contains D, which it doesn't contain it, right so it would
give you false. So that's about contains
equals is basically checks for the equality of string. It takes one argument and it Compares it
against the string object against which you invoke
the equals against. All right, so to give
you an example, so you have S 1 which is at
Eureka Eureka now to print it. So here we do S1 Dot. printing equality of string So since it's the same
it would give you true if had it been different it would give you false. So you can see here. It's printing both the strings are the same you
have different methods, like compare ignore case where in this case we
compared with case, right? If you would have had Eureka
in lowercase, right? If it would have start with lowercase e you
wouldn't have got 0 here. All right, whereas this one more
method which is s 1 dot compared to ignore case when it doesn't consider
the case, right? So even if there
is a case change if this how one
in uppercase and one in lowercase still it
would match all still it would give the value as 0 which means both the strings are
the same we could get some character out
from a string. Okay. There is a method character at there's ends with which again
returns a Boolean value saying that That a string ends
with a particular character. Alright, so here what we are doing
is we are checking whether the string P which holds the value happy
learning is ending with you, which doesn't right. That's the reason
it gave you false. Had it been G here it
would have given it true. Now that's about strings. Now. Let's talk about different
variant of strings. And why do we need it? So there are like three variants of string one is
the string class itself. The other one is stringbuffer
and you have a string Builder. So we'll talk about why
do we need this variance at the first place? So string buffer is nothing
but good for multi-threading when you have multiple threads. Usually it's good
to have string buffer because all the reads and writes
that you do on the string. It is synchronized. So when I say synchronized
there's only one thread that could access a particular
method within a class at any given point so you can't have
multiple threads going in and changing the value
or doing something. So basically if you have a
string within your application, which is been accessed by
multiple threads it's better to go with stream buffer or if there is lot
of not accessed as such access. One factor, but of course if there are a lot
of modifications done and stuff like that
like with stream before you could append a pain
to a particular string which cannot be done in string right
in stream buffer. You could actually do lot
of things it cannot be done and string and just
to make it thread safe. They have made all the methods
that modify the string contents as synchronized so that only one thread can access
it at any given point. So see you can see insert
here right in string. You don't have all these methods
you don't have methods to manipulate the strings
in string, right? Whereas in stringbuffer
you have methods to manipulate the strings. So when I say strings those
are literal strings, right not the string class. All right. So here we have string buffer and we are trying to append
something to the string buffer. So we define a class
we Define stringbuffer. So you could have
like S1 dot append and when you see
a pendant you could see that it appends any data type. This is the important factor
in stringbuffer you have lot of utility methods within or you have lot of
methods to manipulate the string which you don't have
within string class. All right. So this is mutable, right you are changing
the values suppose. I append three exclamation
marks do it, right. So what we are doing here
is we are just printing out the new string. All right. So basically you could you
should see at Eureka and the three exclamation marks. As you could see
here it got upended. So basically it's a mutable
string change the value with them insert is nothing but inserts a new character
at the given position. So here we are saying
that inside w at position zero. You could replace
it replace particular or replace substring
with a new string. So here what we are saying
is replace index starting from 0 till to with
this new character sequence. You could delete something
from it delete sequence of it. So here we are saying from
index 0 delete one character. So if you have two then it
would delete two characters. So basically when you say two characters even
this e would have been gone. Okay, in this case, we are just
deleting one character. So basically this delete method
takes the starting index and the number of characters
following the starting index. Zebras you have like you
could reverse the entire string. Okay, so just to show
you again new string dot if I reverse it. So basically this is a kind
of utility methods which we often use right so you can see it's
been reversed here. All right, you
can see the capacity of the string capacity
of the string buffer is nothing but I think it reserves
16 characters initially when you declare it and it keeps on incrementing it so it has a growth factor
defined within which you did not take care
of at this point, which you did not think
about it at this point because those are internals
to Java but initially when you declare a string
string buffer storage space for 16 characters, which is 32 bytes. If you have stringbuffer by do
we have string Builder, right? So string buffer
as I said has some drawbacks. What are the drawbacks is more
about string buffer is synchronized when I
say synchronized which means that only one thread
can enter it only one thread can process it. So basically if you have
a multi-threaded application, you should go
with synchronization because synchronization has
some overhead, right? It has its own trade offs. So when you
when you synchronized what happens is when you move out of
the synchronized methods DVM internally has
to do some operations which takes some time. So basically it's good
to avoid synchronization and which would make the application much
more faster and that's where stringbuilder
comes into picture if it's a
single-threaded application wherein you know that you
don't have multiple threads which are going to access
a particular string in that case. You should go with string
Builder as against ring. First because stringbuffer
would give you a slightly lower in performance
compared to stringbuilder. Most of the things that string buffer does is done
by stringbuilder as well. As far as the functionality
is concerned but it's not thread safe stringbuilder is faster, but it's not thread safe which means that you cannot have
multiple threats accessing it. All right, so to keep it simple, if you have multiple threads
accessing or string buffer, then you should go
with stringbuffer. But if you have
a single-threaded application, you should go with string
Builder which would make the application much more faster than stringbuffer again
with stringbuilder. The default capacity is 60
when you initialize it stores as you could see
it allocated 16 space for 16 characters initially. So as far as the
demo is concerned, it's pretty much
similar to stringbuffer. As far as the
outcome is concerned. It's pretty much similar to
stream buffer is no difference as such but as far as
the performance is concerned stringbuilder is faster
than string buffer because it's not synchronized. Okay, so you define
a string Builder with happy and you append learning to it? Okay, and if you
try to print s B1 which is appended with learning you will see happy learning
would see it been upended. Okay similar to stringbuffer when you delete character from index position
zero and one character from that position you would see that the H which is the first
character has been deleted out so you could see that at index 1 you
could insert welcome. You can see the entire string that is welcome being
inserted between okay, then you have reverse
Could reverse the entire string pretty much similar
to string buffer. So again, this one
is very similar. You have you are appending
you're deleting then you are inserting here you
have reversing here. This is pretty much similar to
what we did for stringbuffer as far as the syntax and semantics is concerned and the outcome is
the same as well. Just a performance change
in terms of speed right? So, when do you stringbuffer
and stringbuilder as I said if you have multiple threads you should go with string buffer
to make it thread safe, but it would be slower
as compared to stringbuilder. Okay stringbuilder is specifically good enough and you
have single-threaded application and it would be faster since it's not synchronized. So to make it thread-safe
you have synchronization which adds over it to the performance which takes
tool on the performance. That's why stringbuffer
is slower why to use object-oriented Concepts? So let's talk about
classes and objects. So classes are nothing
but it has got a street and behavior right as you could see
you have a class and you have
different objects, right? There's a phone
which is a class and which has got different types
of phones right rotary phone. Then you have a touch-tone phone
and you have a cellular phone this are objects
basically, right? So you define phone
which is pretty much Jen Rick and which has got State
and behavior class is something that is generate that has got State and behavior
but objects is something that is an instance of a class which would have
specific State and behavior. So phone by itself phone
is a Class by itself. Which may or may not have
specific behavior, but you could see that the specific phones
will have its own behavior to could Define
its own behavior. So all these three things that you see here
three types of phones and nothing but objects objects
of one class state is something that is defined by
instance variables, right? It's a class level variable
right at the class level you define something that gives State and behavior
is nothing but something that is defined by methods
like calculator was a class where in we had add
method and add method basically gave some Behavior
to the calculator class, right? So what are attributes
so you have a class and you have
attributes attributes and nothing but a property
of object and in Java, this is defined by your instance
variables basically class will have properties
which is nothing but the state which would be defined
by instance variables and you could imagine every instance will have
its own set of properties. It won't be the same right
in terms of the phone that we saw earlier. There were three different types
of phones you could imagine that it would have
different properties right? It's not the same. So what are the naming
conventions in generally used at the industry level for Java. So this is not something that is actually taken
care by compiler. So even if you follow this naming conventions still
the compiler would pass through but these are best practices or this is good to have thing
in the industry conventions is more about to keep On
the same page and make it easier for other developers
to understand more right or keep things simpler. So that's why
we have conventions. If you wouldn't have conventions
then people would prefer to write in their own way which would make
us difficult to understand. Alright. So for class name it
start with uppercase as we saw in all
the examples you would see that I have always used
started with the uppercase or it's rather camel casing. So in this case you could see
stringbuffer demo, right? So it starts with
upper case you have B, which is again
upper case you have B, which is again uppercase. This is nothing but camel casing
it starts with upper case. Basically it follows camel casing interface name is
again similar to class. It starts with upper case
you have method name which would be lower case always which should start
with lower case, but you could have it follows camel casing but it has
to start with lowercase. So maybe it's a predefined
method with in Java. Right? So you could see main
starting with lowercase or I created a dry Tad is again put C uppercase. If you would have say
for example at numbers you would have something
of this sort adverse. If you want to append
numbers to it, it should start with uppercase. So basically it's camel casing
but starting with lower case where as class name. It's a camel casing which starts with upper case
variable name is again camel casing we
should start with lowercase and constant is always like it has to be
everything in uppercase. So basically if I Define
a constant final string, I would write
something like this. okay, so and if you want
to add more words to it, it should be
like this underscore So it should be separated
out band score. All right. So these are the conventions that followed in Industry
by Java community. So mostly even
if you go to the source code if you want to see something dig
into the source code of java you would see same naming convention being
followed types of variables. We spoke about the types
of variables again to brief you through we have local variables
local variables are nothing but the variables
that are defined in a method. So if you define something
within a method that's local variable so ARG 100 or suppose
I Define and T local where is equal to a hundred. So this is
a local variable right? If you remember this is
within the scope of a method once the control goes out of a method your variable
is no longer accessible and also it gives space for
the jvm for garbage collector to kick in and clean up
this particular memory space. Variables are nothing
but it's defined at the instance level so
here for that matter. This constant is
also instance variable. All right, so I
can Define integer variable starts with lower case
and it follows camel casing. So this integer is nothing
but an instance variable. It's at the class level right
when your class is loaded when you refer
to this particular class, you will have your instance
variable initialized by Java. So instance variables
are declared in a class, but outside a method
Constructor or any block. Okay class variables are nothing
but static variables and it is one copy per class. So as against instance variable,
which is one per object, whereas static variable
or class level variable are it's just one per class. So if you define static, this is just one per class
and this could be accessed directly using calculator
calculator dot constant example, you would be able to access it
but for instance variable, you need to have
an object created. This is non-static basically
non static instance variable. So one of the reasons
why you need to access instance variable is because different instances
might have different values for a particular
instance variable, right? I could Define
calculator one right? Let me put it as calculator and we have like
normal calculator. You could have
one more class which is like scientific calculator. It's one more object. Now a normal calculator
can have its instance value as 10 and scientific calculator can have its instance value as a hundred
you have different values, but whereas in static
since it's one per class, it's not at the object level. So you have mod is
equal to new demo, which is an instance
of a class demo. And you print message right d dot print message and it
should print this message. So basically there's
a class demo which has got
a method print message and we are trying
to invoke that message from the main method. Okay, let's talk about
the constrictor constrictor is nothing but when you invoke
new keyword new calculator, there is a Constructor implicit
Constructor for each class, which is without any parameters. So we'll talk about that. But when you do new calculator, basically there's a method which could be used by
the programmers to initialize variables if they want
to initialize something. So for each instance, if you want the same value
for instance variable, you could initialize it
with in Constructor. So basically Constructors are
for initialization or if you want to do some kind of pre-processing
break on invocation if you want to initialize
something or do some kind of pre-processing that could be done through
Constructor Constructor is used in creation of an object. It is a block of the code
used to initialize an object. So when I say
initialize an object, it's nothing but initialize
some property or variable within your class Constructor must have the same
name as the class. It is in and it does not have
any return type. So unlike method, which has got a return
type Constructor won't have a return type at all because what we are trying to do through Constructor is
just to initialize objects within but you can't return
something out of it. So basically you Constructor
is a special method which you don't have control over you are not doing anything
within it you're not trying to actually return
something out of it, right? You don't have control
over its invocation. It's done by jvm itself jvm
calls this special method when you invoke knew or when you create an instance
of it by using this new keyword Constructors are of
two types default Constructor and parameterised Constructor. So when I say
default Constructor and parameterised Constructor, this is nothing but
so I am defining a Constructor now calculator as I said, it has to have
the same name as the class. Okay. So this is a Constructor. And as I said, this could be used
for initialization of variables. Say I initialize this 200. So for all the objects
you would see this being initialized to 200. That's the initialization. Okay, so I have created
two instance of it to instance of calculator class that is normal calculator
and scientific calculator. Let me do normal calculator
dot instance variable. Okay. So here we are printing the
value of the instance variable. Let me copy
the same thing again, but in this case. the second case I would be
As you could see here. We have a Constructor. I defined a Constructor
here Constructor for a class which is initializing
the instance variable to Value 200. So as in when you call this new
calculator a new instance of calculator would be created. The first thing
that would be called. Is this Constructor
and which would initialize it. So basically what we are trying
to do here is we are right after the construction
of this particular object. We are going to print the values
of instance variable to see if it assigned 202 it. So here you can see the value
200 being printed out. So basically if I wouldn't have Constructor then the value
wouldn't have been 200. So let me comment out this one. This is how we comment in Java. By the way. This is a block comment
which starts with Slash and asterisk and which ends
with asterisk and smash. So I commented out that one I
comment out the Constructor and you would see the value
being initialized to 0 so you could see value
been initialized to 0. All right, so that's what
Constructor is all about. Now. This is a default Constructor. You could have
parameterised Constructor, which is like integer
you provide some value right and you assign
this value to variable. So instead of hard-coding
this value of 200 for the instance variable
you could pass on some value during the construction
of the object. So basically what we are doing
here is I pass 30 here and bypass 40 here. Alright, so I am passing 30 and I'm passing
42 the Constructor. And as you could see here, we are initializing
the instance variable to that value. So basically for
normal calculator, it should be 30
and for scientific. It should be 40. Yeah, as you could see
here you have 30 and 40 min printed out and this is
the parameterised Constructor. That's what this default
and parameterised Constructor and that's what it is all about. So default Constructor
is you don't even have to specify any Constructor. So I commented this calculator
constructed still implicitly. There is the Constructor
put in by jvm, which is the
default Constructor. So it's not mandatory
to have Constructor each time unless you want
to initialize something. So what's the difference
between Constructor and Method constructive
must not have a return type? Whereas method may
or may not have a return type here you could see that
unlike the methods add integer, which return something. This doesn't say anything. This doesn't return anything because we are not doing
anything within it. You're just initializing it initializing some instance
variables right Constructor name must be same as the class so that This is a contract
this has to be followed Constructor has to have
same name as the class, since you are not invoking
the Constructor by yourself. It's done by the jvm. You don't have control
over invocation of Constructor and you have to follow
the naming pattern that Java recommends to or Java forces us
to you have to make sure that instructor is given
the same name as the class name. Whereas method can have any name as we saw the add method you're
free to use whatever method name that you want to Constructor is used to initialize
the state of an object. We saw the instance variable
being initialized within the Constructor method
is basically it gives some Behavior to a class right we saw add method which is giving some Behavior
to the calculator method, which is nothing
but adding up two numbers. Similarly. You could have multiplied
you could have divided and stuff like that which adds more Behavior
to it Constructor is invoked. Implicitly so you don't have control
over invocation of Constructor, which is done by Java itself. When you try to
instantiate a class or when you use the new keyword, it's implicitly invoked
by Java by jvm. Whereas method you have
to invoke it manually. So basically when you do this Constructor
is called by itself. Whereas when you want
to call add numbers, you have to
invoke it explicitly. How does Constructor work
the moment object of a class is created The Constructor
of the class is called which initializes
the class attributes, right? So we saw about this. So when you use the new keyword
jvm by itself would give a call to the Constructor which could be
used for initializing initializing instance variables
within your class. So type of Constructors this default Constructor and
this parametrize Constructor, which we already spoke
about the Constructor, which is created by the compiler without any parameters is
the default Constructor and the Constructor
with specific number of parameters is called
parameterized Constructor. So here we spoke
about this already. So we have integer value, right? This is a
parameterised Constructor, since you are passing parameters
to the Constructor, whereas if you don't Define
anything Java by itself, so in this case you could see
that we didn't have a Constructor for
this class straight. I read them all we don't have
Constructor for this class. So Java by itself puts
her default Constructor for array demo, which is known as
default Constructor. So it's not mandatory that you need to have
Constructor every time since Java takes care of it. That's the differentiation
between default Constructor and parametrization. We use parameterised Constructor for passing values
to the Constructor and initializing something
based on the value that's been passed
out past in brother. So the default Constructor
is used to provide the default values to the object like 0 null
depending on the type right when I didn't have
any Constructor at all for a moment. I am going to comment this. So this is a line comment
when you put two slashes. It's a line comment. Okay, it's commenting just this particular line This
is a block comment and this line comment block
comment is slash asterisk and ends with asterisk. / whereas line comment is
two slashes forward slashes. Okay. So basically a comment
or disc instructors as well. Alright now we have this
calculator class now lets me. Let me print the value
of the instance variable. value of instance
variable initialized by default Constructor. All right, so we don't have
a Constructor at all. So that's what I
am trying to say here. I commented out
this Constructors, right? So we don't have
a Constructor at all. And when you create
a new calculator jvm by itself would have
a default Constructor which is used by jvm
to initialize variables within so you would see this instance variable has
zero value as 0 because that's what the default
Constructor does. It assigns some value
to it has like specific values for integer it 0 if it's a class it would be null so you could see the value being
printed as 0 if it's a class it would assign value null. So in this case you have string
right and you could see 0 null depending on the type
of instance variable that we are dealing. We saw how we pass parameters
and initialized it. Constructor overloading is just
like method overloading without written type
Constructor overloading in Java is a method of having
more than one Constructor with different parameter lists. Like we defined add we had to add methods and now I have
renamed this to add numbers, but basically this
was add method right so you could have multiple
methods with the same name but different parameter lists, which is known as overloading
similarly for Constructor. You could have
the same Paradigm. So basically what we
are trying to do here is we have a Constructor
with 1 parameter that sing teacher I'll Define
one more Constructor here with two parameters. So we Define one more parameter
here and I say for example, I put something like this. So we are adding up
these two parameters and putting it
into instance variable. Okay, this is
Constructor overloading. So here you have single
parameter been passed here. You have multiple parameters
being passed So based on whatever you pass
here suppose I say 10 and 20. Or say I say? So on construction you should C-130 as the value
of the instance variable. Okay, as you could see here, you have the instance variable
initialized to 130, which is nothing but edition
of hundred and ten and twenty and you could have something
like this just hundred and ten, which is also K because you have
a single distinct defined as well Constructor taking
a single value as well. And in this case, it would be just a hundred
and so Constructors are nothing but methods which helps
in construction of object. All right, so you get
a hundred and ten here? So Constructor overloading is
in Java is a technique of having more than one Constructor
with different parameter lists. So we had a demo about it as I showed there were
multiple Constructors one with one parameter and the other one
with integer parameters and during runtime
based on whatever you pass a particular instructor
would be called in this case. You could see that in the first case which is shop s 1 you
could see the first Constructor been called which has
two integers as being passed. Whereas when you create object S 2 which has
two integer parameters and one string you could see that second Constructor
is being called. What's Constructor chaining
so Constructor chaining is the process of calling one Constructor from
another Constructor with respect to the current object? The real purpose
of Constructor chaining is to pass parameters to a bunch
of different Constructor, but the initialization should be done at a single place
Constructor chaining can be done in two ways within the same
class from the base class and Constructor chaining
occurs through inheritance. So basically for
Constructor chaining, there are two key words
that we have. So one is this this
itself is a keyword in Java this pH is
this is a keyword and the super keyword. Let's see how we how we do it
for this particular Constructor. I have this Constructor
which has this value, right? So instead of
doing this directly, what I could do is so here. I was initializing
this value directly to the instance variable. What I could do
through Constructor chaining as I could do this and I could pass
the value comma zero. So basically you're
chaining here, right? You could see that what I am trying
to do here is I am trying to invoke this Constructor
from this Constructor. That's what the chain
is all about. So when you say this it
tries to find Constructor within your class which takes two parameters
to integer parameters and this is the one
it finds out, right? It has two parameters. And basically what we
are doing is we are keeping the second parameter is 0 which means it would initialize
the instance variable to whatever value you have here, right? This is what Constructor
chaining is all about. It's more about calling
Constructor of the same class within the Structure
of the same class. So basically from
this Constructor you are giving a call to this Constructor
that is constructive change. Super should be the first it gives a call to
the super Constructor. So you have a subclass
and superclass, right? What do you do here is
you give a call to superclass? For Constructor chaining. I think they
should be good enough where and you use this keyword
to call Constructors within the same class. You basically chain
them together, right? We have demonstration
on Constructor chaining here. When you create student you
could see there's a Constructor without any parameter and we could see
this Meghan been called. So basically what we are trying
to do here is the default name would be Meghan, right? So and again we have
one more Constructor, which is overloaded Constructor, which takes name and in that case it would give
a call with the specified name and Mark as 70. So basically 70
is a default marks that we are signing and you
can is the default name here. If you don't provide name,
it would be Meghan. All right. So this is what Constructor
chaining is all about. Static keyword
static keyword again, we have spoken about
in couple of instances, but I'll just walk you
through this slide again. The static keyword is used
for memory management static is non access modifier used
in Java accessible applicable for blocks methods class
variables static keyword is used to refer the common
properties of an object. So as we spoke it's
at the class level, it's not at the object level. We have it common
across all the objects right when the static keyword is used
to declare any parameter. Then memory is allocated
only once for that parameter. So in this example, we could see that
since it is one per class. So you would have
this constant example Define just once right
it would be allocated. Just once whereas the non-static
ones like this in. This variable you
would have memory allocated for each and every instance. So basically for this instance, you would have memory allocated
for this instance variable for again this normal calculator that we had earlier
you would again have a memory allocated
for instance variable. All right, so it's
one per object whereas the static ones
are one per class. So yeah memory is allocated
only once for that parameter. All right. So here we can see that this we have
a static string company which has some company
named put in there and we are just displaying it right we can see that we are displaying ID salary
and Company and you could see that for both the instances
for even and E2 you have two employees here with ID 25 and salary
25,000 and we have employee to with salary 30. Sorry with ID 30 and
salary 3000 right? So we are defining
two instances of employees and you can see here. We are not passing
the company name as a parameter to the Constructor right still when you display it look
at the output at the right side. You can see that it has displayed
twenty five twenty five thousand and SRT Traders
the company name came by itself because it's one per class. So what we are assuming is this class is basically designed
just for one company, right that is SRT creators. So all the instances of the class are
all the employees that you create here. All the instances of employees that you create here will have
the same company name that is defined here since it is one per class. Whereas their ID
and salary would be variable which would differ as per the value that you
passed to the Constructor. here we can see that company is a static variable little
allocates memory only once So here it could be seen that you as I mentioned earlier
you have reference variables being created out in the stack. And in the Heap memory, you could see
values being stored. So ID is tri-five salaries
25,000 for E2 ID is 30 and salaries 3000 and you
can see the static variable. So basically static variable
is stored in a different space which is permanent
generation memory. That's where the static
variables are stored. So method could have
static as well. When a method is static
you did not create instance of a method to call
that method instance of a class to call that method
pretty much similar to static variables, right? So basically I can have
one more static method here. So say for example I have
private static all right, so So what I was trying
to say here is you could have calculator. . And you could directly
call the display method. So you do not have instance of a class created its
at the class level. This is at the class level
rather write one per class. Let's talk about this keyword that this keyword is used
as a reference variables to the current object. So basically what what it
is trying to say here is so if I want to
print something here, let me print
the instance variable, right? So within the add method what I am trying to do is
I am printing the value of instance variable
Within add numbers, right? So I'm trying to print the value of the instance variable
within add numbers which would be
basically this is where we are calling at numbers. So basically it should be
a hundred and ten, right? When we have such scenarios where and we refer
to an instance variable within a method we could see
here printing the value of instance variable
within add numbers gives you a hundred and ten
right the implicitly what happens is it puts this dot here
this dot instance variable. All right. So what we are trying
to say is the instance on which the add numbers
was called on the same instance, whatever the value of
instance variable is just print that thing out. So this is implicitly
put in here you need not use this keyword. This keyword is usually used when you have something
like this right when you have instance variable suppose. You have something of this sort. Right? One of your parameters
is same as as the instance variable, right? So you want to differentiate
which is the instance variable and which is
this variable right? So that's when you use this When you say
this dot instance variable, this is referring
to this instance variable and this instance variable to the right hand side
is referring to this one. Alright, so that's when you have to explicitly
put this or in other cases. It's done by the jvm itself. You did not take care of it. All right, so So, this can be passed
as an argument in the Constructor call. This can be used to invoke
current class method. This can be passed as
an argument the method call and this can be used to invoke
current class Constructor. This could be past basically
if there is one more. so say for example, you have something of this sort
which is pretty big though, but Admitted taking
calculator as its parameter. Okay, so I'm just trying
to demo you could actually take calculator as an argument
for any of the methods within. All right. So you have ADD method which takes calculator
as its parameter. Alright, so here say for example
within this method don't think about the logic it's
not logical though. I'm just trying to show
you it could be done. Right? So I have ad and I put this
within your method you could have you could pass
as an argument you could pass this as an argument. So basically you
are invoking this one. So now if I print it you can see in add numbers you
have this method being called. So yeah here you
can see printing out the add method taking calculator
has its parameter. So basically it's calling
this on by passing this. So here we spoke
about the Constructor earlier. We saw how this could be used
in The Constructor and one of the use cases as I said here you could see
that similar to the example that I spoke regarding
the instance variable. You could see
the parameter the name of the parameter is rule number which is same as the name
of the instance variable. This one is pretty
much similar to that. You could see
that the name of the parameter that is passed to
the Constructor is same as the instance variable name
the rule number two. The left hand side is nothing
but instance variable within the class info
whereas to the right hand side. It's a rule number that is passed as an as
an argument to the Constructor similarly for the name
you have this dot name, which is referring to the name
the instance variable in the class info
and to the right hand side. It's a parameter that's passed
to the Constructor. That's a typical use of this. So we are creating a message
here and you can see that we are giving a call
within the Constructor. This is within
the Constructor actually, so we saw this
in the previous example. Basically, this is what it does write
this value of 0 that is what this is doing within
the Constructor you have this and you are giving a call. So in this case this Annie would
give a call to message string n and would print it out. So how does it work
the main function is executed. So again, this is a sequence
in which the things execute behind the scenes. The main function
is executed first, when an object of the class
is created a default Constructor is called okay, in this case, the one
without parameter is called right then you have this dot any which is nothing
but you're giving a call to the Constructor
within the same class, but with the parameter
any so the jvm would check whether you have a Constructor
with parameters as string, so it finds it and it would give
a call to that Constructor, which is nothing
but the Constructor that you see here
in a Blue Block right, then it would similar
to any method after the method
invocation is done. It comes back
to the calling method, right? So after this and is called it
comes back here then it prints. Welcome to edu Rica. And once this is done, it would go back
to the main method in general. What happens is whenever
a method is invoked the local variables and everything is pushed onto the stack similar
to C. Write in C. Also you have a calling stack. So your local variables
go into the stack. The calling method is invoked after the method
is being invoked and is completely done. It would come back to the stack and start off from
where it had left earlier. So typically how the subroutines and everything work
in programming language. That's how it's done
in Java as well. So that's why we
have calling stack. So that's the sequence
of execution that happens. So let's start off with object-oriented
programming Concepts. This is pretty much generic. This is not something
that is just for Java. So this is object
oriented programming concept, which usually all the object-oriented
programming languages use it or adhere to it. So we have Which we'll
be covering up in the topics to come polymorphism, which is we have
like static polymorphism and we have Dynamic polymorphism
cover it up in details. The coming slides will talk about what is
abstraction and also how Java has encapsulation or how Java is aligned words
the encapsulation feature of object-oriented programming. So let's start off
with inheritance just to give you an analogy you could think
of inheritance anything that is derived have
some super class or you have something from which
other subclasses are derived when you have some feature
of your parents. We say that you inherited right because you have got it
from your parent. So you have a parent so this could be an illogical
to something of that sort. Maybe you are looks is inherited
from your parents sort of that is exactly
what inheritance is all about. You have a parent class and you could have
subclasses out of it and this subclass
is would inherit. Features or inherited State
or the behavior? I would say
of your parent class. So to give you an example as you could think of vehicle
right vehicle is generic thing which could be a super class so vehicle could be thought
of as a superclass. Now, there are subclasses
to Vehicles you have bike which is a type
of vehicle you have car which is a type
of vehicle you have buses, which is again a variant
of vehicle and truck of course is again a vehicle. So basically this defines
easier relationship by if you read it out
you could Clearly say that bike is a vehicle
car is a vehicle but it's a vehicle
and similarly truck is vehicle. So basically this is something
like it defines. He's a relationship. So let's see about
how actually this classes or the sub classes inherit from the parent classes just
to read out inheritance is a powerful feature
object-oriented programming through which one
object acquires some or all properties. Behavior of parent object. So as I said,
it's an easy relationship. So he's a relationship
is represented in Java through inheritance. It could also be seen as
a parent child relationship. So subclasses are actually
child of parent classes in the previous case you have
by which is a subclass of superclass vehicle. So vehicle is a superclass and henceforth we
would be talking in this terms of we would be using
this terminology is so just wanted to be sure you get
it so vehicle is nothing but a superclass and by could be
henceforth referred as subclass child classes
would be referred as subclass. So you have method overriding what do you achieve
by inheritance is more about method overriding
to achieve runtime polymorphism. And the second thing
is code reuse ability as I mentioned
the subclass would inherit properties and behavior
from your superclass. Your parent class so there
could be some method defined in your super class which need not be redefined
in your subclass. It inherits by itself. That is the property
of inheritance. If it has got a common Behavior
like say you have two kinds of calculator different types of calculated the example
that we spoke about yesterday. There could be
a parent class calculator, which is adding numbers
as is you provide two numbers. It adds up and it gives
you maybe this add Behavior could be added into the calculator
Claus now Suppose there is a subclass of calculator where in you have this scientific
calculator or something which is modifying
this behavior of our which is using the same behavior of add right basically
a normal calculator or a scientific calculator
will have the same add Behavior adding up two numbers. Whatever you send
it as a parameter, it would add it up
and give you the result. So basically you would Define
this ad in the calculator in the scientific calculator. That would be the subclass of your calculator you need
Redefine this add method. It would inherit
from the calculator method. So that reduces would redundancy or it helps you
in code reuse ability. You need not redefine
the add method we have lot of slides to come
about method overriding and Method overloading so I won't talk it right away. This is inheritance. You have a manager class
and you have like employee which is extending manager. So what we are trying
to show here is e dot salary as you could see here. There's a salary property
in a manager and this employed to is extending manager and we could see here that employee to in
Harrods salary property though. It doesn't have
a salary property. We are able to access
the salary property from employee to let
me give you an example. You just have to click
on create new project and give some project name. I'll give a dude a car modules 3 so it opens
up a new window you could go to the source folder and you could right click on it
and Create a new class. So basically I'll do one thing. I'll create an employee class. I'll follow the same example
that's been mentioned here. I create calm down
at Eureka dot manager class. So calm down Eureka is nothing
but the package name and manager is your class name. So now I Define a property
here say salary in that case, right suppose. I say maybe I will put
it as wrong salary. So I Define a property
within your manager, which is salary. Now I Define one more class. So you could either Define it
with in the same file or you could create
a new class for Simplicity. I create a new class. It will create employee. So it created an employee class
within calm down Eureka package. Now, let's do main which is your entry point
for the program. Now as you could see
I haven't defined salary within employ. The first thing
that I'll have to do is we are talking about inheritance. So employ extends. This is a keyword
used for inheritance. So employ extends manager. So now you could see
there is a property which is salary which is defined in the manager
and this employee which is the subclass
of manager and let's see if salary is
accessible to employ. This is a place of manager. So I Define employ EMP is
equal to Nu employ. This is how we create instance
of the class using new now. Let's see if
just for Simplicity. I will give this e MP dot salary
you could see that right just to be sure I print out so as we can see
here salary though. It's not defined in employ. It has been inherited
from rather from your manager. We can have one
more instance created which is like manager is equal
to new manager. This is instance
of manager class. Now, I do manager dot salary
is equal to salary of manager. Is it just printing it out? So what we have done
here is again, I repeat the same thing. So we have
a manager within manager. We have defined a field salary
and we have employee which is extending manager
and the employee class. We don't have the field or we don't have the property
salary defined here, but we could see here in this example wherein we
created the instance of employ and we are accessing salary
property from here though. It's not defined
specifically in employee. It's been inherited
from the parent class that's manager and manager
of course has salary field which is been access of here and we could assign
some value to it. I run the program
it should compile and create a class file out of it and it runs
the class file using jvm. So yeah, as you could see here, it's printing out values
for salary of employee and manager as well. So that's about inheritance
it see inheriting the property salary
from parent loss. Now, what are different
types of inheritance that we have this Bill
inheritance wherein you have a parent class and you define a subclass
out of it so similar to what we spoke. We had a manager class
and we had employee class which was inheriting manager. That's about single inheritance. You can have hierarchical
inheritance wherein you could have multiple classes
inheriting from a same class. So you could have a and be inheriting
from a single class. You could have multi-level
inheritance wherein you have one class inheriting
from another and again, you could have subclass
of the subclass parent class you inherited or you subclass it
or extended whatever you say so there is one level. So you have a child class. Now, you could have
one more sub class of this child class. That's what multi-level
inheritance is all about. So as we go through the example, it should give you a clear idea
about what I'm talking about so single inheritance, so we have vehicle
and we have bike which is extending vehicle. So this Similar to
what we defined here. So what we did here
is single inheritance. You had a manager
and you subclass debt and this is just single
inheritance one level. So what is
hierarchical inheritance? So you have a vehicle and you have two subclasses
created out of vehicle. So there are two child's
of a parent class. So this could be
pretty much similar to a parent having two kids
right there could be two cats and they inherit some property
from your parent. So it's pretty much
similar to that. So you have a vehicle class which is the super class
and you have subclasses to it. So, let's see how this works. So I create a vehicle class
which is the super class. I have a vehicle class and civically class
has a property which says integer say
number of Wheels. This could be one of
the property of a vehicle class. You have say for example,
you have the mileage. So these are common properties
that you have in vehicle. Say you have Motion
just to add a behavior to this particular class. I Define method move and I just print
this thing out here. I defend two properties here
for vehicle class, which is number of wheels and the mileage and add
a behavior to the class by introducing method which is move which is nothing
but I'm just printing it out. So ideally you would have
some functionality written within or you would have lines
of code written within just because we are talking
about inheritance just to show the properties and behavior is been
inherited by the subclass for Simplicity sake we don't have any logic
written within move. It's just printing it out saying that just to indicate
that you know, there's a move method
within the vehicle class is being called. We're just printing it
out there but in reality as I said there would be
actual logic written with them. So now I Define car class
and I defined by class. So now I say that car is extending
which is nothing but sub class of vehicle. So remember we said
easy relationship. Chip car is a vehicle. So what we are
saying is subclassing or we are inheriting properties
of vehicle into car suppose. I change the property of any you method within or say
I can have its own moment when car cross. So basically we
are overriding it. What we are trying
to do is we are trying to whatever method you had
within your car class or the vehicle class. You are overriding it
for the car class. You are trying to change
something similarly in your by class. You could overwrite the move. So first thing that we'll have to do is bike
should extent your vehicle. So bike is a vehicle we
are extending it now. We are again overriding
this move method to say move in by class. So now basically we
can have seven more just for simplicity's sake we have
just a class wherein you would write the main method. So this is generally Practice were in such classes
are called as client classes where in you have a main method
and you do something with it? I just call it as
automobile management class. So you have a main method
so suppose you want to change the number
of wheels for a car. So what you would do is
car car is equal to Nu or it won't be carved would be like suppose I put
Mercedes is equal to new car by create Mercedes. I create BMW is equal
to new car. So now what we do is I want
to overwrite the property that is number of wheels
for Mercedes to for similarly. I could have a bike class say
r 1 is equal to Mu by something of this sort you
could have Ducati is equal to Nu by so this is just
to give you an idea of how we have classes
and objects right now. You could imagine
what objects is all about. So Mercedes is object
of car BMW is object of car. Arvin is object of bike and Ducati is again an object
of by so now I could overwrite the properties here
say number of vehicles as to so yeah, this is what it is all about. This should give you some idea about how we use Java you have
a class you have subclasses, then you kind of create objects and you could override
the properties with them and you could change when I say override is
nothing but you could modify the values within
your subclasses and similarly, you could change
the behavior vehicle by itself would have
some Behavior defined but Mercedes and BMW, which is a car would have
its own kind of behavior, which is not
inherited from parent you're overriding it
when you say this this could be
an illogical to something like kid kid doesn't have
the same features as a parent. It is something
like it's been overridden right? It's peculiar to
that particular kid, and that's what this is. About so you could override it. Now. Let me print move or let
me call the move method on BMW so you could see a move method and when I run it it should show
move method in car class since it's a movement that called on car BMW
is instance of car. So this should give
you some idea about how are we inheriting properties
and behavior from parent class. So here we can see
that move in car class. So again, you could
Define your own method within your subclass, which is not something that is inherited
from your parent class. So BMW by itself or car by itself could have
something like sector board which is not in vehicle. Maybe this is specific to car. So this is what we spoke about
is hierarchical inheritance. Now, let's talk
about multi-level inheritance. So basically it's
nothing but say you have a super class category. So let me use the same example. You have a vehicle class
you Have a car which is extending vehicle. Now I Define one more class, which is nothing
but superclass Supercar which is extending car. Basically, I can put this turbo
in Supercar rather that would make more sense. This is like
kind of multi-level. So I am putting this turbo
here in supercars. You have a vehicle class
you have a car which is surplus of vehicle. You have a Supercar
which is a subclass of car. So all the properties that you have in vehicle class
could be accessed in car as well as Supercar. That's what we want to see here. So you could have something
like say change Wheels which is void which is
not returning anything here. I just want to show you that we can still access number
of Wheels here though. It's not defined
in car or Supercar but in vehicle class you could actually it
is still visible here and you can modify it. That's the beauty of it again. Brief, you have a vehicle class
you have a car class, which is extending
vehicle class. You have a Supercar class,
which is extending car class. So basically there
is a multi-level of inheritance and all
the properties and behavior that you have in vehicle class
would be visible to car class as well as Supercar cross and Supercar class can access
properties and behavior that is there specific
to car class. What I'm trying to say is
if you define a new method here, so I just mention here Behavior
specific to class to car. So there's some behavior
that is specific to car that we have defined
within the car class. Now Supercar class
can access this one as well. So you could see here
you could access Behavior specific to car as well. If you look it as a tree. This is a leaf node. This is super car class
can access everything from vehicle and car class. Whereas. Our class can access everything
from vehicle class, but it's not the other way
around car cannot access something that is
specific to Supercar. There's a turbo method that we have put in
into the Supercar class. Now. If you try to access
Turbo from here, you won't be able to access it. All right, so it's
not the other way round. So you cannot access something that is specific
to your subclass in your super class. Whereas you can access anything that is there in your superclass
into your subclass. So it's a one directional flow
from superclass to subclass. Now, let's talk about has
a relationship has a relationship is nothing but you have properties
within your class, which is has a relationship. All right. So say for
example employee, right? We defined the employee class and employee would have
an ID specific to employ and it can have salary
and stuff like that which is has a relationship which is nothing but employ as
ID sort of right so a department in a class Let's talk about this example
a department in a college has several professors without
existence of departments. There is good chance for the professor's to exist
hence professors and Department are loosely associated. And this loose Association
is known as aggregation. So one can exist without other
which is loose Association and such thing is
nothing but aggregation. So here you could
see employ here. You could see name
name class itself, which has got first
and last name. So basically you
have a name class which has got property as first and last and which is nothing
but the first name and the last name of any entity. It's not associated
with anything right now. It's a different entity name is
a different entity which would have first
and last name now this employee info class, which has got ID and
which has got name so you can see name hear
this name property is nothing but The instance of name class that is there
the left hand side. So this is has a relationship. This says that
employee info has name. So basically this is what it is when you talk about has
a relationship its containment. Basically you have class
as a property in a class. So in this case
name is a property within your employee info and similarly this name could
be used somewhere else as well. It's not that it has to be used
just in employee info. That's a kind of Detachment
they have right. It's not tightly coupled. It's Loosely coupled
or decoupled. So basically you have name which is altogether a different
entity defined as a class which would have first
and the last name and you would have an employee
in for which is containing name which has name. So this is has a relationship and also to give you idea
about has a relationship. It's not just
it has to be object. Right so vehicle has number
of Wheels vehicle has Uh, this could be thought
of as a relationship. So let's talk
about polymorphism. Now when one task is performed
by different ways, then it is called as
polymorphism Polly is multiple of ism is forms. Basically, that's
the meaning behind it. So multiple forms. That's what polymorphism means and when one task is performed
by different ways, then it's called as
polymorphism this person which is the super class. You have a subclass student is
again person millionaire is a person these
are super classes. So you have a person class
you have super class student and millionaire you
have a behavior, which is nothing but P Bill and which would be specific
to both of them. So as we move on you
would get much more idea about the different kinds, but basically you
have multiple forms. That's what polymorphism
is all about. So, what is Method overloading
so we spoke about this yesterday if you remember we spoke about Constructor
overloading we're in you Had multiple Constructors Define
one was integer integer, and the other one was like it was taking
three parameters integer integer n 3 integers, right? So basically this is what method
overloading is all about to have the same name of a method but you have different number of
parameters passed to the method or you have different type of parameters passed
to the object to the method and based on that. It would understand
which is a method that needs to be called. So suppose you have ad with
two integer parameters Define and you have ADD with three
integer parameters defined now when you invoke add method
on a particular instance of calculator and you
pass two parameters to it, it would appropriately call
add method with two parameters and if you pass
three parameters to it, it would call one
with three parameters or it would resolve it during the runtime which one
to be called rather. It's not overloading
doesn't happen during runtime. It's done during the linking
of the resolving operation. Ben's during the
compile time itself. That's why it's
static polymorphism method overloading is nothing
but static polymorphism. So return type is not taken
into consideration when it comes to Method overloading. It's just the parameters
that a particular method takes. So Alex wants to write a code which can be used to find
out the area of triangle as well as of circle. So generic code which
would have area of triangle and circle so such are
the instances wherein you could use method overloading. So what's the thought behind
is I want to find area of both the shapes here
area is the common method. It's there for both the shapes. It's therefore rectangle. It would be there for square. It would be there for Circle
and so on and so forth. So basically you
would have a shift method which would have area
which is a common method. So instead of writing
two methods of different names. I will write area as
the method name for both shape. And a path different arguments according to
the respective shape. So instead of defining
multiple area methods you would have just
a general area method defined in your shape class and your subclasses
would overloaded as per the type of shape. So here we can see that this
area class there's area method which is taking integer since it's a triangle
its base and height. So it's taking base
and height as parameter. So Java doesn't understand
base and height. This is user defined by the way. It understand. There are two integer parameters
passed through the area Whenever there are two integer parameters
passed to area method. This one would be called. The other one is again, we have one more method which is area which is
by the same name and which is taking just
one integer parameter, which is radius. So this is supposedly
for circle Pi R square. So during runtime
when you call it, so I'm not repeating
this exercise again, because we did the same. Yesterday if you remember we kind of had multiple add methods
in the calculator and we saw that it was getting resolved
to the proper one based on the number
of actual parameters that you pass. So I will just read through the slides to make you
give more explanation on this but it's pretty straightforward. So here you have area method
which is ticking for six which is nothing but
it would get resolved during compile-time this particular area method
invocation would get resolved to this one since it is taking
two integer parameters. Second one is taking just
one integer parameter, which is 5 so it understands that it has to call
this area method the second area method
that's been defined in method demo and it
would call it accordingly. So here you could see that when you run this
particular program you could see that the first one resolved it
to Triangle and it said that the area of triangle is
nothing but 4 into 6 into point five, which is nothing
but 12 the second one goes 2 pie R square. And it gives answer as
seventy eight point five. So you could see there are
two different invocations done based on the number
of actual parameters. Now, let's talk about type
of parameter the method overloading can happen
on type of parameter as well. So you could have multiple
methods with the same name taking same number of arguments but different data types one could be taking
integer as a parameter. The other one could be taken
string as a parameter and during runtime ordering
compile time itself. It would resolve that, you know, this one should be resolved
to this invocation and the other one should be
resolved to the other one. So basically it tries to resolve
based on the parameter based on the data type
of the parameter that you pass. So here's the example wherein
you have two different methods. I will take this one. Say for example,
I Define public integer. So it's a dummy value
to be printed one of the best practices when you write Java code is
to express it, right. So you can have
a big variable name you shouldn't be restricting
on variable name which makes it difficult for other programmers
to understand. So it's good to have big
variable name versus small one, which is not that expressive. So here I said dummies
string value to be printed. I'm printing integer value is
nothing but dumb integer value and here I am printing so we have two methods
with the same name but it's taking different
data types as argument and we are just printing it out. So I Define a main method here
and I Define manager. So we have instance
of manager senior manager grade 2 dot display I
pass integer to it. I pass hundred to it and I pass so I have to Method
invocations here. One is first one. We are passing
hundred the second one. We are passing a string to it
and it gets resolved. You could see that the first one would go
to this display method which says printing
integer value the next one would go to this. Display method which
print string value so you could see here. Right? So first one is
printing integer value. The second one is
printing string van. So based on the type
of the parameter that you pass through are passed
to the method particular method would be called This
is static polymorphism. Now what's runtime polymorphism. So since it is resolved
during the compile time, it is static polymorphism. There are few things that gets resolved
during the runtime or the compiler cannot judge
it up front what the instance would be and that's when it does it
during the runtime and that is nothing
but dynamic polymorphism or method overriding so
method overriding is mostly used in an easy relationship. So in one of the methods or we
saw in vehicle and car example, we have a move method here
and here we overrode it. You can see override annotation
here for the move because you're overriding
it overriding the behavior of vehicle in car class. So that's where it says that this Easy relationship
method overriding must be used in case of inheritance that is easy relationship method
must have the same name as in the parent class. We saw in the move
in the example move. We have the same name as
in this super class. So huichol has a method move
and car has a method move as well method must have
the same parameters as in the parent class as
against method overloading which has different
parameters method overriding you have to be sure that it takes the same parameter
if I change this to integer if I add an integer
parameter to it, so it's not taking it as
overriding you could see it. It's not been taken as overriding because you have
integer parameter to it. So basically it has
to have same number of or it has to have the same
signature as your parent class. So that's about
method overriding. Let's have a demo on this so
which we already saw but I will again A trait on that so basically this example you
could see there's a man class which has got a pay method which is adding Behavior
to the man method and you could see
it's a dummy printer and you have a millionaire is
a man and you could see it overrides the pay behavior and you run this program. One thing to note here is you
can assign me linear to man. You can assign
unlike all the examples that we saw we are creating
instances of the same class or assigning the instance
of a class to the same class. But in this case you
could see the instance of millionaire is being assigned
to reference of man. This is something that happens only in Easy
relationship or inheritance. So what I am trying
to say here is a go-to automobile management I have car I have a new car which is Mercedes I could assign
this Mercedes to vehicle since Mercedes is a vertical it should be a sign you
should be able to assign it. This is something that you need to keep in
mind your subclass object could be assigned to superclass. So here we have Mercedes
being assigned to vehicle. But one thing to note here
again is the tricky part is vehicle itself has
its own move method, which Moving vehicle class and Mercedes which is car
itself has its move method with this move in car class. So the tricky part here is when you would do something
like vehicle dot move just give a thought about it
which one should be called. So you have two variants
of move method here. You have one in car
and one in vehicle. So the one in vehicle
is printing out moving vehicle class and one in car is the overridden version of vehicle with says
move in car class. Now, what we are doing
here is we are creating an instance of a car class and we are assigning
that instance to vehicle and we are calling
the move method. So just give a thought whether the move method
on the vehicle class would be called or a move method on the car class
would be called. So this is where method overriding comes
into picture so method overriding is nothing but
it's a runtime polymorphism which is done at the runtime. So during the runtime
jvm would see that Mercedes is nothing
but the instance of car though, it's assigned to vehicle which is super class still
an instance of class. So during compile-time jvm
wouldn't have a friend knowledge that which move are you calling? Is it on vehicle class or is
it on something else or some sub class of vehicle? So it doesn't decided during
the compile time it delays it or there's a lazy binding that happens delays it
till the time you run it. So when you run it, it understands that this vehicle
is actually pointing to car. That's Mercedes. So when you run
this you could see that I will comment
out this piece of code. So this is how we comment out
that's a block comment. So when I move
this you could see that move glass on car has been called
and not vehicle that is what is if you get this concept, you're pretty good in terms
of object oriented. By the way. This is an important Concept
in object-oriented Paradigm. So you could see here move
in car classes. Called similarly vehicle could have I call it
as vehicle one, right? I Define one more vehicle here, which is like new vehicle and I invoke the method on vehicle to so
the second variant would call the move method
in your vehicle class. The first one calls on the curved glass the second
one calls on the baker was since its object
of vehicle itself. So basically you have to see
on the right side, which is the object that's been assigned
since its object of vehicle. It's vehicle. But since this one
is object of car, that's the reason you have
car class being called. So we had some discussion
on this keyword yesterday. So super keyword is similar
to that super keyword is just that it is called on superclass. This is called on the same
class super is called on the immediate subclass immediate parent class you
could have multi levels, right? But this one is calling
the immediate parent used to refer immediate parent. Us instance variable used
to invoke parent class method and there's one more
Super keyword one more form in which you could use is
to have class Constructor. So basically whenever
you create a class whenever you call a class
whenever you call Constructor of a class by default jvm by itself would give a call
to the superclass Constructor, which we would be looking
at the further slides. So here we have vehicle leaven, which is a super class which defines string
Wheels vehicle moves because of wheels
so that the string that the property
of a vehicle you have a truck which extends vehicle
and then within truck you have your overriding
the wheels property saying that truck has four wheels. This is kind of your
overriding the property. It's not called
overriding though when it comes to properties. But basically you
have changing the values within your truck class print
wheel is nothing but a method that's defined in. Truck which would bring
the number of wheels in your truck class
and it has got super dot Wheels which would print the number
of wheels in your or print the value of the Veals
not number of Wheels value of the wheels property
within your vehicle class. So we will look at this one. So we have a vehicle class
and we have string Wheels which is a property
within a vehicle class which has some value
put in right? We have a truck class again, which has got wheels
and it is overriding the value. It is just changing the value as truck has four wheels with interrupt class you
have print will method which is printing
the wheel or the value that this particular
Wheels property holds it would print it first
one would be the value that this particular truck class
would hold and the other one that you see here
the second print statement, which is doing super dot Wheels
is actually printing the value of wheels in vehicle class. So, let me show you
a quick demo on this thing. So we Have a vehicle class which were in we are defining
the default number of Wheels as for say for example, and now we have a bike class, which is overriding
vehicle class. And what we are going
to do here is we are going to change the value
of number of Wheels. I have a method to print
number of fields, which would give suppose
I change your number of Wheels to say to so here we
print number of Wheels first and I would have
one more print statement which would be printing
super DOT number of Wheels within a by class. We have a print number
of bills method first. We are changing the number
of Wheels to 2 and then we are printing
the number of wheels for bike and number of wheels
on the superclass. All right, and by default we
have set the number of wheels in the vehicle class to before so we have
a bike class now I remove this to so now I print
the number of Wheels. So I create the instance of bike and I invoke
print number of Wheels. Now you could see that first it would print
to and on super dot. Basically. This is what it's going
to call so first it will print to so basically here we need to have one more
teacher number of fields when it comes
to instance variables. It's not overridden as
such so I have like number of Wheels defined here again and here I change number of Wheels to to so
let me run it again. So when it comes
to instance variable when you define one more field
here of the same name, it's not overriding it. It's rather creating
a new instance variable. So now you could see that when you print number
of Wheels it's printing out to which is nothing but the value here value
of this instance variable. Whereas when you do
super DOT number of Wheels, you have a default value of 4
here which is been printed out. So on super it gives
a call to superclass. So here you are creating. It's at the Constructor level. And we can see
that so it's more about as I mentioned
within your Constructor. The first thing that is called when you create an instance
is a super Constructor is called first and then your sub class
Constructor or I mean to say is when you create instance of car. So your first thing that would be called
is the Constructor of vehicle and it would do
all the initialization that's required in vehicle. And then it would call
the cars Constructor. So what I mean to say
is for example, I create a Constructor here
and I print saying that we are within Constructor
of fecal of superclass vehicle. Now we have this car class
and say we have Constructor for car class as well. Remember we said that there's a default
Constructor implicit Constructor that's already been
put by GBM itself. You don't have to
take care about it. So I don't do anything here. So basically you
need not create you do. Right Constructor jvm
by default right Constructor, unless you want to write something or you want
to initialize something. That's when you would
write explicitly you would write Constructor. But in this case since we
are not initializing anything as such I won't put
a Constructor car. What I'm trying to say
is we are creating an instance of car here. And let's see when we
create the instance of car. There is a super Constructor
that's been called. That's what I wanted to show. So that's why we created
a Constructor here for vehicle. This is not a method. This is constructed by the way, since it has got
the same name as your class and it doesn't have
any written value. So so I have printed
it out saying that we are in the Constructor
when we call this now when we create the instance
of car you could see that this Constructor
of superclass that's vehicle that's been called. So this is done
implicitly by compiler. You don't have to care about it. So here you could see whenever you create the instance
of car you would see that we are in construction. Of superclass vehicle
and the second print statement that you see is directly
for the vehicle sensation. So even for car you could see so this will get
rid of confusion. So there's only one instance
of car being created and we can see that it
is calling vehicle Constructor and it's implicitly put we don't have to explicitly
put it jvm by itself operates that way and how it calls is nothing
but by Super Final keyword we again touch based on this one
earlier in the session. Number one final keyword is non
access modifier applicable only to variable method or a class
when it's applied to a variable. We say that the variable content
cannot be changed usually use final when you want
to define a constant within your application. So that's final a method
could be defined as final you define a method
as final when you say that your subclass
cannot overwrite it that's when you define it
as final you define a class. As final when you say that there cannot be
any subclass of that class. So you cannot subclass it like if you try to extend
on a final class you would get an error
compile time error saying that you cannot extend it. So just to show you maybe if I make this as final your car
would show an error saying that you cannot inherit
from final class. That's Comdata recorded pickle. So that's about final class. And if you make
this method final you would again get an error
in the class saying that you cannot overwrite
this the car class you are trying to override
the move method since its final it showing
you an error saying that move cannot overwrite move
in calm dot Ed u-- recorded vehicle overridden
method is final. Let's remove this finer and you should see
the error is gone. And also if you want to see
at the instance level if you define this as for number of Wheels as for now
within this vehicle, if you're trying to modify
this number of Units to to it would throw
you an error saying that cannot assign a value
to final variable. All right, so that's
what it does it. It's not access modifier, but it regulates it in a way that you can't change the value
in case of variables you can change the value
in terms of class. You can't subclass it or you cannot create
a child class of a final class and in terms of methods, if you have final method
you cannot override that particular method
in your subclass. So final modifier can be applied
to class method instance variable class variables local
variable and Method parameters. So final variable is used to create constant variables
when it comes to variable as I said, usually you use final variable when you want to
have constants, right and it would be final static. By the way. If you have a constant
usually final and static static final final methods
is used to prevent method overriding in terms. Method the demo that I
showed you previously we saw that we cannot override it
in terms of class. When you have a final class, you won't be able to create
subclass of it which we saw. All right, it gives you
an error some examples of final clause in string class. So system class in Java dot Lang dot package
is final as well string class that we have been
using string class that's been exposed by
or Java itself has or Java by itself defines it
that class is final as well. If you try to
extend string class, it would show you an error
it would give you an error. So system is kind of
putting a contract or Java by itself is putting
a contract or is saying that cannot extend
the string class. You cannot extend Its Behavior. You can't change anything
any of the behavior within your string class by yo, that's why they have marked
it as final if a method is declared as final then
it cannot be overridden in your child class. If a Variable is declared
as final then you cannot change the value
of that particular class or cannot change the reference
of that particular class when it comes to objects. So we will see that later a Constructor
cannot be declared as final. So that's the rule you cannot
declare the constructors final and blank final variable should
be initialized in Constructor. So maybe in this case if you wouldn't have
any value here, you declared this as final if
you don't have any value here. It has to be assigned
an Constructor right now. It's giving an error saying that it's not initialized
if you mark it as for it should be gone. So it's mandatory that if you put instance
variable as Final in class, it's mandatory that you assign
some value in the Constructor. If you don't then compiler would throw an error so
here you can't override it. So basically you have
a final method void run and you have a sub class of vehicle and you're trying
to override Run method, it shows you an error. So this is what we saw
in case of was Final and when we try to override it
in car we got an error and it's all compiled sign if you declare any class as final you
cannot overwrite that class which we saw it gives
you a compile-time error. So when it declared a vehicle as
final and when you try to extend when you try
to create car class, which extends vehicle class
it gave you an error because vehicle class was
fake lettuce final again. This is a compile time. Now what's Dynamic binding which is also known as runtime polymorphism is
nothing but during runtime it decides which instance
of which instance of a method should be called or which method
should be called. So this is in case
of again inheritance and when you override
the method in your subclass, so we saw this earlier
again to just to show you we had this move method here and in I have this move method
and in automobile management, we did this thing
we have a Mercedes that is assigned to vehicle class class reference
rather vehicle class reference of reference named by vehicle
1 and in the second thing we have vehicle itself. So first one is pointing
to an object of car, which is Mercedes and the second one is referring
to the object of vehicle itself. So this is what dynamic
polymorphism is all about. The first one gives
a call to the move method in car the second one
second one gives a call to the move method in vehicle. So yeah, you could see here. So move in car class and then it calls
a moving vehicle class and it happens at run time. That's why it's
runtime polymorphism. So abstraction is a mechanism of hiding the implementation
details from the user and only providing
the functionality of a user. So basically you
could have abstraction. We're in on the first day. We spoke about the shape class
and the circle class and Wrangle and square
and stuff like that. Right? So basically shape is a class
which is abstract class, which doesn't know all
the functionality up front door. It doesn't have all
the behavior of front. It doesn't know what would be the behavior
of a circle class or it doesn't know. What is the behavior
of a square class when I see Behavior. It's nothing but calculation
of area calculation of area is nothing but it
adds Behavior to the class and calculation of area in your Square class would be
different calculation of area in your circle class
would be different. So shape by itself doesn't know what the implementation
of area method I would say. So that is what is attraction. There are two ways
in which you could provide abstraction in Java one is
by abstraction class, which is not hundred
percent abstract, which could have like abstract methods like area
in this case is about Track but there could be some methods which is same throughout
or common throughout all the subclasses of shape say
for example printing area. You just have to have
a print statement which is printing area
for a particular shape from the implementation per se it's same throughout
all the classes area method would be something
that is abstract. Whereas display area
could be something that is not an abstract method. So in such cases wherein you have blend of abstract as
well as non abstract methods, that's where you
use abstract class. So it's not hundred
percent abstract. Whereas in interface it has
to be interface is something which says that it has to be
a hundred percent abstract. So interface is
altogether a new construct that we have in Java when it comes to abstract
class abstract is just a modified to a class. So you write class and you
just prepend it by abstract which makes that class
and abstract class. Whereas interface is something
that is a new construct that we are going
to see in the coming. Slides upset class and Abstract methods
so abstract method is as I said area
would be abstract method in this case wherein you don't
have a concrete implementation of area in your shape class. That's the scenario
in such cases wherein you don't have a complete
concrete implementation of a particular method
you would declare it as abstract method and
if you have an abstract method, if you have at least
one abstract method in your class, you have to declare
that class as abstract class or else compiler
would throw an error. So whenever you have
a abstract class, it means that there is
at least one method within that particular class
which is declared as abstract. So when you suppress
this abstract class so shape for that matter when you subclass shape shape
has got a area method which is abstract. Now when you subclass it
when you create Circle, which is nothing
but class Circle which extends shape now you
are creating surplus of it. That case you have to ensure
that you implement area. If you don't Implement area, it is still kept as abstract
and you will have to make circle class
as abstract as well. If you don't give
the actual implementation. So an abstract method is
a method that is declared without implementation any class that contains one or
more abstract methods must be declared
with abstract keyword and abstract class is a class that is declared
with abstract keyword and abstract class may or may not have
all abstract methods. So as I said, it's a mixture of abstract
and on abstract methods and abstract class
is mostly used for inheritance. So let me take the same example
of shape and shapes. So we Define a shape
which would have abstract area. This is what I was saying. So when you have at least
one abstract method the compiler will throw an error. So in this case it is saying that you have abstract method
but your class is not abstract. So we have to make
this one as abstract. And as I said abstract class
is nothing but a modifier you just have a modifier that you need to prepare
into the class. This is abstract method
and you say you have a method which is public void. It's not returning anything. We are just displaying area now
rather than defining it here. Maybe I will put something
like So we have a shift method and now I declare
Circle method now, this circle method
is extending shape now. It's throwing an error and it
says you have to implement the abstract methods shape as got abstract method if you don't implement it
as I mentioned earlier, if you don't implement it if you choose not to implement
the area method then you will have to make this abstract. If you make this abstract
error would go off. But in this case since we know the concrete
implementation of area for Circle will have
to implement it when I say we will have
to implement it we say area and we override it. So for Simplicity reason, I'll just put
some value here for now since we are talking
about abstraction. I'll just keep it simple. So basically what we
are trying to do here is we have implemented area which would be nothing
but your Pi R square actually, so here we have a shape class and we are overriding
the idea method here. And this is how you abstract it. When you run it, so basically you
could have something like suppose I create
a shape utility class. So this is pretty much
like overriding methods. So you could have a shape
class shape circle is equal to New Circle and you
could call Circle dot area. So basically what you would get
is nothing but a float value, which is your area area of let me put it
this way area of circle when I want to print it. What I would do is
circle dot display area and I print area of circle what we have seen here is
there was abstract method area which was implemented in your subclass that Circle and
when I give a call to it and here you could see that again similar
to vehicles that we spoke about instance of circle
is being assigned to shape and when you give a call to
it you could see that method on circle is being called
and not on shape because shape by itself doesn't
have any implementation of area. So one thing to note here is
when you have Class. So here you could see this value
being printed operate abstract class would have one or more
abstract methods for sure. And when you subclass it, you have to ensure
that you give implementation of your abstract methods. If you choose
not to implemented, then you will have
to make the subclass as abstract as well. So execution of abstract method. This is very much similar
to normal exhibition that we have. So the main method you have
instance of mobile class created this case then there's
a default Constructor of mobile class gets
created gets executed. So pretty much similar
to normal execution when you create
an instance of Nokia, which is subclass of mobile. As I said the first statement that you have the Constructor
of subclass is nothing but super or it calls
the super Constructor. So here we can see that the default Constructor
for super is being called when you try
to instantiate Nokia as we are running run method, but in Mobile class run
is an abstract method so run method from Nokia class gets
executed similar to the example that we saw so shape
area class area method on Circle got executed
and not on shape. What is the encapsulation that encap solution is
the methodology of binding code and data together
into a single unit. So basically everything
it's a encapsulation. It's put as one so you
could imagine class being put as one right classes
called this for that matter. You see everything
been encapsulated as one right you group these together you group this integer and long which is a property of vehicle
and it has got some Behavior as through this move. It's all encapsulated as one or it's all put
together as one entity that is nothing
but encapsulation. So basically you could
imagine a capsule right which has got
multiple ingredients which has multiple made sense
or chemical components which are put together
into one capsule and you have you think
capsule has one mixing but it's basically combination
of chemical components Within Thing is
for encapsulation. There is access modifier comes into picture you have
this access modifiers or private and you have public you have protected
you have default this access modifiers restrict or it restricts the visibility of regular component
of a class say method or variable or anything. So that's encapsulation feature
of object-oriented programming. You can't see everything. It's not that everything
is open for everyone. So you can have
restriction you have different levels of restriction when it comes to visibility
of this components that is a part
of encapsulation as well. So to achieve encapsulation in Java declare the variables
as private usually the best practices
not to expose everything because once you expose
something as public or once you expose it for the application
to access you have to ensure that you maintain it right
because anyone can access it. So your class is becoming
much more fragile a I won't talk about
this topics right now because fragile D is something
that is related to code quality or coupling we say so I don't want
to touch on that. But basically the best practice is to have less
visibility restrict visibility or different visibility
as much as possible. Try to make it as much less
as possible make it private. Basically if you could make all the variables as private
it would be good thing. So basically all non private or public variables are
liability for application. So it increases the maintenance
of the application and it's easy to break that way if you make some changes
to a class it becomes very difficult the future
to maintain it. So usually the general practice
is to keep the methods variables as private not methods variables
as private and we have Getters and Setters method which exposes which are public
methods or mutator methods which would expose this variable to the outside
world through public. So usually we don't
have Setter methods. We restrict
Setter methods again. Usually you have a private since variable and you
have a getter method which is a public method which is nothing
but Returns the value of the instance variable
to the outside world. So data hiding the user
will have no idea about the inner implementation
of the class. What are the advantages
of data hiding user need not know the core
implementation of the class. It increases flexibility. We can make variables
and methods read only and right only as
per the requirement. So imagine if you didn't have
all this access modifiers, there's only one that is public
which is exposed to everyone so it would create a Havoc. So this is basically based
on your requirements. You could have
different patterns of this access modifiers used
within the application. It makes testing easy. So basically Hotpoint is
reuse ability easy to reuse and easy to change
with the new requirement. So with reusability, even the maintainability of the particular
application is improved when you have this encapsulation
and easy to reuse in the sense if imagine The way around where in you have
only private methods so a class could access
only the instance variables within a class nothing
from outside world. It cannot be accessed
from outside as well. Imagine such a scenario
right in that case. You would have a lot of code
redundancy right everywhere. You would write the same code. It might be the same thing. We have already implemented
in some other class, but you will have
to re-implement it since it's not accessible
outside the class. So that's how encapsulation
increases the reusability of who and it makes testing easier. Of course. So here you could see
that employ one. So this is the encapsulation
mutator method that I was talking about. So basically you
have employee one which has got string name, which is private
you could see here. It's defined as private when I
say private this name property would be used only
within this class. If you try to access it from outside class
you would get an error but there might be scenarios in
which you want to Says this name from outside class you
want to understand what its value is in that case. You would have something
like this right? You would have
getter method get name, which is nothing but
it's written type is string which is the data type for name and it's returning the name. Now one thing to observe
here is this is public. This one was Private name was
private but get name is public which means it could be accessed
from outside as well. Similarly. You could have Setters
which is not a good practice. By the way, you
shouldn't have Setter methods. So again Setter is something
like you pass the value that you want to set
this particular name variable. So basically you are saying
that whatever you send through this method is going
to set to the name variable. So we are referred to this particular
example in Maine. So you create an instance
of employee one who have edad set name
you're sitting at well X and when you access it
you do e dot get name. So basically what we
are trying to say here is a demo end caps is a Glass it's not the same class. So you have employee one and you have demo end caps as
a different class though. It's a different class till you are able to access
your name employee name from this class. This is again, a private instance variable you
are able to do this just because you have
this Getters and Setters, let understand interfaces
interfaces are nothing but could imagine
interface as a blueprint or it is something that
it's a specification rather, right and interface could be
thought of as a specification. This is how it should be. So basically it could be
a company manufacturing bottles or remote rate. It would say that this is how it should be basically there
should be so-and-so buttons. There should be
this button should be here. This button should be there
and something of that sort. So basically through interphase what we do is we specify
the contract we say that this is
how it should be now. For example, you could have specification
mentioned in a piece of paper. This is how Remote should be and there could be different
vendors for this remote who would be actual
manufacturing remote and which would be aligned to this particular
remote specifications. Then you could check that. Okay, so and so specifications
are met which means that this this particular thing
could be used as a remote. So basically these are nothing
but the specifications for the system so
through interphase you say that this is how it should be and you
would have different vendors or you would have
different implementations that align to the specifications and if they match up
to the specification, it means that it's
a correct one. So hence an interface contains
all the specifications and can be used
for creating a new remote. So all you see here, there's a joystick
this AC remote this TV remote and everything. It has got different things but there's something
in common and that's what you specify through interface and interface
contains variables and methods but the methods declared inside interface or by
default abstract methods. As we saw in the earlier
slide interface is hundred percent abstract. So all the methods that you have
within interface is abstract and interface is used
to achieve abstraction. It is used to achieve loose coupling when I
say loose coupling. It's like you are not binding
everything into a class. Basically you say
that fits a remote. It has to have
this features, right? So basically your kind
of decoupling it or you can see that all the implementations of remote will have
so-and-so specifications, which is been introduced
by interface also in Java, you cannot have
multiple inheritance. You cannot have a class which extends multiple
classes cannot have car which extends vehicle and
which extends the for example locomotive locomotive is
one of the classes if for example, so, you cannot have a class which extends to classes
that is multiple inheritance. Do you could have levels and you could have
hierarchical inheritance, but you cannot have
multiple inheritance. But through interfaces you
can have multiple inheritance you could parlament
multiple interfaces, but not multiple classes again, since this is inheritance interface is
hundred percent abstract class. And basically you
create sub classes from or you implement
an interface is nothing but it follows
he's a relationship. So what's the difference
between interface and a class and interface can
never be instantiated just to give you an example, I'll show you what interface is. So instead of this class. I will make this interface. So this is how we Define an
interface we Define interface, but as I said, the interface is
hundred percent abstract. Everything has to be attract. You cannot have methods
something of this sort. You cannot have a concrete
implementation of method though. You could have a default method
which we would be looking at in the in the slides to come
but at this point, let's imagine that you have
a ship class and whatever methods you
have you declared within your ship class has
to be Track a by default. It is abstract. You did not even mention it by default jvm puts
it has abstract. Even if you mention it abstract,
it's not a problem. It is abstract. So now when I unlike extends that we do on glass
or for the face you implement it so you implement shape class. So you'll have to make it public
by default the access modifier for a method the face is public. So here you can see that we have implemented
it we could see that it has a hundred
percent abstract. So with this you could see most
of this differences being listed here and interface
should contain abstract methods, which we saw class can contain
only concrete methods. We are talking about normal class here
not the abstract class. The members of the interface
are always public which we again saw when I didn't implement this one as public Circle
it gave me an error. So by default it is public the members of the class
can be private public or protected and interface
can I have a Constructor since we are not
creating instance. The first point you
can see that interface is cannot be instantiated since we
cannot instantiate interface. There's no need of Constructor
a class can have constructed to initialize the variables which we met yesterday
implements keyword is used for inheritance and whereas
in terms of class, we have extends which we saw now right
for interfaces you we changed it to implements
rather than exchange after extends keyword. Any number of interfaces
can be given this is multiple inheritance
that we spoke about whereas after extends you can have only
one and only one class. You cannot have multiple classes
cannot contain instance Fields. The only field that can appear in our interface
must be declared both static and final
can contain instance Fields. So only the constants
would be declared when your interfaces
whereas with in class. You can have all levels
of all the instance variables. Classes have implementation whereas this is between class
and abstract class. So classes have implementation
abstract classes have no implementations or they
can have implementation as well. So it's a mixture of abstract methods
and non abstract methods as we saw. So abstract class is
not hundred percent abstract right unlike interfaces. You could have
concrete implementation as well concrete classes
are instantiated to create object abstract classes cannot be instantiated
similar to interfaces abstract classes cannot be
instantiated a concrete class can be final and abstract
class can never be final as it has no defined functions for abstract class
to be a complete. It has to be extended. That's what the focus
is abstract class and interface is an abstract
class can be extended with class using keyword extends and whereas interface can be implemented
to a class using implements which we saw. Abstract class can extend
only one class at a time and interface can extend number
of interfaces at a time. So yeah, this is one thing we're
in your interface can extend other interfaces, right and you could have
multiple interfaces extended abstract class can have
private default protected and public members and interface members are
default or by default public in abstract class keyword
abstract is mandatory to declare a method
as an abstract method which we saw okay in interphase. It's not mandatory because by jvm by default put
set abstract classes are to achieve zero to
hundred percent of abstraction, which means that you could have some concrete
implementation as well. Whereas interfaces
or hundred percent abstract. You cannot have anything you
cannot have any implementation within but you could have
a default methods abstract class can have abstract and on abstract methods
again here abstract class can have Constructors. Interface cannot have
Constructors which we saw earlier abstract class can have abstract
and non abstract methods since it's not a
hundred percent abstract. Whereas interface can have only
abstract methods by the way from java it as I said, there's a default
method being introduced which is nothing but you could have a concrete
implementation written within interface class interface
relationship you have class which extends other class you have class which implements interface
you have interface which can extend other interface if there's an interface already
defined and you want to inherit some methods or you want
to inherit the methods that you have within
the other interface would do it using extends
a class extends another class while implements an interface and interface extends
another interface class cannot extend multiple classes, but can Implement
multiple interfaces. So here you could see
that this one class. Which is extending
the class on the top and this one at the right side. It's time to extend it. If you try to extend
multiple classes, it would give you
a compile-time error. It won't allow you to inherit
from multiple classes. Whereas in this case, you could see it's implementing
multiple interfaces on the top. You could see one interface
been implemented by this class and there's one more
interface to the right which is being implemented
by this class class cannot extend multiple classes, but it could Implement
multiple interfaces which gives an opening
for multiple inheritance when any interface gets compiled
compiler automatically adds access modifiers to the members. So this is done by default
its internal Edition. So here you could
see interface demo which has got one variable that is int count is equal to 10 and it has got a method
which is output now when this demo dot Java, which is an interface, which gets compiled you See
that by default. It has put it as public static
final so count 10 would be given access modifier public static
final so four variables jvm by itself puts public static final and four methods it would put
it as public abstract. So that is the reason
when we had the area method when we try to override
it it gave an error saying that it has to be public. So John went to a bank he
wants to credit some money to his account. So let's see this one. So basically here you could see
to implementation of it you have money interface and you have
operation as its method. So now you could see
two implementations of it one is debit and the other one
is credited with in debit. We are just saying that we are writing
a dummy statement. They're saying that we are
debating money from this account whereas credit is nothing. But again, we
are printing saying that we are crediting
money to this account. So now when you create
instance of money or you create in It's off credit and assign it to money
and money dot operation. You would have operation method on credit being called
in this example. We can see that there's
a shape interface which has abstract area
and there's a circle which returns this value right
and say I declare one more class which is square which implements shape and its
again three main error saying that you will have
to declare it. You will have to
implement the method so I will read this and say
I written some dummy value like hundred you have a square
and said Circle say circle area. We are just hard
coding it right now. We don't have to implement it. So it gives you two hundred. It's returning 200 as float. And this one
is returning hundred. So what we can do here is
we have this shape utility. So here we have this thing
called on Circle. So I will just print
it out here saying And now I have one
more say for example, I create one more shape which is square nothing
but Nu Square now what we are doing is we
are going to print out where dot area so instead
of assigning to a variable you could do it this way
as well area of a square. What we did is we
have interface shape and we have a area method
which is abstract. We have two concrete
implementations of it Circle and square and we are instantiated circle and square here and we
are calling area method on it. By the way, you could see here that this is
dynamic polymorphism Circle and square is been assigned
to the shape reference. It's not directly to the circle. You would see hundred and
two hundred mean printer know so Circle was 200
and square was hundred and you could see two hundred and hundred so it's basically
Dynamic polymorphisms followed in interface as well. You could extend an interface
with another interface. So suppose you have
one more Switch is for now just too. So I create
an interface test interface which has like test method. So you have a test interface
which has void test and you could have shape which
is extending test interface. Now your circle and your Square
would give an error because there is one more method
that you need to implement. If you don't implement
it you will have to either make this abstract. If you make it abstract, it should go off
but in this case suppose we want to implement it
then you will have to ensure that you implement test method
as well once implemented the error should be gone
similarly in square. You will have to find it. So that's what is extending one
interface with another right? So basically here you
could see there's walkable. There's a runnable
and when you do it when you implement runnable, you will have to ensure
that you implement Walk and Run both the methods. It's a class extending one class and implementing more
than one interface. There's two interfaces
Walk and Run so you could see animal which implements walk and So
then it will have to implement both the methods Walk and Run whereas there's a human glass
which extends animal. So this is basically
there's a class which is implementing
multiple interfaces and which has to ensure that it implements
both the methods. So in this case walk and run
it has to ensure that it implements Walk and Run
and this one class which is extending
from this particular class and you could see here that you could assign human
which is extending which is a subclass of animal we could see that human could be assigned
to walk and run as well since it is implemented from there. So you could have H 1 dot walk and H 2 dot run sort
of you have given a call to this methods. So basically this is again if you understand the idea
of runtime polymorphism or dynamic polymorphism, which is nothing
but assigning the instance of subclass to superclass
you should get idea of me. All this thing we are pretty
much talking the same thing all this is talking
about Dynamic polymorphism. If you get that thing,
right you have good enough. So we are talking
about default method right since Java it you could
have default implementation within your interface. You could say that you
cannot have a concrete method but you could have if you put a concrete methods
something like this, it would give you an error. Okay, it gives you
an error saying that it's not allowed but you
could have it as default. Once you define is default. It's good enough. So all this methods are all
these classes circle square and all these classes
would get would inherit this they can't override it. They can't do anything with it, but they would inherit this we
can give a call though, but he can't override it. So basically I'll
just show it here. So basically you
have default method which is say say and
which is printing out. Hello. Welcome to edu Rekha, right and you can see here. Flash interface demo, which is implementing welcome
and you could see here. Hello bean concrete
implementation of L, which is nothing but
it's printing out the message that is passed
to the hello method so though default class
interface demo doesn't declare say method it
inherits from welcome. When you do out dot say you
could see the default method being invoked here. We could see that you know, hello welcome to edu
Drake has been printed out which is nothing but the output
of default method so basically default methods
are not but method which cannot be overridden but is available
for all the classes that implements a
particular interface or implements that interface so rules for using
private methods in interfaces following all the rules
for using private methods in interfaces private interface
method cannot be abstract private method can be used only inside interface
private static method can be called from other static. Non-static interface methods
private non static methods cannot be called
from private static methods. This might look confusing
at this point, but you could think that first
of all private interface method cannot be abstract because we want it to be implemented in some
other implementation, right? We cannot keep it
private since interface by itself doesn't have
the implementation of it. You want to implement
that method in some other class. So it cannot be private
private method can be used only inside interface. So if we Define a private method
within an interface, it can be used only
within the interface. So basically you
could have a default method which is private, right? So basically default method
itself cannot be private but within default method, so what I am trying
to say is so here you could have private void
which is doing nothing but here your default method
would call this private method. So private method can only
be used within the interface and it's usually used 24
get private static method can be called from other static. This is pretty much similar
to other classes normal classes private non static methods
cannot be called from private static methods. This is a common rule that we have private non
static methods cannot be called from private static method. So if you have a static method
within the static method, you cannot call
a non static method. Remember we mentioned it earlier unless we create
the instance of it. We can't call it. But in this case you
cannot call it at all. So it's not on a class
you're invoking it basically within an interface. So private methods is
specifically you could call Private methods from within
your default method in interface and since private methods are
not accessible from outside. That's the only reason you
could have private method near interface static methods
in an interface. So you could have
something like this where in you have
interface one and you have a static method display? You remember static
methods are more of a class level method, right? You need not have to create instance of a class
to invoke a static method if an interface has
a static method you could call it directly by interface dot
the name of the interface does the name of the method so we can have a static
method like static. So this method could be called so you could have something
like this method and you could call it directly
using the interface name. So we have this so now within shape utility
you could wreck akahl, like as you could see here, you could call the static method directly by the name
of the interface. You cannot have
normal methods within it unless it's a default
one interface features four different jdk version. So interface has evolved
throughout the versions of JD case. So just to brief on that. We have jdk 121 .7 having normal interfaces
with constant static variables as we said the variables that you would have in a The
freezer typically constants which is public static final
and with abstract methods, of course in Java 8 it evolved
and we have a default method as I said, there would be
one default method which would be inherited by
all the interfaces extending that interface and you have
static methods as well, which was not there earlier
in Java 9 and later versions. So in Industry right now, it's mostly Java 8
that's been used across very few have gone to Java
9 all the big data Frameworks and everything we have
is supporting Java it at this point. So with the latest version that's Java 9 and above we
have static constant static variables abstract methods
default method static methods and they have come up
with this two methods which are nothing
but private methods and private static method, which was not there earlier. Now you could have
this things as well. It makes very little sense to
have all this scope variables, but maybe they might Have or something as
a part of evolution, but at this point, I believe since this private
methods cannot be called from outside it just that you have control
over the default method. So basically maybe if you have a big
logic to be written within your default method just to modularize
it just to break it into multiple methods not to
have one monolith big function or big method you could have
this private methods. That's what I can think. What is the package we have been
using package since day one. So package is nothing
but it's a namespace it's for avoiding Collision. So basically I could write
a name class with name shape and maybe someone else within my team would
write the same thing. Right? So basically at the end
when we archive it together like we have a jar file, which is Java archive when we archive this files
together there is going to be named Collision, right? You wouldn't know
which shape class. Are you referring to? So basically namespace
is nothing but it adds. Stewart and it avoids
Collision classes in the same package can access
each other's members. So basically you can have
within a package. So we'll talk about
the import statements that will give you
a clearer understanding of what we are talking about. But basically within a package
as you could see here, we have not done anything
to refer any of these classes. So it's within a package
we have calmed said Eureka and we have all these classes
within this package so you could see that employ
or maybe manager which is a different class
in the same package. We are accessing it directly. We are not doing anything
different for it. But when you want to access it from a different package you
have to do something else which is nothing
but importing the package the normal living convention
is usually domain name here. You could see we
wenshan calm down at Eureka. So it's usually something of that sort dorji dot
example dot hyphenated name. It has to be lower
case usually written in lower case companies
use their reversed. Net domain name to begin
their package names. So basically if you have
my package or example.com, you would have it
in reverse order. This is typically a one of
the best practices of practices that's been followed
across industry to define the package but it
doesn't have any constraints from the Java side as such you could do anything. So for example, if I make it uppercase,
so basically it's saying that it's not showing error
because of its in uppercase, but basically you don't have
a directory starting with uppercase Aspire Java
or from the Java side. You don't have any constraints. For example, I could do something like So basically it
does convert it into lower case, even if you give uppercase. I don't know whether this is
a feature in IntelliJ IDE, or it is of course it has
to do something with the ID because Heidi is converting it
into lower case as far as the Java naming
convention is concerned. This is what we do but it doesn't have constraint
Java predefined packages. So Java itself
has many packages. So you could imagine
the entire language been written in Java source code. So basically all this you
would find in the source code when we refer to the string when we refer
to string string is a class which resides in Java dot Lang. There is Java dot language is
nothing but Java dot language. So string is something that resides in Java dot
Lang object is a class which is a super class
for all the classes. So, you know,
what super classes are after we went through
the inheritance thing. So you have super class
and you have subclasses. So the superclass All
the classes no matter what class you use with in Java. All the classes are inherited
from a class called object. There is a class object in Java from which all
the classes have inherited from our all the class inherit from this particular
class thread is used for multi-threading. Java dot length of thread is used for multi-threading
multi-threading is nothing but 2 lightweight processes in
order to leverage the potential of your processors. So if you have multi-core, then you could have
multiple operations happening at the same instance of time. That's what thread is all for you make it faster
you have exception class you have system class
Java dot language system. This package is used to achieve
the language functionality such as conversion of data from string to fundamental data display
the output on the console and many more the package
is quoted by default. So you don't have to
specifically explicitly import. This particular package is by default voted into
your application Java dot util. This is like utility classes
you have Elections and stuff like that
into your Java dot util this package is used
for developing quality or reliable applications
in Java or J2 ee this package contains
various classes and interfaces which improves the performance
of j2me application. So basically these
are utility classes. It does something
in terms of performance or does some conversions
or something of that sort. Java dot IO is a package
which contains something like file input stream
file output stream and stuff like that, which is basically for interacting with
your files with your I/O. So basically if you want to load
something into your memory, if you want to read
something from your file or write something go file
in your local directory, you would use something
like Java dot IO package if you want to do some kind of
socket networking or some kind of network programming
you would use java.net which has something
like socket datagrampacket datagram socket Etc. We have applet tablet is
nothing but application that gets loaded
into your browser. It's not you. So as of now earlier
it is to be used but now there are a lot
of other technologies that have come up
but this is something like an applet is a Java program which runs in the context of
w WR world wide web for browser. You have Java dot e WT
which is like event-driven like you could
have UI applications. If you click on your checkbox or button there
would be even triggered and you would have
an event handler handling it if you click on a mouse or something you would have
a even triggered. So basically all these classes
are grouped into this package, which is Java dot AWD so you could see
the Java dot w dot even which has like Mouse listener. This is specific to event
without this classes. It is impossible to handle events generated by
G UI components. So as far as the front end is concerned as
far as all this a WTF that is concerned. It's not in use basically. Java is much more useful
in terms of back and program which means you take data
and Do something with your data and stuff like that, but it's not well suited
for UI applications and it's not used to that extent
in Market or industry. You have Java dot SQL which is nothing
but your database related stuff. So we want to connect to your post gray or if you
want to connect to Oracle. You have all the stuff
written in Java dot SQL. So mostly in Java data skill, you have interfaces
and this interfaces as I said, it's nothing but specifications and this specifications are
implemented by database vendors. So it's nothing
but interface is just an abstract method it would have
like four five abstract methods within so all
this concrete implementation. Someone will have two women
to use this interfaces or someone will have a class which will implement
this interface has and we as developers can
use those classes to interact with databases. So Wenders like Oracle will have
its own set of implementation to the Patients that are mentioned
in Java dot SQL as I said most of the thing
in Java dot SQL or interfaces. So about the access modifier. We have spoken earlier. We have public we have protected
private and default modifier public is nothing but
it could be accessed from anywhere within
your application. So you could have your methods
as public you could have your class as public you could have your instance
variables as public which means that particular
method could be accessed from anywhere within
your application. You could have protected
modifier protected modifier is nothing but your subclass
is can access it and your current package
whatever the package in which a particular method or particular class resides in
which you have protected method. You could access it
from that class or any class from
that particular package access the protected methods defined
within a class that package so I will give you an example since we have spoken
about inheritance now, so I will give you a demo
on protected private. Modifier is basically
it's private. It's within a class. You cannot access
it from outside. If you try to access it, you would get a compile
time error saying that it's not visible default
modifier is package is public within package So within package
any class can access it. So basically it's like protected right
protected can be accessed within the package
plus it has like if a sub classes are
outside the package, even though subclasses
can access it whereas in default. It's just within the package. So protected has wider scope
then default modifier. This is kind of public so public
has almost like everything so why didn't scope then comes
protected then comes default and then comes private so access
modifiers public word Republic. So when you have Public Access modifier
within a class in this case, you have two packages. Are you Ricardo back one and a new record out back to
and you have some public members within your class one, which we can see here
that all this public. Members could be accessed
by Class 2 class 3, which is there in the same
package as class 1 that is at Eureka dot Pack 1. So now there are two classes
in a do record back to one is a class which doesn't have
any relationship with glass one but still it
can access it though. It's there in
a different package. But still it can access
the public members of class one. You can see class for which
is a child of last one since it extends class one, but it's there
in a different package but still it can access
the public members of class 1 so protected protected is nothing but it could be accessed
within the package in which the class is defined and it
could be accessed by members that are outside the package but
child of that particular class. So in this case we can see that there are few protected
members in class one which could be accessed
by Class 2 and class 3 since they are in the same
package as class 1 plus 3 and class two are defined
in Eddie cannot pack 1 we have class 5 Is not related to class 1 which means
it's not a subclass or it doesn't have any relationship with class
1 in that case class 5 cannot access any protected
members within class 1. So here we have class for which
extends class 1 which is nothing but plus 4 is a subclass
of class 1 which is there in a different package
at your record back to but it can access
the protected members of class one since it is there
in a different package private member is nothing
but it can be accessed just within the class
in which it is Define. So in this case you could see
that this is private members. So you have class one
which has got private members and you can see
that class to contacts is it class three contacts? Is it either class 4 or
plus 5 no one can access it. It's just that class
one can access private members. So we have seen this in examples that we took in session
one default package. So default package is nothing but only within the package
in which it is defined. It so in this case
you have class one which has got default members
with default scope and you can see that class 2
and class 3 can access it but not class 4 and Class
5 since they are out of this package since Class 2 and class 3 are
defined in the same package as class 1 that is
a deal-breaker DOT back one. That's the reason you
could access from there. This is same for
attribute or method. There's a table here, which is summarizing whatever
we discussed so far you have modified public. So yeah, it's within the class. Yes. It's within the package. Yes, if it's
within the subclass. Yes and within the world days so everywhere it
could be accessed right? That's why you have public
protected is within the class. Yes, within packages
within subclass. Yes, but not within world. So just within
package and subclass, but if you have different package or
if you have different package, but it's not a subclass. Then you can't access it. No modifier, which is a default scope
within the classes within the Yes, but we saw that it cannot be accessed
within the subclass if the subclass is
in a different package when we save world world
is nothing but any package and they are not related in
this case the previous example that we should saw
last five is something that could be thought of as laws
that are unrelated. But reside in a different
package private is just within the class you can see that it's not with package
within the package. It's not within the subclass. It's not within the world. So I think we have spoken about private public
and default scope earlier. Let's start off with protected. So in the meanwhile
when it starts, let's talk about this. So here we can see package demo which shows public it
has got a public method that is message. There are three ways to access
the package from outside. So let me talk about
how we actually recorded. So there are three ways to
access the package from outside. The package one is
with import this case like you had a direct a 1
and enter a car to right there. Sample that we saw earlier. I do record Pack 1 and add you taken right back to these
are the two packages you have if you want to access
something you want to access class 3 from class 5 you
would have to import a new record Pac-12 class 3, since it is outside the package of back one if it's
within the package so far the examples that we
were taking was all within the same package, so we didn't have
to import it now. I will just show you an example
wherein you would have something that is outside the package
and I will show you how to access it. So we have to import it. So whenever you have it
in different package, then you have to input
that particular package within one thing is importing
the entire package. The other one is importing
a particular class. So in this case you
have a package demo, and we can see
that within package demo. There's a pack demo, which is nothing but a class
defined within it. So, let's see how to access package
from another package you have a Demo here that's a class that is defined
within the package demo as you could see here. There is one method
which is MSG and which is taking two parameters
as input TJ Ryan integer J. So what are the ways in which you could access
this particular class that is packed demo
from outside the package. So the first thing that you could do
is you could import the entire package itself. So demo dot star
or demo dot asterisk as you could see here, which says that all the classes
within this particular package can be accessed
from this particular class. So you have a package
demo class defined here, which says import demo dot star and which would input everything
all the classes within demo. So in this case back
the more you could see that pack demo class
could be accessed from within package demo class that's there in
different package. So basically this
package demo class that you see here is defined in some other package
other thing is See if you want to import
just a class and not the entire package. You could do that thing as well. So here what we are doing is
import demo dot pack demo. So we are importing
a specific class and not the entire package
that could be done as well. And the third one is
instead of importing you can do one thing you can have
fully qualified path name or fully qualified name
like demo dot pack demo. That's your class name. You can access it
within your class. So basically you would use
the fully qualified name who might use it. You did not do it, but you might use it in case
where you're just using it once within your class, but you would go with
this options demo dot pack demo or demo dot star in which you
class has multiple is referring to the class in different
package multiple times. So in that case, you just do it once
and could be used within your class. You need not do it
again and again, so I create a new class which is Calm down
at Eureka new DOT. So I created a new package. So there is one
that is calm down Eddie Rekha, and the other one that is calm dot ed
u de canoe this are different packages you have if you want to use something
within this package Comdata Rekha suppose I want
to use Vehicles, right? So this is what I
was talking about. When you try to access it. You can't do it you
can access vehicle from here because it's there
in a different package. Now you are not able
to access it because you haven't imported it. So what I do here is
import calm dot Ed u-- Rica dot vehicle once I do this I am able
to access it now. Now what I was saying is if you are accessing multiple
classes from multiple classes within the package like car also you are accessing so instead
of writing it like this. So what you would do is calm down at Eureka the car now
the compilation error has gone. So basically instead of doing
this like instead of writing. Multiple times the other option that we have is like calm down
at Eureka dot star. So now if I get rid of this 2 inputs
still it would work. I don't need these two inputs because we have putted all
the classes within the package. So it's able to access
both the classes vehicles and Ed Eureka from
calm dotted Eureka. The other one was you could get rid of this now
it's showing up error. What you could do is calm
down Eureka dot vehicle. You could access it directly
with the fully qualified name so you can see
the error has gone. So these are the three ways
in which you could access different packages or access classes
from different packages. Now, let's understand. What is the regular expression so regular expression pretty
much similar to other languages that you have regular expression
is nothing but an expression through which you
could extract some sequence of characters from your string or you could check whether a specific Fake
regular expression or whether a string is aligned to
a particular regular expression. So you could Define
a regular expression saying that if for example email ID, right one of the use cases
of regular Expressions could be like you have email IDs and you
might have seen on websites where in you do some kind
of registration or something and if you don't give
a proper syntactic 1 then what it would do is it
would give you an error at the red gmail.com. If you don't give that it would throw
you an error showing that it's not proper. So it's not checking
against the Gmail server to see whether your email ID
is proper or not. So it is just
checking syntactically. You might have seen it. So if you give a wrong
syntactic email ID and if you go to the next tab, if you tap to the next
column or to the next space what it would show is you
haven't entered it correctly. So basically what it's doing is its checking it
against a regular expression. It has got a regular expression
saying that This is how an email ID
could be it should end with so-and-so characters. It should be at the rate. It should have at the rate. It should have Gmail or it should have
some characters in between then add followed by.com
or something of that sort. So basically to have this syntactic this thing
done just to ensure that you have given it properly
you have a regular expression. So yeah, one of the use cases
could be to have this pattern Checker usually to see if you're giving value which aligns to
what is expected. So maybe other thing could be if you're typing something or if you have been asked
to put some amount and if you type characters there it would give
you an error saying that it's not allowed those type of checks could be done
through regular expression or if you want some value to start with a particular character and
end with a particular character. You can check it
against a regular expression regular expression is
a pattern used for searching and manipulating strings. It could be used for
manipulating strings as well. So one of the use cases is Ching and the other one
is for manipulating the regular expression
either matches the text or fields to match. So basically it
would validate and say whether it's a match
or it's feeling so we call regular
expression as Rex which is nothing but abbreviation
for regular expression. So Java supports
regular expression, and these are the pluses that we have with in Java, which
is in Java dot util package. So remember we spoke
about Java dot util package which has got utility classes. So these are among them. So here you can see
a pattern class you have mature class and you have patterns
in tax and tax exception. So basically if you
have some exception if it's not proper, then you would get
some exception as well. So we would be taking an example
clarify what this is all about. So here are some
matching patterns used in regular expression. So it just about
to read through it. So you have like ABC It
means it has to exactly match ABC if the string that you are matching it
against has the content ABC it would match when you put it
into square bracket, which is any letter a b
or c should match any character. And again if there's a negation
if within the square bracket, if you have this negation Mark, which says that any character
except these three characters should be matched. So if you put D it
will match the second case if you put a or b or c it will match and here
it would be from D to Z. If you put anything it
will match not just alphabets. It could be anything
any character A to Z. So when you say A to Z, it says that we are giving
a sequence of it, right? So we are saying from a
it's a range basically so it understands range as well. So when you say a - Z which means that it is from A
to Z here we are saying that any one letter or digit. Ben sequence so basically
you could have uppercase and lowercase as well. Basically it is saying
it should be in sequence. It should end with basically digit at the N dot is some kind
of a wild-card character saying that any one character except line Terminator
must be in sequence. This one indicates
beginning of line. So we say that line
should begin with so and so you could put
some character here and we can say that if a line begins when Sue and Sue character sequence
or whatever regular expression that we have put in then
the entire line matches. The other one is end
of the line with check if any character present at the end of the line
other thing is word boundary. We have an example about this so which would give you
a clear idea about it, but it's more about it
cannot be part of a word here when we put slash B to the front
and the end or to the start and the end of a particular
character sequence, which means that it has
to be separate word, but it I'd be part of some other
word /b to verify that any character is not present at the word
boundary /g to check that the character is present at the end of the previous
match metacharacters. So we have /t instead
of writing 029. You could use metacharacters. /d to define DJ when you want to Define
on digit which is like you can see here
negation of 029 set, which is non digit which could be like
alphabets peace or anything which could be grouped as /t /
s is a whitespace character who space tabs and stuff
like that could be enter for that matter
is whitespace character /s is a non whitespace character which means the actual character
rather than white space / W is a word character
and / uppercase W is a non word character
you have quantifiers, which is a quantifier defines
how often an element can occur. So star, which means that zero or more times
plus which means that it has to occur one or more
times question mark is it could be no or just one time you
could mention the number of times you want
a particular sequence to occur, which could be put
into your curly braces occurs X number of times x you could put a range within within your curly
braces X comma Y which means that it should occur
somewhere between X and Y. So it's a range you have
asterisk question mark it tries to find
the smallest match. This makes the
regular expression stop at the first match. So as and when it finds
the first match it would stop so we will have a quick demo
on regular expression. So here before we start off
we Define a pattern here. Basically, then you could see it
is basically saying from A to Z and followed by character one or more character
then we have a check here, which is nothing
but a string again. Which we are going
to check first. We compile the pattern. This is a regular
expression pattern that you have you're going
to check against. So the first thing that we have to do is we have
to compile this pattern to see if it's properly done or not. So first thing is to compile it
against patent and if it's correct up to the mark
you would get the instance if it's wrong then
there would be some kind of exception thrown then
there is a matcher. So once you have the pattern
you do pattern matcher and you provide the string
against which you want to check in this case you have happy learning welcome
to Eddie break is the string that spin past and
when you do see dot find if this is fine, it would return the result true and if you remember the while
construct it would get in only if this is true, so it's a loop so it would basically
I trait through and you could see here that it's displaying
all the characters. I'll quickly run this. Let's name the class has
pattern Checker now, I write a main method
now if Remember, we had a pattern there which was like a to z
followed by actress. Then we have string
against which you want to check or you could say
simple string to check. So we just put this one. So once you have
this string to check now, what we want to do is we want to
compile this particular pattern. So what we do patten.com pile, so one thing to see here is
that's the beauty of using the IntelliJ or Eclipse. So you could see here. This package is already
been imported when you use it. Unless you have multiple classes
with name patterns, it would ask you
to specifically explicitly mention which one you opt for. But in this case there was
just one pattern class. So it imported it automatically
then we give the pattern here. So basically if this
pattern is correct, if it's rightly formed
syntactically you would get a pattern here or so. Pat and I believe we have
a compiled pattern now now what we do is we take
this compile pattern and I think we
have matured here. We get the matcher. No so matcher would
check again string. So you have a string to check
which would give you matcher. So here it's asking me which mature do I want
I'll select this one and you see this one getting
in put it here. So this is what we have done. We have compiled the pattern and
we have provided the argument against which we have
to check as a part of nature. We get the instance of matcher. So everything is
in terms of class. This is what object oriented
programming is all about. You have a pattern
which is a class. You have a method within pattern which is
compiling your pattern. So this is what object oriented
programming is all about. Everything is realized in terms
of classes and objects. This is nothing but the object
of pattern class company. So now what I do
is matcher Dot Find I just print this one
match her dot check. So basically what we
are trying to do here is once the entire string passes through we are trying to get
the substring out of it. So when we get
the substring from matcher, you would get the string indexes
begin index and you would get matched end as well. So when we run it,
you should get a PP y n so the first character
would be trimmed off so you could see first character
being trained of each line. So I'm putting
regular expression. We saw that Java dot util
don't reg ex gets imported. Then you have patent then
you have string to be checked against the pattern
and the sentence which is to be matched are given
A 2 Z means any character from A to Z and plus means one or more
the sentence check is checked whether it matches the pattern
or not the strings from the sentence which match
the pattern are printed. So basically here we could see that Echizen uppercase and we
don't have uppercase here. So that's the reason I dreamed
of the first character. So basically if I add H hear
you now eh would match as well and it won't cream H
or it won't remove edge. You should be able
to see H as well. So yeah, as you could see here
you have H appearing as with previous case. It was getting primed
of so this one is for the word boundary. As I said,
if you want to have something like you want to be sure
it's a separate word and it's not a part of any word you could put
something like this. So basically what we
can do here is so we can mention here something
like special are we and then in so what we are trying to do
here is you could see here. What we are saying is
we want to separate word as in we don't want it to be
a part of any other word. So here in learning
do you have iin? It didn't pass it
because it's word boundary whereas Just a
separate word here. It just passed this one. So if and I remove this one
you could have seen two ions. That's what I mean to say. So now what's exception
exception handling is nothing but typically so here
you could see two ions when it's / / be it
would be just the ones that are complete word instead
of matching the word boundary. Let's talk about
what are exceptions and exception is an event which occurs during
the execution of a program that disrupts the normal flow
of the program instruction. So to give you
an example yesterday, we spoke about arrays, right if array size is 5 and if you try to access
something more than four like if array size is 5 which means that the index is
range from 0 to 4, if you try to access
something more than four like if you try to access
Sixth Element within the array it would give you an error
saying array index out of bounds or if a particular Their object
is assigned null value. And if you're trying
to access that method within that particular object, you would get
null pointer exception since it's not
instantiated as yet when you instantiate it that's
when the object gets created. But if your reference
is pointing to null and if you're trying to access
something within that reference or a class you would get
null pointer exception similarly you have like / 0
and stuff like that. It's basically something
that is not expected or something that would
disrupt the normal flow of program execution. When an exception occurs the jvm
creates an exception object to identify the type
of the exception that has occurred. So basically within itself, it would create it
or the gold would create it so I can create my own
custom exception tomorrow. If I am writing an application
usually in applications. That's how we do. We write our own
custom exceptions. I can Define my own exception as well if My application
something is not working or something is not running as I would expect it
to I would throw an exception so that within my application
it properly logs or it properly prints out
in my console saying that this is the exception that's been triggered
due to so-and-so condition. So an exception is often
referred to as runtime error. So here we can see divide
by zero exception as an example. Now there are different types
of exceptions first one being checked exception the other one
being unchecked exception and the third one being error. So checked exception is
something that happens in the compile time. What happens is when you have
a checked exception when you are invoking some method, which is throwing
a checked exception and okay. I don't want to get
into the catch block as yet because we
haven't covered it. So this is also called
as compile-time exception. It means if a method is throwing
a checked exception then it should handle the exception
using the try Clash block. It should declare the exception
using throws keyword. Otherwise, the program will give a compilation error whenever
there's a checked exception that's been thrown out
thrown out in the sense not at the runtime. There could be methods
which is throwing an exception. So whenever there is a checked
exception you have to ensure when you give a call to
that particular method say there is a method X which is throwing
some checked exception which is throwing some checked
exception from your application. You are trying to
access this method X when you try to access
this method X you have to ensure that you are taking care
of the checked exception that is thrown from X. If you don't take care of it, it would give you
a compilation error when I say when you
don't take care of it. How do you take
care of exception? That would be the first question that would have come
to your mind. So when I say you have
to take care is nothing but you have to catch it. You have to
handle that exception. So try and catch is a mechanism through Which you
handle the exception. So what you would do is
Method call or the call to X you would put
it into a try block and the catch block. You would say that if this particular
exception occurs execute this block of code, that is a Handler
for exception X or checked exception
that is thrown from method X. So basically you write a Handler
for in the catch block saying that this is what I want to do
when this exception occurs. Once you have that
when your program runs even if the exception occurs, it won't stop
at that point it would go and check whatever is written
and whatever piece of code that you have written
and it can continue from there on it's basically a decision
made by the developer whether to carry from their own or whether you want to break
it there whenever there's a checked exception
you have to ensure that you handle it either handle it or you say that I'm not going
to handle this. I am just going to throw
this off from my method or throw this off from the Well, I'm executing this method
X method X which we spoke about which is throwing
checked exception. I can choose not to handle it
and just to throw it off to the calling program wherever
the execution initiated from. So if you don't do that, you would get a compilation
error unchecked exception unlike checked exception. It's not mandatory that you catch
it's not mandatory that you handle it. So runtime exception basically
it could occur any time and it's not mandatory that you go
and actually handle it. So even if you don't handle
it jvm would be okay with it and it won't give you
compile time error. So basically these are nothing but runtime exception
so divide by 0 that we spoke about his nothing but a runtime exception
it's not mandatory that you go and actually, you know handle it
during the compile time. You can either handle it
or you can leave it as is and during the runtime
you would get an exception. So compiler doesn't check
for the unchecked exception. It's done at the
runtime now error. These are Conditions that are
external to the application and that application
usually cannot anticipate or recover from it. For example, if stack Overflow occurs
and error will arise they are also ignored
during the time of compilation. So even the error condition
cannot be anticipated during the compilation time. It's done during runtime. Right? So one of the classic example is
the stack Overflow, we're in see for example, you call the same methods like thousand times not
thousand time is too less for the stack to get overflowed. But suppose you call it like million times you call
same method right in that case. Remember when I said when you give a call
to the method it goes to the call stack, right? We have a call stack. So it would push something
it would push state of class or it would push the properties that's been passed as an argument the class or to
the method to the stack. I treatable if you call it
like million times, what would -
you would get stack Overflow because basically everything
would get into the stack and it would basically, you know, give you a memory
or float or even memory for the Heap memory
for that matter if you create lot of classes if you create a lot
of instances of classes, you are Heap memory
would get overflowed and you would get
out of memory error. Those are classic
examples of error. So what the hierarchy
of exception in Java when it comes to classes
you have a stable interface and then you have error and you have exception. So exception is further. It has got runtime exception. The other ones are
the checked exceptions. So ioexception SQL exception. These are the checked exception. This has to be handled if there's a method
which is throwing one of these checked exceptions. You have to ensure that when you give a call to
such methods you handle it or you throw it from your method to the right side
its runtime exception, so it need not be handled
as I said. Divide by zero and stuff
like that would be runtime exception even
array index out of bounds and Class cast exception
arithmetic exception. Then you have
null pointer exception that we spoke about all these exceptions
are unchecked exception and you need not actually handle
it during compilation time. So why to use exceptions when we execute a given program
will get an exception exception handling is performed
in order to get the output. So basically, why do we handle
exception is nothing but to get the program going
rather than breaking it at that point use of exception handling
process exceptions from program components handle
exceptions in a uniform manner in large projects. So basically, why do we do it? So it's done basically to get the process going rather
than stopping it at that point and you could handle
it the way you want to that 's the reason
you have this exception handlers give you a simple. Example suppose 29 by zero what I am trying
to print here result after dividing 29 by zero. So basically when you run this, it's not showing up
any compile time error. It's compiling fine. Now when I run it since it's a runtime exception
it's compiling fine. But when I run it, let's see if it
throws an exception. So as you could see here it
throws arithmetic exception which is divided by 0
and this is happening at the runtime. That's why it's
a runtime exception or unchecked exception when a runtime exception
occurs program gets crashed and control comes
out of the program as we saw here when we ran it. It didn't run this part of it. You could see that it broke out
just right from here. So whenever there
is an exception if you haven't handled it
program control would come out from there exception handling
is done to execute the program without getting an exception. So handling is done basically
to handle the exception whenever the exception
occurs do some action it. It's flexibility to
the developer to handle it the way they want to and get
it going mainly try catch and finally our keywords
for exception handling. So we have a trike at as I said, there's a try block where in all the suspicious one
or wherever the exception you think that there
could be exception occurring could put it into a trike block
and in the catch block, you would say that if
a particular exception occurs, this is what I want to do. All right, that's
the catch block. The finally block is nothing but no matter the exception
is thrown or not. A finally block is going
to execute at the end. So basically finally
block is usually used to release resources, right when you
deal with databases and stuff you create
connections against database or you create some socket
connections and stuff like that. When you do some socket
programming finally would be a place where in once the execution
of the method is done or execution of something
is done you say that we can release these
resources of rather than Still establishing the connection, right which picks up some
of your resources CPU resources or which takes up memory. So basically it's to release of
the memory exception handling. So let's talk about try try
block is nothing but code that could generate
so suspicious could as I said that could generate
an error is written into the try block. So the cache block could be more about catching
a specific exception and doing something with it. So you could opt
out to just break at that point or do something with it say for example want
to profile an application or you want to have
some instrumentation set for the application to see how much time what are the exceptions
that occurring during runtime, right if you want to see that may be a typical way in which it is done is
you write all this exceptions into a database and we're in later could apply
some analytics to see you know, what kind of Errors
have occurred in the application you could see
that later on so that one of those cases where a new Let Whenever there
is a particular exception you put it into a database you make
an entry in the database saying that this is the exception that was caught
in so-and-so time. And you could later on
have some analytics to see how it could be improved how the application
could be improved. So finally block is nothing
but with a successful or unsuccessful the block
is going to get executed as I said, this is nothing but mostly
it's used to release resources such as connections
and stuff like that. Let's see a demo of how we can handle exceptions
to give you an example of try catch us with this was
this is a suspicious code which we are running. Maybe you could put this in
to try catch block and save and there is any kind
of arithmetic exception that occurs just printing It Out Printing
any kind of rhythmatic. So what we are doing
here is nothing but we are catching exception and we are printing it so everything is
in terms of classes again see exception itself. A class so you could click
on it control click and you could see it as a class. This is source code
for arithmetic exception. So you could see extends
runtime exception which means arithmetic expression is
a runtime exception. So it's a subclass of runtime exception
you could see super and everything being used here
whatever we discussed about. So arithmetic exception is
nothing but it's a Constructor right and you could see
super been called here. So that's how you could get into exception and you could
read through it to understand how the source code
is being written that would give you a good idea about how flexible Java
is it's very much when it comes to flexibility and when it comes
to object-oriented Paradigm, it's very much
cleanly followed code so you could go and actually see at the the way
the programs are being written. If you remember when you'd we did 29
by 0 the program bro, it came right from there and it didn't execute
the following code. Now we have Handled it. We are saying that whenever there is
an arithmetic expression in this piece of code. That's here. We are saying that whenever there is
an arithmetic exception. We are going to just print it
and we are going to continue it. Don't stop at that point. So you could see here the program didn't break right
it give you an opportunity for you to actually
handle it and it didn't break it continued. So you could see this statements
been executed as well. That's why you
have this results. So we had printed here. So as a part of handling
exception handling, what we did is we just printed
out saying that what kind of exception had occurred. So exception dot get message that gave like divide
by zero this divided by 0 that you see here is nothing but is printed out
by this message. So it give you an opportunity to handle it and get
the program running as is so try
catch finally block. Basically. What I can do here is let me Define integer
denominator is equal to So as I said finally block
is going to execute no matter of pot is going to get executed. So I just print the message
here saying I will say here. I'll put denominator when the denominator is
0 we would get exception and it would come
to the exception block here or the catch block here and it would print it and then it would come
to the finally block. So let me run this and see so
as you could see here, it came to the exception Handler
it caught arithmetic expression that is divided by 0
and then we printed out saying that printing the typical
message or the actual exception that we got and it came
to the finally block here. Let me put a scenario which is not going to throw
exception in this case. My denominator is 1 which means 29 by one we
shouldn't throw any exception. So what I want to show
is still it would execute the finally block so you could see here
29 been printed out which this got executed
successfully this time because the denominator is not 0 it's one it got successfully
executed still the finally block is been executed why to use
multiple Catch blocks so you could have
multiple exceptions and you could write
multiple catch blocks. There are different exceptions
that we spoke about it could be like a pointer exception as well
which you want to handle right? So it depends upon your program logic or
what you are trying to do here. So there could be null pointer
exception then you have finally so you have multiple
catch blocks here. So you usually don't handle
null pointer exception but this is just
to give you an example. So basically you have
this arithmetic exception here been handled then you
have null pointer exception being handled here then you have finally so if you want to have different
exceptions to be handled within your application, you could have multiple
cache blocks since all the exceptions are derived
from exception catch exception. He should be placed at the end. So basically if you put
the exception this exception, right if you
remember the hierarchy that we spoke about all
the exceptions are derived out of exception class so you could have
something of this sort. So if it is not an arithmetic expression
not a null pointer exception then is of course going
to be some kind of exception which is going to be handled
in this exception block. So basically we are catching
all the exceptions here first is specific
to edit mattock exception. The second one is
null pointer exception if it's not a null
pointer exception or arithmetic exception then
this particular cache block is bound to get executed and it has to be last
you cannot place it first because if you place it first
this two blocks exception Handler blocks will
never get executed because even this two
exceptions are a subtype of exception class itself. So it has to be it is mandatory
that you place it at the end or else it would be be
compiled time exception so you could have something
like array index out of bounds and stuff. So just to give you
this is integer array. I put one two three
I Define an array now I say integer array
of Three elements right and if I try to access
or just choose so when there are three elements
the index ranges from 0 to 2. So now I put three here. So this is generic exception
Handler for all the exceptions. We would have this Handler
when you run it. This is going to give you
a rain dicks out of bound because you are trying
to access element at index 3 which doesn't exist. So you would see
a generic exception and so it came here. What I was trying to say is so you could have arraigned X
Out of bound here, right? So instead of null
pointer exception now, I have arranged index
out of bounds now, it would be handled
by this block and it wouldn't come to
the generic exception Handler. So here you saw it came to
the generic exception Handler. Now what you would
get is array index out of bounds exception Handler because it's been handled by
this particular cache block and not the last catch block. So this one is as you go down
it becomes generate. So here you could see
it's been handled by array index out of bounds exception
as you go down. It becomes generic more. Generally it is
multiple catch block. So this is pretty much similar. We have re we have
arithmetic exception that occurred array
has four elements 023 and you are trying
to access the 10th element. That's when you would get array
index out of bounds exception as we saw there could
be nested try the rain. You could have try
and inside try. So basically when you
have prai inside try if there's an exception
that occurs in the nested one or the innermost one, it would try to see
if there's a catch Handler for that particular
exception innermost one. If it doesn't find then
it goes to the outer one. So in many cases it may happen that a part of the block
may cause an error and the entire block
may cause another such cases. You're going s to try block. So what I was trying to say
is you have this one. We have one more like exception
or shouldn't be done. So you have a nested one within
this try you have one more wire. This thing with says array index
which is handling null pointer exception sending
just the null pointer exception. It's not handling
array index out of bounds. So what I was trying to say is
if such scenario occurs, it would check the innermost one if it finds
the exception Handler, it would execute it. If it doesn't find then it
would come to the outer one. So basically though this try
doesn't have Handler for arraigned X Out of pound
still it would be taken care of so you can see here. It came to the outer one. So if you would have some piece
of code right after this, it won't get executed. So this piece of this code
will not execute if inner try so basically if there's a reception
which occurs in the inner block and if it's not handled it
would come to the outer block but this piece of code whatever
you have in between this catch and this catch would At x equal to Y to use throw keyword
the Java through keyword is used to explicitly
to throw an exception while executing the program. So if you want to throw
something as I said, you could create
your own custom exception and if you want to throw something
you could throw it out you could throw an exception
from your program. It can be used to throw checked
or unchecked exception any kind of exception could be thrown
using throws up using through and the Java through keyword
is used inside a method so you could see here. Basically if B is equal
to 0 you throw new exception / 0 causes an exception. So before it goes to actually
dividing it by a by B, you are kind of handling it
prior to that you are checking whether denominator is 0
if the denominator is 0 you're throwing Exception
by yourself, you are creating a new exception. This is kind
of your own exception, right you are you're creating
your own exception and saying that it's divided by 0
so for any condition so basically Denominator
is equal to equal to 0 you could throw it from
you're saying or denominator. So basically if I keep
this denominator has zero and this should be prior
to this just cut this and this should be done prior to this event to use throws
throw this something as I said, when you have
a checked exception, you can either handle
it using prai catch or you have to throw it
out of the method saying that I am not going to handle this let the collar
handle it you could do that using throws keyword. The method is not taking
the responsibility to handle a checked exception and it is, you know, asking the collar of the method to
actually handle it. This is in terms
of just checked exception when you have
a checked exception. So basically since you're
throwing it from there, but since you have Handler
here is coming to this so you have this denominator you
through an exception from here, but this exception
is been handled here, so it came here saying
That generic exception Handler. All right. So if I remove this that's the reason you have
generic exception Handler here. So I remove this Handler
I'm not going to handle exceptions whenever you
throw an exception. It has to be handled since exception is
a checked exception. So basically you could
have run time exception which need not be handled. So basically the Handler
that you see here, we just have two handlers which is for arithmetic
exception and array index out of bounds exception, but we don't have a Handler
for runtime exception. So that's the reason
it gave you an error saying denominator is 0 so, this is an exception that we
through here using throws. So it's giving you
an error right here because this is
a checked exception. The exception itself is
is a checked exception. Now, you could either handle it like the way we
had handled it here. You could write catch exception
and you could handle the way you want to so you
have two options now when you get into this scenario
into this situation, You have two ways to handle
it either right exception and handle it. This would be a Handler. If you see the compilation error
has gone or this is one thing that you could do
or the other thing that you could do is you
could ask this method this method can say
I'm not going to handle it. I'm going to throw it
for my collar to handle it. So the main method is saying
I am not going to handle it. I'm just throwing it off
from my side from my code or the caller to handle it. So see the exception has
again the error has gone. So basically Whenever there
is a checked exception you have to option and this is happening
at the compile time, by the way,
so you have to ensure that you either handle it
or you throw it throw in the sense throws
its through throws me anything that I am not going to handle
this at the collar handle him as you could see the throws keyword was added
in the method signature. We saw how we Throw exception. We throw exception
from here you check for some condition
you throw exception from Why uvu's throws throw is
basically to throw an exception and a method saying that I am not going
to handle the exception. So what's the difference
between through and throws the throw keyword is used to
explicitly throw an exception. The throws keyword is used
to declare an exception. The through keyword
is followed by an instance. The throws keyword is followed
by throwable class. Alright, so here you
could see this is throws keyword is actually by instance you create
an instance of exception. Whereas throws is the class itself through keyword
is used within a method and throws keyword is used
with the method signature. So you could see through
is used within a method within the method body and you could see throws
at the signature level. So you have throws and throw so throw is nothing
but whenever you want to check whether there is an exception
and you want to throw it out you want to actually
trigger the exception that's when you would right through
and you would This exception. So basically here we
are checking for a condition if denominator is equal to zero, which is potentially which would cause error
further down the line. So we are checking
it up front saying that if the denominator is 0 then we are not passing it
further write in such scenarios. We could throw
the exception right away. That's how you figure
the exception from the program Rose is nothing but it's
at the signature level of the method that you could see and what you mention
out by throws this that main is saying here that I'm not going
to handle the exception and just going to throw it off. So this are unchecked
exceptions, by the way. So whatever is not
been handled here if there's some exception
handled here it would get to the exception Handler
or the catch block. But if there is something that is not been handled
here would be thrown out of this main method
main method won't handle it. That's the reason
why we have throws through keyword is used
within the method and throws keyword is used
with the method signature. Through keyword can throw
only one exception whereas throws keyword
can be used to declare multiple exception. Basically, you could have something like this one
exception say ioexception so you could have
multiple exceptions here. So the main is saying I'm
not going to handle ioexception. I'm not going to handle
exception or something of that so you could have
multiple exceptions after throws user-defined exceptions. You can create your own
exception and it is called as user-defined exception or custom exceptions
user-defined exception class can be created by creating a
class child class of exception. So basically create exception. I create a clasp
which is SE custom exception. Now, this custom exception
is extending exception so you could have
your own classes defined and it would have like this. So what you exception you get you go you could pass
that exception directly here. So this is See, what I'm trying to do here
is overloading of Constructor. So you could see
if you are passing string. It would come to this. If you are passing exception
to come to this Constructor. So you could create
your own exception here. So basically to give you example
of this instead of exception. What I throw is I can have
a new custom exception. So initially I
was throwing exception. Now what I am saying is
new custom exception. This is the exception
that I have created. It's my own exception
when I run this now, you can see that it
should throw custom exception so you can see here exception in thread main thread main is
nothing but your main method where your program is executing
and it shows the exception type which is custom exception
which is created by me and I have passed the strings
in the denominator is 0 and at what point or at which line this particular
exception occurred can see it in the stack trace. This is a stack Trace basically. Whatever you get here when an exception occurs
is nothing but stack Trace. So hi everyone, welcome to module number four
before I start off L. Just briefed on what we covered
in module number 3, so we covered on Hoops
Concepts in general. What are the Hoops Concepts what are different
concepts or terminologies that we have in oops? Then we saw how Java is aligned
to those Hoops Concepts how Java is known as
object oriented program, right or how Java
is aligned to object oriented programming Paradigm. Then we spoke
about abstract classes, which is a different
modifier all together, right and then we spoke about
a hundred percent abstraction, which is nothing but interface
which is a construct in Java which helps you
to specify something and you could have
different implementations as per the specifications then we spoke
about exception, right? What are different exceptions and why do we have
exceptions at all? And how do we catch exceptions or what is the need
to catch exception and what are different types
of exceptions right? Have like checked unchecked
exceptions checked exception has to be caught by your application or a particular method my top
to just throw it off rather than actually handling it through
the throws keyword, right? We touch base on regular
expression as well. And why do we need
regular expression and what are different classes that Java has to support
regular expression? Alright. So today we would be
covering file handling and Java Collections framework. All right. So file handling is nothing but you have external files
you might have something on your network or it could be on your local machine
itself and you want to access it and do something on it or you might want to have data that's been coming
to your program. You might want to
write it into a file so that you could kind
of analyze it later. I spoke about exception right? If you get an exception, you could write it into a file so that you could later
on go through it and understand at what time
a particular exception occurred and you could act upon it. It's a kind of profiling and instrumentation turn on
application to understand more on the behavior
of the application and to improvise on it. Such activities could be done
using file handling will talk about
Java Collections framework. Java Collections framework
is nothing but you have a re array list and everything. That is we spoke about arrays
in the previous topics. But Java Collections framework
itself exposes array list, which is a dynamic list. You don't have to manage it. So remember in list we said that when you take Claire a list
or declare an array, you have to mention
the size of it whereas array list is dynamic. You don't have to mention it. It keeps growing. So these are the topics that we are going to cover
file input output of operation in Java wrapper classes in Java. We are going to talk about
Java collection Frameworks. We are going to talk about list
and its classification in Java Q in Java and sets and
their classification in Java. So as you could relate all
this Action all this components within the collection
Frameworks are nothing but data structures in general. That's you straight. So maybe in see you might have
used different data structure and whereas in
different languages, you have different
data structures, right? This is just to handle
data data structures are nothing but to store data efficiently and you could select one
of them based on the use cases that you're handling
within your application. So let's start
with file I/O file I/ O is nothing but you have a file on your disk
and if you want to do something if you want to write to that or if you want to read
from that file, you would ideally
use file I/O API. All right. So file I/O is used
to process the input and produce output
for a specific file. All right, so you
could access some file within your local
disk do something and you can write it on
to a different file as well. Write Java dot IO package contains all the classes
required for input and output operation for a Phi. All right, so As we said package is nothing
but namespacing right? So everything is grouped. All the I/O classes are
all the classes in Java that is handling. IO is grouped into
Java dot IO package. Okay, that makes it easier for programmers to
understand as well. Right? So if you're doing a lot
of I/O operations, you could directly say
import Java dot IO dot star which would in put
all the classes within your Java dot IO package. All right, the files
can be text file or it could be binary file, right so you could imagine not always
you deal with a text file, right you have
other files as well. So nowadays. There's a lot
of things going on on iot right internet of things. So you get data
from different systems. It could be like
your mobile phones. It could be from the car sensors
or elsewhere, right? You have a real-time
raw information coming in into your system for analytics. So such data
cannot be a text file. Txt file as such is
a heavy file, right so such iot applications. What is been passed between
systems our intercommunication between systems is done
through a binary file, which is kind
of lightweight right compared to text file
txt files are heavier. So you could imagine this files
not being just the text file. It could be binary files and so
on when I say binary files, it could be it could be images as well write different images that could be shared
among system or some image that is there
on your local disk, which you want to read into Java and do something on it some kind
of graphical processing on it right stream is
a sequence of data. So you convert this file into a stream and you
use it with in Java. Okay, we'll look at example, which would give you a clear
idea of what I'm talking about. Okay, so here you
can see an example where in you have a file which is student dot txt
into your local system into your local disk where you are running
this program right then you have a pretty Traitor this is nothing
but a printwriter is a class that is exposed by Java which is there in Java dot IO package you
would pass on this file. So initially you have new file and you pass on
the path of this file that you are going
to read or do operations on not just read it could be
right operations as well. So basically you have new file and you specify the path name
or initialize the file. The next thing that you do is
you have printwriter wherein you pass this file. All right. Now what we are trying to do
here is we are trying to write into a Phi, right? We are trying to write the name
or the some ID or something. We're trying to write
this content into a Phi right into your local file
will write a program on this which would give you
a clear idea and the next step that we are doing here is kind
of we are reading it from a Phi. Alright. So the first step that you do is write it
into a file The Next Step that you do is read
from the same file and print the contents of it. All right, so it's not mandatory that you have to specify
the same file for reading right? This is for just
for the convenience or just to demo it. We are using the same
file you could have different file as well. All right, so let me show you
how this is done. So again, I create
a new project for today, which is All right, so we create a new
project and Eureka. module 4 Alright,
so we have this project now. Let's create a new class. Calm down daddy. Rekha is nothing
but the package name and I give up. input output demo Alright, so before we start off
I can do one thing. I can create a folder here. Say said, Eureka. All right, so we'll put
all the files here. So this is the empty folder that I have created right now
or let me put it here. So for Simplicity, I'm going to put it
on C drive itself. Alright, so on see have created
a director IO directory where in we are going
to dump all the files, right? Whatever we are going
to do is going to come into this particular directory. Alright. So the first thing that we are going to do is so
now we are thinking of writing into a file first right? So I create a main method right? The first thing
that I do is create a file. All right, and I
create a new file. Which is nothing, but I am calling the Constructor
of a class of the class file, which is with in Java. Right? It's not something
that we are writing. So Java itself has
this internal file class, which is file. All right. So now a point
to this particular directory. All right, calm down
Ed Eureka IO and we say so I call it
as employee info dot txt. Alright, so we are going
to write into this file now from java program. So now it's showing
up an error saying that which file I
want to refer to as we said the all
the I/O related files all the all the I/O
related classes are placed in Java dot IO package. So I select this package once selected you can see
an import statement here. Being up. So why do we
have input statement because file is a class which resides in a different
package then calm down Eureka had it been
within calm down Eureka. You need not import
it it's outside. So you have to put it right then there are different ways
in which you could write it, but now we'll follow
the same example. So I write
printwriter printwriter. Is there within Java dot IO and you could see
it imported here. All right employ
info writers if example, okay now we create a new printwriter and if you see
the Constructor of printwriter, so we spoke about Constructor
overloading and stuff like that. Right? So you could see
if you go into the source code. If you want to Deep dive
more you could go into the source code
and see it takes file. Alright, so here you
could see an option which is nothing
but it consumes file. So the file
which we created above. I can put it as
e employ info file. All right. So there's a file
that's created here. So I put the same
file here right since the Constructor
supports file itself. Now this is checked exception. All right, you could see here. It is saying Java
is explicitly saying that you are not
handling this exception. All right. So ideally the better practice is we shouldn't be writing
everything into the main because it would become
cumbersome to understand later on right you
shouldn't be dumping everything to the main method. So as a good practice, what you should do
is you should create a new method right to file. All right. So this is best
practices, right? It's not mandatory. Java is not going to tell you
there is an error or something. But as a part of best practices, this is how you
should write programs which would make
it readable for others because tomorrow some other
developer is going to handle this particular class. It's not that you
have going to be there throughout right so basically so that other developers
can easily read It and maintain it. Well, this is how we write it. I move this content. Whatever the writing part is. I move this content here. Alright, so now it's showing
up an error saying that it's not been handled
right file not found exception is not been handled because it's
a checked exception. So remember in the checked
exception we said that there are two options one
is to handle it within your method all
this right to file method can hop to throw it off saying that I am not going to handle
it let the caller handle it. So when I say caller caller is
nothing but this method alright, so I am going to create
say here input demo. Sam trading in instance here. Alright and demoed right to file
and I'm going to pass the file that we created here. All right, so there was one file
that we created here which is pointing
to an employee info Dot txt. And we are calling
this method to write it if you think about
the reusability part of it. So this is how you make
the method reusable. If you put it into Maine
you cannot reuse it. If you're taking the right logic
outside the main and refactoring and putting all the code that is specific to writing
to a file do particular method. You could reuse
this method you're making it generic right now. I opted to throw it off
or let's handle it. All right when I
say let's handle it. It's nothing but you
have try catch block. All right, so I say Catch
so what exception was that? It was filenotfoundexception. So you need to have
file already in place. Alright, so here I print saying that given file was not found
on the local disk. All right, and once that file
Maybe we can print the name of the file as well. Alright, so here we
have chosen to handle it. Okay, so we remove this. Alright, so we have a try catch block written now
and we say that Okay, so we are handling this error. So we say that it
just print a message saying that given file was not found
on the local disk. And as a good practice, I don't want
further processing right if I don't have a file I don't
want to process it further. So I say through
runtime exception and I so runtime exception
is unchecked exception. It won't give you error even
if you don't handle it, right whereas this was
a checked exception. That's why you
are getting error. Basically. What I'm doing is I'm catching
the checked exception and wrapping it
into unchecked exception. All right, because I don't want
this to be processed further. So once we have
this printwriter set, so I'll have to take
this print right outside or I'll get here. Alright, so what I do
is employ Dot println and I write some content to it and say in this case
I am writing vinod. I write some ID to it as well. Anything you could write. Okay one side right
into the file. I have to ensure
that I close the file. So basically you
could have finally block so you would do this. I'll have to take so this if this is within try
so it's not accessible within the finally block. So to make it accessible what you will have to do is
you'll have to take it outside. All right. So I Define it outside Dry block so that it gets
accessed in finally. Alright, so now what I do is employ
info dot writer Dot close I close it. So that's one of the use cases
of finally as I said, it's basically for
closing the resources. So this finally
would execute even if this doesn't throw or don't throw any exception
and it would get executed even if it throws an exception. All right, so that's what the use
of finally block is. So let me quickly run
this program to see I have to create a file here. If I create a text
file here Dot txt. All right before I create a file maybe I will I would want
to show you what happens if we don't have a file, right? So if you don't have
a file I run it so we don't have anything
in to see at Eureka I oh, all right. Basically, you're trying
to write into a file which doesn't exist at all. So it's building. And it's running now. Even if you don't have a file, it doesn't throw file
not found exception rather. It creates one on its own. So remember we
didn't have anything here. Now. Let's see the content
of this file. You could see whatever we rode
right the employee name and you could see
the employee ID, which is hundred. So whatever you wrote
here came into that file. All right. Now, let's write
a program to scan or read through this file. All right, so maybe I
can use the same file or I can use something
like All right. So I write something
like BMW cities howdy. All right, I I write
something like this. It's a vehicle info and say you have something
like let's keep it as is okay. So you have
vehicle info in here. So now we are writing
a program to read from a file. All right, so we pass on
the file parameter here. There are different ways
in which you can do. All right, so we create
scanner now scanner takes if you see instructor you
could see that scanner takes file as a parameter. All right. So I put scanner file again. It is saying that file not found
exception is to be handled. So in this case, you have to be sure
the file is present, right, since you are reading
the file the earlier case it was writing to the file which can create a file but reading to the file
you have to be sure that the file is present or else you would get
a file not found exception. So in this case,
I choose to throw the exception. The read file is saying that I don't want
to handle this exception i instead threw it off. All right, you
could see throws here. Okay. Now what we do is we read
lines from it, right? So we have like Okay, so we read line from it
and we just print it out. basically, you would have
something like So let me just print line read
from the input file, right? So this is nothing but we are just printing
whatever we read from there. Basically, this should have
something like it should Loop in until it's end of the file. Alright, so this is how you use the while loop
similar to what you do in C and C++ right till the end of the file till yo F character is encountered you kind of read
the Lines within the file. All right. So this is a method that we have written but we
haven't invoked this method yet. So I create file since it's a different file
we have to create a file vehicle info
is equal to new file. We give the path of it, which is nothing but a Eureka
IO vehicle info dot txt. All right, we
created a file here. Now, what we are going to do
is we are going to call read file on this file or vehicle info file and we should be able
to see the contents of it. All right. So now one thing here is since you have thrown
exception it's saying that exception has
to be handled here. All right, I can choose
to not handle the exception here as well and I am adding it
to the method signature. Sure, so main
would throw as well. So basically what
would happen is if you don't have a file which is being read your program
would stop at that point because you're not handling
it anywhere, right? You're just throwing
it off up the ladder. So basically at the end if you don't have a file
you're going to get an exception your program
is going to stop there. I run this file and
let's see what we get. All right, so you
could see BMW Mercedes and Audi being read out
from vehicle info. This was the content
that we had within the file and which you could
see it's been bred. So file writer and file reader so similar to print this one is
a different way of writing it. So what's written
within this program is nothing but we create an instance
of file writer and we pass the string the path
of the file rather as an input to the file writer
now file writer is nothing but
it's character-oriented right print was not
as such character oriented. This one is character oriented which means two bites
right character is nothing but two bite-sized with in Java. So this one is not
like it doesn't work at the byte level. Basically, whenever you're dealing with
character-oriented file, you could use this one rather
than printwriter. All right, objectify
lighter is being created which is a character
oriented file or which is a character oriented place. All right, and you write
to a file you're writing to the file here. All right, and similarly
when you use file reader, it's a character oriented reader
reads character one character at a time from the file
that you have mentioned here. So maybe I will take just
an example of writing it because it's going to be
pretty much similar. So quickly write this program. You have a main method
you create a method to say you have public
or it could be a private method as I said, the best practice
would be to restrict as much as possible rate. If you don't want this method
to be called from outside, you could have private method so it's going
to be right to file. So you need to give string
or you can have file as well. Whatever you prefer
to would have file and file to write to okay. So basically we were talking
about file right? All right, so I create
file right to object. Okay, and again say
it's a bike info. And I pause this file
to which you have to write. All right. So again, you could see now you
could see a checked exception that is nothing but issuing
that ioexception has to be handled now I
choose to throw it off. I'm not handling it here. Bike in four thought
I write to the file and I write some content. Basically, this should be writer
just to make it more elaborate. All right, I say
right Road close close this particular file. Okay. Now I give a call to this method which is nothing
but file writer demo is equal to Nu we are creating
instance of it. Okay, let me create a file which is nothing
but file bike info file and which is new file
and within the same directory, which is nothing
but calm dot Ed u-- record at I/O. I create by info Dot txt. Alright, so what we are doing
here is using file writer. We are going to write
into biking for DOT txt. And we are going
to write this content that is Ducati and maybe after this we could have
whatever you have in buffer that that would be flushed
off to or disc. Alright, so when I
run this basically we don't have a file now bike info
and I think it should create it so you could see here. We don't have a bike info file. Okay. So again, let me talk
about this program. So what we have written
is we have a file. So what we are trying to do
is we are earlier the program we wrote using printwriter. Now we are going to use
five writer which is a character stream based I/
O so we are going to write into bike info dot txt file and we have a method
right to file in which we are creating
a file writer object which is taking
up this parameter or taking this pile, which we are going to read
through as the input. All right and not read
through its rather, right? So the file to which
we are going to write is taken as an input parameter to the file writer and we
are writing into this file. So right now we are just
writing to cart either. All right. So I invoke this method
like file writer demo dot right to file and I pass
on this file here. All right shows up an error
that you have to handle iOS. Option which is been thrown
from right to file. So I choose not to handle
it here as well. Which means if you
don't have that file or if there's some ioexception that's been triggered you
would program would stop. All right, so I
run this program. So basically, it
should create file and should write to it as well. All right, so I go
to the directory. So you see bike info file
has been created here. We didn't have it earlier. It got created
after we ran this program now, I just open it up and you should see the value
Ducati been written there. All right, so that's
about file writer and similar to that. You have to just
read through it. You have to pass the file that you want to read
as a parameter and you just have while loop
to iterate through till the end of the file
and you can print the character. So basically it's pretty
much similar to what we did for the printwriter, but I just wanted to demo
for one of these cases so we took an example
of why writer. Alright, so now let's move
towards stream stream based I /O so Java streams are used
to perform input and output operations
on eight bits. A bite right screams
is basically operating on a bite input stream. It is used to read the data from The Source it could be
file it could be keyboard or it could be anywhere across
across the network, right? It could be a socket as well. So basically it is used to read
the data from the source that is input stream
and output stream is nothing but if you want to write
something from your program to any resource on a network, that would be nothing but write that would be nothing
but output stream. All right. So with output stream you
would typically write data to a destination
and with input stream. You're going to read
it from a source. All right, just to walk you
through so we have object as I said all classes or every class in Java
is inherited from a class. That is object. All right. This is a super class for all the objects all
the classes in Java. Okay. So you have object
and you you could see that this input stream
and output stream. So let's talk
about the input stream. There's file input. Beam, there's byte array input
stream this filter input stream and this object input stream. So we'll talk about this
in the coming slides. Why do we have
object input stream and stuff like that. But right now you could imagine that we have multiple classes
or you could think that there are multiple classes
with it input stream, which are used
for different use cases. Like you have
buffered input stream, which is nothing
but it buffers it. It doesn't read
or write it in one go. It's sort of buffers it
and then it flushes it over. All right output stream
similar to input stream. We have an output stream. It's an interface. I believe which has got
several implementations like file output stream. You have byte
array output stream. You have filter output stream. You have object output stream and filter output stream
is further categorized as or has further sub classes
as buffered output stream and data output stream. All right, so in further slides, we are going to discuss file input Stream file output
stream object input stream and object output stream. Okay, so file
output stream class and file input stream class. Let's talk about it. The file output stream class is used to write
to a file right you you could take a bite array
and you could write to a Phi. All right, so you
could take something. If you have a string
you could convert it into a byte array
and you could pass it and it would write to a file. So remember we said it's
a byte oriented, right? So basically it's going
to write take array as input and it's going to write to it write to the file that you
have mentioned in there. Right so you could take
integer as well. It is used to write
the specified bite to the file output stream. So you could provide
integer as well. There's a close method
which is nothing but closing the Stream
So streams are nothing but it is hooked up
to the resources. It is taking up resources and there is a Action
between your program and the file established rate
when you create three times. So when you close it you close
that connection and it is free for garbage collector to remove that particular
object from memory. So basically freeze
memory as well right unless you close it. It's going to stay
in the memory. So it's a good practice
to close it right after you use it. Okay rights, you could write
to a particular offset, which could be done
using right method. So right length bites, whatever length you have
mentioned in as third argument, it would write it
to a particular offset. It would write the bite
that you have even or bite that you
have passed in as input. It would write that bite do a particular Offset
you have flush method, which is nothing
but flushes the output stream and forces any buffered
output bytes to be written out. All right, so it
could be buffered as I said, so not writing it each and every time You have bite
basically it buffers it and you could have flush method
to flush it off to the Phi. So basically we
have buffered stream, which is this Method All right. So here we have
file output stream and using file output stream. We rewrite it to the file
and then we close the file. All right, as far as
the syntax is concerned. It's pretty much similar
to file writer example that we took but just to give
you a demo just to show you how it is. We'll have fun demo done here. All right, so I
create a new class which is nothing
but file output stream demo. Alright, so we
have a main method and I create a new method which is like file
write to a file. Which could be
like private method private void write to a file? Alright, so we are going
to write to this file using what using file output Stream
So it showing up this so I select Java
dot IO dot fight. All right. Okay now I create
file output stream. Create an instance
of it right similar to how we did for other programs. Now, it says file not found
exception has to be handled. I choose not to handle it and I throw it back
to the calling program. All right. So now what I do is I do file
dot right file output stream. I am going to write
it to this file. So I just write a text here. All right. So write a text here. Hello folks. Hope you're enjoying the session
and I just closed it off again it throws ioexception
when you close it. So remember we said there
could be multiple exceptions that could be thrown
out of a method. So I again I choose
to throw this one as well. So basically what I'm trying
to do here is I throw IO exception as well. Okay, so it doesn't take
a string as a as an input. So what I have to do is
I have to do not get bites. As we saw the Constructor
of it constructed isn't takes string as input in case of output stream or in
case of file output stream. It interacts in terms of byte array
and stuff like that. So I converted this string
into byte array. So when you see get bites get
bites method is a method on a string class which converts the string
into array of bytes. All right. So now what I do is I give
a call to this particular. I'm writing to a file and I'm going to take
create a new file. So I can take
the same file, right? I am going to take a b
or else I will create a new one. All right, so I create a file
which is like message dot txt or you need not even create it. It will create by its own. I will delete it may be okay on the thing is I love
to create see a Eureka yo. All right. And here we say message dot txt. All right, so I call a method
to write to the file using file output stream night
choose to throw it off from here as well. Alright, so we have a method which is going to write into
a file using file output stream. All right, so I
run this program. Okay, it ran successfully. Let me open this message and see if we have the
message written there. All right, so you
could see here. Hello folks. Hope you're enjoying the session which is written
from your program. All right, so this file
input stream as well, which is pretty much similar
it again operates in terms of bytes. As you could see the signatures
of the methods within it would read the contents
of the file into the byte array that you have passed
as a parameter. The second one is to read from a particular
offset the length that you have mentioned or passed as a parameter close
is pretty much similar. It would close the connection that's been established and it would make
the class available for garbage collector
to clean it off. Okay garbage collector
is nothing but unlike see where in you have to delegate
the memory location that's been used garbage
collector is parallel thread that is run by jvm to remove the
or to free up the memory space that's been acquired by classes. So it runs sporadically it's
not within your control. It runs per radically and it
clears of the memory locations. We have a reed method
which is nothing but reads the next bite
from the input source. So on the file input stream
instance on which you read it, it would read out the next bite
and if it's end of the stream, it would return -1. So the return value is integer as you could see here you
could skip specified number of bytes from the input stream and available Returns
the number of bytes that can be read
from the currents tree, right? So maximum number of bytes
that could be read out. So I'm just going to read
through this light or if you want. Yeah, I can take
an example maybe since we didn't take
example on reader. I'll take one example
and reader as well. Okay, so here I to file
input stream demo All right, so we create a class here and I have a main method here. Okay. I have a private method which is void and it's
not returning anything and I said read from file. All right. which takes file Again,
I'll have to import file. Okay, so Java dot you could see the input statement
coming up here. So now I create
file input stream. Okay. I create a new instance of it. Which would typically take for that matter it
would take string as well. Just to show you
a different variant of it. It's not that you have
to always pass file it you could pass string as well. Alright, so we are
passing a string here. It says file not found
exception has to be handled since its read you
have to ensure that you have the file there. Right? So I choose to again
throw off this exception. So I'm not handling it. So typically you
would handle exception when you want to do
something on it. Right when file not found if you're trying to read a file
and that file doesn't exist in your drive. I wouldn't handle it. I would just throw it off. I want program
to break right there. Right? I don't want it to proceed because our program at this particular method
is trying to read from a file and if it doesn't exist it, it doesn't make sense
to proceed further. All right, so I
have input stream. Now what I do is not read and as you could see it's written
in integer, right so This has to be looped. All right. This has to be looped
until you get minus 1 right. So basically you would have like
say teacher and you have like so this is integer
read from file. All right, and I
keep this as integer, which is so whatever you read
I need to assign this because I want to write that as well. All right, so I'm assigning to this and unless this
is minus 1 you are going to read through write it
again shows exception, which I need to handle. So this time it's ioexception and I'm going to throw
this one as well. All right, so you have a reed
method you are going to read it and basically till the time
its minus 1 it's going to be red right now. What I'm going to do
is within the loop. I'm going to just type. So basically I'm going to just
type cuz this to character. It's read as integer. So you have to convert
it into character. If you want to see
in terms of character. If or else you would get
the ASCII value of it. Alright, once this is done. Basically I need to close
off the stream as well. Okay. Now what I do is
I create the instance of file output stream demo. Just nothing, but creating
instance of it. Right demo dot read from file. But remember this time we are
not creating a file instance. We are just passing the string. All right, so you
could take any of this file since we are reading it we could
take like let me take bike in for it just got valued Ducati. So I'm passing this
as a string this time. All right, and it's
a different variant. You could pass it
as a file as well. You could pass it
as a string as well. But since I have been passing
as a file in previous examples this time I choose
to pass it as a string. Alright, so now I
am throwing it off from here as well since I
don't want to handle it right. So if I get an error,
I want the program to break. So that's the reason
I am throwing it off from here as well. So coordinator, let's see. What's it? Okay, so I have to put
double slash here. All right. I miss that one. So basically if you
don't put double slash it would take it as a regular
expression sort of again. It's not bike
in Foods dot txt, which I missed I believe so it says that bike
info file doesn't exist. Right since it's
a text file, right? You have to provide
the extension as well. All right, so you
could see it read in terms of characters, right? So you could see the first
character read as D then then you could see it followed till
till it red Ducati. All right, so that's
about file stream or file input stream. That's how you write programs. Now what serialization and deserialization I
will quickly cover on this one since this is something that's been used widely
in big data when it comes to Big Data or when it comes
to distributed computing. Just not to if you
understand it's good. If you don't understand you
don't have to think much but I'm just talking in terms
of distributed computing. Right? So when it comes to Big Data, it's not that you have
server farms and everything. Your program doesn't run
on server Farm anymore. It's more about you
have commodity Hardware on which a program is run and that's what
Big Data Frameworks are good about the investments
in terms of infrastructure by having server Farms
has been reduced a lot has been cut down a lot and you could have
commodity Hardware on which you could have this
distributed Frameworks running. So say for example, you might have heard
about Hadoop or Apache spark, which could actually run
on normal Hardware right or you could Need
to on cloud as well. So you have like
Amazon web service which is cloud like you
you have Google as well Google services, which exposes as a cloud
you have a seizure, which is nothing
but Microsoft's Cloud. So all these are kind of not big
Hardware not server Farms that you have. It's a normal Hardware
that you could configure and you could run
through your chunks of data or petabytes of data that comes in from cloud
or from elsewhere, right? So that's the beauty of it. That's the beauty
of java and one of the main things
are main feature that Java has
got a serialization and deserialization which helps in having this
distributed framework going. Okay. So serialization is nothing
but you have class right and you you create
instance of a class, which is nothing
but object right now this instance of a class if you want to pass it over
to some other computer or some other computer
on your network, right? This could be done just because this Serialization
there's a concept of serialization right suppose. I create some object
of a class today on my computer. And if I want to pass
the same state, right it's about
passing the street not the behavior behavior is
of course just methods, right? So it's about passing
the state of the object. So whatever state my object is or whatever properties
my object bolts at some particular point if I want to pass it over
to some other computer on the network. This could be done just because you have
serialization was what you would do is basically if you remember the object stays
in Heap right Heap memory, which is protected which no other process can get
into that particular. He process Heap memory, right? That's a security
that Java provides if you remember in the first
slide we covered it, right. So what Java does by serialization is whatever
contains of a particular object or whatever contains
a particular object whole set any could be written. To your disk as a binary file and you could send it over
to some other computer via wire, or you could take
it plug in your USB drive and you could just take that
particular file the binary file that's created and you
can go elsewhere and just play that file or just deserialize it
to see the contents of it. Right? So you could imagine
this is something that is needed in terms
of distributed computing since not everything
is been carried out on a single computer you
you would process something on your computer you would you
would write it to a file and you need to pass
on this file toward or transport this file to different computer right
or typical example in which you would think of serialization
is more about you. Could you could have say for example one operation
carried out on one computer and same operation or different operation
on a same file carried out on some other computer now you want to move Just them
together and that's where you would
have serialization and deserialization coming into
picture basically to understand the concept serialization is nothing but writing the state
of the object to a file and deserialization is nothing but again taking
the state of the object that's been written to the file
again putting it back to a class format or when you want to use
this serialized class. You would basically
deserialize it use it. So serialization is a process
of converting an object mrs. To sequence of bytes, which can be persisted
to a disk or file and can be sent through streams
or can send across wire or could be you could actually
take it on your drive and transport it elsewhere
the reverse process which will convert
data bytes into object is called D serialization. All right. So how do we have
this serialization and deserialization done or what classes we have
for supporting it. Let's talk about that. All right in this example. You have a student info which is having ID
and name, right? And basically you could see that we have created
an instance of student info which which has value
of 9 and John. All right. And now what we are doing is we
are writing the state state is nothing but the value that this particular
object holds right which is nothing but ID
of 9 and name value of John, right? So we are writing this
into a do a file which is nothing
but student Dot txt. And and we are just writing
that to a particular file. Okay, and this is nothing
but the student dot txt file that you see it should be txt. Actually. It's it's a binary file. So you should I would rather
prefer to have student dot Pi n or binary and you
would write it to that file using right object. So the supporting class for serialization is
object output stream and object input stream. All right, so I will quickly
take a demo of this. So the first thing that we do
is serialization serialization is done by object output stream. All right. So again, we have
a main method suppose. I want to serialize it. So I would do something like say I have a private method
which is void, which is serialize. Okay. So the first thing I
would want to create is nothing but Java class
which will hold the state right. So this is a class which you want to serialize
or which you want to send it across two different computers. So such losses are known
as model classes, right? Basically such classes
are nothing but classes which holds chunks of data. So for Simplicity, we have taken small data
like ID and name, but in general you would have
like chunks of data. They're all right. So here I say Vehicle info. Maybe this is the class
that I have here. Alright, and now what I do is suppose
I have Suppose I have two parameters here. All right, so I have
two parameters here, which is nothing but integer and suppose I have
like string name of equal. Alright, so now I Define
a Constructor for vehicle info which takes T three parameters
for Simplicity number of Wheels. First. Say for example,
I take name of vehicle. then it's number of wheels and
say I have one more parameter, which is mileage. All right. Remember we use of this keyword since the name of the arguments and the name of the instance
variables are the same we need to use this
this DOT number of Wheels. Is equal to number of Wheels? All right, and this dot mileage
is equal to mileage. All right. So this is a simple model class which is supposed
to hold values. Basically in reality. This would be holding
like chunks of values. Okay. Imagine like could
be like megabytes of information or even
huge gigabytes of information. All right, but
for Simplicity here, we are taking
this simple class right. Now. What we want to do is we want
to see realize this into a GFI. We are going to
create an instance of this particular class and we are going
to dry this state or whatever values we have
that particular instance. We are going to
write it to a file so that it could be read
from somewhere else or it could be used by
any computers on the network. All right, so I
have vehicle info. Again suppose I write BMW is
equal to new vehicle info. Now, what I have to pass
is name of the vehicle, which is BMW right number of and I pass some value
like Like 10, all right. Okay. Now we have created
instance of vehicle info and we have passed the values that we want to pass it and now
we want to see realized this. Okay. So how do we see realize
is nothing but we use object output stream, right? So what does it take? So basically you could go
into the source code and if you want to deal
more you could actually see what other Constructors that it takes. You could see it
takes output stream. So one is output stream
as a Constructor. If it takes output stream, then I'll have to create
file or stream. Basically. I will name this as object stream and this one
would be filestream. Okay, I create a new
file output stream and you could pass the file
on which you want to write it. All right. So in this case the file on which I want to write
a particular class. I will pass it as file and I'll be passing
it over here. All right. So what I am trying to do
here is resolve this okay. So you take the file or to which
you want to see realize so basically this vehicle info
would be serialized into this file and this file would
be transported anywhere across your network. So it shows file
not found exception again, I choose to throw it. It shows my exception now, I've passed this
file stream here. Alright, so this is
how we usually write programs. You have file input
stream file output stream, which is nothing but the file to which you want to write write
the state of the object and you instantiate
object output stream. Okay. Now let me write to it. Okay. So basically what are you
going to write is nothing but vehicle info just
instance of okay. So you're going to you
want to write this instance of vehicle info particular
instance of vehicle info into your into the file? Okay. So I write something like this. Okay. So so basically what we'll have to do here is
whenever you have this thing whenever you want to write or whenever you want
to write the state of a class to a file you need
to implement one interface, which is serializable. All right. It's a do-nothing interface. It's just used by it's
a mock-up interface as well marker interface rather. It is just used by jvm to say that this particular class
could be serialized but it doesn't have
any methods within it as you could see if it would. I've had some methods it
would have shown an error saying that you should implement it. But in this case it didn't
because it doesn't have any methods within right? So basically when you
have object streamed, right? Okay, so it takes all right. So we we create objects stream and we pass the file
that we want to write to and we have right object method
which would take the instance of the class that you
want to write and we have like we flush it
and we close it. So one thing to note here
is vehicle info class has to implement serializable. That's a marker interface
serializable is nothing but a marker interface and it doesn't have any method
within it is just an indicator as you could see it's
an empty interface. All right. This is the source code of it. You could see it's
an empty interface. It is just a marker or it is just a notification
to the jvm saying that this class is something
that could be serialized. Alright, so we have this class and we are going
to serialize the state of BMW object into a Phi. Alright, so now what I do is I create
Object output stream demo and I call serialized within it now this serializes
taking two parameters. So if the first parameter is
this is other way of passing it. We are not actually
creating instance. We are passing it directly. All right, so I pass this
and I say serialized file. Okay, maybe dot bin
and the other parameter that it's taking is nothing
but the instance of class that you want to serialize. Alright, so here we
are again getting exception which needs to be thrown off. Alright, so this is
a simple class that we have we have vehicle info which carries BMW instance or we have created instance
of vehicle info with BMW values and we are trying to serialize
this to the to a file which is serialized
file dot bin. Okay. Let me see if it runs. Alright, so I hope it ran now. This is a binary file. If you see you are not going
to understand everything that you have within this file. Okay, so I just Okay, so here you could see
it's not something that could be completely readable, but you could get
some idea about it. It's during game W. All right, and this is not meant for you to read it writes
not in a human readable form. This is basically for passing
this over a network and at the other end you
would deserialize it. Alright, so this is
how we see realized it now. We will check on
how we deserialize it. All right. So you you saw
the contents right? It's something that
is not readable. Okay again, I'll open it up. Not everything would make sense. But you could see
that this is for BMW. So basically you could see
the value BMW here, right? So now what I do is I want
to see see realize this right. So this is
how you see realize it. We spoke about it how we see realized it now we
are going to deserialize this. So basically this
deserialization won't happen on the same computer. It might or might not
or it could be saved different application within
the same computer as well. So if you have
two applications running and want to interact
between the two applications running on the same computer
could use serialization and deserialization or you
could majority of the use case for this feature is more about passing it
over the network. All right. So, let's see
how we deserialize it. Okay. So when you easy realize it
you use object input stream. Okay, so in the same class
or I'll just for Simplicity sake I'll change this
to object stream demo because this is
not just all right, so I Defector it and I change we name this too. Okay, so this is been renamed
to object stream demo now create a private method, which is nothing
but void deserialize. Again First DC realization you
need to have the file right you could imagine of you
having the file and file should be okay. Okay. So now what we do is basically we could have
this as a file rather since we are going
to send the same file. Same file for DC
realizing as well. So it's better to have
it defined here. And you pass it as CD list. Okay so far we have serialized it now we are going
to deserialize it. So what you do in D
serialization is nothing but you use object. So the first thing that you will have to create
similar to be created file input stream about now, we are going to file output
stream in the serialized case, but here we are going
to create a file input stream. And a provide the fight here. Alright, so we have file
input stream created now we have object input stream. Alright, we are creating
instance of it and it would be new object input stream and you would be passing
the fill input stream that you created the step above all red showing
you for exception. You have to could either throw
it or you could handle it. So this case I'm
throwing it off. Alright, so we have so here you could see
we had bright object now, I'll have read object. So read object throws
filenotfoundexception or class not found exception that you need to handle
right again through it. So here you could
see IO exception and class not found
exception right single method can choose to throw
multiple exceptions from within. All right, so we have chosen
to throw it now we have vehicle info
or we don't know whether it's BMW at that point. So I say d serialized object. All right, so object streamed
read object by default. It returns object type. So we need to we
need to type casted. This is how we typecasted
one form to the other. So basically we know
that object streamed or read object is going
to give us vehicle info object. That's why we can
actually type cast it. All right. So now what I do is once I get this D
serialized object, I'm going to print out
the values that I have within. All right, so I'm going to print
the name of the vehicle. So I say All right put us. Right, so name of the vehicle
the serialized file similarly. I just copy paste. It will print number
of Wheels Alright and we'll print mileage
of we go I need this one. Alright, so basically
we are serializing it and then DC realizing it
after deer is realizing it. We are printing the value
of the contents or we are printing the contents
of a particular object to see if it is what we expect. All right, so maybe
I can do one thing. I can delete this off. Let me close this and let
me delete this off. Okay. I'm deleting serialized info. I'm going to run
this program again and this program will serialize
and deserialize it. Okay, it will see realize it
in the first case. And now I'm going to write would
be serialization deserialized and the serialized file. All right now here as well. I am going to throw away. Okay. So first we are going
to serialize it and then we are going
to deserialize it and see whether we get the contents
that we expect. All right, so it's running. Let's see if the file
has been created. So we deleted the files. It's not yet come. So we can see
that a file was created here. Right which is a serialized file
and we printed the value from be serialized file as
well after DC realization. We printed the value
of the contents in the serialized file just like we got the expected value
which was BMW 4 and 10, which you had said. So basically what we
are doing here is we are storing the state of a class or state of the object to a disk and this
could be transported anywhere when I say it could
be transported is nothing but this is just a binary file, right so you could take it
into your text file or you could take it
into your pen drive and you could take it anywhere. All right. So that's the
beauty of serialization and deserialization. I spent more time on this because this is something
that is very important for Big Data since big data is nothing
but all the big data Frameworks that we have they follow
distributed computing and this is one
of the important internals of distributed computing though you need not. Take care of it. It's all taken care by
the Big Data framework. But this is an important
concept to understand. All right, so let me quickly
talk about wrapper classes. It's not an important topic to but I will quickly
cover on this thing. So wrapper classes are
nothing but you have primitive data types that we discussed
the first day, right? So initially we didn't have
this wrapper classes in picture when the initial version
of java was created. So data types were dealt in terms of primitive
data type itself. Then since Java is
object oriented, right? It has to be completely
object-oriented so they came up with a concept that we shouldn't be
dealing data types as a primitive data type rather. We should be having
some sort of object to it which is rapper, right which is wrapping
this primitive data type. So in order to make
it completely object-oriented they have come up
with this wrapper classes, right so int when you
define int right if you define int
something of this sort, it's Native whereas you
would have something like this. Inti is going to be
primitive data type and whereas you would have
something like this which is nothing
but wrapper class, right? So if you go into
the wrapper class, you could go into the source
code and see it's nothing but it's doing the same thing. It has got some utility methods
as well on the top of it, but basically it
storing your value. So for now they have changed
the source code quite a bit. Basically, it's touring in terms
of characters, I believe. All right, so you
need not take care of this. But what I am trying to say
is wrapper class is nothing but a rapper built
upon the primitive data type so that everything is taken care
in terms of classes since it's completely object-oriented
programming language, right? So Java has a class dedicated
to each of the Primitive types. These are known
as wrapper classes because they wrap
the primitive data type into the object of that class. All right, so you could see for
bite you have a wrapper class corresponding wrapper class as
bite with starts with capital. Be all right, since it's a class it has
to start with uppercase or it has to follow
camel casing short has again short int has
integer long has long float. You could see
a corresponding wrapper class with name float double will have double character
CH AR will have character which starts with a bouquet
see again Boolean again has camel cased Boolean
as its wrapper class. All right, so when it comes to classes
you could have hierarchy. So basically you could see that all this byte short integer
long float double. Everything is subclassed
from number. So basically in the source code that we saw for integer
you could see it's extending number right? So that's what it is saying
here is a subclass of number integer is
a subclass of number. So how do we
reduce wrapper class? It's basically you just have
to pass value to it. You could have as
a part of Constructor, you could pass some kind
of value to it. So you could either assign value
of hundred right or you could have something
like Something like this. Okay. So you have different
variants of it. You could either create
it directly assign literal value to it, or you could have
something like this but as you could see
this is deprecated. This is no longer required. Actually. It is still accepting it. It's not throwing
compile time error, but it's deprecated. Which means if you're
writing a new code, you shouldn't be
writing it this way. So there's also concept
of Auto boxing which is nothing but if you have like integer a could
be assigned value K directly. All right, or could be assigned
value J directly. So it could be converted
from wrapper class into your primitive type
without any kind of conversion. That is known as Auto boxing. It does it by itself? What is generic in Java generic
is nothing but template in C C++ in C++ rather you have
you define a template which is which is a general. Thing you're not putting in a specific data type
you are saying that this is what it is. It's a template and you could have
any data type during runtime. So basically what you're trying
to say is this particular method or this particular class
is a generic class, which could handle any data type
that is passed. So it's not specific. All right. So generics in Java is similar to templates in C++ generique
enabled type parameters when defining classes interfaces
and methods, right? So the type parameter is nothing but a generic type
and it's not saying that it's going to deal just
with integer or with character or with string. It is saying that it
could handle anything that comes anytime
that you would send it any type that you would instant. She ate that class with. All right. So when we take example, you should get some more idea
about this generate provide compile time. Type safety allowing programmers to catch invalid types
at the compile time. So generics work
on type Erasure, which is nothing
but which is done at the compile time itself. Basically, it's done
at the compile time. It can catch exhibitions
during the compile time itself, or it could prompt you during
the compile time itself, right? We can specify the type
the angular brackets. So whatever type you want to do, whatever type is
that class going to handle we can put it
into angular brackets, which makes it generate right? So here you could see that this is a method
which is print array which is taking e as type. So as you could see
he is the type here. All right, he is a type here
and we are not mentioning that it is going to take
print integer array or string array
or something of that sort. We are seeing that it generates. So whatever you pass or whatever you
instantiate it with it's going to take that array
and print elements within it. All right, so this Method
could be thought of as a generic method, right you could think of this printer as
a generic method not a method which is just taking integer
and printing it. It could be string array
or it could be anything else. So that's what
generic means advantages of generics type safety objects or single type can
be stored in generics. We would be looking at it in the next example
typecasting is not required. There is no need to type casters because it knows
that what kind of objects that particular data
structure would carry or hold compile time checking
it checks type mismatch error in compile time, which avoids runtime errors. All right. So imagine a list which we are going to talk
in further slides what is list, but imagine a list
which is a collection. All right, and you have
like imagine a list which is holding strings. All right, so you have list dot add and you you
add a direct cut to it. Now when you get 0 typically get Zero would have object
the return type would be object since it doesn't know that it is just carrying string
know where you have mentioned that it is a string of it's a list of string right? It's a generic list so it could hold
integer value as well. Alright, so in that case, what you need to do is
when you do list dot get 0 you have to Typecast
to the string here. The next element
could be integer. We don't know right since we haven't said
that it's a list of string. So that's that the reason you
need to have typecasting done. All right now using
generics you could Define that this list is
a list of string. All right, it's going to carry
only string nothing else. It's going to hold now. It makes it simple right
you add either a car now. If you try to during
the compile time itself, if you try to add
integer to it, like list dot add hundred. It would throw an error saying that it cannot pulled integer
because it's meant for string. So that's the advantage
that you get over. Rick's you could hold it
you could catch errors during the compile time itself. All right, so it
won't allow you to add or it won't allow
you to put a hundred in to your list of string. All right, and since we know it's going to hold
only string there's no need of typecasting it as well. You can see here. It's not typecasting it in this case you had to put
this string here, right? So basically in this case,
you need not type custard. There's no type
question required because we know it's
a list of string now what a collection Frameworks
collections framework is nothing but you have data structures
in terms of classes. Again, it's a wrapper
for data structure. All right, it's nothing but like you have array which is
normal primitive arrays, but this one would be
sort of growing array. So basically you need not take
care of actually, you know adding
up indexes to it. It would automatically It's
a self growable array. So you could imagine when it comes to array you
could imagine collection. You could imagine
one of the classes within collection is list, which is nothing but growable
array of any data type. All right, so Java Collections framework
provides an architecture to store and manipulate
a group of objects or Java Collections framework
includes the following it has interfaces classes and algorithm interfaces is
nothing but again specification. This is how it should be. So Java says that you know, when you have a list it
should have so-and-so methods like adding to the list setting to the list removing some elements to the list
something of that sort. So it defines collection
you have a collection you should have so-and-so methods and list should have so-and-so
methods and so on and so forth. So basically it's for
specification classes is nothing but concrete implementation so list by itself would have
Would have all the methods that you just the it's
an interface, right? So it would have all the methods that you want
without any implementation. But this classes
would be actually implementing it or rather. It would be
implementing this interfaces and would be giving a concrete
implementation for methods. Right? So as you could read here, it's concrete implementations
of collection interfaces in essence. They are reusable
data structures, right algorithm is nothing
but there are utility algorithms that you have like if you want to sort
a particular collection or if you want to sort a list list
of string you could do it using using your algorithm using
a predefined algorithms that already comes
pre-loaded with Java. All right when I say algorithms and where are
these algorithms residing? It is a class
which is collections. So you have a collection which is an interface
top level interface and you have a collections class
which is class. Which is holding all the
utility methods or algorithms, whatever you call who basically you could just
read through this hierarchy. These are different types
of data structures that has been supported by Java. You have a collection. So the top level interface is as you could see
there's collection, which is extending
I treble all right, extending iterable interface
collection itself is an interface you have
a list as interface, which is extending collection. All right. So list is extending collection
Q is extending collection set is extending collection. So we have three distinct type of data structures
Year's list queue and set list is nothing but you
could say it's a ordered one, right it maintains
the insertion order write the order in which you
inserted data into the list Q is nothing but
first in first out and whatever you push in
first would come out first and set is nothing but To sit
in mathematical form right over in you have unique values. You cannot have
duplicate values. So that's what set is
but it's it need not be ordered. It need not maintain
the insertion order, right? So you have the concrete
implementations for list our array list, which is nothing
but again similar to array that we have right
the normal primitive array that we use. So it's a wrapper class for it. We have a linked list. Alright, so this linked list is
nothing but doubly linked list. All right, so you could insert
from you could Traverse the either direction you
have Vector as well which is which is Legacy Forum, which is not used
to that extent yet as of now. So we have vector
and we have a stack which extends this Vector
redstack is nothing but last in first out and it adds some more capability
on the top of this Vector, which is nothing but it's a subclass of Victor. All right, so these
are Implementations of list we have a Q and
as you could see here, there's one interface
here DQ which is nothing but it is extending Q. Alright and we have an array D Cube
which is implementation of TQ. All right. It's a class which is
implementing DQ interface. All right, this is
a priority queue as well, which is a class
which is implementing Q when it comes to set
we have a sorted set which is again an interface
which is extending set and as you could see
there is a tree set, which is a concrete
implementation of sortedset and it sorts the element
that you put into a set. It sorts it into
a specific order. All right, again, the concrete implementation
of set f is our hash set which is nothing but
which does some kind of hashing which is a default
implementation of set and which doesn't
maintain insertion order as set is nothing but it is indexed
to for fast reversal or Want to go get
something out of a set, its kind of indexed set. You could say right it has
buckets and everything. It follows hashing algorithm, right which is which is basically for indexing or which is basically meant
for retrieving data faster from the hash set from the set
and that implementation. That's the default
implementation which is has said, all right, there is a linked hash set which
maintains the insertion order. All right. This has said doesn't maintain
the internet insertion order. So if you put X & Y
into your hash set and if you retrieve it or
if you Traverse through it and print the values, it's not mandatory that you would get X
and Y in the same order whereas in the linked has set
its pretty much you could be a hundred percent sure
that X would come before why all right. So it maintains insertion order
what is less list has nothing but an ordered
collection of elements which can contain duplicate son like sect
it can contain duplicates, but it has ordered an unlike say
State has ordered write lists are further classified into
following arraylist linked list and vectors, right? So based on the use case, you could select one
of these data structures. Let's talk about array
list arraylist is nothing but similar to arrays that we had and here you
could see element stored within of size 5-a released of size 5 and you could see
value stored within right. So this is how you instantiate an arraylist array list object
is equal to new arraylist and you have an arraylist
created one of the main things about arraylist is as I said itself growable or its Dynamic you unlike array
the normal primitive array where in you had to
within your square brackets, you had to mention
the size of the array during the Declaration itself. Whereas in Array list, you need not have
to mention this sighs. All right, it grows
by itself as then when you insert data
into it, it would go So basically you
could imagine a normal in general scenarios or in most of the programming cases or in
most of the real use cases. You don't know up front. What is the size of data that a particular array
is going to hold right. Now the number of elements
that a particular array is going to hold you
cannot know it up front because things
are Dynamic right? So suppose you are reading
from the database. You don't know what that size of the data or what what
are the number of elements that a particular database
is going to have. So typically you could imagine real cases
you would go with arraylist and not primitive arrays. All right. So also you could imagine
this is this is this is saving us in terms of memory because we are not hard
coding the values of it. So by default, it starts with 10 size of 10
and then it keeps growing as and when you insert it. So again, it has a logic it
doesn't keep going for each and every That you do but it has a logic
within to grow it by particular size. So which is all optimized which is good for your
for your cases use cases. So these are the methods
that we have within our A-list. It's very straightforward. When you do add it
appends the specific. It's usually add and
not collection for collection. You have a doll methods. So it's a typo here
you have ad and you you mention an element that you want to
insert into a list if it's a string you would have string string element or
if it's something else if it's an integer, you would have integer element
you could add it to a particular index you could clear it removes
all the elements from the list you
could have last index of a written the index of
this list of the last occurrence of the mentioned object. So if you have multiple as we said they could be
duplicate values within but when you give last index of
it's giving you the last index All right last index
of the object that's been passed
you could clone it. So it's basically coming
clone is nothing but a method that they're within
your object class and it would shallow
copy the array list. So whatever list you have
there would be a clone of it. Right so clone is
as we could see it's it's it's from the object class. So any class that you
create could be clone. All right, then
you have to array so you could have
an array list and if you want to convert it into
a primitive array and use it in some form you could do
that thing as well by doing two array you
could trim to size. So trim to size is nothing
but prims the capacity of this array list instance
to the list current size. All right. So whatever is the size it would trim to that so
moving on let us understand how we can Traverse
through a list of collection. So travel cell is done
through I traitor interface. Okay. So basically you have
a nitrate interface and that's how you Traverse it. Basically you have
implementations of it since it's an interface
it is it is just the specification you would have
an implementation of it. So I traitor is an interface
that I traits the elements. It is used to Traverse
The Collection access the data element and remove the data elements
of the collection. All right, it's used
for traversal as well as removal of data elements
within the collection. Okay. So what are the methods that we have within I
traitor first is has next. So it's it's nothing but as you could imagine
it is written in Boolean. So if it has a next element
it would return you true. Okay, and if it doesn't then if the arraylist
is already exhausted then it would give you false. So you would I basically would have a loop
wherein you would see if it has a name next right and if it has next you could
This is the next element using next Method All right, so next
would return the actual object and to remove it you
could do I treated or remove which removes the last element
written by the I traitor. Alright, so here you could see how I treat her
is being used you have you declare an array list and you you I trade through it and you print the elements
so quickly we can take this. So basically I do
calm dot edu Rekha dot I create one more package
now for arraylist. Okay, Isaac collections,
demo dot array list. All right, so I have this
particular class created now. I create a main method
and I create private void. I write a method which is create
array list for demo. All right, as you could imagine
when I see create it's going to return an arraylist. All right, we want
it to return list. Okay, what I do here
is I would create list and this list is going
to be list of string. Okay, imagine generic that we spoke
about you are saying that it is going to be
list of string now, it's three mirrors saying
which list I want it's going to be Java dot util so you could see Java
dot util doll wrist here. Now. I say it's strings dot new. I didn't list. You're saying that here what we are doing is
we are instantiated. So we have a list of strings
and we are instantiated it since we want arraylist. It's going to be a release. So here you could see array list
being imported as well. All right. Now what we are going
to do here is we are going to add some values
to it strings dot add or maybe I will put again since we have been
talking about cars and bikes I will cars right? So we are creating
here cars list of car. All right, so I
put BMW But what? all right, so all German cars
and then we Then we written it. We are returning this. So we are creating a collection. Right and we are
inserting data into it and we are returning it. All right, so this would create
a list for me right now. I want to I trade
this list, okay. So I create a private method
which would return void and which food print
arraylist or demo. All right. So as you could imagine this is going to take
a list as parameter. All right list list
to be printed or it's pretty much implicit or implied that list is
whatever list you pass as a parameter is going
to be taken for printing. Okay. So here what I would do
is list dot I traitor I take the I traitor. Okay, so I get
the list I traitor I say I traitor and it's a list I traitor All right. So I take this list I traitor and I say list right while while it has
any elements within so, how do we check with whether it has elements
within is nothing but dot has next if you remember while it has any elements
within what we are going to do is we are going to print
out print the value the list. Alright, we are going to print
it using I traitor dot next. Okay. So I've created two methods one
is create a released for demo and the other one
is print arraylist for demo create arraylist
is doing nothing, but it's creating a list and it is returning the list and printer a demo
is printing the list that you have passed
as a parameter. Okay, so I create a new element of array list
demo dot create arraylist. All right, and whatever I realize
that I get over. Will is that I get I
would be putting it here. Right now I create
one more this and I print it. All right. Now when I print it
I am going to pass this returned array list. All right, I think
it's pretty clear now. So we have created
a released in this method and we have returned it and in the second case we
are just going to print it. We are going to take
any array list and we are going to print it. All right. So let's see. So rest of the collections most of the collections you do
it pretty much similarly. It's just that you know, it's used for
different use cases. All right, I am getting
some error I think okay. Yeah, you could see here. It has printed BMW Mercedes and Audi which we had put
into the arraylist. Alright, so that's how you kind of
I trade through it. Similarly. You could just remove it. You could use list I traitor Don't remove will remove
the current element that's penetrated. All right. So yeah, this is I
don't need to actually create one dot remove
you could remove it. All right Drew. So that's how you remove it
if you want to so you you have the same syntax. So basically we don't use
I traitors nowadays more. It's more about we have Java 8
there are different constructs. Like we have Lambda
expressions and stuff. We have screams
stream processing, which is you have I traitors. All right. So this is what we have
we have a hydrator, which is I creating
through all the elements right and you could remove
it as well using the I traitor usually nowadays. We use Java 8 streams which helps us to I'd rate
through which is pretty much like the underneath is I traitor and stuff but there
are some some kind of abstractions done so that we don't
actually deal with I traitors there's
some kind of abstractions are it's less verbose
in this case. You have to write a lot of code
to print through and everything. Whereas in streams. It would be just one method call which would do lot
of things right. So that's what has
been used as of now, but this should be good enough
to start off with to understand the basics of it. Alright other thing
is I was talking about the best practices. So it's good to have things
broken down in methods. So that could reuse it rather
than putting everything into the main method
which makes it difficult for any other developers
to understand mode. So basically it's
a good practice. Make it modular, right and which enables
reusability as well which reduces the lines
of code within your program. So tomorrow if I
have some other list, which I want to I trait I
can just pass the list to this and it would right fit
and give me the results. So I don't have to write
the same piece of code again. Alright, so moving on so we have a released arraylist
is nothing but abstraction done on a primitive array. So what are the advantages
of using array list? It's more about it's faster in terms of retrieval right
index based retrieval suppose. If you want to get
to the index to just write like arraylist get to and it would give
you the one at the end x 2 or the element
at the index to whereas when it comes
to insertions and deletions. If you want to insert
a particular object at index 2 what it has
to do is it has to move that was there at the index
to to the index 3 and it has to increment
the entire array by one or move to the right by Position
which is pretty cumbersome, right which takes a lot
of time so insertions and deletions are not good
when it comes to arraylist, whereas when it comes
to retrieval it's faster. So based on the use case
you have to decide which data structure
you should go for right? So simply put we think
of Big Data applications. It's mostly about you don't have
insertions and deletions as such it's not transaction, right but typical
online transaction processing this thing would be
application or say, for example, you have Amazon
right Amazon or something where in you have a lot
of transactions happening which needs insertions
and deletions right in that case arraylist
is not a good option. Whereas in terms of big data, which is like analytics right
online analytical processing which doesn't have
transactions as such right. It doesn't have
insertions and deletions. It is one-time load
you have data you load it into your data structures and
you do some kind of processing or you do some kind
of analytics on This data, but you don't
manipulate this data. You don't actually have insertions or deletions
done in such cases. It's better to go
with a realist. All right, so which is a variant which is good
for insertions and deletions that is linked list. All right, when it comes
to insertions and deletions and you want to maintain the order of the list
insertion order of the list. That's when you would go
with linked lists. All right. So linked list is
a sequence of Link's which contain items
each link contains connection to another link and that's how insertions and
deletions are simpler. You don't have to shift
elements to the right when you insert it or you don't have
to shift elements the left when you delete it. There are two types of linked lists to store
element singly linked list and doubly linked list singly
linked list is nothing but it has pointers in One Direction
doubly linked list is like it has previous
and the next its stores. Both each node would store
previous element pointer to the previous element
and the next element. So yeah, this is a singly
linked list wherein you see that it has pointed to the next. It doesn't have pointed
to the previous one, right? It's a one directional
traversal, right? Whereas in doubly linked list, you could see
that it is looping back to the previous element as well. So it has a pointer to the next and it has pointed
to the previous one. It's a bi-directional traversal. So linked list has
pretty much similar to arraylist you have ad you
could add a particular object. You could check whether a particular object is
contained within the linked list and that object has to be passed
as a parameter to contains. You could add a certain element
at a particular index. You could add it to the
to the head of the list you could add to the last you could
check the size of the list. You can remove the element
from the list and you could get the index
of a particular element so you could pass some element
and get the index of it since linked list is again, it can have duplicate elements. If you want to get
the last index of a particular element you
could do that thing as well. So if you have
multiple elements, you would get the last one
right the index of the last one. So linked list example
here you could see that a linked list
of string is being created and you add values to it, which is fragile Rahul and Richard you
add things to it. And and yeah, this is just about adding
elements to the list. All right. So arraylist versus linked List
released internally uses Dynamic array to store
the elements since I said, it's Groove able it grows on its own linked list
internally uses doubly linked list to store
the elements to add an element in between or to
remove an element from the array list slow because it internally uses array if any element is removed
from the array list, then the rest of the elements
should be shifted to the left. All right, similarly when you add something
to the list you have to move everything
to the right adding an element in between or removing an element with linked list
is faster than arraylist because it uses
doubly linked list. So no element shifting
is required, right? You don't have
to shift any address. Or something. It's just about
moving the pointers. Right? So you would just move
it skip one element and move to the next in
terms of deletion. Whereas in terms of insertion, you would insert a node and you would manipulate the pointers according
T. Alright arraylist can act as a list only
it is normally for list but linked list could be thought
of as a list as well as Q right since it's a doubly linked list
you could have like first-in first-out arraylist is better
for storing and accessing data. All right. So as I said, this is pretty much good enough
for analytical sort of application analytical
nature of application. Whereas when it comes to transactional linked list
would be better. So linked list is better
for manipulating data and it is slow
in searching an element because it needs to compare
the elements from the first note when it comes to you know, index based search. It is slower because it has to start
all the way from the start. Was it goes through links? Right? It has links to next
element and that's how it traverses through
vectors are similar to erase but the Legacy form of it. It's a dynamic array again
similar to arraylist. All right, it could be
visualized very much similar to array list, but just that it's
a legacy of java. It's not used to that extent or I would say it's not used
at all at this point. But what is important to note
is Vector is synchronized when it comes to multi-threading
it's better to go with Vector, but nowadays we have
concurrent arraylist arraylist that is supporting concurrency. So there are a lot
of optimized versions of it which gives lot
of performance Improvement. So vectors are no more used
as such an industry. It's a Legacy form of arraylist. There are concurrent
versions of arraylist that that has been evolved which could be used
in multi-threaded applications. All right, Victor. Contain many Legacy methods that are not part
of collections framework. So it doesn't even fit
into collection framework because it contains
some Legacy methods which are no longer used or which are not part
of collection framework at all. Now Vector is again taken
into collection framework and it implements list and that's the reason it
has the implementation for this methods because this methods are
typically coming from collection and list collection interface and list interface and all
the concrete implementations have to implemented. And since Victor is one of the concrete
implementations of list. They have to ensure that they Implement
these methods as well. All right. So these are the methods
pretty much similar to what we spoke earlier
add clear and add to a particular index remove and then you could have size and you could have last index
of and last index of object. So it's a vector of string
then you add element you add. Issued fun and Kumar and you
just write great through it to print out
the message from a chiffon and Kumar would be the output
of this application or this program. All right, so you could see
I traitors use here as well. Like we did it in list. So let's talk about QQ is
nothing but first in first out whatever goes in first would be first to come
out a priority queue allows you to initialize the queue. These are implementations of Q. So you have
a priority queue you have as we said linked list is
list as well as Q so you could have linked list assigned
to a queue right linked list is the list and linked list is
a queue right is a relationship which means it's
extending it right. So here we can see double
ended queue lets you to a door and remove so double-ended
interface DQ DQ interface allows you to Add and remove elements from Peak
as well as from the bottom. That's what DQ is
double ended queue, right and array d q is nothing
but the concrete implementation of DQ EQ is an interface and the concrete
implementation is array d q. So what are the Q
& DQ methods you have ADD method which is nothing but it adds
to the top of the queue and it returns a Boolean as you could see here
if it is successful if it has added
to the top of the queue it would give you true. And if not, then it would give you
false right you have offer which inserts the specified
element into the queue again, it does the similar stuff. It inserts to the cube. All right, you have removed which removes the head
of the queue we have pull which retrieves and removes
the head of the queue again. It does the same thing retrieves and removes the head
of the queue and returns null if the queue is empty. All right, bullying is nothing
but getting the top of the queue. And you have element which retrieves but
does not remove. All right. So when you do Q dot element
it would give you the top of the queue of the head
of the queue, but it would just give you
but it would still be there. So if you want to check value
that is on the top of the queue if you want to check it and do something with it
based on the value that is there on the top
of the list or top of the queue. If you want to perform
some actions we can do it using element Peak again does
the same thing it retrieves but it does not remove
the head of the queue if you want to actually retrieve
and remove the head of the queue you would
either use remove or pole. Basically you would use pole not remove right remove is
not a good operation to do when you want to retrieve
and do some actions on it. The best practice would be to use piec to retrieve and use
Pole to actually retrieve and remove Alright, so let's take an example of Q. So right here
in the package I create. Secretary main method, right? So I create private. Q v8q for demo All right, so it's asking me
which Q I will go with this one, which is Java dot util dot Q. All right. Now I am creating a new priority queue which is
a concrete implementation which would be say
for example of integer, right? So I create a queue of integers. So we are putting integers
within all right, and what we are doing is new. I am instance eating it. Alright, so this is a q which is going to
hold just integers. That's what Jen Rick's come
into picture, right? Queue of integers
dot add suppose. I put a hundred and then
I put ad could is used to as I said to insert
right and I put 50. So I've created a queue
and I written this Q. So I've created a q so far. Let me print this queue. Alright, so we have which is going to return void
and print queue for demo and which is going to take you. All right Q of Cl you
don't even put it here. I so now, let's see how we can retrieve elements
from it one way is to I trade through it
and let's see how pole and other things work right? So let me get the head
of the list. So this is just retrieving
it right retrieving head of the list. We are not removing it it is
still there in the queue. We are just trying
to check what it is. So when I say when it's
retrieving it speak right now if I want to remove it if I want to kind
of retrieve and remove it. So basically what I'm
trying to say here is when you have q dot Peak
it's going to return the top of the list
which is nothing but 50. All right. So the first one the peak
is just retrieving it. Whereas when I pull it
it's going to retrieve and remove as well. So I have q dot pole
is going to now when I do s out retrieve and remove Say this is
the first attempt. All right, and we again do it
which is the second attempt. This is just to show you that when you pull it it's
actually removing it as well. Whereas Peak is not removing it. All right. So Peak is just retrieving it
and this one is removing it. So the first pole
is going to give you 50 whereas the second pole
is not going to give you 50. It's going to give you 200 because it has removed
50 from the queue. All right, so this is
what I wanted to show. So let me Q demo Alright,
so here I'm going to do demo Dot. So when it comes to generic we
can make this generic Q program by doing something of this and instead of hard-coding it
you could put a Ste here. Right now, let's keep it as is. Alright, so the first case Q is
being created the second case. We are going to see
how we can pole works. Retrieving is just ringing and it is still
keeping that element at the top of the queue whereas polling is actually
removing it as well. All right, so you could see
here Peak is giving you the last one here. It's a double-ended one. So it's giving you
the last one here and pull is giving you this one. It's based on Friday. I think. All right, so you can see pole is giving you 50 as well
and when you pull it again, it's giving you a hundred. All right, let's move
on to the double ended queue. All right. So here we have something
like you could remove first. All right, you know, so it's a double ended queue
you could in fact in both the directions
you you could actually remove first and add to the last and stuff like that. So you could see here that there's a double
ended queue created with four elements initially
2142 63 and 84 and you could see that remove first is removing 4221 rather from here
since 21 is the first one so it's removing 21
and remove lost or add last it's adding to the last which is nothing but it's adding
hundred and five to the last So what is set is nothing but as we said it's a representation of mathematical set
which is unique which holds unique values right? You cannot have duplicate values within set set has
its implementation in various classes such as
hashtag preset and linked as set so it's
a mathematical set abstraction. We have variants of set in Java which is has said
linked hash set and we said hash set is
nothing but it hashes it or basically there's
this indexing done and it's good for retrieval as you could imagine
since it's indexed. It's good for retrieval. Okay. So the analogy behind this could be our it
is analogous to index page that you have in books, right you have
index page you just go to the index page and see
at what page is the content that you are looking
out for this one is pretty much similar to that. So when you do hashing
you would be able to retrieve it much faster
then sequential retrieval. All right, so that's what has said does and it
has unique values of course, which is a property of a set. You can't have
multiple values within or duplicate values within it
doesn't sort automatically. This is a typo here has set is acid doesn't maintain
maintain any order at all its internal to The order in which the retrieval would
be done is pretty much internal to the runtime or
what I mean to say is if you have a has set
with the same content and if you run it
multiple times you would see that the retrieval is different
in different instances. So it doesn't maintain
any order your application might demand something
or demand a data structure that is set as well
as it maintains just the insertion order right? That's a scenario in which you would go
with linked hash set. So link - there is nothing
but set which has its insertion order maintained. All right. So the third one is tree set, which is nothing but it so these are the methods
that gets inherited into hash set and but similar
to other collections that we have, but just to talk about this one so you have ad which is just
adding object into hazard or linked has set
you have contains which is basically checking whether a particular. Object is present in a set. You can clear
the contents of the set. You can check whether a set is empty
using he's empty method. You can remove a particular
object from a set using remove method and pass. The object that you
want to remove clone is nothing but a method that is inherited
from object class, which is super class and it is basically meant
for cloning any data structure or any class
or any instance of a class. All right. So when I say cloning it's
not but making a copy of it and it's a shallow copy. There is a steep coffee and there's a shallow copy
shallow copy is nothing but the properties
within the set. So the references remain
the same basically you would have a value say
for example string right? If you have a value say
at Eureka you would basically have both the set pointing to
the same instance of a dareka. All right. So it's a shallow copy
and deep copies were in you would have
different instances or together. So when A Change Is Made
in new set A particular element it won't be reflected
in the other set. So that's deep copy, but by default the shallow
copy that's done. If you want to deep copied then you will have
to use some other utility or you some other class. All right, there's an iterator
similar to other collection you can have I traitor
to iterate through the set and if you want to check the size of the set you
could use the size method. All right. So let's see an example
of hash set and linked has set. Alright, so here I have created
two methods create hash set which creates the instance
of has set and add some integer values to it, which is 130 340 and 440 and you see there is
one more method created which is create linked hash set which is again inserting
three elements into it, which is hundred three hundred
and five one. So I return this. All right now I write a method
to 848 through it. Which is displaying nothing and Print set and
which would hit s. All right. What you do is you have like set to print dot you
could have I traitor right which would give you I traitor which would give you an instance
of I traitor for set. Alright, so we have I
traitor created for set now. Let's iterate through it. so remember how we
I treated list so you would say set
I traitor dot has next if it has next then
print the value of So basically we have this then you have set
I traitor dot next which would give you
the actual value. Alright, so we have a method which would I trade
through the set and display its content? All right. Now what I do is I create
instance of set demo. I create has set
and whatever value I get. I put it as as set. That's it for demo. All right, keep it I set. All right. Now I have against it. I say linked has set for demo. So basically we just
creating the set. All right, then we create
the linked hash set now said demo we are going to print it. The first one to be printed
is is Hash set for demo. And this is what is
reusable ET right? See I'm not fighting the method
to print it multiple times. It's just once and
which could be used for printing has set as
well as linked has sit. So this is what reusability
is all about. If you don't expose
it as a method and if you write it
within your main method, you won't be able to reuse it and you would have
to write the same piece of code multiple times which adds to the redundancy and
which is not a good practice. And this also makes it much
more readable by looking at it. You can understand that. Okay, it's creating a hazard. The second method
is creating a link has said and the third one
is printing asset. So it makes much
more readable, right? So that's an important
factor as well when it comes to programming. Alright, so here we can see that when I printed the hash set
it gave me 133 4440. Now the thing is it's
just three elements. So it has maintained
the insertion order. But basically if I have
more elements you can just copy this multiple. Okay, I remove this. Okay. Now you can see that you won't get it
in insertion order since it was it was
just three elements its by fluke that you got it in the same
order as which you inserted. So if you see it now. So now you can see that, you know, the first element
that got retrieved is 4401 which was basically you put
it at the last ride. So it's pretty much random. As I said linked has set. The retrieval would be
pretty much random. You could see 4401 then 130
which was the first element inserted than 340 then
440 then you saw 40, which is again out of order. So basically this is what linked has said does
and suppose I put the same values in the link
has set you would see that insertion order
is maintained. All right, so from here if you see from 130
in from here, it's printing linked has it and you could see the insertion
order being maintained as is 4410 and
when you see Hazard, which is very much
like this one, you can see that it's random. All right, so that's what link has set
an asset differs own preset is nothing, but it Sorted set and you have a retain
all method retain all method is nothing but intersection
between two sets. So basically you
could pass one more set to the retain all method and you would get
an intersection of two sets. So what I mean to say is
if you set has value one, two, one, two, three four and you
pass one more set to it or you invoke retain all method
and pass one more set to it which has values 1 and 2. All right. So your Source set on
which retain all method is being called that has got
four elements 1 2 3 & 4 whereas the set that is passed to retain all
contains only two elements. That is one and two. All right. Now when you invoke it
your Source will have only one and two your 3 & 4
would be removed off from the source set because the retinol method is
nothing but it's an intersection between two sets. Okay? So size and hashcode, so all these methods remain
the same as other ones that you have
in different collections, right? So you have like size
which would give you size. Hash code is nothing
but a unique integer that's written for
any object in Java. It's not just free set. Any object in Java
when you invoke hashcode, it would give unique integer. All right, because this particular method
is inherited from object class of java contains is nothing but pretty much similar you
pass element and check whether that element is contained in the
source set contains. All is something like retain
all it would return true only if all the elements
in the collection that's passed here as an argument is present
in the source set. All right, it has to have
everything all the elements. So the previous case wherein
I said the source has one two, three and four and
if you do collect contains all on a set Are you pass
a set to contains all with values 1 and 2 it would return true. Whereas if you pass a collection with values 5 & 6
it would say false because you don't have values
5 & 6 in your Source collection. All right, I traitor is nothing
but it Returns the iterator that we checked on you can convert it to to array any collection
could be converted to to array which would give
you object array. You could check
equals basically checks if the collection is I
think it has to be empty here it checks whether
your collection is empty. So there's a typo here. Just to give you an example. I will create one more. So I copied the same method
and I said create rehash set. All right. So what I do here is I
will make these changes. I will keep it as this could be kept as set
and this is like free. All right, so tree set
and and we are set. Now I print this one. Okay, basically set
the dough dot create rehash set. All right, so I'm printing
this so prior to that. Maybe I will put a statement
here printing stre set. All right, so I created a tree
set with this random values 133 4440 and stuff like that. Now let's check
whether it has sorted it or not. Right? So I created a tree set
and I'm just printing it here. So what you can see here there's
we have created reset now if you see it right after printing tree
set all the values that you see here
then 3044 41 3440. It's all sorted efficiency. Right and it's Unique as well. So if you insert it
multiple times like if you insert n multiple times still in it
would take Just one value of 10. All right, so you
cannot have multiple values if you put 10 unlike array list
or linked list, which will have multiple values. This would take just one 10. All right, it would
ignore the other one. Enunciate is a special type
of set which creates genome is nothing but a constant
it's a replacement for constant in Java. So basically the replacement for public static
final and basically for constant earlier. It was like we used
to use public static final but now it's advisable
to use enums four constants. All right, we'll see an example which would give you much
more clear idea about it. So first one is all of all
of method is nothing but creates an enum set
containing all of the elements in the specified element type. So it would create enum set
with all of the elements that you have copy of is nothing but creates
an enum set initialized from the specified collection. All right, so you
could pass a collection and it would create
an enum set out of it. None of is creates a MD enum set
with the specified element type or this creates a in mm set initially containing
the specified element. Can you could
initialize it as well? So basically here we are giving a specific class
with which it would be created or the enum set would be
created range creates a enum set initially containing
the specified elements, right and clone is nothing. But again, it's
pretty much similar. As I said clone is a is a method that is inherited
from object class and is meant to clone or have a shallow copy
of the data structure against which it is invoked
or object against which it which the Clone
method is invoked. All right. So here we can see
there's the enum which is months. Alright, so here you
could see a in a months which has like
three months declared within Jan Feb and March. All right. So now what you do is,
you know him set off and you just wait set out
of two of these elements, which is Fab and March. All right, so this is
what Them office so you could have some enum values put in and it
would create set out of it. Now when you write
rate through it, you would see
that you have Fab and March into your genome set. All right. So this is something
that is required when you have enums
with multiple constants and if you want to have or you want to create set
out of it and do something with it, right? So it would be
pretty much common or you imagine of enums as
exhaustive list of constants, right which is used
throughout your application. Now there might be instances where in you want to have
you want to put them into set and do something with it. Right? So basically this is mint because the values
within your enum cannot be put into a data structure as of now
or prepare to enum set. We were not able to put
the values within the enums into a data structure, right? It was considered as
a separate entity. So now this is That you could put it
into a data structure as object and you could play
around with it. So that's the reason
we have enum set. What is map map is nothing
but it's a key/value pair and it is unique Keys
you it holds unique keys. So suppose if you try to insert
same key with different value, you would have
your value updated or overwritten with the new one. All right, so but it won't duplicate it. So what I mean to say is
it maintains a key value pair, but the key is going
to be unique across. All right. So This Could Be Imagined
as a table, right? You have a table
in data structure, which has got one primary
key say employee ID and there's a name which is like name
of the employee right? Imagine. This ID is a primary key, right? So you cannot
have multiple values. So if you try
to put some multiple if you try to put
one more value to it, it won't allow you to put in. The only thing that you
could do is update the value of existing ideas. He's our add a new ID. So this is pretty
much similar to that. Right map is specifically
for maintaining key value pair and we're in Keys
would be unique and if you try to map and existing key
with a new value, you would see that the value
is been overwritten, but you won't have
to kick it keys. Right again. There are different variants that we would look
at map has hash map which is similar to Hash set which is based
on indexing or hashing. All right, you
have linked hash map, which is pretty
much similar again. Hashmap doesn't maintain
the sequence of insertions linked hashmap maintains
the sequence of insertions. There is a sorted map
which is again free map and which is sorted
on based on Keys. All right. So the structure that you see here is
pretty much similar to set right we had hash set we had linked hash set
and we had preset so this one is pretty much
on the same lines as set So how do you put data
into your hash map? It's with put method, right you have put method and
you you put some key and value. All right, we have put all
we can have an existing map. And if you want to put
all the key value pairs that they're into a map
into a new map, you could use put all
or you could remove some key. You could get some key. All right, you could check whether a particular key
is contained within hashmap. You could get
your key all the keys in the hashmap as a set, which is key set give
you extract all the keys as set and as
their unique already, then you would get
a new set returned out from he said entry said Returns the set view containing
all key value keys and values. So basically you
would get all the keys and values as a set when it comes to entry set from the entry said
you could get key and value distinctly. All right, so get key
is nothing but obtained a key get value would give
you a value against the key. Now. What are the typical exceptions that you get when you deal
with map some exceptions Throne while using map interface is
no such element exception. So when you are trying
to invoke some item from the map if you're trying to invoke a key
that doesn't exist. This is what you would get. Okay, this is more about
when there are no items if there is no item
that exists in the map at all if it's an empty one, and if you are trying
to retrieve something that's when you would get
no such element exception. All right Class cast exception
is pretty much. It's a generic exception that you get when you try
to cast it against an object or suppose value is a string. All right, and if you try
to cast it to integer you would get a Class cast exception since string cannot be
mapped into integer. All right. Now pointer exception
is the runtime exception which we saw that if You haven't initialized
your hash map. And if you try to put
something into it, you would get
null pointer exception. So you have to make sure that you instantiate
the map first and then start using it
unsupported operation exception. This occurs when an attempt is made to change a map which
is unmodified unmodifiable. So you can get unmodifiable
version of a map. And if you try to change
something within it this is what you are going
to get unsupported operation. Hashmap linked hashmap
and free map. So this is pretty much similar
to the examples that we saw for the set write Java
hashmap class implements the map interface
by using hash tables. It inherits abstract map
and implements map interface. It contains only unique
elements hash map contains values based on the key. It may have
multiple null values, but only one real key. So this is important to note. You can have
multiple null values. But only in one alky
you can't have multiple in alkies sonal is also
treated as a key as a valid key when it comes to hashmap, right? Whereas in hash table this one more variant
of key-value pair, which is Hash table, which would throw you an error
if you have G as null but hashmap take ski as null so
that's an advantage of it. So hash map doesn't maintain
the order of the element linked hashmap maintains
the order of the elements. In which they were entered and treemap sorts
based on the key. So these are pretty
much the same thing that we discussed
for map earlier. If you see entry set key set
and all those things we have already discussed about
and it's the same this something that we have
in specific to tree map. You could get first key. You could get lost key. All right, since it is sorted
you could get it now. There's a hashmap example. I create a main method first. Then I create private map
and then create. hashmap And I create
a new map here say app of integer string. Typically you would have integer
as your ID right employ map. All right, and which
would be new suppose. I create a new hash map. Read so I'm creating
a new map here, which is like the key would be integer
your value would be string. not put Buddhism method that we use and say
employ map dot put Alright, so this is how you put
into it put into map. All right, so I'd written
this map from here. So we so we'll take
an example of hash map. Where in we would
be putting some ID and we would be putting
some value as a string and we would check how it gets I treated or how we can hydrate through
or get something out of the set out of the map. Okay. So here you can see
that I created a hashmap. I created this method which is create hashmap
and I put some value within which is nothing but
and you could see here. It's a map of
integer and string. So I put a value of one and I put value as
X I put 2 and value as Y and I put a hundred
and value as a right. So I created a map
of employee ID and employ name so to say right? Okay, so I've created this and so what we
are going to do here is so you could even
print out a map. See if you want if I print it out like this like
map to print you would see all the values contained
within the map. All right, so this is all right. I print the hash map right here. So basically I created
demo dot create hashmap. Okay, demo dot print map and
let's print this map here. All right, so we have inserted
three entries into this map 12 and hundred with ID 1 to 100
and which has got value of XY and a respectively And what we are doing is we are
just printing the map contains of the map right here. So you could see here is 1/2 and
hundred been printed out here. Alright. So again, this is a hash map and you could have
it's based on hashing. So it doesn't
maintain any order. So if you have multiple values
within you would see that the order is
not maintained similar to what we had in hashmap. So if I put something
like this Alright now when I run it you would see that insertion order
is not being maintained and when you retrieve it, you will get it in any order. All right here we can see
that the order is not been maintained
112 is displayed first, which is second last actually. All right, so it gives you
all the entries within the map but it won't maintain
the insertion order. So that's if you want to maintain the insertion order
you have used linked hashmap. All right, if I change this to link
to map linked hashmap just one single change would sigh
copy the same stuff here. All right, and I
put a link hashmap. All right and suppose I create
one more which is 43 map. All right, so we
have created three Maps here one is your tree map. So the other one is linked
hashmap link - map now. Let's print one by one, right? The first one is hashmap that's
already been printed here. Now, I create linked hashmap. Right? And the third one that I print
is demo dot create remap. All right, so we have all
the three maps created and we are printing it here. Alright, so here you could see
that when it comes to hashmap. The key value pair
is not maintained. Right? Whereas when it comes
to link the hashmap. This is a link hashmap
and you could see that the order is exactly
the same as the order in which we put in. All right, and when it comes to tree map with the third one
and here you can see that it's sorted one. So sorted by your key. Not the value. Alright, so see the key
to the left hand side when it says 1 equal to X1 is
the key and X is the value if you see it will see that 12 Levin 2,100 hundred
and eleven hundred and twelve 1010 and 1100 so you could see
that it's been sorted / the key. All right. So this genome map in a map with specialized map
implementation for enum Keys. All right, which we saw here. We can see that there is a enum
which is nothing but constants and you could see
three constants been put into the months, which is Jan Feb and March and you could see here
is a in a map created for all the months
or for all the months that you have within your genome that is months right
you have this in a map and you could actually put in
values something like this. So basically in a map is nothing
but you could use the enums or the value within
the enums as your keys. All right, when you use
in a maps and you could just write rate
through it to see that you know, you have this Keys put in
and values put in properly. All right. So, so just to give you
an example we can have we can create an enum here. I'll choose to create
them same one and I create enum here, right? So I create in a month and
which has got say for example, Jan Feb March. All right, so we
have created this now what I do is I create a new
in a map with months and with string as its value, so I create a main. Gina map fifth month and maybe we could put
into your head. I create this in a map here. All right in a map of our you
have month and integer. Alright, so here we
will have to give a month dot or even months. Okay? Ticks class 1 class. All right. So in the Constructor we
could see that it takes class as a parameter. So we put one thought class
as a parameter now I put ma'am don't put I put like the the key is your it
is depicting something like seals ton per month. All right it basically
it refrains you from putting anything but
the enum value as your key. All right, so that's what we are trying to do here
and you could just print. In a map calendar and you should be able
to see the values. All right, so it's basically
restricting the key as one of the values or one
of the constants declared within your enum. See how you can see here. Jan is equal to hundred fehb
is equal to 200 you could. Now I will quickly talk
about comparable and comparator comparable and comparator are
the two interfaces or it's used when you want to have sorted set or if you want to sort
a collection say for example, you have lists of integer and you want to sort it a list
of integer is something that is by default could be done because integer itself
implements comparator, but if you have
a self-defined class or if you have your own
class say for example, if you have your own
defined class something like this vehicle info, which has like a number
of Wheels mileage and name of the vehicle put in now if you want to sort
this particular class if you give it to a sorter, it won't understand because this is
a self-defined class straight. It won't understand what you want to sort
in this right. Basically when you have
something of this sort when you have your own defined
class and you want to sort it, that's when you use
some variable and comparator. All right, so I'll just walk you
through it so comparable. Phase is used to sort the objects of user-defined
class in an order. So to give you an example suppose you have
an employee class which has got ID and
say salary, right? If you want to sort
it by default. Java wouldn't know what you want to sort within
that particular class, right? You want to sort it
by the identifier or the ID field
within the employ or if that's the use case, then it could be like you want to understand
the order in which employees joined the company
and the other case. Could you want to sort it
by salary to understand which employees taking
the most salary or to understand the sequence in which salaries been paid
to the employees, right? So to make Java understand which use case you
are trying to solve based on which identifier or based on which property or instance variable
within your class. You want to sort
to just indicate Java that this is what we want
to do express it in a form of implementing
comparable interface. It is in Java dot length package
and it contains only one method that is compared to it provides
single sorting sequence only that is you can sort
the elements based on one data only you can't have
multiple data consort based on multiple data. All right. So I'll just walk
you through this which would give you an example. So so basically
you have a student which implements comparable
now here you could relate to the example that I took wherein
you have roll number and name now you
want to sort it. Now what we are trying to sort
here is by rule number. So that's how you
express using comparable. Right? You have comparable
student, right? And you could see here. There's a compareto method that this comparable student has
got all the comparable interface has got now compared to will
take student as a parameter. All right. Now you could see that we are comparing
rule number right you're comparing the rule number
of the parameter student that's been passed
to the compared to if it is equal then it's 0 right you don't have
to do anything if it is greater, then you written as 1 and if it is less then you return
as minus 1 so basically based on this compared to Java
will do sorting All right, it will sort it based
on whatever you provide here. So what you are trying
to tell Java is if it is equal we are returning
0 so this is a contract. Okay. This is what we need
to actually this is how it's been coded
or this is a contract that you need to follow
whenever you compare to. So if it is a real number
then you say it's rule number 0 or return 0 if
if both the real numbers match if the one in your
instance is greater than the one being passed here. Then it would written
one or else - one. All right. So how do we use this? So basically you can see
here you created student. All right, so they were like three students
created 101103 and 102. You could see three IDs
being created here. All right. Now what you're doing here
is collections dot sort and you're passing
your array list of student and you use collections dots Not right when you do
collections dot sort what it would do is
it would arrange it or it would sort the array
the order of rule number so 1 0 1 would be first
102 would be second and 103 would be the last. All right, so there's comparable
and this comparator. All right. There are two interfaces
comparator is nothing but it is used to order
the object of use again. It is used to order the object
of user-defined class. But what is different in comparable is
comparable takes compared to which takes just
one parameter as input and the other parameter is
nothing but the instance within the class itself. All right, although this instance
rather the instance on which this particular method or instance on which
compareto method was called. All right. So basically comparable
will have only one method compared to all right, whereas comparator when you use comparator
interface it will it will take two methods or it will take two parameters
in the compare method. All right, and it will compare
both the parameters that are passed. So basically it's for customized sorting
in the first example, that is comparable. We are putting
the logic of comparing within the class itself, but you have a separate class which implements this
particular comparison logic. So basically you could see here
right you have a class student and student is just holding
the values of roll number name. All right, you don't see how you don't see
the comparison logic with them. Now you have another class
which is named comparator which implements comparator. Alright this name comparator
which implements comparator now if you see the compare method, it takes two parameters, the earlier one the compareto
method incomparable was taking just one parameter here. It is chicken
two parameters, right? And what you could do is
you could simply compare based on name right since name is a string you
could do S1 dot name dot compared to S 2 dot name. This would compare
based on name. There's another one you could
have one more class created which is nothing but rule number comparator which
implements again comparator. Now here you would
use the same logic that you defined earlier
for rule number. All right. If S1 dot roll number
is equal to equal to S 2 dot roll number return 0 else if S1 dot roll number
is greater than x 2 dot roll number
written one or else if it is less if S1 dot roll number
is less than S2. Total number written minus 1 So based on this logic
you would see that the compare or you
would see the Sorting Happening Now, how do we use this? So we have defined a class. We have defined a model class. So model class is
nothing but a class that has got just
the state right student. If you see student
doesn't have any Behavior as such it doesn't have
any method with them. It is just a state. So this is a model class. Alright, so student
is a model class which has record roll number
and name and we have two separate comparators
defined here named comparator, which is comparing
the name and we have a rule number comparator, which is comparing
based on rule number. Alright now, how do we use it? This is not sorting at yet. Right? How do we use it? So how do you use it is nothing but you have
collections dot sort. All right. This is pretty much similar to proceed other part
of the program. This is just about putting
the data into your class. All right, so you have 1 0 1 put in as Vijay 106 put in
as a J1 05 put in as Jay. Alright, and now we
are trying to sort this based on rule number
as well as name. So both this can't happen
in one go by the way. All right. This is like first you can have
something done on rule number and so it's not in one go. All right, you could do it
in step five manner. So as you could see here, how are we using this comparator is nothing but you have
collections dot sort and then comes the collection that you want to sort. In this case. It is a L2. All right, and then you
provide the comparator. So here you are providing
new name comparator. Alright, so after
This particular statement is called you would see that the collection
is been sorted based on name. All right, and
the first one here as you could see
collections dot saute L2 and here you are passing
roll number comparator in the first statement or here the first collections
dot sort statement would sort based on Roll number. Whereas the lower one
would sort based on name. All right. So this is basically offloading or just decoupling
your comparison logic out of your class. That's when you would
go with comparator. Whereas you would go
with comparable when you want to put the logic
within the class itself. All right, so it depends on
what use case you want to do. But as far as the
performance is concerned, it's pretty much the same. All right, even if use comparable or comparator,
it's pretty much the same. It just depends on
how you want to write it the programmers wish
so few people refer to have modular programming
rather than coupling everything into one class. They would go with comparator and few people like to add
things to the class itself, which they would
go with comparable. So what is comparator and comparable comparator
provide single sorting sequence? That is we can sort
the collection on the basis of single statement
such as ID or name as we saw that you would have
just one compareto method and based on that. You would have
the sequencing done or the Sorting done. Whereas comparator you
could have multiple learning since you could
have multiple classes implementing this comparator and you could write
your own logic like in the previous example, we saw that we had a comparator
based on rule number and we had a comparator
based on name as well comparable effects original class comparator does not affect
the original class. So we saw the student class
right the student class within the student class itself. You define the compareto method
when you use comparable, whereas when you use comparator
you wrote different classes. So that's about decoupling that I mention comparable
provides compare to method to sort the elements and comparator provides
compare method to sort. All right comparable is found
in Java dot Lang package and comparator is found
in Java dot util package. We can sort the list
of comparable type by collections dot sort lists and we can sort list
of elements of comparator type by collections dot sort lists
comma comparator method. All right, when I say list,
it's a list of some type, right? So in the previous case,
it was list of student and since student class itself
at the logic for comparison. We don't have to mention
it explicitly taken care of by itself. Whereas in this case, where an you use comparator
and you had different classes where in you put the comparison
logic in that case, you have to explicitly
give the comparator right? Like we give something
for rule number. We instantiated rule
number comparator and gave it for sorting by a rule number and we
instantiated name compare. There for sorting by name. Alright, so that's how we sort
user defined classes. So basically why do we have
comparable and comparator just to reiterate but jvm
or Java wouldn't know how to sort
a user-defined class, right? It could be based
on rule number. It could be based on names. It won't know by itself
what you're trying to do. So that's how you using. This interfaces you express
your logic of comparison. So what is XML so Henry handles
the database of a college but the data is stored
in a form of XML file. He wants to extract
information from this now. He is learning XML
so that he can handle it easily. So what is XML all about? It's extensible markup language. It is designed to store and transport data XML
has hierarchical human readable format XML
is platform independent and language independent. Why did XML come into picture
at the first place? So it's basically you have
different systems Mauro you might develop some system
or you might have some service that is exposed
to the outside world. So what happens is they has to
be some contract you as a client or you as a service provider. First of all would expose
a contract saying that if you give input to
my service in so-and-so format, I will give you output
in Swann Format, so basically when you want
to send data from a client the service you would send it
in a specific format that the client understands
or the server understands. So the server exposes or the server expresses
the input format in a XML form and this
is platform independent. This is like you might have
a service tomorrow in created in.net
which can use the same XML as used by Java program as well. So it's a platform
independent thing. Basically, it's used
for carrying data as I said store
and transport of data, which we'll see
in the coming slides but you could imagine
this as nothing but a file which is used to send
data from your client to the server for communication. It's pretty much human readable. It's not like yesterday we saw but serializing and serializing
the state of the object which was not human readable. So this one is pretty much
human readable you could imagine like you would have
an employee ID or You want to start something
in the employee directory and there's a service which is exposed for
that you could imagine that you could send the ID to it or you could send
an employee name to it and format in which it is sent would be pretty
much human readable. You could see that okay,
there's an ID there is a name which is sent to the server
and the server is doing so and so things
so it's hierarchical and it's pretty much
human readable again, as I mentioned
platform independent and language-independent. It's agnostic of all
these Technologies. So there are a lot
of existing Services which use xml's as a part
of input data and output data. So as we go
through the examples, you should be clear to you guys
about what XML is all about why we need XML XML
is an industry standard for delivering content
on the internet. So it's a standard. So most of the services most
of data entry communication that's happening within
in Annette is done in the form of XML. They communicate with each other
in the form of XML XML is designed to store and transport data XML
is the extensible because it provides
a facility to Define new tags. It's not that
once you define it. It's all done. So it's extensible. It's extensibility feature
wherein I can say today, my server is accepting employee
ID and employee named tomorrow. My server want to accept
employee salary as well. So you could add
that to it add tags to it, which makes it extensible. So it's not one time Define. You could change it. You could evolve the xml's XML
is used to describe the content and structure of data
in a document. So it has got its own schema
and you can say that my XML is going
to contain just email ID and employee named nothing else
and you could validate VL XML or the actual XML that you have against the schema and if you Some extra
parameters put in it. Would throw you an error. So that's about white need XML. Let's talk about what are
the features of XML? Why is it so widely used
writing XML is pretty much easy. As I said, it's human readable
and you could actually write it and there's a lot
of API or lot of sdks that are exposed for reading and writing with xml's and very
optimized version of it. So you could see parses, right? We had multiple parses. It's for Performance
Based on the needs of your particular application or the nature
of your application. You would select one
of the parsers. So writing xml's is very easy. The other one is XML data can
be extended with DTD and xsd. It's a schema description. As I said, you could extend it. It's not that it's
one time Define. You could extend it XML can work on any platform
this platform agnostic. You could run it
on any platform either Dot. Or it could be different
languages or different platform. It could be different
operating systems as well. I could run it
on line X tomorrow or I could run it on dotnet
any tool can open XML file and can parse it
in programming language. So simple editor or even
notepad you could open it in notepad plus plus
and just you through it and there are different tools
available in the market as well, which would give you
kind of format your xml's so that it's much more readable. So there are a lot
of tools available already XML separates data from HTML. It separates the actual data from HTML code XML
simplifies data sharing. So basically as I said it pretty much intercommunication
standard between systems, you just have to put it into XML and you share it across systems
XML simplifies data transport. What is the difference
between XML and HTML so XML is used for storing data
and data communication. So as I said inter
system communication standard and HTML is used for display. So whatever you see
on the web is something that is you have a HTML page
you have coded it in HTML format and it's used for displaying it
XML uses user-defined tax HTML has its own predefined tags. So when you define your XML,
it's a user-defined XML. As I said today. I might have a service which is taking employee ID
and employee name which is like user defined
which is not predefined. Whereas when you use
HTML HTML is nothing but it has to get parsed into or it has to get
past into a page which has been
visualized by clients. So that's why you have
a predefined tags. You cannot have anything you cannot put something of your own
or if you put your own tags, it would show up an error. So it's validated reason
being you have to compile it or you have to run through
to show it as a view or show it as a HTML page
with the plants. There's an interpreter which has to understand
what you're trying to do. So it's predefined tags XML is case sensitive and
HTML is case insensitive in XML. It is mandatory
to close all the tags. So you cannot keep
any tags open. So we'll talk about the tags. Once you see the format
of the xml's but basically if you have a every property
or every data that you want to send
out will be enclosed in a tag you'll have
to ensure the tag is closed. So for example employee ID
right employee ID will have opening tag and it will have
an employee ID as a value and you will have to close
the tag you have to ensure that employee ID tag is closed
right after the value in HTML. It's not mandatory to close the tax all
the time XML is dynamic because it is used
to Transport data HTML is static because it is to display it it. So basically when I say,
it's Dynamic it's extensible. So tomorrow you could change it. You could change the format or you could change
add few more elements or few more tags
or add some attributes. So it's pretty Dynamic
would change it whereas HTML is aligned
to a proper predefined tags and you can't change return. You cannot add
some tags additional tags of your own XML preserves white space and HTML
does not preserve white space. So what are the rules let's talk about XML rule XML considers
white space as the actual data. So whatever you are sending
data through XML. So imagine you are sending data
between two systems, right? So space is also a character
when it comes to XML. So suppose you want
to send some data that is client is typing. So of course you need To have
Space Center as well. You cannot have spacing node. It's actual data between
two systems communication between two systems and
since space is valid data. It's been considered
as data by XML ordering and nesting of XML document
should be proper. As I said, you have to ensure
that once you open a tag you have to close
it there could be nesting so there could be a tag with says employ
and within employed tag, you might have employee ID tag, and you might have
employee name tag. And once you have
this employee ID and employee name tag, you have to ensure
that you close the employee tag. So that's nesting. So your nesting ID
and name within employee tag. So your this might be really
confusing at this point. If you have no idea about what the structure
of XML is all about, but don't worry
in the coming slides. We have examples and it's pretty straightforward
XML tags are case sensitive every opening tag must. Have a close tag else XML
be not correctly function. What does an XML file consists
of it has one root element that is one tag, which encloses
the remaining tags. So it has one root element within which the entire
content would be and each elements consist
of start tag content tag and an end tag. So there is one
of the components of XML is nothing but element within an element
you would again have some content expressed
in form of element again, which will have start
tag content tag again and end tag. This is about nesting it
will see in the example which is pretty much
like readable format XML tracks are case-sensitive opening and closing tags should be exactly the same without
any difference in the case. So you have to ensure that it's been enclosed
with the same case as it was started off. This is an XML. So the first That you see is
nothing but XML declaration. The first line that you
see here rather is nothing but XML Declaration of prologue. So this is nothing but kind
of saying what the XML is or the format in which
it is encoded here. You could have your dtds which we'll see
in the coming slides but so kind of summarizing your
XML what the XML is all about. That's your Declaration of
prologue and that's mandatory. If you don't put it it
would throw you an error then comes the student tag, which is user defined you could imagine this as
a user-defined XML, right and you could imagine
this as data being or you could have
a service a for example, which is doing something
with this data may be inserting to a database right? So you could imagine this
being sent from client or you have a webpage
say for example, wherein you enter
first name last name and email address
of a student and say for example that comes to a server
and it's loaded. To your database. So the root element of the document is nothing
but student here, you can see a student tag. And as you can see here, it's an element which starts with angular
bracket then the name of the element and it ends
with the angular bracket. So this is student
and then the next line is about you define
three tags within it. This is nothing
but the content of student and here you can see
it's following same strategy or it is following
the same structure. You have was named Henry and disclosed the
first name element. You can see the second element
as last name and with starts with angular bracket last name
and and the angular brackets. Then there is actual value lie, and you could see
that it ends with the tag or with the element last name. So one thing to remember here
is about start and ending of a tag ending of element. You can see the right
after the value. The element is closed and you
can see This thing here as well. So student is a element and you can see
first name last name and email being nested
into student element nested or they are the child elements
of the root element. So you have child
elements defined here and you have the last line which defines the end
of the root element here. We have XML which has doors
or which is used to transport. First name last name and email address
of a student across systems. Let me show you
the tree structure of this XML so it could be imagined as
student being the root element and you can see
that first name last name and email is nothing but your child or is
the child for student since it's a root element
and you could see the values the actual content of it
within your first name tag, you saw the value
Henry within the last name you saw the value lie and within the email address
you saw Henry 123 at gmail.com. So the leaf node is nothing
but the content of elements or the actual
contents of the XML that you're trying
to send across systems. This is pretty straightforward. Like you could realize XML
in a form of free format where in your root node is
nothing but element of your XML and the leaf nodes or the leaves are nothing but the actual value
stored in the XML. So let me talk about three rules
in this given example student is a root element. Then first name last name and email are
descendants of student. This is pretty
much straightforward when it comes to tree so you have a root node
and you have descendants and we can see
from the structure and sisters in this example
student is ancestor of all other elements, so root node, so it's ancestor of all other elements
within this tree order XML attributes you
can have attributes. Which are common across or you could have
some attributes defined within an element. So here we can see that message. That's nothing but an XML
with the root node messages and you could see
individual messages within so there are two messages here
within messages Tab. And the first one is to any
and it's from John and you have a body there
the actual body of the message what you want to send
and you can see here this ID or this something that has been provided
as an attribute, which is nothing but you
could see Mi di is equal to 1 that's attribute has to be
enclosed within single quotes or double quotes. So whatever you see
within the element and closed within codes that is nothing
but attribute so modifier, you can say some kind
of a modifier to your element. So attributes add more
information about the element it is adding some more Formation to the element XML attributes
must always be coated either. It should be within single quote or you could have it
within double quotes here. We have it within double quotes
for our XML comments. So to make it more readable or to increase
the maintainability of an XML so that someone
else can understand what you are trying to do you
could have comments put in so this is pretty much similar
to comments in other languages. The reason why we rationale
behind why we put the comments it's more about make
it much more verbose and understand what bag is all
about how we comment is nothing but you
have opening angle bracket. Then you have exclamation mark
then two hyphens and after the - you have the comment and once you have the comment
you close it with double - and then closing angle bracket. So one thing to note
here is exclamation mark, is there only when you
start the comment and at the end you don't have
Exclamation mark double - and then closing angle bracket
similar comments are just like HTML comments comments
are used to make the code more understandable. What are the rules? Do not Nest a comment
inside the other comment? Okay, you can't Nest it. And I don't see any need to nested was your
just expressing it or we are just adding comments
to make it more readable. So if you nested it would give
you an error do not use comments before and XML declaration
XML declaration should be the first line. You shouldn't be using comment
before that comments can be used anywhere in XML file
except attribute value. So you can't put comment
within an element or you can't put it right after the element
is defined or say, for example, you have
this message tag, right which starts with
angular bracket and then message and right after the message. You can't have comment your
element tag has to be closed after this closing angular
bracket you could Any comment but it cannot be within this space wherein
you define the attribute so basically comment
can be put anywhere but it cannot be
as attribute value. So let's see a well-formed XML and what do we
call well-formed XML as there must be exactly
1 root element and XML should have exactly
one root element. You cannot have multiple every
start tag has a match intact. So we saw in
the previous example, like if you start student you
have to ensure have an intact for student as well. So that's what it is about
every start tag must have an end tag attribute must be
coated either with single quotes or you could have
double quotes comments and processing instructions
may not appear inside a tag cannot be inside a tag and you have opening
angular brackets or and must not occur
inside a data element. Your data cannot have this
as value or your data element cannot Contain this as a part
of the name of element. So let's move
towards XML validation. So well-formed XML
can be validated against DTD or xsd. So communication between
multiple systems you have to ensure plant is sending
data or is kind of you know, preparing an XML which is aligned
to what server expects right? So that's where you
have decreed in the and xsd. Let's see. What is D TD. E TD is a EB NF grammar
defining XML structure. It's a normalized
form at grammar, which defined XML structure
a DTD defines a legal element of an XML document. So it says what XML can contain
what an element could be or what the attributes could be
and it's a legal element. Okay. So basically when you define a DTD you can expose
the service today, which could be used
by Tomorrow right? Google can be using it
for some purpose. So this is a legal document
saying that my service expect or accepts the times
1 so format, so you have to send it
in so-and-so format for us to process it through. All right. So it's a legal document
between multiple organizations XS T is nothing but used
to address the shortcomings of DTD uses name space
to allow for reuse of existing definitions. So you could Define an xsd
and you could just use it or through name spacing you
can have it within other pieces of xml's as well. So, let's see. What is GT D PT d stands
for document type definition. DTD is used to define structure
of an XML document or DTD defines the legal
elements of an XML document as we spoke. It defines legal elements, or which cannot be Accepted so basically you define what your
XML is all about through DTD so you could see
a student DTD here. So you have XML which is nothing but
which has student which has first name
last name email and marks. All right. This is what you have
within your XML. Now you define a DTD which could be put
into your doctype. So the first tag that you see is
nothing but declaration and it's linking your kind
of tying it against a DTD with that's defined
external DTD file. All right, you define this and you have a DTD file
below which is student dot DT D. And here you can see
that it says that within student
element you can have for other elements or as
a nesting of for other elements, which is first name
last name email and marks. All right, if you since this DTD is linked with
your document or with your ex. Mel document now if we try to add something
if you have one more element here which could be
like a dress right? If you have one
more element here, which is address. It would throw you an error
because your ETD says that student can have only
first name last name email and marks address is not a valid
element within student. All right. First name now, let's define. What can we have in first name? Alright. So first name is nothing
but character data again. Last name is a character
data email is again a string and Marx is again taken as
character sort of so this is how we Define DTD. Alright, so we are trying
to establish the structure or we are trying to say that student can have
a nice one so fields and if there's something
else then it's invalid. So here we can see
ETD contains root element and declare the child
elements we can see That it says student can have
only first name last name and email and marks. It defines last
name child element and data from this element
is possible right when it is PC data. It's possible again
you have first name, which is possible
you have last name, which is possible
you have email address which is possible
and you have marks which is possible. All right. So what is XML schema XML schema
is used to express constraints about XML document. All right, it's pretty much
it does the same purpose as DTD but it's much more
advanced than DTV. It has much more features
XML provides more control on XML structure a well-formed XML document
can be validated against xsd. So you have an xsd
again similar to DT which defines the structure and a well-formed XML
should be validated or should be Against
a particular axis T. So here we see an xsd, which is much more verbose or which is much more clearer to understand compared
to DT DT D was something like was not expressing
to that extent but X is T is pretty clear in terms of what
the content could be. Again. It defines the root node
and declare the child elements. So here you can see that exists is defined
in a form of XML itself. All right, it follows
the same pattern as the XML. So it says element
which is a keyword. All right element is
a keyword for your xsd and you have student
as a attribute. So this you could realize xsd
as I said as an XML itself, it's a valid XML cracker, which says that you have
an element with name student now what can students
hold is again a sequence when you say sequence it has
to The same sequence break the sequence it's again
going to be invalid then it says first element first child element within
student should be first name. The next one to follow
should be last name. The next one should be email and the last one
should be marks. All right, and it
defines what type is particular elements hold. So first name is a string. Last name is a string. You may raise a string
and Marx is a string as well. So this is how it is you define
a structure to the XML and you have to ensure
for your XML to be valid. It has to be valid against this exists e it's a
similar scheme are descriptive. So what's the difference
between DTD and Xs T DT v stands for document type
definition XS d stands for XML schema definition. DTD is not extensible
access T is X Zebra dpv provides less control on XML structure xsd provides
more control on XML structure. ETD does not support data types
xsd supports data type. We sort the data types
like string and stuff which is like it supported just in exist. You don't have DTD supporting and DTD does not define
the order of child elements as we could see it just says that you could have
four elements within but it doesn't have any specific
order as such whereas when it comes to xsd. You could Define
a sequence right as we saw in the previous example, we said that the first one
should be the first name, then the last name then
email ID and then marks so you could Define the sequence in which your sub elements
should occur XML CSS file CSS is used to add more tiles
to the XML document. So if you want to color
coded or do something that's when You CSS pretty much
similar to HTML document. So here we can see
that you could Define student which has got
a background color of pink. Then you have first name, which has different
font sizes here. First name last name
and email ID and marks which has got
different font sizes. So we want to have font size
of 25 for this child elements. You want to display it
as a block and color as white and the margin
left as 50 pixels. All right, when you have such thing defined
if you want to link it up if you want to link CSS to XML, you need to have
a XML stylesheet tag defined and you would type
as text or css and you put H ref as your CSS name to make
the changes in the styles of the XML file CSS file
is linked to XML file through this statement. So this is how you link
your CSS file to your XML file. Now. What is XS L XS L stands for extensible stylesheet
language XSL navigates all the nodes and elements and display
XML data in a particular format. All right, it's basically for parsing sort of it navigates
through all the nodes and elements queries
can be specified in XSL. If you want to query
some particular data or like we had message
this thing in a couple of slides back. We saw multiple messages
within message, right? So if you want to read some
messages extract the messages that are sent by the users you could wear it out using
excessive it displays data on the browser as per the format given
in the Excel file. So, let's see what is
accessible file all about. Okay. So here what you're
doing is nothing but you're extracting data. All right, you are. Acting first name. So the first name here
would be taken from your student and would be displayed here. And again the second one you have last name you select
the last name particularly. This is acting
upon student dot XML. All right, how do you link up accessible to XML is
pretty much similar to CSS. You have style sheet
and you have type as text / XSL and not CSS, right and you have H ref
as student accessor. So that's 4X s l--
and again, let's see. What's the difference
between CSS and Xs L fi CSS files
are easy to understand Excel files are difficult to
understand CSS is less powerful than accessible CSS is
specifically for display right changing the font size changing
the colors background colors and foreground color
and everything XSL is more. Full then CSS since you can extract
data or do something with it. Basically, it's a processor. You actually can process
the XML using Excel CSS does not use XML notations
Excel uses XML notations, which helps in writing code. CSS can be read by
modern web browsers XSL is not supported by
many web browsers. Now, let's talk
about XML parsers. Okay. So XML parser is nothing
but you parse through you have an XML and you want
to read data from it or XML parsers could be used
for writing the XML as well. Okay, creating an XML
could create an XML using XML parsers as well or you could read
through the existing xml's. So an XML parser is
a software Library which provides client
applications to work with XML document
and XML parser is used to check whether the Comment is
in well format or not. It is basically used for compiling our parsing
your XML as well. It is used to validate
an XML document and parsing XML refers to going through XML document
to access data or to modify data in one
or the other way. All right, you could actually
read through the xml's or you could extract data or you could modify
data using XML parsers. What a bar says here. You could see XML document
right being sent to the parser parser is
nothing but API so you send the XML The Source XML or the XML
that you are trying to pass is going to be sent
to the XML parser and this API is going to be used by client application
right to parse the XML files. So XML parsing could
be broadly classified into two different types
one is object-based and one is event-based right
object-based is nothing but document object model
or it is also known as Dom even base. We have two different parses when it comes to even
based one is sacks and the other one is tax. All right, so let's talk about
object based model Dom parser. It stands for
document object model. It is an object-oriented representation of
an XML parser tree. So remember we assign XML and we passed it
into a tree like structure where in your root node
of the tree was the root element from your XML and we had all the elements and at the end the leaves
were nothing but the values or the data that the XML stores
actual values right or XML stores or care. Rather, so that's
what trees all about. It defines the standard way
to access and manipulate documents Dom is a common way
for traversing the tree. So as we look
through the examples, you should get Fair idea about it creating an XML
document using Dom parser. So what is required
to use Dom parsers? How do we do that? First is you have
to import all the parsers. You have to import
all the classes that you have
within partial Java x dot XML dot parsers. These are all input statements
that you have. You have to import
different packages which when you use
IntelliJ or Eclipse, it would prompt you to import it it would suggest
you to import it. So you did not actually
write this input statements, but it's very important to understand what we
are trying to do here. So these are different packages
that we are trying to import and as you could see
all your XML related classes. Are put into Java x dot XML dot transform
or basically G of x dot XML package. So once you import it, you can start using the classes
within the first thing that you do is
when you generate an XML, you have document
Builder Factory, so you have document build
a factory dot new instance. You create a new instance of it and you get document build
a factory that's instance of it. So now with the document
Builder Factory instance that you got you would create
a new document Builder Okay. So this is
a factory design pattern. We have a design pattern in Java and document Builder factor
is nothing but it's following a factory design pattern, right? You don't have to
think much about it. But basically what we
are trying to do is instead of creating the instance
of something on our own which is like we usually do with new
and the class name, right? Sort of doing it on our own
Factory design pattern is nothing but the creation logic
is written within a class which is not exposed to you. So you need not create
it there's some class which creates instance for you. All right, and that is nothing but a factory class then you
create a document Builder. So it's nothing but F dot
new document Builder. Okay, you handle exceptions
and everything here. So now let's start with creating
the actual document. You have the root
element as students. All right, and within student you have
student within students you create student and within student you have
like first name last name email and marks and you could see
first name put as Henry. So how do you create
element is nothing but using dog create element, how do you create
X node or text node or the actual value
that you have? Then your element you would do
it with create text node, and you could Nest
it using appendchild. So basically you have
first name appended to T1, which is nothing
but this one right T1 is appended to the first name
first name element that you have T2, which is the text node,
which is holding. The last name is appended to the last name element p 3
is appended to email element and the for which is your marks which is appended
to Mark's element. So basically this is
how you make nesting of your nesting
within the xml's. Alright. So once you create this document
you append all the child's and everything you create
a well-formed document here. Are you create an XML
here and all the XML that you would get
is within this dog, since we are creating element
you could see here we are. Getting elements within doc
creating elements and text node and everything within dog. So at the end once you
have all this done, you would have a well-defined
XML stored as a form of document class. So we want to print
this particular document in a text format, right which could
be readable by us or do you want an XML out of it? So that's when
we use Transformer. So there is a transform
Factory dot again since it's a factory design pattern. It's exposing a method which is nothing
but new instance. So you create a new instance
of Transformer factory and you create
a new Transformer. So at then what you get is
nothing but a Transformer and what are we trying
to transform is nothing but we are trying
to transform the object or the document object
that we created. We are trying to transform it
into a human-readable text file or the XML file all So that's a transformation
that we are trying to do here. So here you could see that you transform
it TDOT transform and you pass the document object that you created and put
the element into element and text notes and everything into which
is holding a valid XML. You are trying to transform
it into a XML file. So how you do
that is T dot transform. Then you have the new Dom source and you specify
the instance of document which holds your XML then
you have stream result and new stream result class which takes file output stream
as its parameter. So you have to pass
the parameter where you want to write this XML to and
when you run this at the end, we are just printing
that XML file is been generated. The first thing that we do
is we are creating a document and using the document. We are creating elements
the wave that we want. So in this case, We have a students
as the root node and within student
you have student and within student
you have first name last name email ID
and marks, right? We created this
structure till here. And as you could imagine
this is just dealt in the form of object. Right which is stored in dog. So now since you want
to write it into a file, which is into a human-readable
form or which could be passed across Network. You have to transform
this into XML file, which could be read. So that's what we do
here through Transformer. We are transforming
your document or the XML which is in the form
of document into a file. So, let's see this program. In the meanwhile,
we can do one thing. I will create one
more directory here. At Eureka XML. Okay, and we don't have
any files with them. Yeah, let's hold
on for a minute. Yeah, I just come up. All right, so it's the same
program that we spoke about. So I have loaded into my ID. So we do the same steps here. We create all the elements all
the required elements and stuff. So we are writing it
into a file right so you could have
your own file here, whatever file you
want to write into. okay, so I right
into the directory that we created
which is nothing but Ed Eureka XML we
are writing the XML file there. All right, let me
execute this program. It's building it and if it's generated you should get
XML file generated at the end. So this is about using Dom. All right. So when you say Dom it's nothing
but document object model its building it. So hold on for a minute. In that see I think it
should come up soon. Right. I think it's coming up. Alright, so we have
this program here, which is kind
of creating XML document. This is same as
what we spoke in the slide. Right what I walked you through. So basically you have
students you're creating students elements
within students element you are going to have student and then first name
last name email and marks. Alright, we are going
to create a text node within this elements. So this is nothing
but your first name, which would go into
the first name element. This is the last name which would go into
the last name element that we created earlier. Then we have email and marks going
into a prospective element. Alright. So basically we are nesting
it here at the end. We have the Transformer which is kind of taking
the document and converting it into XML file that we want. So let me go and delete this
off and run the program. In this folder,
we don't have any file right I run this program from here. So you could see
that it says XML file generated. All right. So let's go to the folder
and see up there is a file that's generated that is
student studying similar. Now I can open this with any tool say
I open it with notepad and I see something
like this right now. I want to format this
I want to format this into because this is
like one single string, which is Big right? So if I want to format it, we have tools
that are online, even you could format
it online, right? So I put this and I say
I want like three spaces or indent level which is good and I formatted okay when I click the format. You can see that it formatted
the entire XML for me. So the basic thing that it's doing is just
about formatting this XML. All right, this is much more
readable right after formatting. You can see that it's readable can see
first name as Henry Lee and Henry 123 at gmail.com
and you have 70 put in here, which is what we expect out. Okay. So we saw this output after
running the program Now quickly. Let me run through
what's Dom parser and how do we use Dom parser
for parsing and existing XML? All right. So these are the classes
that you need to import which would be suggested
by your IDE as well either IntelliJ or Eclipse. So you have document Builder
Factory you use the same thing get the new instance
from the factory where in you get an instance of document Builder Factory with
this you create document Builder and once you have the document
Builder you parse it Boca parse method The document Builder and pass
the XML file name, right? So whatever XML you want to pass
you would send it across now. Once you have this past
if you want to get the node name if you want to display something
like what's the root element within your XML you
could do something like this talk dot get document
element and get no name. So this would basically
display the first element that you have within your XML, which is nothing
but the root element right you could read this on the name. You have the tag names
or element name. So you have methods like get Elements by tag name and you could give
the name of the element and it would retrieve
it as a node list. Now, you will have to I trait through this node list
to display the contents of it. All right. So here what you do is
you I trade through it. So when you get a node list, basically you would
get list of notes. All right. So now what we are doing is we
are printing it out one by one. Printing the nodes
are the contents that we have within one by one. So in this case, you can see that when you
do student dot get Elements by tag names and you
can see student here. So this would give
the number of student that you have within a document
the previous example that we took the number of element is just one right we
just had entry for one student. So it would I try it. Just once in this case it would
I try it just once all right. And what we are doing here
is we are kind of taking again element by tag name and these are nothing
but your actual values or the first name
last name email and marks this Loop
is going to run just once since we have only one student and this is how you display
the content of an XML. So basically what we
are doing is we are parsing it when we say parse we
are trying to get data or we have trying to load data
into Dom or document. And we are printing it out. Why do we have parsers is
nothing but to retrieve data if you want to query
out particular data, you could do it. You could write some logic
to read out a particular data from an XML. Say for example, you might have a long XML
and you want to read data pertaining to student Henry. So what you could do
here is you could write some logic here saying that if student is equal to Henry then written
mock secured by Henry. So that's why we have
XML parsers in picture to have it loaded into memory
and play around with it. Alright, so let's see the example of XML reading
using Dom I give the path here as see Give the same file. All right at Eureka XML. Student dot XML that we created
or let me do one thing. So I create one
more student here. Say for example. Just for Simplicity purposes. I'm just putting test last name
as the last name test email and I put test Mouse. All right. So these are the values that I have put
for one more student that I've created or maybe I will put this one
as Just to be consistent. So we have two students now
within so first one is Henry D. And the other one is like we have created
a test to let me show you when we run this program. What we are trying to do is
we are going to read this XML that we have created
and it's going to parse it parsing is nothing but it's going to display
the contents of it. So it's going to Loop through its going to understand
there are two students within and it's going to display
first name last name email and mock secured
by each student. All right. It says the
processing instruction. Okay, we can see the output
being displayed here. All right, so we can see two students here the current
element and really calm and re 1 2 3 gmail.com and 70
and there is one more student that we added directly
into the XML and we can see it displayed as well
saying that test first name, press last name test email
and test marks. So that's how we bars it. Okay using Dom parser and
what Dom parser does is nothing but it creates a tree if you remember I said
it creates a tree like model that was there
in one of the slides that we discussed earlier. It creates a tree-like structure with a root element
as your root node, and your leaves are
nothing but this values Henry Lee and all this stuff
whatever is been displayed here or nothing but leaves so
of your tree advantages and disadvantages of using
Dom it is preferred when we have to randomly
access separate parts of the document. So if you don't want to do
it sequentially its preferred that you use Dom it supports
both read and write operation. So we created XML using Dom and we read XML
using Dom as well. So the first example that
we took about creating student dot XML was using Dom
as well since it was document. Remember we created
object of document and then we inserted
all the elements within that is nothing but Dom it supports both read
and write operation as we saw and what are
the disadvantages of using it. It is slower than other parsers
since it has to create free. So it's a one time activity
that it does. So remember in
the second example that we took we saw parse here, right the sparse here document Builder dot parse this
is going to take lot of time because it's going
to create a tree if you XML is big enough
based on the size of the XML it would take time because it's going
to create tree. Parsa's something that is going to take time and
it's not very memory efficient since you could imagine
if you have a big XML so xml's in general are like it could have like
a hundred million records within they are humongous. They are not small examples
that we are dealing right now. It's coming from
different systems, right? So you could imagine
their system pushing data in the form of XML and sending it to some other
system to process it. So it could be humongous
could grow up to like a hundred million records
or something of that sort. So imagine that you want to load
all this into memory, right? I'm create a tree. So this parse method is going
to take a long time to create a tree and the other thing
is it's not memory efficient because it's going to load
this entire document into your memory, right which is going to take like lot of achebe's
of memory right to load it. So it's not pretty
memory efficient when it comes to parsing using Tom. So that's the reason
we have other variants of parsing which is
not document object model, which is basically event-based. So we have like two parses
even base parser one is like for push parsing it is sacks and whereas for will
parsing it is Stacks. All right, so we'll just go through what is sax parser and
sax parser sax parser is nothing but it stands for simple API for
XML sax parser reads XML file. Sequentially. It's an event-based right? So when I say even
based what happens is when a parsing event occurs, the parser invoke
the corresponding method of a corresponding Handler. So basically you define
a Handler you say that if I get so and so tag or if I get start of element tag go
to this particular Handler. All right, and this handlers are nothing
but user-defined handlers so you could say that Not get
a start of element tag. Go to this Handler
and do something, right? It could be as simple as printing it or it could be
as simple as filtering it. So it's up to you to write
the logic for the Handler but what the framework
does is nothing, but when you see a opening tag, it would give a call
to your method. Alright you Handler
method sax parser is used when we have
a large XML document. As I said in the previous
example of you know hundred thousand records that you have within
XML file document object model is not that efficient because it's going to load
everything into the memory which is going to take a lot
of time as well as memory, which is going to consume
a lot of memory. So it's not good in terms
of time and space complexity. Whereas Sachs does a good job
when it comes to large xml's when it comes
to parsing large xml's because it's not storing or it's not parsing everything
into a object in one go. It's an event. Just so basically you would see that it sequentially goes
through the XML and as and when it sees
something right start of element start of an attribute
or anything of that sort. It would give a call to Handler
and Handler would process it. So basically it's
not storing anything. It's not retaining
any information into memory. It is just calling
the event handler and just leaving it right there. So since it's
not consuming memory, it's good when it comes
to large xml's but it's not good for random search
right random parsing because it goes sequentially so
for sax parser again, you could see the files present in Java x dot XML dot parses
dot sax parser earlier, it was document and here
it's sax parser again. You could have
this Imports done by your ID. This is what you
event handler is all about. Right? So you are defining
a an event handler here, which is nothing
but a default Handler so Your XML reader
using Sachs is nothing but a default Handler
is a relationship is a default Handler you extended
your extending default Handler, which is maybe an internal
interface to your sax parser. Once you extend it. It's not an interface or it since it's extending
it has to be class. All right, it's a class. So the default parser
or the default Handler would have this methods
within which is nothing but start element you have characters you have end
element and end document. So these are the methods
within right when you give a big XML in this example
or when I say this one, so when it comes to student, which is your root node, it would go to start document
when it reads this XML. It understands that it's
a start of document. So it says document begins here. It would go sequentially
this parser what it would do. Is it would read
this entire file and it would go sequentially when I say sequentially
then it would understand that there is an element again and it would give a call
to start element and here what you could do is
you could print it. So what we are doing
here is nothing but we are printing the XML
document using sax parser. All right, which is event-based
whenever a particular event occurs in your XML. It would give a call
to the particular Handler. So whenever there is a start of
document in this case a student is a start of element again, which would go
into start element. All right, when does it come
into characters is nothing but when it encounters Henry
when it encounters Henry, it would go into characters. All right, you see
a character's method here. It would go into characters
and you can see that it's a character array. Alright, so here it would print the entire array
which is nothing but the value. Lou Henry and all
this Leaf nodes. All right, Henry Lee
and whatever values that you have would be printed
by this characters method whereas the tag names would be
printed by your start element and end element. This would be your end element. All right. So this is pretty much
like it's an event-driven one, whenever it encounters
something framework gives a call to a particular method and this method is user defined you could do whatever
you want to so this is how you create a instance of it. So you have sax parser
Factory dot new instance dot new sax parser. You create the instance
of sax parser. Now you parse it P dot parse and you provide the Handler
as well then let that you have provided which is nothing
but XML reader using sacks. That's your Handler. So you have to create
the instance of it and pass it over. Let's see this program now also you could see it is reading
students dot XML, right? So I'll have to change
this name to see. Ed Eureka XML All right. So let's run this program which is the same program that
I spoke about in the slide, which is even based you
could see methods implemented here and you could see
it extending default Handler. All right. So there's a default
Handler this start document basically start document and everything is coming
from your default Handler. All right, and in
the start element, we are just printing
It characters and again when it comes to end
we are ending it and when it comes to end of the document we
are just printing saying that document ends here. Alright, so we are reading
the same student file and this time it's using sacks. So you can see here when it encountered
start of the document. It printed document begins here. Then you could see
elements printed sequentially. So this is what it is. This is like event-driven right
and at the end when it reaches the end of the document you
can see document and C are being printed out. So basically this is as I said even driven
and this is sequential, right it goes line by line. So if you say you have like
a hundred thousand records within your XML and
say the last entry that you are searching for it's going to go through the entire XML delete
encounters the last any when it comes
to random search or if you want to search randomly if it's not well suited
but when it comes to Big XML, it's much better than Tom
since it's not loading anything. So it's not keeping
anything into the memory. It's just parsing it
it just printing it out and it leaves it right there. So what are the advantages
of Sacks, it is simple. It is memory efficient. Sax parser is faster
than any other parser. It handles large document. We spoke about all this right
here disadvantages of using is land will be unable to
understand the whole information because data is
broken into pieces. So it's not storing
it in one place. It's broken into pieces. It's not even storing it into
memory just flushing it off. It's just writing it
and leaving it. So what's the difference between
Dom and sax parser Dom stands for document object model Sixth and four simple API
for XML Dom reads. The entire document sacks
reads node by node, which we saw sequential. It would go Dom is useful when reading small to
medium-sized xml's Sachs is used when big XML files
need to be parsed. Sax is good for big
and this one Dom is used for Two medium sized Dom
is tree-based parser. We saw it creates a tree
and sax is event-based far sir. We saw how it has
event handler and you saw that it calls a particular
method based on the event that it encounters Tom is little
slow as compared to Saks and because it has to create
the entire tree and sax is faster than Dom once the tree is created. I think Tom would retrieve
it much faster than sacks. But the tree creation
itself takes longer time, right when you parse it. It has to create
a document model which takes a lot
of time Dom can insert and delete nodes since it has entire
tree it pre-loaded. You could actually go and delete it you have
the entire tree loaded so you can Traverse
to any particular node and delete a particular node or delete a part
of a tree itself, which means that you could do
insertions and deletions whereas sack Doesn't store anything in memory
just reads there and just pushes it off. So you cannot insert or delete nodes
into your Source XML. So basically it's meant
for just doing something or retrieving information
from your XML. It cannot manipulate
the source XML sax parser is cannot manipulate the source
XML now we have one more which is Stacks. So in terms of sacks, if you imagine sex,
it's a push API. All right, when I say push API it's nothing
but it reads through scans through the XML and
when it encounters an event, it pushes the Handler
to handle it. So there's a push from your API to the handler
do perform some actions whereas Stacks it's a cool API, lets go through it
to understand more stack stands for Java streaming API for XML sax parser
pulls the required data from the XML this Sax parser maintains a cursor
at the current position in the document allows
to extract the content available at the cursor. So basically it
maintains the cursor at the current position
in the document which allows it to extract
the content available at the cursor again, you could see Java x
dot XML dot stream in the first one the Dom we
had document the second one. We had sacks. Now the third one
you could see stream. So that's the beauty of packages you could understand
what files are there with them? Okay. So using Stacks
you could see here. We create an event handler
XML element Factory dot create XML event handler
and new file reader. So you pass a new file reader and it's nothing
but the XML file that you want to pass. Now, you could see
that you get all the elements. So basically you have
even Trader and you get the elements of front or you get all the events
that you have. Then and XML. All right and UI
thread through it. Now you have a switch statement which would do
the processing for you which would say, for example, you have
a start element similar to how we saw in the sax parser. So you have a start element and if it's a start element
and even would be passed and you could actually
get the element value. So basically what we
are doing here is we are getting all the events
and we are iterating through it and we have a switch statement
which is handling the event. So instead of having
the event Handler written in a separate class. We are writing the event handler
in the same class. This is kind of
again decoupling right? So imagine yesterday. We spoke about
comparable and comparator. So comparable was like
compareto method was written within your class right
within your model class, which was student yesterday. All right. And again, we had
other example of comparator which had a compare method which was Into student objects
as an argument. So that's the difference. Right? So we are decoupling it. We are writing
the entire comparison logic to a different class so we can
we can imagine the same here. So that's what the difference
between Stacks and stacks is Stacks is writing it
within the same class. Whereas sacks you
have a separate class for event handling so you could
see here pretty much similar to how we did in the sacks so you can have like if it's a character
then you have even - characters you print
the characters when you encounter and document you have event as in document and so on basically
you get all the events and you I trade through it and you have switched
treatment handling the event. All right, so I
take this example. So the first thing that I'll have to do
is change the file name. Ed Eureka XML and I
just run through it. Alright, so here we can see
start element student. You have first element as Henry
and so and so forth again, first name Henry and stuff
like that again. You can see the same second
student being parsed as well which was a dummy student that we inserted and at the end you will see end
of the element student. Alright, so this is how we parse using
three different parsers and we saw about advantages and disadvantages and which one
would be apt one per your use. All right. So you have to understand
the nature of the application or nature of the XML is that you are dealing
with and based on that you could decide
which parser to go for so that's about the parsers. Now, let's talk about XPath XPath expression is
a query language used to select path of XML document
based on the query string. You can create a query string and you can retrieve Wait using
X bar X power threatens a node set representing XML nodes
at the end of the path red. So this is basically
like wearing language or you have X path expression, which you could write
query in this example. If I want to get first name of
a student with so-and-so marks if I want to get
a first name of student with 80% marks, right? I could do that using XPath. So basically it's
for querying right and it returns a node
representing the XML nodes at the end of the path. It is used to Traverse
elements and attributes of an XML document
XPath defines the structure and provides XPath expression. So the 7 type of nodes that can be output
of the execution of XPath expression is root element text attribute
comment processing instructions and namespace. We'll take a look at it
expert defines a pattern or path expression
to select nodes or node sets in XML document what I expect Expressions
you have node name, which is used
to select all nodes with the given node name you
define a particular node name and you could select all
the nodes within an XML document that has named as node name. So it could be either element. It could be
attribute or anything, but it could be just
element named rather. It specifies that selection
starts from the root node. If you have 1/4, it says that it starts
from the root node. It specifies that the selection
starts from the current node that match the selection. All right, so / scans the entire document / /
is nothing but the current node dot it is again select
the current node. So whatever node you
are at during parsing, it would print it out
dot dot is parent node. And at the rate is
it selects attributes. So if you want to carry
out certain attributes like at the rate ID is equal to 10 say the employee IDs
been stored as an attribute and if you want to have employee ID with value hundred
you could query out saying that at the rate ID is equal to hundred steps
to use XPath again. You have expert
related packages. You have to import you have
to create document filter. You have to create
an XPath object and XPath path expression
create a document from a file or a stream. So basically when you
are creating document is nothing but it's
a dom-based parser. Oh, basically it's
not well suited for big xml's for small or medium-sized XML. It's good enough because it's creating document
out of your XML then fourth create an XPath object
and an XPath expression. Let's do you have to create
object and you have to pass the expression that you want
to retrieve compile the XPath expression first, you have to ensure that the XPath expression that you have provided is up
to the mark and it doesn't have any error and you're
following the contract that XPath expression has
I'd rate over the list of nodes. Once you get the result
of the XPath expression you have to I'd read
through the list of nodes, which is nothing but the result
and examine attributes and examine sub-elements, right? That's a typical way
in which you would use XPath so you could see here. It's again Java x
dot XML dot X path. There is a separate
package for it and it will have all
the classes related to it like expat Factory
you have constants and you have like exception and you have expert
class itself here. We are again parsing
students XML we pass it into Document first as we mentioned the steps
that we spoke about we create the document and then you apply the XPath
you have expression here / class / student. All right, and then you
compile this expression what you expression you have here you compile it
and you then evaluate it so evaluation is nothing
but you are retreating to the result and you
are printing out the result that you got
to broadly classify. What we are doing here is we
are creating a document object out of the XML file
and the next step that we do is we
compiled the expression and then we are evaluating it evaluation is nothing but doing
something with the result. There are a couple
of checked exceptions that you will have to take care
of so you could see that it's been handled here. It's not specifically handling. It is just printing
out the stack Trace. So let me quickly. The take this example. Alright, so from here
go to resources. So let me go
to documents downloads. And it's let me run
through the same example and see if it runs. Alright, so we have I take the same example c letter c
at Eureka XML Okay, so, let's see if it runs. It in fine dot txt size
change this to XML. Okay, let's try to run. So what I am doing here
is pretty much passing this XML and then reading it through. So basically just to again tell you I love to see why
it's not running at this point, but it's more about you
just created document model. You have your XPath set or you have the XPath
expression you compile it and then you evaluate it
which is nothing but whatever results you get. You can do something on it. All right, let me move
on to the next slide. Dom4j is open source, Java based library to parse
XML document dom4j is flexible and memory efficient. It integrates. Well with Tom Sachs apis, it should be used
when you need the information in an XML document
more than once. So basically with sacks if you want to pass
through more than once if you want the information
from the same XML more than once it's not that efficient because it will have
to parse it again. So it doesn't store anything. It has to go through it again. Whereas this one is something that integrates well
with dom and sax apis, which allow developers
to use the information in an XML document
more than once. So what are the steps? So basically you have
to download this dom4j dot jar from the website
or from the GitHub. So there's a GitHub mentioned
above so you'll have to go and download the latest
version from there. So once you have that Library, this is a common thing
that you do in Java. You download a jar file. You can go and download
any particular jar file that you opt for
when I say jar file. It's nothing but the third
party Java archive, which is nothing but
it's a group of classes together doing something. You can download any jar
into a specific directory and you can add it
into your application. There could be a third
party say for example, I want to add
two numbers or say, for example, you want to do
some big data processing a Java by itself doesn't have a big data processing
library or framework. So what it would do
is Big Data framework will have a jar file exposed. Right which is z for example
Apache Apache is a provider which is providing solution
for big data, right? So you would have the libraries or you would have
everything coded into a jar file for big data processing now
you need to import that jar file into Are you need to link
up your application to that particular jar file to leverage big data
processing in application. So in that typical scenario, what you do is you would have
this jar files downloaded into your local directory and have you could add
those external jar files or this is how you link
to your applications. All right. So you go to Java you right
click on your application go to build path. Then you click
on Java build path here. And then there's a button
here to the right which is ADD external jars. You would have a jar file
in this case dom4j 2.1 dot o you have
this jar files here. Now you link up
to your application and you click on that and you click on open that would add
the jar file to your application and you can apply and close. So now you could leverage
that particular jar file or the functionality that is exposed by the jar file
into your application. All right, in this case, it was dom4j introduction
to Jack's be Jack's b stands for Java architecture
for XML binding. It's a specification. Actually Jack's be is used
to write Java objects into XML and vice versa. All right, so you
could write it or read it. What are the features
of Jack speed supports for all w3c schema features read all the standard w3c standard
and all the features that you have in w3c. It has a support for it. It reduces a lot of generated
schema derived classes. It cut Downs rather on the generated classes scheme
are derived classes small runtime libraries
in terms of size. It's pretty lightweight it provides additional
validation support by jxp, 1.3 validation API. It steps to convert Java object into XML create a pojo
or bind the scheme. And generate the classes. So basically Jags B is nothing
but from the schema, you can create your class. All right, if you schema says
like remember we had an excess T wherein we saw that it was like an XML
which you could read through like you could have the schema if you remember we had
a student schema wherein we declared
this is what the format of XML would be you could have the name you would have
student as a starting tag. We defined the sequence as well. Like first name should
be first then last name then email address
and then marks right? We Define the sequence as well. So that is nothing but
that's a schema. That is XS T. So when use Jack's be
what you do is from the schema, you can create Java classes. So basically schema is nothing
but schema tells this is what an XML can contain
and from schema. You can have
Java classes created so there would be a Java class by the name student and within
student there would be spring so We had the data type
Putin in the exist as well. Like first name would be string last name
would be string and stuff. There's a mapping
between this data type and Java data type. What it would do is nothing but it would create
all these properties or all the properties that you have all
the elements of elements that you have within student. There would be
a corresponding property created in a Java class. So basically this Java class could be thought of as
a container for your XML, right you could parse them
into this Java class and that's where Jack's
be comes into picture. It's a binding it binds your XML
into this Java classes. All right. So create Jack's be
context object the so the next step is to create
Jack's be context object. Then create the
Marshal ER objects. You have to
Marshal and unmarshal. So in this case, since we are going to do
from pocho into XML, it's going to
be Marshall method. All right. Create the content free
by using set methods. All right, whatever. You want to set your going
to set it into Java object. So unlike earlier
in the Dom example that we took we were
actually creating the tree. If you remember weapon child
and stuff like that, which makes it very difficult
to understand right which is difficult to maintain
and if you miss something it's cumbersome to
actually maintain it. Now, you have a student class
wherein you just have to set into the student class. All right, so create the content
free by using set methods and then call the Marshal method
to convert this class into an XML. We have a student class
and within student class. We would have all
the properties created which is derived
from your schema class from your schema xsd or rather scheming
existing mean the same and what you are doing here is you are going to set
it in to set values that you want in the XML in. The instance variables
in this class student and we are going to Marshall
it to convert this into XML. So basically rather
than creating XML on your own what you are doing
here is you're using the Marshall method to do it. So once you Marshall it, you should be able
to get the XML. So let's understand Jason. Jason is nothing
but JavaScript object notation. We will look at the format
of it very soon. It is easy to read and write
than XML XML is bit cumbersome when it comes to reading and writing and it takes
occupies lot of memory as well. Jason is language-independent
similar to XML. It's language independent. It is lightweight
compared to XML and which is nothing
but lightweight data interchange format XML is a data
interchange format as well. And Jason is pretty much like the same used
for data interchange. The medium of communication
between two different systems Jason supports arrays of objects
strings numbers and values. So most of the rest API
is restful apis, which is nothing but
a web service built upon HTTP. Mostly they use Json
for communication between client and rest API systems. So this is because it's pretty lightweight
and it's lighter compared to XML and as you could imagine since it is across networks since communication is
happening across networks. You need to have
lightweight system or lightweight medium or else it would occupy
lot of the bandwidth between communication just because it is lightweight. It's preferable interchange
format difference between Json and XML Json stands for JavaScript object
notation XML stands for extensible markup language. Jason is simple to read and write XML is
difficult to Then rate so we have been looking
at the examples which were not pretty straightforward. Right? We had a lot
of code to be put in so it is difficult to read and write Jason is data-oriented
XML is document-oriented. Jason is less secure
than XML XML is more secure than Jason Jason supports only
text and number data type XML supports many data type as text number images
charts graphs Etc. Alright, so it has restriction
with the number of data types that can hold Json object
holds key value pair. We took example of student
earlier the form of XML, right? We're in new head. First name last name and marks. This is the same example,
but in Jason, so here you could see opening
brace and closing brace and you could see
student is a key and followed by colon and again, There's opening brace
and closing brace for student which means it is saying that student is object
if you have value as which starts
with opening brace, which means that the object
the second one is as you get deep into this particular object wherein
you see first name, right? First name is the key
and you see a literal which is Henry as object
as the value rather and as you can see here I
Henry is not object. That's why you don't have
it within braces, which means it's
a literal value. Alright again, you have
last name and D'Souza which is a literal value
you have marks and 50, which is a literal value just
to summarize whenever you have: to the left side of the colon is nothing but the key
the right side it's a value and if you have a value
starting with coats, which means that it's
objects a complex object or you have multiple things with So in this case, you could see
that within object. You have like three things put
in like first name last name and marks basically
student can be mapped to some object in Java which will have first name
last name and mouse. So each key is represented
as string in Jason and key is always string in Jason and the value can be of any type Json array
represents order list of values. It is always ordered. Json array can store string
number Boolean or objects. It can have string it can hold
number it can hold Boolean or any other object as well. So here you can see the first example is array
representing days of a week and you could see Monday
Tuesday Wednesday, Thursday, Friday Saturday and Sunday put
in there, right you could see another example is students and within students
you could see it. Students is nothing
but array of student and each student has
first name last name email. So basically this is
how you could interpret it. So students is nothing
but it's an array. So the key is to dance here. Let's see how to run it. So the first thing
that you do is Jason simple, so you can see here jar file
is already downloaded which I would be using so
we have like Jason simple. All right, so it's not there. Let me see. So whenever you want to deal
with Jason's the first thing that you would do is you have
multiple apis though, but the slides to come
we are referring to Jason simple jar. So the first thing that I would do is I
would download Jason simple jar. All right, so I go. So you could go and download
this Jason simple jar. Okay, usually nowadays. We don't do this because we have other we
need tools like mavin mavin is a build tool and you have a file XML file
wherein you provide all the jars that you want and it
would download it by itself. So it has got a repository from which it would
download all the jars. You don't have
to explicitly put it but I don't want to confuse
at this point with Maven. Let's do it this way downloading
it and then linking it. All right, so it's connecting. Basically, we are
downloading the jar, right and you could see it
has downloaded it. It's pretty small
like when dkb jar because those are
all class files. It's Java archive, which is nothing
but class file. So I take this and I
kind of unzip it. Okay, so I get
this directory here and you should be able
to see a jar file. Now. This is nothing
but an executable jar file you could see it here would see
the type as executable jar file. All right. So now I put it into
on let's for Simplicity. Let me put it here itself. All right, so I
create a new folder. Which is Ed, Eureka? Jason and I put it here. So now we'll have to link up
our application with that. So what I do. So when we had
this dom4j downloaded and linked up we'll have
to do the similar stuff for this thing as well. So since I am using IntelliJ, the steps would be
different than Eclipse. But basically what you
do is you go into let me see the option here. There's open module settings. So you go to the
open module settings and you would see something
of this sort coming up. Alright, so now I want
to add something right. Add a particular Library. So I go to libraries first. I click on add Java
and I've Traverse to the path that I put the jar file into so I put it into
Ed Eureka Jason. I select this jar file
and click on OK. So this is basically
you're trying to link your application to
a particular jar file. All right, so you
could leverage it. So here you can see
that this is jar file that will link
to your application. All right, I apply it which I already did
and I will click on OK OK, so that's how you link any executable jar
to your application. So you go to the build path
you go to this is how you do it in Eclipse. Like in IntelliJ. I
did module settings where as in Eclipse. You would go to the build path. You would go
to the add external jars and you would select the path
and then apply and close. So this is how you do
it in Eclipse. So encoding Jason in Java, how do we encode
Jason in Java? How do we write a Jason? How do we actually
create Jason in Java? All right. So I had to comment this
earlier now I uncomment this so there was some
are earlier now. Let me try to resolving it. Okay, it's taking So it's asking
me which Java class to resolve. So there is a Json object class. We'll have to see so
let me select this one. So I have a Json file. So similarly, I would prefer
just to keep best practices. I would say. Json object and this is like private method
the return type is Json object and I say create Jason. Andre and I would prefer
to put this here rather than in main method that's one of the best
practices by the way, it's not something
that you have to do. But as I said, I prefer to write something like
this give a meaningful name. Something like this. So I'm just iterating
through this so that you get to understand. What are the best practices
it's not mandatory. So I say student. Jason then I say student. So this is to make it
more readable tomorrow if I come and look at it. I would be able
to understand and maybe as I said there would be
many other developers who would be looking
at the same code that you have written in order for them to understand and to
increase the maintainability and reusability Factor as well. It's better to write like this. Alright, and then I
could even say private void. Bring Jason. And I take the Json object. You have a print method which is taking
Json object and say I call it as Jason because it
could be any generic Jason and I print it out saying Jason. All right. So you have new Json encode
a Creator instance of it and I create Jason
now this Json object. Which is nothing
but student Jason. It's going to be here
and I'm going to call new. Json encode dot print Jason and I'm going to pass
the student Jason here. So we have created a Json here
with first name last name and email address
and we have marks as well and we are printing this Jason
there so I have run it. Let's see what it shows up. So Jason is pretty much light
weight as compared to XML as you could imagine
right XML has all this start tag in tag
and stuff like that. So when it comes to
a humongous big chunk of data, like millions of data, you're processing you
could imagine the size of Jason is size of XML would be pretty much high
as compared to Jason since Jason is just doing it
in the form of key value pair. You don't have to end it
you don't have the end tags and stuff like that
when it comes to readability. I think in terms
of readability XML could be better but
when it comes to size, this one is better. Jason is better. So machine to
machine interaction. Jason is better whereas Deputy I think XML
could be at times more readable to humans compared to Jason's. Alright, so here you
can see Jason being created. So again if I want to format
this there are online tools since this have widely become standard for data
exchange standards you have lot of tools dealing with it. All right, if I want to do
online tools itself rather if I want to do
Jason for matter, I have Jason for matter as well, which is online. And it's validating as well. If you miss something if you
don't have a empty braces, or if you don't have
a closing brace, it would give you an error, right? So if I do this, you can see that it formatted it and it has given you
to collapse and expand so you could parse through and understand more
about this Jesus. Also, it validates it. So if I remove this Cody Breeze and if I try to do it it would say
it's a invalid Jason. So if I scroll down
it shows invalid Jason since it was expecting
closing Breeze at the end. I put this braces
and it should be back up again. Be able to parse it. All right, so
that's about Jason. So what do we have next
is creating Json file. So you could write
it into a file. Basically what you
could convert it is into a string and you
could write it into a file. All right, so if I want
to write here Yeah, I want to write to file and I said Json object for right
this Json object into a file. What I would do is say I do
it using file writer and I take the file name as well. Say for example or string. It should be absolute filename. All right, so it's absolute path
of the file name. So I do F or maybe I can use it
within the file writer, right? So I create a file writer,
which is nothing but Jason. File writer since we know that it's going
to write just Jason's. All right. I create the instance of it. What does it take? So we have created
a file writer for writing. It is showing some exception. Remember we have to add
exception to throw it. Now. What I do is Json file writer. . Right I'm going
to write this thing Json object as a string. Okay, so Jason dot
to Json string. All right, I got a string and I
would write it into a file. Now. What I do is Jason
brighter dot flush. I would flush whatever
is been buffered. And last thing that I
would do is close it. So one thing to remember is
you should always close it. If you don't close it. It's going to remain open and which is going to consume
lot of your memory at the end which might become a bottleneck
for your application. So remember you whenever
you deal with file, you have to close it at the end. Now what I do is new I create
a new instance of Json encode and I kind of write to a file. Okay write this to a file and I need to provide
file path as well. So I say Ed Eureka. Jason died say Student Jason I have to handle
the exception here as well. If I want handle I can handle it or else I can choose
to throw it off. So in this case,
I have thrown it off. So you could see the program
executed successfully now. Let me go to a director Jason
and I see student Jason here. Okay, go to see I go
to a to record Jason. I just open it up and you
should be able to see students that Jason has all the fields that we have gotten
right first name marks email and this thing so yeah, we saw how to write it
into a Json file, right? So we have created a Json file and we have similar thing
like how to read it from a Json file you
have like Json parser, which is again, you need to pass
your file reader and which would pass it
into a particular Json object. So from your file, you are basically converting it
into a Json object and from Json object. You can read whatever data
you want to again give you an example you could have
private void read Json and you could have
string say absolute. Alright, so you have this now what I'm trying to do is
I'll create a new Json parser. You can see here. There's a parse method
which takes filereader. All right, so I do dot bars. All right, and you could see
there's a second method here, which is taking
reader All right. So what I do is bars new file reader file reader
is nothing but is a reader that's why you can use it there
and I give absolute path name. All right, so this
should pass your Jason. So it's asking me to import it. I am putted it. So this file not found exception that I need to handle which
I will rather throw it off. Alright, so as you
could see here, I have thrown of filed all
these other exceptional swell that I need to handle which is nothing
but IO exception which is again, I've thrown it off. Alright, so we have
Parts this o on parsing what do you get is nothing
but object You get Json as object right here. You have passed it. And you have got
Jason as object. Now. What I'm going to do is I'm
just print going to print say one of the attributes
not all since it's going to be the same. I'm going to print
the first name. So it says there's no method. Let me see. So you have this it cannot
be taken as object directly. It has to be taken
as Json object so that we could read it. All right. So this has to be typed
costed to Json object. This is basically typecasting. All right, what is typecasting is
nothing but you know what is going
to be written doubt. But from the pass
is going to be Json object so we can do it
something of this sort. All right, once you do this,
you can get based on the key. So I give first name key. Let me print
the last name as well. All right, and let
me print the email as well to for convenience. So basically we are going
to read from this so its first name last name and email as we can see
first name is lowercase. So this would give an error. So we have passed it as well, right we have read
it from Json file. Now. What I do is I'll have
to give a call to this which is nothing but Jason
and quote dot read Jason and I passed the same file here. All right. Now it is asking me
to handle the exceptions. So I add it
to the method signature as I choose not to handle it. All right. So what we have done here
is nothing but we are we are parsing the Json file. All right. So we have a read Jason method which is taking absolute
file name as its parameter. We have a jsonparser class, which is one
of the classes from the jar that we downloaded
Jason simple jar that we downloaded and since it's put
into your application since we have attached it
with our application. We are able to use
those classes, right? If you wouldn't have done
that step of linking the library with the application you won't
be able to use this classes. Okay, because these are
third party classes. This is not as a part
of the standard Java kit or SDK that comes with Java. We are to download it
and then link it up with our application
using module settings or if you are in an eclipse, then it would be
configured build path. Then you parse it and you
provide the reader instance of reader in this case. I passed file reader and I
give the absolute file name. Once this is done you
should be able to read messages or read the content
or read the keys that you have within your file. You get this an object then I do
Json dot get first name then I do Jason don't get last name. And the last thing
that I am printing is email. All right. Let's see if this works. So I'm running this. You could see the value
being printed here. First name that came out as John
then the last name that is Lee and the email that we printed. That is John at the
right one two, three. All right, so that's about XML and Json
which is nothing but it's a standard set across industry
for data entry exchange. So yeah having said that one of the main
differences between XML and Json is its lightweight and most of the companies
are the industries moving towards using Jason's
rather than xml's but xml's our Legacy and they have lot
of weed they carry a lot of weight in the industries lot
of systems at this point. I call the financial systems. They have Legacy systems
and they deal with xml's and less of Jesus. But Jason is something
that is upcoming and lot of systems
have started migrating to or started using Json speak since they are lightweight that's pretty much
it from my sight and thanks a lot for Sting and I hope you guys
all become an emerging coders and practice a lot on coding. All right, so all
the best thank you. I hope you have enjoyed
listening to this video. Please be kind enough to like it and you can comment any
of your doubts and queries and we will reply them at the earliest do look out
for more videos in our playlist And subscribe to Edureka channel
to learn more. Happy learning.
