DEV Community: Chhavi Joshi

Day 2 Java learning: Prime numbers in range

Chhavi Joshi — Fri, 07 Nov 2025 08:54:46 +0000

Yesterday we studied about functions, so today lets write code to print prime numbers in a range using function.

Lets start with the first writing a function to print prime numbers:

What we did in this code was, first we made a function prime with void as return type. We then created a variable count and initialized it to zero. This counter variable was made to count the number of times a number is divisible by any num other than 1 or itself to check if it's prime or not. Every time the number becomes fully divisible by some other num the value of this counter variable increases so at first we initialized it to 0, and then increment it after checking the condition.
For checking this condition we made a for loop which starts from 2 till squareroot of the number (for optimization), we could have also continued the loop until the number, then in the loop we checked the remainder on dividing the number with every num and if it comes as zero, it means the number is completely divisible by that number and hence the number is not prime.
Once we find a single number that can completely divide the number to be checked for prime, we increment the value of count and break the loop.

Then we check if the value of count still remains zero or not. If count = 0, till the end of loop it means the number wasn't divisible by any other number and therefore it's prime and so we print the number.

We could have checked if the number is prime or not by another way as well

In this we chose the return type as boolean and then repeated the same loop as we did earlier but this time instead of making a variable counter we directly return true or false to the caller (as the returntype is boolean)

Now so far we wrote the code to check if a number is prime or not, but we need to print all the prime numbers in the mentioned range. So for this let's write another function that would use one of these functions to check if a number is prime or not and then print all the prime numbers that come in the range.

So in this we wrote function with returntype as void again, which takes two numbers as parameters and then runs a loop from the first number to the second number and inside it, calls the isPrime function and after checking if the number is prime or not it prints them.

Then in the main method we provide the variables and call the range method.

Day 1, part II : Call by value

Chhavi Joshi — Wed, 05 Nov 2025 16:41:21 +0000

Earlier we talked about what functions are, how their syntax looks like and how they work, now let us dive a level deeper into it.

The functions in java are "call by value", which means that the value that we provide as argument is not directly given to the function but a copy of its value is given.

Lets understand it by example of swap function:

Output:

In this code we wrote the print statement inside the function itself so we got out desired result, but if we remove the print statement from the function and write

System.out.println("a = " + a + "b = " + b);

in the main function instead, the code would show different behaviour, i.e. its original value would be displayed. Because what we sent in the function was a copy of actual variables and their scope lies inside the function only. So if we wrote the print statement outside the swap function the original value would be printed and not what we did to their copy

Day 1 of daily coding: Functions is java

Chhavi Joshi — Wed, 05 Nov 2025 16:11:32 +0000

We know that functions in java are block of code written to perform a specific task. For example if we need to add two numbers multiple times in same code, it would be very tedious to rewrite the same code again and again, so instead we create a function or a method (a function inside a class is called method) in java. So that instead of writing the whole code we can just call that function.

The syntax of a function appears as follow:

<Access specifier>   <returntype>   <name of finction> (parameter){
...body of function
}

Example:

Above is code for function that would print Hello World three times, we can see that at first we mentioned the access specifier then the type of function, as I wrote it in the main class that would contain the main function later in the code, i wrote static. Then comes the return type of this function, which here is void as it would not return anything, then is the name of function and inside it, is its
body.

If instead of void i would have mentioned int as the return type then, at the end of code i would've to return some value, so here i decided to return the number of times Hello World would be printed. Note that this return value is what the function caller gets back and is not displayed or printed.

output:

Another example would help us understand better:
Sum calculation function:

Here we wrote int as the return type and passed two parameters in the parenthesis. We can see two numbers in the parameter block this means that when we call the function we would need to provide two numbers to it as argument and the function would perform whatever task is mentioned in the body on those values. Then at the end the function returns some value to the caller.
Main method:

Here in the main method I asked for two numbers as input and then passed them as arguments to the function. You can notice that here the value of function call is assigned to a variable sum as:
int sum = calculateSum(a,b)
which means that sum would contain the value that the calculateSum function would return when a and b are passed as arguments in it.
Output:

And this is how the final output would look like.

Code optimization (Prime no.)

Chhavi Joshi — Sat, 06 Sep 2025 15:08:32 +0000

Question:

To take 'n' inputs from user and tell if the number is prime or not.

Let's solve this step by step and analyze how we can reduce it's time complexity.
We know that prime numbers are the numbers which are divisible by only 1 and the number itself.
So the main concept that would be used here is that, we need to check the remainder when we divide the number by each number, if the remainder is 0, the number is completely divisible by that number and then we will increase the value of count, which would be a counter variable initialzed to count the number of times the input num got completely divided. On the basis of which we will tell if the num is prime or not.

So the first code that i wrote for this was:

Output of which appears as:

This code is technically correct but the number of time it iterates makes its time complexity very high.

So the first and most basic change I did was to decrease the number of iterations in the for loop of div.

I changed it from:
for(int div = 1; div <= n; div++ ){ if(n % div == 0){ count++; } if(count == 2){ System.out.println("Prime"); } }

to:
for(int div = 2; div < n; div++ ){ if(n % div == 0){ count++; } } if(count == 0){ System.out.println("Prime"); }

which reduces two iterations, we know that the prime nums are divisible by 1 and the num itself so we can exclude these two cases and check if any other num completely divides the num, if it does then the num is not prime and if it doesn't the num is prime.
So this reduces two iterations yet it does not help us significantly.

There's a pattern we need to analyze in the divisors of a number, take an example:
24, it's divisors can be written as:
1 x 24
2 x 12
3 x 8

4 x 6

6 x 4
8 x 3
12 x 2
24 x 1

We know that square root of 24 is 4.89, so did you notice some pattern in the divisors of the number around it's sqrt, it is clear that the number of times a num can be completely divided before it's sqrt is same as the no. of diviors it would have after the sqrt.

So instead of iterating the second loop till n we can iterate it till sqrt of n which would reduce the iterations to almost half.

So the code would now look as follows:

for(int div = 2; div * div < n; div++ ){ if(n % div == 0){ count++; } } if(count == 0){ System.out.println("Prime"); }
we cannot write sqrt n directly so instead I wrote it as div * div < n

But there's one more optimization that we could do in this, i.e. if a number is divisible by any other number instead of 1 and the num itself then it is called prime, even if there's only one num other then these two, so what we can do is break the loop as soon as we find the very first number that is divisor of the num except 1 and itself.

So the final code would look as follows:

Exception Handling in java

Chhavi Joshi — Thu, 28 Aug 2025 16:10:10 +0000

We know that there are various types of error which we might come across in coding, they are broadly classified as following types:

1. Syntax Error

Error in the syntax such as initializing value without declaration, absence of semicolon etc are considered syntax error.

2. Logical Error

When wrong logic is applied to the code, it is called logical error. This type of error do not cause any problem in compilation or execution but they perform the wrong task, i.e. the code doesn't behave in the expected manner.

3. Runtime Error

These are the errors that we do not realize until the code is run, i. e. we cannot view them at compile time as they occur at runtime. These errors can usually be treated and these are then called exceptions.

Exception:

So exception in java is basically a resolvable event the disrupts the normal flow of program.

common exceptions that we come across are:

NullPointerException
ArithmeticException
ArrayIndexOutOfBoundException
-IllegalArgumentException
-NumberFormatException

Try catch and finally block:

So assume following code, in this I've declared an array, and its asking the user to enter an index to be retrived. As the length of array is 5 so entering index til 4 is valid and if index greater than 4 is entered in normal circumstances it would give error.

But we do not want our program to crash over such pity things such as invalid input so we perform exception handling, where we make two blocks a Try block that contains the code that might cause error, by this we tell the compiler to try doing that part of code, and if it throws an error it is given to the Catch block which catches the error by its type mentioned in the parentheses and then does the action that shows us that the error has been dealt.
And then we have Finally block that is executed whether any error arise or not, the only time it is not executed is when there's an error in the finally block as well, or when it contains a dead thread or when we use System.exit().

Constructors in thread and Thread priority

Chhavi Joshi — Wed, 27 Aug 2025 04:04:33 +0000

There are 8 constructors in Thread class.

1) Thread():
It's the one we usually use for creating objects of Thread.

2) Thread(Runnable):
We use this constructor when we use the Runnable interface for thread creation.

3) Thread(name):
It is used to name a thread, so it's easy for debugging.

Main class:

Output:

3) Thread(Runnable, name)
When we create an object for thread using runnable interface, it is done in two step, first where we write obj using the name of class and second step where we use thread class and pass the onj name as argument of it, for example:
Class obj = new Class();
Thread ob = new Thread(obj);
but using this constructor we can directly make the object in one step.

Main class:

Priority

We can also prioritioze which thread to run first using setPriority() method

In the code above I used MAX, MIN priorities but we can also give specified priority as obj.setPriority(7);
and also return the priority of an object by printing obj.getPriority()

Output:

Multithreading with Runnable Interface

Chhavi Joshi — Tue, 26 Aug 2025 15:58:12 +0000

Earlier we studied how to perform multithreading using the class Thread, but we know that in java multiple inheritance is not possible so if we want to perform multithreading in a derived class we would not be able to extend the Thread class. So to resolve this issue we can also perform multithreading by using interface!

The Runnable interface performs the same functions as that of the Thread class but we know that we can implement multiple interfaces together and even in a derived class, so they resolve this issue and so are generally preferred more.

Code:

Below is the code for the same.

The normal classes appear exactly same to that of implementing multithreading through Thread class. But the only difference lies in the object formation in the main class shown below.

We can see that first we need to make objects of the classes like we usually do but then we also need to make objects of the class Thread which would contain the objects m1 and m2 of the normal classes. And at the end we call t1 and t2 the objects of Thread class.

Output:

We can see how the statement of thread3 was executed before thread2 and that too the thread was switched before compelete execution as after printing the statement of thread3 6 times only instead of 50 times as mentioned in the code the statements of thread2 were printed.

Multithreading and creating a thread

Chhavi Joshi — Tue, 26 Aug 2025 05:24:17 +0000

Multithreading is a concept in java that offers concurrency (even parallellism if working on quad-core processor).
Thread can be thought as the smallest unit of code and with the help of multithreading we can work on multiple threads concurrently.

Think of a shop for instance that has only one person for assistance, if multiple customers come to a shop then instead of fullfilling their needs one by one i.e. listening to their needs, then waiting for the processing of the product and then giving it to customer and later going to another customer its better to get the requests from other customers while the processing takes place.

This is what we can achieve by multithreading, executing multiple threads concurrently, and switching between threads while one is stuck in a process.

Code:

Firstly when we make a class such that we want to perform multithreading we extend the class Thread which is a built in class in java.

To perform multithreading we use the method run() which again is a method of class Thread that we override in our classes.

Even if we create other methods in the class, to perform them in multithreaded manner we must declare them inside the run() method.

At the time of creating objects of the class and calling the methods we use obj.start(). The start() method is the basis of multithreading and it calls the run() method.

The start() method creates a new thread that can be concurrently run. If we do not call the start method and directly call any other method (even run() ) then the code is executed in sequential manner.

Output:

This is a part of output, where we can clearly see that instead of running the first line for 50 times and then executing the other statement both the statements are being executed concurrently.

I used the for loop for 50 statements as the processing happens so quickly that if the statements were to be printed only a few number of times they might have appeared almost sequential.

Doubts:

Now lets discuss some doubts that might come in our mind as a beginner.

First:Does start() only calls run() method?
Answer: Yes it only calls run() so if any other method is to be made it needs to be either declared inside of run() or called separately. But calling it separately in main thread (main class) makes it sequential.

Second: what if we create a method apart form run().
Answer: In that case we will have to declare the method in the run() method as well, so that when we call start(), all the part of run() of run() is executed including the other methods mentioned in it

in this manner doWork() would also be executed along with run().

Default and Private methods in interface

Chhavi Joshi — Tue, 26 Aug 2025 03:19:32 +0000

We know that interface is like a blueprint class that gives us a hollow structure or scaffold that needs to be used in other classes, by just declaring the methods and not implementing it in the interface. This gives freedom for every class to implement the same method in its own manner, whenever we implement the inteface.

But one thing must be kept in mind that when we derive a class from an interface by implementing it we must either define all the methods present in the interface or we must make the class abstract. This is because when we implement an interace in a class all the methods that were a part of interface earlier are now indirectly present in the class as well, and so if a method is not defined among the existing methods it is present as an abstract method in the class and we already know that even if a class contains a single abstract method it must be abstract itself.

So problem arises when we want to update the interface i.e. add a new method in interface. Earlier it was not possible as when we update the interface by adding even a single method to it, every class that implemented the interface must also be updated, so to solve this problem default methods were introduced.

In my previous post I had already posted this interface Shape where the methods were dimensions() and area(), these were the fields that would be different for every shape but suppose later I thought of adding a method show() that would print "I'm a shape", so i could make this a default method. You'll understand it further by going through its properties mentioned as follows:

They must be defined in the interface itself.
It's not necessary to mention a default method for a class to be concrete.
If we want to use it for other purpose in a class implementing the interface we can simply override the default method.

In this manner default methods are used to add new method without breaking the old code

Now talking about private methods, these are like helper methods used for supporting the default method. Or these can be used when the logic of the default method becomes very long so these can be seperately made and then be called inside the default method like I did in the above code.

properties of private method:

Unlike default methods they can only be used in the interface as they are private.
These cannot be overridden.
These are helper methods of the default method.
Any object cannot call them directly because of private access specifier.

Abstract classes and Interface

Chhavi Joshi — Sat, 23 Aug 2025 12:51:25 +0000

Abstract classes in java are the classes that contain abstract mehtods, and abstract methods are the methods which do not contain any implementation.

We know that the meaning of abstract is something that only exists in thoughts, similarly a method that only has declaration but not implementation are called absract methods.

Even a single abstract method would make the whole class abstract i.e. an abstract class can contain both normal methods and abstract methods, even if there's a single method that is abstract in any normal class, we have to declare the whole class as abstract.

See the example below to understand it further.

Example:

Here Animal is an abstract class with two abstract methods, sound() _and _feet() _ and a normal method _breathe(). The working of method breathe would be same for every animal so it was written as a normal class. Whereas animal's make different sounds and have different number of legs, so these properties would differ for every animal and hence they are not initialized in the class animal itself but in the derived classes. So we can say that basically the abstract methods provide blueprint.

And their working could be understood making object of each class.

Output:

Interface:

Interfaces are similar to abstract classes, as they also contain methods with only declaration and not implementation
This is code for interface, which act as a blueprint for all the shape classes that would be further derived from this.
In interface each method is automatically public and abstract method. So unlike the abstract class which can contain both normal as well as abstract methods, in interface all the methods are automatically abstract.

So interfaces are used to create a blueprint of all the methods should be in its derived classes

To derive a class from interface we use implement keyword, like we use extends for normal classes.

Output:

Overriding

Chhavi Joshi — Fri, 22 Aug 2025 12:32:08 +0000

Overriding is a concept similar to that of method overloading, its just that method overriding takes place in inheritance and unlike method overloading where at least a parameter or return type must be different in both the methods having same name, in function overriding two functions of same name in different classes can be overridden such that their name, number of parameters, type of parameters and return type is also same.

Example:

Output:

Super keyword

Chhavi Joshi — Fri, 22 Aug 2025 05:04:12 +0000

Super keyword is used to access any variable or method or constructor of the immediate parent class in java. So it is a keyword used in inheriatance whenever we want to call a variable, method or constructor in java.

Below is an example that shows how super keyword works.

Example (comparision with this keyword):

In this block of code I've made two classes, a parent class and a child class that extends parent class to perform inheritance.And I made a variable named strength in each class and then I made a method showStrength() to display strengths of both the class.

Now both the variables have same name so if I was to directly call strength the compiler would not know the variable of which of the class is being called, so like we use this keyword to signify that the particular object is being called, we use super keyword to signify that the part of the immediate parent class it to be called.

Output:

So I used this and super keyword together to show the similarity and differences in both of them.

Now below is an example that shows that every constructor has an inbuilt super keyword that is present though it is not visible.

Super in constructor:

In this code again I used the parent and child class but this time I also made a default constructor of each class which would be directly called whenever an object of any of the classes is created.

Then I made an object of the child class only. But when we look at the output the constructor of both the classes have been run. Check the output below for understanding.

Output:

This happened because each constructor has a default inbuilt super keyword mentioned, that executes the constructor of its immediate parent class automatically.

To show the working of the super keyword I've commented super for understanding in each constructor, that even though we do not write it in the code it is automatically present there.