A lots of people think threads is used to cut down the time. that is not how it’s going to work. If you have some proper process which runs for 10 minutes so there is no guarantee you can use 10 threads to get cut down up to one minute. That is not how its going to work. Let’s take example to see why it’s not like that

We have process which has five steps

All together we have 11 seconds of processes. Looking at this chart you will see you have five steps.can you we use five different threads and take this 11/5 to 2 seconds. No which is not possible. Why ? Because there are dependency tasks. so what is the mean by dependency tasks? For an example you can’t save the data to database before validating and the preparation. But you can do these two tasks parallel.

Then you can use two different threads. then you can cut down the time little bit more than 11 seconds. There are no way you can increase the number of threads and cut down the process up to 1 seconds or two seconds that’s not multi-threading in other words you can’t use separate thread to each task and cut down processing time if those are dependent.

Multi- threading means multiple processors / multi tasking. Multi tasking has a two types one is process based and another one is thread based.

What are the differences between these two ?

Sometime When you type code or when you type the document you , you listen to the music at the same time you download the some file from the internet. So that means you are doing the multiple things on the same time. In other words in the same given time there are three processors running on your computer. So if you stop downloading a file will it effect your music ? No will it effect to the what you whatever type ?no so that means these tasks are independent. You can kill any task at any given time which does not give any single effect to other tasks. So that means your operation system run multiple processors in same time which are multiple programs. So that’s called process based multi tasking.

Then what is thread based multitasking ?

The main significant difference is in thread based multitasking is these threads are belongs same project or same main process which run in operating system. In process based example operating system has three different processes . As far as operating system concern there are three processor and in thread based multitasking as far as operating system concerns it can be a one process. So within that one process we can divide into multiple task. For an example let’s say you have 50 files to process on your project. So your task is read the file and save it into database. Let’s assume that 50 files takes 50 minutes to finished the job. If you use two threads then you can cut down the time probably for 30 minutes likewise you can increase it. You can do three threads so what it does is one thread is go take a file and process it and put it into database at the same time other thread will go and take file and read it and put it into database. Why? Because these tasks does not have any dependency. You can use 50 threads and cut down the time unto 5 or 10 minutes BUT there is no way to you can use 100 threads and take this time down to one second or sometime like that. In other words there is no way to you can so something within no time by just increasing the threads.

Why you can use more than 50 threads for 50 files ? Because you have a 50 files right so there is no point to two threads go and take to same file to and trying to process it. This example is get idea about threads and what are the limitation about threads.

As a conclusion there are two types of multitasking one is process based and other one is thread based. If its a process based those are independent from each other, you can kill any process at any time there is no effect on others but when you go the threads based those threads are belongs to one process itself.

what is the thread ? Threads is flow of execution. If you take one thread it’s keep executing all the things maybe multiple instruction you’re executing same time. But if it’s a multithreads so from certain point it go to multiple flow of execution.

How create a thread ?

There are two ways to create threads in java. One is you can extend Thread class and second way to create a thread is implements runnable interface.

No matter how you create. The behaviour of the thread and what the thread does is won’t change. Lets take simple example

We have human, we have man and from a man we have sport man , from a sportsman we have a runner. This mean tell us this is simple inheritance. what it tells runner is sportsman , sportsman is man and man is human. End of the hierarchy runner is human. In other words we create man from Human because man is more specific than the Human, we create sportsman from a man because sportsmen is more than specific than man and finally we create runner from a sportsmen because runner is more specific.

For the reasons if we want to convert this Runner into threads if we extends this into threads class then what happen is break runner and sportsmen relationship. ( runner is a sportsmen relationship in break it) so that means here onwards Runner is a thread.

In the previous inheritance, end of the hierarchy Runner is a Human which is perfect valid scenario to present. But movement we extend the runner from the Thread class , we break that relationship. This is one of the disadvantage in threads. Because java did not support multiple inheritance but java support multiple implementation so it’s always welcome to implement from the runnable interface and if you want give different behaviour implement from those interfaces as well.

Let’s assume this example

We have class Printer that extends from Thread class and here we have to override run() Method and let’s print 0 to 1000. This is the thread class . In other class( main method ) inside the main method we create object from printer “p” and call the start() method using p.start(). We can see start method don’t have inside the printer class but printer come from a thread class and Thread class has a start method. The main thread will also printing 0 to 100. Now main thread start to new thread which is child thread which is supposed to print 0 to 1000 after start method calls main thread start to print 0 to 100.

So what is behaviour of this project (code) ?

Will it terminate the project just after printing 0 to 100 that means child thread will not able to complete the job ? ( java terminate the program only two cases one is if someone call system.exist or when you kill the last non-deamon thread ) in this case we didn’t mention new thread is deamond or non- deamon thread so It will have a default behaviour.

The question is the movement it print the 0 to 100 what the output will see? Will the program will terminate or will the program will wait until the child thread complete its job?

The Printer class extend the Thread class and It’s must override the run() method. Let’s see what happen when if we did not override the run method.

When we execute the above code it will execute without errors. So the point is you can call the start method and it is not must to override the run() method. in other words if its must to override run() method in your thread implementation class? No it’s not if you’re going with extend keyword.

This is how it work.

When you go to Thread class, Thread class has the run method. When you call the start() method in main class ( p.start() ) it go and see the printer class has start() method, but in this case printer class don’t have start method so then it go to parent class ( Thread class because printer class extend from Thread class ). Thread class has start() method.

Within the start() method , they invoke the run() method. When you invoke the run() method, it go and see do I have run() method in printer Class ? No so what it does is ,it has run method inside the Thread class as well

It does not doing anything. In this case it’s empty method. So that’s why above code is working without errors. As a conclusion of this scenario it is not must to override the run method if you extend the thread class but if you not override the run method you are not doing anything . Because whatever the Job thread has to do has to go into run method so if you don’t have run method, there won’t have any job. This scenario valid if you extend the Thread class.

If you implement the Runnable Interface, you can see it like forcing us to override the run() method.

So that’s the behaviour of the interface. If you are implementing any interface, you must override all the methods within the interface.

Back to extends scenario

Here we do override the run method in extend Thread class

We can see both threads are printed. You can see here in Main class we call the start() method but we clearly see printer class don’t have start() method. When Printer Class don’t have start method , what it does is it goes to super class. That is standard inheritance practice. When it go to the parent class (Thread class ) , Thread class has the start method.in the start() method , it’s calling run() method. When it called the run method, it check, run method in printer class , if it has run method, then it will executed.

If you see here , it do something before it go for run method like check threadStatus and it add to the group and finally it started. So there is nothing directly invoke within this start() method.

In run() method, it’s asking to execute the target.run() so target is runnable object

So target type is runnable. So that means of our printer class. So now executing run method on our printer class. So when we have run method on our printer class it will execute when we don’t have a run method in our printer class it goes normal way, it goes to the superclass.but it doesn’t do anything.

Let’s assume this scenario

In main thread ( main class ) supposed to printed 0 to 100 and child thread ( thread class) supposed to printed 0 to 10.

when we execute different times each execution has different orders. That brings up to another point whenever you start the thread there is no guarantee order of the thread. There is something called thread scheduler. So you start the thread and what is does is if its fulfilling all those things it will add your thread into thread scheduler. How the thread scheduler works is entirely depend on your JRE ( end of the scenario JVM) because JVM is a specification and JRE is an implementation. It’s depend on the JVM to JVM so that means if its working on windows machine totally different form if it’s working in Linux or macOS machine. The rule is when you start a thread there is no guarantee which order it will execute. That’s why you see above code given different output in different executing.

Why we have called the start() method?

What happened without calling the start method and directly invoke run method?

Here we print the thread name main class Thread.currentThread().getName() using this method and thread class using currentThread().getName() method.

You can clearly see now thread name is alway “main” and you can see other behaviour it always execute child before it execute the main. This mean we “only have one thread”. What really happening here when you invoke the run method , you are not giving the opportunity to create a new thread so as a result what happens is it just execute the normal method call.

can we invoke run() method directly in multi-threading scenrio ? yes, but it will not create a new thread, it will execute from the parent thread.

why it is forcing us to call for start method ?

The reason is before start the thread it has to do many things like see whether this thread is already exist , whether this thread is ready to run and it needs to register on the registers and adding to thread pools and so and so. We don’t have to do any of these things. JVM take care of everything when you call the start method. When you invoke the start method, it does this do all necessary things and it invoke the run method.

Another scenario

What happens when override the start method in thread class ?

When executed several time we can see here, override start method called first and printed “ this is start” then print always “ main”. Still we don’t see new thread being created. What we did here ? We simply violated OOP principles.

Printer class called start method so what is usually do is it always give the chance to immediate class, so just print class has start method , then it will execute the that method so we block a being opportunity to create new thread. Why ? Because we are blocking is to invoke thread class start method. So it won’t create a new thread, it won’t do anythings, it won’t work.

Another scenario

Can we override the start method and still let you create the thread ?

what we did here is we called super.start() this will do the job. The we have another question ? What is order of printing ?

So you can see here, it will created new thread because we call the super.start() method. when we execute several times it will generate different results(different order). One movement it will print override method first, then child thread then main thread , another movement it will print child thread first then override start method print and then main thread.

The real question is child thread print first, then print the override start() method. Why is this ?

What we do exactly here is printer.start() it goes thread class and call the super.start() method. When you call the super.start() it go to parent class which is thread class and it will created thread and add it to thread pool. This time immediately that thread start to involve. That why we got child printed first.

Diffrent scenario

What happen if you put this is start before the super.start() method?

We can do it. But it will print override method start method always first (“this is start”). Why this is tricky is many people think we can’t do it. Because super must be first argument of the method. Super must be fist line of method when we are invoke super constructor. But not for the super class method.

Another scenario

What happened overload the run method ?

The result will same. Nothing different. If we overload the run method but thread class start method will always invoke run method with no arguments.

If child thread do more job than the main thread ?

When main thread done this job we can print something like this “main thread done” then we know main thread done it done the job . Main thread print 0 to 10 and child thread print 0 to 100 that means child thread do more job than the main thread.

When we execute the above code we will see no matter main thread done this job ( main thread executed first before the child thread but still main thread allow to execute child thread to done it job), child thread still executing to complete the job.

setDaemon thread

What we do is setDaemon thread to child thread

When we execute again we can see main thread ended and child thread not reach to it target to complete the job. So that means when the child thread is the daemon thread, when the main thread is finished the job then the program will terminate.

But question is why child thread not finished , the movement main thread finished the job ? Because child thread print more lines after main thread executed you can see the output. So reason is we printing it here, how the system.out is works like stream, in thread they force print this , print this .. like that , so there is other process it take and print into console. The movement your thread is end it will process unto some addition print lines. Whenever you terminate the main thread, child thread is process up to some additional values.

As a conclusion when your child thread is daemon thread, the program won’t wait until your thread complete the job. When you want program waits until complete the job , then you thread should be non-daemon thread. Program always terminate last non-daemon thread terminate.

Creating thread using implement Runnable interface

If you implement the Runnable interface you must override the run method

We can see here currentThread() method not working ?

Because currentThread() method belongs to Thread class, but when you come from Runnable interface you don’t have that behaviour.

Another point is we clearly see start () method is not working ?

It’s same like start method not belongs to Thread class.

When we implement the Runnable interface, it doesn’t contain any implemented methods. In previous case we extend from Thread class , what happen is our class is extend from a Thread class and Thread implement the Runnable. So end of the scenario it’s coming from Runnable. However what we did is we have intermediate class which called Thread and Thread class implemented all useful methods from Runnable Interface. But now in the this case we don’t have this intermediate Thread class so we don’t have someone to implement this start method.

When we go to Runnable interface its like single abstract interface.

It only have run method. It does not have any other method. There is no way we get the start method.

What can we do now?

We can create objects from the Thread class and pass runnable instance for that and instead of print.start() we can call thread.start()

What happen here is, we have Printer class and that class implement the Runnable interface, we create Thread class instance here and when we create the instance we pass our instance from the Runnable interface. That means we pass “p” instance.

What happen when we execute the program ?

We can see here it will create child thread and main thread. We get the output, that is mixed with two threads.

We create Thread class instance and we pass Runnable interface to that. So that means Thread class has more than one constructor. So Thread class has multiple constructors. It has eight constructor.

Every thread in JVM it has the stack. Each method that execute by that thread create frame inside that stack.

Thread priority

Each thread has a priority. Priorities are represented by a number between 1 and 10. In most cases, the thread scheduler schedules the threads according to their priority (known as preemptive scheduling). But it is not guaranteed because it depends on JVM specification that which scheduling it chooses. Note that not only JVM a Java programmer can also assign the priorities of a thread explicitly in a Java program.

The Maximum thread priority is a 10. If you deal with index then 99.9 % times it starts with 0 (zero). But thread priority is not index. Thread priority is value. Thread priority always start with one (1) and end with 10. Normal priority we consider as 5.

Default thread priority is always 5 is wrong. Let’s see why default priority is not 5.

Set the thread priority

Here we set the thread priority for child thread to 1.

That means lowest priority give the child thread and main thread will be finish the job before child thread.

Here we set the thread priority 10 to child thread (maximum thread priority )

We give child thread to maximum priority that means child thread executed before main thread executed. Because we give higher priority to child thread.

Print the thread priority

In above code we print thread priority using getPriority() method for both main and child threads. We can see main thread is 5 and child thread got 10. This is where confusion start default thread priority is 5 .

Now stop the setPriority() method assign value 10 to child thread

When we execute the above code, both child and main thread are printed “5”.

See what happened before we create thread and set thread priority to main thread 1.

Now we will see main thread and child thread get 1 value.

Before setPriority set to main thread, print the main thread value

Now we can clearly see, before we set the setPriority() to main thread it will has value 5 and after assign value to main thread priority both child and main thread got value 1. If we set main thread priority to 7 then, we can clearly identify before assign setPriority() method it will print 5 and after assign setPriority to 7 both thread will print value 7.

Every thread what we created is default priority is 5 is wrong. The rule is any application, main thread default priority is 5, because no one is created thread, system will created thread so it set the priority to five. There after any thread you created, it get inherit parent thread value. There is no rules “always thread priority is five” .

Passing the setPriority() method to out of boundary value

There we passing the setPriority() method to 11 and we got exception called “ IllegalArgumentException”

What happened if the two thread carrying the same priority.

If main thread set to priority 7 then we don’t need to set priority to child thread because child thread inherit priority from main thread. The output is nothing much difference. because when we give two thread to same behaviour there is no way to predict.

Thread life cycle

When you just defined the thread , we call it is new thread.

When thread is start, it goes to ready state( runnable state).processor assign some task, then thread become running state. After running state when the run() is over, then this thread going to be a dead. This is like usual life. When thread goes to dead state, there is no way to come back that means thread is over. But intermediately there are multiple other steps also for example wait or block state. There are few methods we can call that methods and with that methods thread goes to block state (temporarily hold state).

There is very much possibility from running state it can go back to ready state and then go back to running state. It can go back and forth between running and runnable state. But when it goes to dead, it done.

Join method

There are two threads , thread1 and thread2. Thread1 is waits for thread2 to finish his job. That means thread1 is depend on thread2. In other words thread1 want to result of thread2, to continue thread1 process. Its is not like thread2 want to give result to thread1. so thread1 is call the join method using thread2.join(). These is the where some confusion comes ? Thread1 who waiting until thread2 process and thread1 is going to call the join method but its like thread2.join()

We can pass join() method to milliseconds not only that we can give join() methods to some milliseconds + some nanoseconds . If you can call the join method these three types. If you call join method without specifying any time that is forever.

If that given time period thread2 is finish the job, thread1 can continue rest of the process.

In thread call the join method, runnable state thread become the wait state. In above example thread1 is call the join method on thread2. So thread1 is finish job in certain point and waiting for thread2 to finish the job.

There is rules in thread, if any thread goes to waiting state there is no way directly go to the running state. So end of that ( that means end of the waits state) it has to go to runnable (ready) state.

As I mention above, thread1 is call the join method on thread2, thread1 is going to wait state, there are three ways to thread1 is going to ready state from waiting state,

1. Thread2 is finish the job

2. Time out occur ( join method we pass the certain time period to complete the job, if time is passed, then thread1 is going to Ready state)

3. Got interrupted

Let’s see some example :

There is two thread main and child thread, these two threads print some values. What we going to do here is after thread.start() method, main thread is waits until child thread complete the job. So main thread decide that call the join method on child thread.

We can clearly see, main thread until waiting child thread complete the job. so that means child thread executed first then main thread is executed.

Now we call the sleep method to child thread.

So we pass 250 milliseconds to sleep method, that means every iteration it takes to 250 milliseconds to print the value. Result is same as above, child thread execute first no matter how longs takes time after that main thread is executed.

Here is the different scenario, we pass 5000 milliseconds to join method. That means main thread will wait only 5 seconds to child thread to complete the job.

Child threads has 50 iteration and each iteration takes 250 milliseconds so that means child threads takes 10 seconds to complete the job, but main threads call join method and passing 5000 milliseconds (5 seconds) to wait until child thread complete the job.

That’s the reason why we got output like this. Main threads takes 5 seconds wait , that time period child thread execute half way but when the time out main thread will execute after main thread finish the job rest of the child thread finish the job.

Yield , sleep. and interrupt

Yield method

Yield method is no much useful because the movement use this method, you’re not used of multi threading.

Why yield method is exist ? Because if you want to like kind of debugging scenario , if you want to give more chance to particular threads that the where yield method comes.

How this works

If you have two different threads, any thread can call yield method. The movement yield method called, that thread give hint( signal ) to the thread scheduler to saying like “I am giving chance to other threads”. It doesn’t tell to which threads give chance( not specific thread). If the thread scheduler give chance another thread, then that particular thread who the called yield method go to the waiting state. Then other threads will be execute, but there is no guarantee that particular threads gets the chance.

For example there are three threads , t1,t2 an t3 so t1 call the yield method and either t2 or t3 get chance to execute the thread and t1 go to wait state, if t2 get chance, after t2 executed there is no guarantee again t1 get chance to execute. its probably t3 thread get chance to execute. Because t1 is usual agin in the wait state. After t3 execute t1 get chance but its uptown thread scheduler.

The whole point of yield method is give the chance to other method.

Yield is native method. Because it’s not implemented within the java.

Let’s see in practical ,

The child thread call the yield method, that means child thread give chance to other threads( main thread). So main thread will complete the job first after that child thread execute. ( in this case we have two threads if one thread will excite then other will execute after that, but if we have more than two threads, threads scheduler will decide that which thread will execute)

Sleep method

Sleep method what it does is it can wait certain given time. Sleep method has two different method signatures one is sleep with number of long milliseconds so that method is native method that’s not implemented within java, second method is not native method its implemented with java it has two arguments long milliseconds and int nanoseconds. its same as thread.join method.

When call the sleep method we have to pass time to sleep method, otherwise sleep method is call forever that means thread will become dead state. So sleep method have two signatures

When we call the sleep method what sleep method does is thread will go to the waiting state for a certain given time period. So how is come back ? Either given time period is expired or interrupted.

In java threads we have method called interrupt, the movement we execute the interrupt method, what ever the thread is waiting state is coming back. That’s why when you call the sleep method, you have to catch checked exception called interruptException.

We call the sleep method in child thread in each iteration it will waits 100 milliseconds.

What happed if we interrupt this process ?

In here we don’t wait to the 5000 milliseconds we call interrupt method in that child thread. We can see main thread will completed the job and it got the interrupted exception. So interrupt only works for one sleep method, that’s the reason why after interrupt method called we got interrupted exception and child thread back to sleep.

Let’s see another example

When the thread (child thread) get the chance it wait for 5 seconds. In above code we don’t interrupting. When execute the program we can see main thread print first and after 5 seconds child thread get the chance to execute.

What happened call the interrupt method without using sleep method ?

In this case we did not call the sleep method in child thread, but we call the interrupt method in child thread. In other words call interrupt method which is not sleep. So we can see here main thread and child thread both will execute. No error occurs. Nothing happened. Doesn’t Do any harm.

Java cares about type. For example if you put a floating point numbers into integer variable, unless you acknowledge to the compiler that you might lose precision( everything after decimal point). Variable divided into two types such as primitive and reference types and primitives hold fundamental values ( simple bit pattern) including integers, booleans and floating point numbers. Object reference hold reference to object.

Variable must have a type and have a name.

Primitive Types

There are eight primitive types variable such as boolean, char, byte, short, int, long , double and float.

A variable is just cup ( a Container) . It holds something. It has a size and a type. In java primitives come in different sizes and those sizes have names. When you declared a variable in java, you must declared it with specific type. Each primitive variable has a fixed number of bits ( cup size). The sizes for the six numeric primitives in java are shown below.

Be sure the value can fit into variable

You can’t put a large value into a small cup. If you want to do that, you will lose some. You will get spillage. The compiler tries to help prevent this if it can tell from your code that something’s not going fit in the container( variable/ cup) you’re using.for example,

Why this doesn’t work ?

After all, the value of x is 24 and 24 is definitely small enough to fit into bye, but all the compiler cares about is that you’re trying to put a big things into small thing, and there’s possibility spilling.Don’t expect the compiler will know what the value of x is, even if happen to be able to see it literally in your code.

The compiler won’t let you put a value from a large cup into a small one. But what about other way- putting small value into large cup so its work no errors. The compiler always error on the side of safety.

Back away from that keyword!!!

There are rules in java when you declared name of variables. You can name a class, variable and method according to the following rules.

1. The name must start with letter, underscore(_) or dollar sign($), but can’t start a name with a number.

2.After first character, you can use numbers as well.( don’t start with a number)

3.it can be anything you like, subject to those two rules but just so long as it isn’t one of java’s reserved words( java reserved words means java can use specific keywords when creating a program).

Reference Variable

There is actually no such thing as an Object variable. There is only object reference variable. It doesn’t hold the object itself, but it hold something like pointer to address. JVM knows how to use the reference to get to the object. Object reference variable is full of bits representing a way to get to the object. we can use dot operator on a reference variable.

Ex: dog.bark();

An object reference is just another variable value ( something that goes in a cup, only this time, the value is a remote control).

The three steps of object declaration, creation and assignment.

1. Decalare a reference variable

Dog myDog = new Dog();

Tells the JVM to allocate space for a reference variable and names that variable “myDog”. The reference variable is for of type Dog.

2. Create an Object.

Dog myDog = new Dog();

Tells the JVM to allocate space for a new dog object on the heap.

3. Link the object and the reference

Dog myDog = new Dog();

Assigns the new dog to the reference variable myDog in other words programs to remote control.

Note:

All references for a given JVM will be the same size regardless of the objects they reference, but each JVM might have different way to representing references. So references on one JVM may be smaller or larger than references on another JVM.

Life on the garbage- collection heap

Declare two Book reference variables and create two new Book objects, assigns the Book objects to the reference variables. The two Book objects are now living on the heap.

Declare a new Book Reference variable.rather creating new, third Book object, assign the value of variable “c” to variable “d” so this means take the bits in “c” , make a copy of them and stick thatchy into “d”.

Assign the value of variable b to variable c. So that means the bits inside variable b are copied and that new copy is stuffed into variable c.

Life and death on the heap

The two Book objects are now living on the Heap.

Assign the value of variable c to variable b.he bits inside variable c are copied and that new copy is stuffed into variable b. Both variables hold identical values.

Assign the value null to variable c. This means c a null reference and it doesn’t refer to anything.

Array is like a tray of cups

1. Declare an int array variable. An array variable is a remote control to an array object.

Int [] numbers;

2.create a new int array with a length of 7 and assign it to the previously declared int [] variable “numbers”.

numbers = new int [7] ;

3. Give each element in the array an int value.( elements in an int array are just int variables)

numbers[0] =2;

numbers[1] =4;

… like this pattern

Arrays are always objects, whether they’re declared to hold primitives or object reference. But you can have an array object that’s declared to hold primitive values.in other words, the array object can have elements which are primitives, but array itself is a never primitive.

Every element in an array is just a variable. In other words one of eight primitive variables types or a reference variable.

Make an array of reference type

1. Declare a Dog array variable.

Dog [] pets;

2.create a new Dog array with a length of 7, and assign it to the previously- declared Dog[] variable “pets”.

pets = new Dog[7];

3. Create new Dog Object and assign them to the array elements.( element in a Dog array are just Dog reference variables)

pets[0] = new Dog();

pets[1] = new Dog();

Note:

Dog d1 = new Dog();

d1.name = “Murphy”;

We created a Dog object and used the dot operator on the reference variable d1 to access the name variable.

Dogs in Dog array

When the Dog is in an array, we don’t have an actual variable name (like d1). Instead we use array notation and push the remote control button (dot on an object at a particular Index (position) in the array:

Dog[] myDogs = new Dog[3];

myDogs[O] = new Dog() ;

myDogs[O].name = “Murphy”;

myDogs[O] .bark();

Things the object knows

Things the object does

Things an object knows about itself are called instance variable. They represent object’s state (data) and can have unique values for each object of that type.

Things an object can do are called methods. When you design the class , think about the data an object will need to know about itself and also design methods that operate on that data.objects to have methods that read or write the values of the instance variable.

So objects have instance variable and methods, but those instance variables and methods are designed as part of the class.

What’s the difference between a class and an object?

A class is not an object(but its used to construct them). A class is a blueprint for an object.it tells the virtual machine how to make an object of that particular type. For each object Mae from the class can have its own values for the instance variables of that class. For example Button class to make dozens of different buttons and each button might have its own colour, size, shape, label and so on.

Making first object

To making object we need two classes. One class for the type of object want to use (Dog, Alarm, Car, etc.) and another class to test new class. The tester class is where we put main method and in that main() method we create and access objects of new class type. The tester class has only one responsibility is try out the methods and variables of your new object class type. In other words one class will be real class ( the class whose objects we really want to use) and other class will be the tester class so only the test class will have main method and its sole purpose is to create objects of your new type(not the tester class) and then use the dot operator(.) to access the methods and variables of new objects.

The Dot operator (.)

The dot operator give access the an object’s state and behaviour( instance variable and method).

1. Write your class

2.Write a tester class

3.In tester class, make an object and access the object’s variable and method.

The main method

If you are in main method, you are not really in objeczville. it’s fine for a test program to run within the main method, but in a true Object oriented application, need objects talking to other objects.

The two uses of main :

1. To test your real class

2. To launch/start your java application

A real java application is nothing but object calling to other objects.

Java takes out the Garbage

Each time an object is created in java , it goes into area of memory known as Heap. All objects are stored in the Heap area. The java heap is actually called the Garbage-collectible heap.when you created object, java allocates memory space on the according to how much that particular objects needs. How do you get an object out of heap when you’re done with it? Java manages that memory for you.. when the JVM can see that an object can never used anymore, that object become eligible for garbage collection and if you are running low memory, the garbage collector will run , throw out the unreadable objects and free up the space. So that space can be reused.

The way Java works

Compiler convert source code file into byte code on a virtual machine using java compiler.

Code structure in Java

What goes in a Source file?

A source code file( with the .java extension) hold one class definition.the class represent a piece of programme, although a very small application might need just a single class and class must go within a pair of curly braces.

What goes in a Class?

A class has one or more methods. For example the Dog class has bark method, will hold instruction for how the Dog should bark.methods should declared inside a class.

What goes in Method

Within a curly braces of method, write your instructions for how that method should be performed. Method code is a basically a set of statements.

Anatomy of a class

When the JVM starts running, JVM looks for class that in command line, then is starts looking for specially written method that looks like

Then, JVM runs everything between curly braces of main method. Very java application has to have at least one class and at least one main method(not one main per class, just one main per application).

In Java, everything goes in a class, your source code file(with .java extension) the compiler will convert it into class file (with .class extension) when you run the program.running a java program means telling the JVM to load the class and starts executing its main() method.

Java is a strongly-typed language, that means cannot allow variables to hold data of the wrong type.This is a crucial safety feature.

Syntax Fun

1. Each statement must end in a semicolon.

x= x+1;

2. A single-line comment begin with two forward slashes.

//this is the comment

3. Most white spaces does not matter.

4. Variables are declared with a name and type.

int age; //type:int, name:age

5. Classes and methods must be defined within a pair of curly braces.

public void go() {

//code goes here

}

Why does everything have to be in a class?

Java is an object oriented programming language( OOP) so everything in java is an object and class is blueprint for an object.

Do we need to put a main method in every class we wrote?

Nope. A Java program might use a lot of classes, but we might only have one main method, the one that starts the program running. We might write test classes through that have main method for testing other classes.

System.out.print Vs System.out.println

System.out.println inserts a newline while System.out.print keep printing to same line. If you want each thing print out to be on its own line use println. If you want to everything stick together on one line, use print

Why came up a concept called lambda expression?

1. Introduce a functional programming behaviour to java.

2.Code should be more simple to understand

You can convert any method to lambda expression so you need to understand basic method characteristics.

1.Scope modifier(access modifier or static )

2.Return type or (void — not return type)

3. Parentheses

4.Method name

5. May have parameters or not

Rule of Lambda expression

No modifiers(access)

No return type

No method name

Convert the above method to lambda expression.

If code have one line then we can make it more simple (Remove curly braces).

Here make it more simple

We need integer type variable, but sometime compiler can detect (guess) what is the data type of the variable so we can called this type inference, that means we don’t have to tell what is the data type of this variable.

If we have only single arguments(parameter), then we don’t have to use parentheses(), then this will become something like,

In following code, we have two arguments so we cannot remove the parentheses, but we can remove return keyword, because compiler can identify this has to be return therefore no need to write return keyword.

In conclusion, lambda expression is more simple way to write a same method. If you know java normal method, you can convert to the lambda expression.in lambda expression have three rules, first one is if you have one line of code, you don’t have to use curly braces.second rule is if compiler can guess the data type, you don’t have to use the data type as well we called this type inference. final rule is if compiler guess its going to be return you don’t have to specify the return type as well. When these rule together we called Lambda expression.

To called the lambda expression, we need to Functional interface.

There is method called SAM (Single abstract method) and this concept not introduce java 8, but this concept in functional interface. So SAM and functional interface means single abstract method that’s means your interface can only have single abstract(unimplemented) method.keep in mind not single method.it can only contain single abstract method so that means it can have more than one methods but which should not be abstract.

In other words, functional interface have multiple method, but only have single abstract method, other methods are not should be abstract method.

Any given interface if its has only one single abstract method, we called Functional Interface. So advantage is we can use lambda expression along with this functional interface.

In early days we had a concept, we have an interface, we have a class to implement that interface and then we call that class. So now we remove all those intermediate parts and now we have interface which is functional interface and we just called that functional interface through the lambda expression without having a separate implementation.

Note: if you have functional interface then you have single abstract method, you have one default method and some other static method so this is fine as long as single abstract method but after you want to change and add other method to functional interface, then all the Lambda expression will fail. Because this is not functional interface anymore. In java has concept called Fail-pass they introduce new annotation called Functional Interface.

What Functional Interface annotation does is if you put this annotation top of the class, compiler knows this is functional interface that means compiler knows this class can only have a single abstract method.

This is the example of Functional Interface and that has Single abstract method.Functional interface has any number of default or static methods.

But when we add another abstract method, compiler will show error message because functional interface only have single abstract method.

here the example of classic interface named “Loan” and that extends from functional interface called “Account”.

In “Loan” interface have two abstract methods but its fine because it’s not functional interface (Its classic interface). “Loan” interface extends from “Account” functional interface so extends means more subset of previous one.But if add functional interface annotation in “Loan” interface then compiler will show error and it says multiple non-overriding abstract method. so if you used functional interface annotation both interface and second functional interface can used only overriding method of first interface. in this case “Loan” functional interface can only used “Account” functional interface abstract method otherwise it will show error. In other words “Loan” interface can access its parent interface ‘Account” so Account interface is functional interface and its methods comes “Loan” Interface.

There are main Two types of Casting in java.

1.Widening Type Casting

2.Narrowing Type Casting

Widening Type Casting

Converting a lower data type into a higher one is called Widening type casting.its also known as implicit conversion or casting down.it happens automatically when a converting from a narrower range data type to a wider range data type(converting a lower data type like an int to a higher data type like a double).widening casting have two conditions,

1. Compatibility to the data types. For example data types such as numeric are compatible with numeric data types, but they are not compatible with boolean, char or string data types.in the same way String is not compatible with a boolean data types.

2.if the target type must be larger than the source type. (Ex: 4 bytes to a larger data type 8 bytes)

Widening casting follow the order of convention.

Example:

Output

Narrowing Type Casting

Converting a higher data type into a lower one is called Narrowing Type casting.its also known as explicit conversion or casting up.this is done manually by the programmer and need to do the casting using the “()” operator.if do not perform casting then the compiler reports compile-time error.

Example:

In the above code, we converted the double data type into int data type and the decimal part of the value is lost after the type casting.

byte casting(Additional to refer)

Here we add two byte value and result will assign into another byte variable but compiler will indicates the error for following code. if we used “+” operator minimum in int type. Therefore if we used operator that will return integer type so we need to casting for the get proper result.

In numbering system in circular progression which mean in byte highest value is 127 and lowest value is -128 (byte range -128 to 127). if you imagine numbers are in circle after 127 next value is -128, for example assign 129 to byte variable, compiler knows that exceed the limit and then counting start from -128 and goes two digit two get the answer.

Example:

here the byte “c” variable get 130 and its exceeded byte range therefore it starts counting from -128 and answer is -126.

BigDecimal is a class that belongs to java.math package. We use float and double primitive data types for decimal numbers but there is one problem with these primitive types. Float and double that these types should never be used for precise value, such as currency.

The BigDecimal class provides operations for arithmetic, scale manipulation, rounding, comparison, hashing and format conversion. In addition to class gives its user complete control over rounding behaviour.

In java, BigDecimal consist of a random precision integer scale and a 32 bit integer scale.If positive or zero, the scale is number of digits to the right of the decimal point. If less than zeroth unscaled value of the number is multiplied by ten to the power of the negation of the scale.

Here the main reason why used the BigDecimal

In this case, we used firstly double primitive data type to subtract two numbers and we got answer with additional decimal point numbers. Second we used BigDecimal class type object to assign the values and we got exactly answer.

Features of BigDecimal

1. Scaling and Rounding modes

One of the biggest reason to used BigDecimal is scale the numbers.scaling is how many numbers there after decimal point(Number of digit after decimal point). In BigDecimal class have overloaded method called “setScale()” and we can used that method to scaling the values. setScale() method have two parameters and first one is int value o how many numbers are scaling and second parameter is rounding. In rounding mode there are 8 types are established.

2. No overloaded operators is allowed

In java arithmetic operators like +,-,*,/ not permitted with objects. So these operators are not allowed in BigDecimal. Therefore BigDecimal class provided methods such as add(), subtract(), multiply(), and divide() in addition to class is provided max(), min() and compareTo() method too.

3. Use compareTo() to compare BigDecimal numbers, Not used equals()

Don’t used equal() method to compare two BigDecimal numbers. Only equal method is true both value and scale of two BigDecimal Numbers.

If two numbers are equal compareTo method will return 0 or if first number is greater than second number it will return 1 and second number greater than first number it will return -1.

4. BigDecimal numbers are immutable

We can create BigDecimal objects following ways

1. BigDecimal b1 = new BigDecimal(d)

2.BigDecimal b2 = BigDecimal.valueOf(d)

If you use new BigDecimal() However, then BigDecimal will try to represent the double value as accurately as possible.This will usually result in a lot more digits being stored than what you want.

In computer, there is standard called IEEE 754, this is standard computer used to represent the floating points.

IEEE 754 has 3 basics components :

1. Sign bite

This is the simple as the name,1 bit is assigned for the sign and 0 represents a positive number and 1 represents a negative number.

2.The Exponent

The exponent field needs to represent both positive and negative exponents. A bias is added to the actual exponent in order to get the stored exponent. Single precision(32 bit) takes 8 bit is assigned for the range named exponent while Double precision(64 bit) takes 11 bit is assigned for the ranged named exponent.

3.Mantissa -

This is for the fractional part in other words mantissa is part of a number in scientific notation or floating point number, consisting of its significant digits.

IEEE 754 numbers are divided into three based on above three components such as Single precision , double precision and long double precision.

This is how generally IEEE 754 standards to guiding to represents floating points.

Let takes example how this works.

Convert value 9.1 into IEEE standard 32 bit floating point binary

Step 1 : Determine the sign bit ( 0 if positive, 1 if negative)

Sign bit = 0

Step 2 :convert decimal value to pure binary value( including fractional part)

Common approach is repeatedly half in the whole number part and repeatedly doubling fractional part.

in this above picture, as you noticed that value of 0.2 comes up again, in which case recurring bit pattern so there is no need to keep going and remember this fractional part read in top to bottom.

Step 3 : Normalise to determine the mantissa and the unbiased exponent( place the binary point after leftmost 1)

In this case decimal point is reposition three places to the left to get point back where it was would have to float it three places to the right. So now we have the value of exponent. this is the Scientific notation in 9.1 is represented.

Step 4: Determined the Biased exponent (add 127 then convert to an unsigned binary integer)

Step 5 : remove the leading 1 from the mantissa ( remove the leftmost 1)

The mantissa is always going to be 1 for any real number that we want to represent in this format so there is no need to store it.

This is the final result of 9.1 value represent in IEEE 754 standard

But some cases we do additional steps to convert value to IEEE 754 standard format.

Step 6 : Round mantissa up or down if necessary

In mantissa includes a recurring bit sequence which mean it’s too long to be stored with a finite number of bits.therefore simply chop the mantissa at 23 bits to make it fit.simply chopping the mantissa is effectively rounding it down but in reality a computer will round to the mantissa either up or down to the nearest value.

If you want to round mantissa properly, first need to identify what is 24th bit and then if it’s 0, then we can simply chopped but if its 1 , then we need to add 1 to the mantissa

in this case, 24 bit is 1 and we need to add 1 to the mantissa to floating point rounding.

the final result of the IEEE 754 standard is now little bit difference than above one. this is so called floating point rounding error in computer.

Now we convert this 9.1 IEEE 754 standard into decimal format

Step 1: Determine the sign in decimal

Sign = +(positive) because starting bit is 0

Step 2: determine the exponent.

Exponent part have 8 bit and it starts from second bit and goes up to 9th bit.

10000010 = 130

Step 3 : remove the exponent bias

127 is the bias we add to the exponent part(in single precision).

130- 127 = 3

Step 4 : convert mantissa to decimal

We have 23 bit mantissa and to convert it into decimal it’s easy to use excel sheet.

So exponent value is 0.137500048

Step 5: add 1 to the mantissa include the sign bit

1.137500048

Step 6 : calculate the final result

Now we realise that first we convert 9.1 into binary and that binary code we convert into back to floating point we got not 9.1 but rather than 9.100000384. this is happened because of rounding what we have done. This is floating pint rounding errors we faced in programming language. In java as a solution we used BigDecimal instead of Float and double values.

If computer wants to 10/2, how computer do this is computer subtract 10 by 2 until it hit the zero or go beyond the zero.

It takes five times and results is 10/2 is 5. That how the computer do the division. Same way if computer wants multiplication, it do the additions.

Now the problem is?

10/2 =5 15/3 = 5 but same way working other way round so 5*2 =10, 5*3 =15 that’s how this works.

If we says 1/0 = infinity and same way we can say 2/0= infinity

If you apply the same logic other way round infinity *0 =1 and infinity * 0 =2 .. but this is not possible.

Therefore we do not consider any number divide by zero as infinity.

Here is answer

When we trying to reach zero , 0.1,0.01,0.001 as we go towards to zero, the result will go upwards. Same way reach to zero by negative side the results should go downwards.

These two are never going to meet each other because these two go in two different ways. As results we consider as any number divide by Zero is Undefinable(Undefined).

System based Virtual machine (SVM)

System based virtual machine is one or multiple hardware creates multiple environments to work. These environments are completely independent.

Example: Xen, Hypervisor

Application based Virtual machine(AVM)

Application based virtual machine is don’t have any hardware device to involve, but may have application or software which helps to create environment/platform to run some kind of language and it convert to different language(output) to understand. This types of vm also called as process based virtual machine.

Examples: JVM, CLR(common language runtime- dot.net programme to creates virtual environments), PVM

High-level view of JDK,JRE & JVM

Java Virtual Machine(JVM)

JVM is completely specifications and it says how this should be done.JVM is application based Virtual machine. We cannot installed JVM because its doest not exits.when download the JRE, JVM comes with JRE.when install JRE, JRE will deploy the all codes which can create JVM for particular platform. For example JRE on a windows machine the JRE will deploy the all codes which required to create JVM for windows environments. Therefore JVM is platform dependent.

How JVM works is read the class file and convert it to which your operating system is understand.

The moments start the java program, then creates JVM instance on computer. The moment when program exists then JVM will die.Therefore JVM only exist computer until run the program. If you are executing three different program on your computer, on the same time three JVM instance have created.

JVM Architecture

In JVM architecture there are three main components inside the JVM such as ClassLoader, memory area and executing engine.

ClassLoader

The classLoader main responsibility is taking the class and loading into memory area. classLoader mainly have three characteristics such as loading, linking and initialisation. There are two types of classLoader in JVM,

1. Boostrap classLoader

2. Custom define classLoader

Loading

The main responsibility of loading is taking class file and put into memory.When JVM reading class file, class files has following features such as,

1.Fully qualified class names

2.Variables information

3.Immediate parent information

4.Whether class file is class or interface or enums

Fulfils the these conditions then class file is loaded to Memory Area.Each and every class when is loaded, JVM does creates object from class type and put it into heap.

Example:

We have two class called Employee and Manager.

Employee em = new Employee();

“em” is the object in employee class and when JVM is load Employee class, it creates object from class type and assign class information to that “em” variable and storing into heap. This is happen very first time loading into JVM.

So Manager class referring to Employee class JVM not created additional object from class type because it’s already created. Therefore only very first time JVM created objects from its class type.

Linking

Linking have three steps,

1.Verification

2.Preparation

3.Resolution

Verification

In java has byte code verifier in JVM, It will check whether the particular class will safely execute or not. Therefore the reason why Java is safely execute any environments.

How it works?

When loading Java class, there is sub program called byte code verifier. It will verify whether that particular class come from valid compiler, the class has correct structure and that class has correct formatting.if any of these conditions are not satisfied, JVM throw runtime exception called Verifier Exception.

Preparation

Preparation means if you are using any instance level variable or static variable in your class, preparation part will assign default value for that variables. But not assign to initial values.

Resolution

JVM, cannot understand the codes that we write when we are developing the application, so JVM does before reach to machine level JVM replacing those symbolic links with direct links.

Initialisation

Initialisation means assign real value to variables. In initialisation part, there is rule that every class must initialise before its active use.

What are the active use of class?

1. new Keyword- if you use new keyword, this is consider as active class.

2.class has particular static method- without creating an object invokes the static method.

Example: Employee class have particular static method called verifier employee so we can use manager class to verifier method without creating object. Employee.verifier();

3.assign values to static field. Ex: Employee.code = “k”;

4. Main method- if class is initial and has main method then this class consider as active class.

5.getInstance(Reflection) -if you use reflection method to load the class(getInstance type) this is consider as active class.

6.instance subclass-

Example: if you used manager class which exchange from employee, you are not creating object from employee, but you are creating object from manager that case it will create object from employee class.

Initialising process

There are four ways to java can initialise its class.

1. new Keyword

2.clone method

3. Reflection API — getInstance()

4.Java.IO.ObjectInputStream- with this class we can create new object.

Default constructor

If class has no constructor compiler will create no argument constructor called as default constructor.

If you create two class with same name(identical name) JVM will load only one class. Because always class loader take unique class name.

So these cases JVM will take first class-path as to class to load (priority is what comes first).

But completely different when we give JVM parameters JVM arguments to execute- that case JVM will take last one.

Conclusion- if its a class-path it take the first one and it its an arguments it take last one.

Memory Area

When loading the classes. All classes are storing into memory area. Mainly memory area divided into five components such as Method area, Heap area, stack, PC register and native method area.

For each and every JVM, only have one method area and heap area but stack, PC register and native method area are created per thread.

Method area — class files are loaded to method area.

Heap area — Hold the objects(all the objects are storing here)

Stack- Keep the method information(local variables).

PC register — hold the information for next execution but not native methods

Native method area- provide facility to hold native methods

Data types in JVM

There are two types of data types in JVM.

1. Primitive types — holds the value of data

2.Reference types- holding the references not holding values

Word Size

Word-Size is a just a based we need to assign value into the word-size to explain that we cannot measure word-size.The length of the word size is decided by the particular platform and there are two rules to define the length of word-size.

1. Particular word should be able to hold any primitive datatypes.

2.two of words should be carry long value.

Therefore , the word size should be at least 32 bits.

Java Runtime Environment (JRE)

JRE is an implementation and it says how is does in particular environments. JRE is platform-dependent, because JRE is on windows machine is totally different in JRE in macOS machine. JRE provide the class libraries and other resources that a specific java program needs to run.

JRE consist of ?

JRE is composed a variety of supporting software tools and features. such as

1. Deployment solutions

included as a component of the JRE installation are deployment technologies like java web start and java plugin that improve on the activation of application and offer advanced support for future java updates.

2.Developement toolkits

The JRE also contains toolkit to designed to help developers to further developing their UI.

3.Language and Utility libraries

consist with the JRE are java.lang and java.util packages that are fundamental for the design of java applications.

example: collections Framework, Concurrency utilities

Java Development Kit (JDK)

The Java Development Kit is a software development environment used for developing java applications and applets.The JDK includes tools for developing and testing programs written in the java programming language and running on the Java platform.