DEV Community: Saravanan B

Core Java - Executer Framework.

Saravanan B — Mon, 06 Mar 2023 09:54:39 +0000

If we follow traditional approach to create a thread or implement a runnable interface, then we have certain limitations.

Time Consuming - every time we need to create a thread its time and resource consuming.
Poor Resource Management - Lets take a example of our application creates 1000 threads and only 500 threads is used remaining thread lies as not used.
Robust - if a million threads access came our application stops.

To overcome this Executer framework was introduced to overcome this. It overcomes the limitations of thread.

It will have a pool of thread whenever needed a thread perform a task and again moved to pool.

Callable and future - using runnable we cannot return a value. To overcome this callable is introduced. Call method is

Core Java - Multithreading - 2.

Saravanan B — Wed, 01 Mar 2023 06:12:36 +0000

Using Runnable interface --

public class RunImpl implements Runnable {

    @Override
    public void run() {
        System.out.println("Processed the checks");
    }

    public static void main(String[] args) {
        RunImpl ri = new RunImpl();

        Thread t = new Thread(ri);
        t.start();
    }

}

By using the runnable interface, we can extend the other class if need no need for implementation of thread class.

Yield Method --

public class ThreadYield extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("Child Thread");
            Thread.yield();
        }
    }
}

public class ThreadYieldImpl {
    public static void main(String[] args) {
        ThreadYield ty = new ThreadYield();
        ty.start();

        for (int i = 0; i < 10; i++) {
            System.out.println("Main Thread");
        }
    }
}

It will wait for main thread to executed and execute the thread.

Thread Intrrupt -- It will intrrupt the thread.

public class Interuppted extends Thread {
    @Override
    public void run() {
        try {
            for (int i = 0; i < 10; i++) {
                System.out.println("I am a lazy Thread");
                Thread.sleep(2000);
            }
        } catch (InterruptedException e) {
            System.out.println("Got Interupted");
        }
    }
}

public class InteruptedImpl {
    public static void main(String[] args) {
        Interuppted ip = new Interuppted();
        ip.start();

        ip.interrupt();

        System.out.println("End of main method");
    }
}

output --

End of main method I am a lazy Thread Got Interupted

We can only interrupt the thread in a sleep mode.

Synchronization - If two thread is trying to access same object there might be a chance of data getting corrupted.

In Synchronization the thread trying to access first thread will get access, second thread has to wait till the first thread completes the task.

Class level lock - If we mark a synchronized block as static and the block is class level locked.

Interthread Communications - wait () notify () notify all ().

T1 invokes wait method it will wait and t2 starts work on thread and notify once work done and again t1 completes its work.

public class ThreadInter extends Thread {
    int total;

    @Override
    public void run() {
        System.out.println("Child thread is calculating sum");

        synchronized (this) {
            for (int i = 0; i < 10; i++) {
                total += i;
            }
            this.notify();
        }
    }
}

public class InterImpl {
    public static void main(String[] args) throws InterruptedException {
        ThreadInter ti = new ThreadInter();
        ti.start();

        synchronized (ti) {
            System.out.println("Main Thread is waiting");
            ti.wait();
            System.out.println("Main Thread notified");
            System.out.println(ti.total);
        }
    }
}

Thread group is something we can set values and do operation on parent thread and child will get the values.

public class Threadgroup {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName());
        System.out.println(Thread.currentThread().getThreadGroup().getParent().getName());

        ThreadGroup parent = new ThreadGroup("Parent");
        System.out.println(parent.getName());
        ThreadGroup child = new ThreadGroup(parent, "child");
        System.out.println(child.getParent().getName());
        System.out.println(child.getName());
    }
}

Output --
main system Parent Parent child

Here in this example, we are going to set child priority as 4 and the class which inherits child as get priority 4.

ThreadGroup parent = new ThreadGroup("Parent");
        System.out.println(parent.getName());
        ThreadGroup child = new ThreadGroup(parent, "child");
        System.out.println(child.getParent().getName());
        System.out.println(child.getName());

        Thread thread1 = new Thread(child, "Thread1");
        child.setMaxPriority(4);
        Thread thread2 = new Thread(child,"Thread2");
        System.out.println(thread1.getThreadGroup().getName());
        System.out.println(thread1.getPriority());
        System.out.println(thread2.getPriority());

Here the child thread priority is set to 4 after thread1 creation so the thread1 still have the default priority and thread2 will have the updated priority.

Daemon Thread -- Runs in background and assists other thread example garbage collector runs in background and cleanup the objects its not using.

isDeamon method is used to check and returns true if true.
setDeamon is used to set thread as deamon.
main thread cannot be set as deamon thread.

Deadlock -- Multiple thread waiting on each other resources. Example method1 access and do task same time method2 access and do task in method 1 both methods are synchornized.

Core Java - MultiThreading - 1

Saravanan B — Mon, 27 Feb 2023 03:55:50 +0000

Single Thread -- In this example the program executes by order.

public class SingleThread {
    public static void main(String[] args) {
        SingleThread st = new SingleThread();
        st.printNumbers();
        for (int j = 0; j < 2; j++) {
            System.out.print("j: " + j + "\t");
        }
    }

    void printNumbers() {
        for (int i = 0; i < 2; i++) {
            System.out.print("i: " + i + "\t");
        }
    }
}

Output -- i: 0 i: 1 j: 0 j: 1

MultiThread -- we can implement multithreading by extending Thread class or using runnable interface.

public class MultiThreaded extends Thread {
    public static void main(String[] args) {
        MultiThreaded mt = new MultiThreaded();
        mt.start();

        for (int j = 0; j < 5; j++) {
            System.out.print("j: " + j + "\t");
        }
    }

    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.print("i: " + i + "\t");
        }
    }
}

Output --

2nd time output--

Sleep Method -- Thread.sleep(1000); If we use this in thread it will print the output taking the time mentioned in mille seconds. Above i mentioned 1000 which is equal to 1second.

Joiner -- wait for run method to execute first and then process the next line.

public class Joiner extends Thread {
    static int n;
    static int sum = 0;

    public static void main(String[] args) throws InterruptedException {
        System.out.println("Sum of first 'N' numbers");
        System.out.println("Enter a vale");
        Scanner sc = new Scanner(System.in);
        Joiner.n = sc.nextInt();

        Joiner joiner = new Joiner();
        joiner.start();
        joiner.join();

        System.out.println("Sum of first "+Joiner.n+"  n numbers  is "+Joiner.sum);
    }

    public void run() {
        for(int i=1;i<= Joiner.n;i++) {
            Joiner.sum +=i;
        }
    }
}

Output

Sum of first 'N' numbers Enter a vale 2 Sum of first2 n numbers is 3

Output without Joiner --
Sum of first 'N' numbers Enter a vale 2 Sum of first 2 n numbers is 0

Calculating Time taken for a thread.

long start = System.currentTimeMillis();
long end = System.currentTimeMillis();
        System.out.println("total time taken "+(end-start)/1000+" seconds");

Thread Identity - Assigne a name to Thread.

public class ThreadName extends Thread{
    public static void main(String[] args) {
        ThreadName t = new ThreadName();
        t.start();

        Thread current = Thread.currentThread();
        System.out.println("Current Thread name : "+current.getName());
    }

    public void run() {
        Thread t = Thread.currentThread();
        t.setName("Now Thread name is set to this");
        System.out.println("Thread name : "+t.getName());
    }
}

Current Thread name : main Thread name : Now Thread name is changed to this

thread priority -- In certain situation we need to set the tread to executed first.

Minimum is 1 and the maximum is 10.


public class ThreadName extends Thread {
    public static void main(String[] args) {

        ThreadName t1 = new ThreadName();
        t1.setPriority(MIN_PRIORITY);
        t1.setName("Minimun priortiy Thread");
        t1.start();

        ThreadName t = new ThreadName();
        t.setPriority(MAX_PRIORITY);
        t.setName("Maximum priority Thread");
        t.start();
    }

    public void run() {
        System.out.println("Thread name : " + Thread.currentThread().getName());
    }
}

Output --

Thread name: Maximum priority Thread Thread name: Minimum priority Thread

Here maximum priority thread is executed first and then minimum priority thread.

Its always up to JVM to which thread to get executed first even though if we set the priority.

Core Java - Exception Handling.

Saravanan B — Wed, 22 Feb 2023 10:40:47 +0000

Runtime error are exception and we need to handle it.

public class Test {
    public static void main(String[] args) {
        int a=12/8;
        System.out.println("Result : "+a);
        System.out.println("Before Exception");
        int b = a/0; //Exception code
        System.out.println("Result : "+b);
        System.out.println("After exception");
    }
}

Arithmetic Exception - it happens when we try to do calculations like divide by zero.
Number format Exception - it happens when we try to parse a string into integer.
ArrayIndexOutOfBound - trying to access the element with the index out of bounds means array size is 4 and trying to access element at 5 is out of bound.
NullPointerException - It happens when we call the method of object without creating instance of it.

public class ArrayIndexOutOfBound {
    public static void main(String[] args) {
        int a[] = {1,2,3};
        System.out.println("Trying to get element at 4 : "+ a[4]);
    }
}

Output - java.lang.ArrayIndexOutOfBoundsException

public class ArrayIndexOutOfBound {
    public static void main(String[] args) {
        int a[] = {1,2,3};
        System.out.println("Trying to get element at 4 : "+ a[4]);
    }
    void method1() {
        System.out.println("null");
    }
}

public class NullPointer {
    static ArrayIndexOutOfBound a;

    public static void main(String[] args) {
        NullPointer.a.method1();
    }
}

Output - java.lang.NullPointerException

We can handle a exception using try catch throw finally and throws.

try{ code that cause exception }catch(Exception e){ Exception }

Handling Arithmetic Exception.

public class Arithmatic {
    public static void main(String[] args) {
        try {int b = 12 / 0; // Exception code
        } catch (Exception e) { System.out.println(e+ ": can't divide by zero");}
        System.out.println("After exception");
    }
}

Output -- java.lang.ArithmeticException: / by zero: can't divide by zero
After exception

Handling ArrayIndexOutbound

public class ArrayIndexOutOfBound {
    public static void main(String[] args) {
        int a[] = { 1, 2, 3 };

        try {
            System.out.println("Trying to get element at 4 : " + a[4]);
        } catch (Exception e) {
            System.out.println(e);
        }

        System.out.println("After exception Code");
    }

Output -- java.lang.ArrayIndexOutOfBoundsException: Index 4 out of bounds for length 3
After exception Code

Handling NullPointerException.

public class NullPointer {
    static ArrayIndexOutOfBound a;
    public static void main(String[] args) {
        try {
            NullPointer.a.method1();
        } catch (Exception e) {
            System.out.println(e);
        }
    }
}

Output -- java.lang.NullPointerException: Cannot invoke "com.exception.ArrayIndexOutOfBound.method1()" because "com.exception.NullPointer.a" is null

Once we handled an exception using parent class like Exception and then we try to handle specific exceptions after parent exception it will throw an error.

Checked Exception needs to be handled unlike unchecked Exception otherwise compiler won't compile the program.

Finally -- even if there is exception or not this block will gets executed always.

throws -- We don't want to write catch for a method and we want the method to handle the exception we use throws keyword.

public class tryingThrows {
    public static void main(String[] args) throws FileNotFoundException{
        tryingThrows ty = new tryingThrows();
        ty.fis();
        System.out.println("After Exception");
    }
    void fis() throws FileNotFoundException {
        FileInputStream fis = new FileInputStream("");
    }
}

It will throw a exception and not execute the code after the exception throws keyword is used to just to declare that the method not gonna handle exception but whichever implements needs to handle.

Throw -- Explicitly throw exception or throw our own exception.

public class Throw {
    public static void main(String[] args) {
        throw new RuntimeException("Trying throw");
    }
}

In checked Exception we need to handle the with try catch for throw.

custom Exception --

Unchecked Custom Exception -

public class UncheckedCustomException extends RuntimeException {
    UncheckedCustomException(String message){
        super(message);
    }
}

public class Test {
public static void main(String[] args) {
    throw new UncheckedCustomException("Business Exception");
}
}

Output -

Checked Exception-

public class CheckedCustomException extends Exception{
    CheckedCustomException(String message){
        super(message);
    }
}

public class TestChecked {
    public static void main(String[] args) throws CheckedCustomException {
        throw new CheckedCustomException("Checked Custom Exception");
    }
}

Assertions - Testing and debugging.

Assert expression;
Used for testing in junit and spring..

public class Assert {
public static void main(String[] args) {
    int a=10;
    int b=20;
    assert(a>b):"Condtion not satisfied";
}
}

If the condition passed return nothing else throws exception.

Core Java - Encapsulation.

Saravanan B — Thu, 16 Feb 2023 02:44:11 +0000

Encapsulation is a process of binding data and code together. 2 Major advantage of encapsulation is security and easy enhancement.

public class Customer {
    private String firstName;
    private String lastName;
    private String debitCard;

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public String getDebitCard() {
        return debitCard;
    }

    public void setDebitCard(String debitCard) {
        this.debitCard = debitCard;
    }
}

public class Test {
    public static void main(String[] args) {
        Customer c = new Customer();
        c.setFirstName("dev");
        c.setLastName(".to");
        c.setDebitCard("1234");
        System.out.println(c.getFirstName()+" "+c.getLastName()+" "+c.getDebitCard());
    }
}

Output - dev .to 1234

Core Java - Polymorphism

Saravanan B — Wed, 15 Feb 2023 16:34:12 +0000

Polymorphism Poly means many.
Morphic means Shapes.

It means a object can behave differently while communicating with different objects.

Two types of polymorphism
Compile time or static binding
Runtime or dynamic binding

Compile time which is also static binding we can achieve compile time polymorphism by method overloading.
Method overloading means same method name with different signature arguments or different number of arguments.


public class CompileTime {
    void add(int a, int b) {
        int result = a + b;
        System.out.println("Result is : " + result);
    }

    void add(float a, float b) {
        float result = a + b;
        System.out.println("Result is : " + result);
    }

    void add(int a, int b, int c) {
        int result = a + b + c;
        System.out.println("Result is : " + result);
    }

    public static void main(String[] args) {
        CompileTime ct = new CompileTime();
        ct.add(10, 20);
        ct.add(10.1f, 20.5f);
    }
}

Output :
Result is : 30
Result is : 30.6

Runtime Polymorphism

public interface Runtime {
        void start();
        void shutDown();
}

public class MacBook implements Runtime {
    @Override
    public void start() {
        System.out.println("Inside macbook start");
    }
    @Override
    public void shutDown() {
        System.out.println("Inside macbook shutdown");
    }
}

public class MacBookAir implements Runtime{
    @Override
    public void start() {
        System.out.println("Inside MacbookAir Start");
    }
    @Override
    public void shutDown() {
        System.out.println("Inside MacBookAir shut down");
    }
}

public class RuntimePoly {
    public static void main(String[] args) {
            Runtime mac = new MacBook();
            Runtime air = new MacBookAir();
            mac.start();
            air.start();
    }
}

Output
Inside macbook start
Inside MacbookAir Start

Object Casting
We can convert child class object to parent vise versa.

Upcasting is when we create a object for child from parent.
Runtime mac = new MacBook();

DownCasting is when we create a object for parent from child.
MacBook m1 = (MacBook)mac;

AutoTypeCasting -- The compiler will automatically promote to next available type if the exact type not found.

public class CompileTime {
    void add(float a) {
        System.out.println("Result is : " + a);
    }

    public static void main(String[] args) {
        CompileTime ct = new CompileTime();
        ct.add(10);
        ct.add(10.1f);
    }
}

Output - Result is : 10.0
Result is : 10.1

Overriding -- The static method in the parent cannot be override as non static methods. Vise versa non static method cannot be converted to static method in child.

If we use parent class to create a object for child and call the variable it will call the parent variable.

public interface Runtime {
        String s ="Hello";
}

public class MacBook implements Runtime {
    String s = "Hello MacBook";
}

public class RuntimePoly {
    public static void main(String[] args) {
                Runtime mac = new MacBook();
        System.out.println(mac.s);
    }
}

Output Hello

Overloading of main method.

public static void main(String[] args) {
        System.out.println("String[] args");
        main(10);
    }
    public static void main(int args) {
        System.out.println("int args overloaded main method");
    }

Even though we overload main method JVM will take method with String[] args. We need to call the method with overloaded method in main method then only jvm will print the output of the method.

Core Java - Final & Marker Interface

Saravanan B — Tue, 14 Feb 2023 14:40:22 +0000

Final
If a class is marked as final, we cannot extend the class.
If a variable is marked as final, we cannot change the value of it.
If a method is marked as final, we cannot override it.

An a marker interface is interface which has no method by using we are telling jvm to perform some actions.
Serializable cloneable.

Core Java - Interface

Saravanan B — Tue, 14 Feb 2023 14:05:39 +0000

Interface Fully Abstract methods.

public interface Car {
    void go();
    void stop();
}

public class Honda implements Car{

    @Override
    public void go() {
        System.out.println("Implemented go method");
    }

    @Override
    public void stop() {
        System.out.println("Implemented stop method");
    }

}

public class Test {
    public static void main(String[] args) {
        Honda h = new Honda();
        h.go();
        h.stop();
    }
}

An interface is a contract whereas Abstract method contains partial implementation.

An interface is by default public abstract method.

Variable in interface is public static final and should be initialized.

cannot define blocks and constructor.

Core Java - Abstraction

Saravanan B — Tue, 14 Feb 2023 13:26:45 +0000

Abstraction
Abstract means theoretical not practical or not implemented.
If we need to watch TV we need not to know how TV works we just switch channels using remote.

Abstract class can be fully and partially implemented Abstract class.

Abstraction means hiding the internal details of implementation.

We cannot create a instance of abstract class

public abstract class BMV {
    void commonFunctionality() {
        System.out.println("Inside common fun");
    }
    abstract void acclerate();
}

public class ThreeSeries extends BMV {
    @Override
    void acclerate() {
        System.out.println("Inside 3 series can go upto 120");
    }
}

public abstract class FiveSeries extends BMV{
    abstract void acclerate();
}

public class Test {
    public static void main(String[] args) {
        ThreeSeries three = new ThreeSeries();
        three.acclerate();
        three.commonFunctionality();
    }
}

Output - Inside 3 series can go upto 120
Inside common fun

Access modifiers --

we can't mark abstract class as final.
we can't mark abstract method as static.

DSA - Binary Search

Saravanan B — Tue, 14 Feb 2023 06:54:15 +0000

Binary search
It's an algorithm which is optimized way to find a element in array.
let's take an example array which is sorted.
arr[] = {1,2,3,4,5,6};

Here target is to find 5.

first it will take no of index here 5 after it will take half of the index = 2 the element in 2 index is 3. 3 is lesser then 5 again from index 3 to 5 it will take the half. If the element 4 is greater than target it will search from index 0 to 2. Now index is 4 and element is 5. and 5 is equal to target and it prints the output.

Example

arr[] = {1,5,7,9,10,15}; target = 10;

1st - index = 5
Start = 0 end= 5
binary search = 0+5/2 -> 2(index)

Value in index 2 is 7 and 7 is lesser than target.

2nd - {9,10,15}
Start = 3 end = 5
binary = 3+5/2 -> 4(index)

Value in index 4 is 10 and its equal to target.

Now output is index 4.

Time complexity -

Best case - O(1) //size does not matter if element is found in first index
Worst Case - logN.

public class BinarySearch {
    public static void main(String[] args) {
        int arr[] = {1,2,3,5,6,7,9,10};
        int target = 6;
        int ans =binarySearch(arr,target);
        System.out.println(ans);
    }

    static int binarySearch(int[] arr, int target) {
        int start =0;
        int end = arr.length-1;
        while(start <= end) {
            int mid = start+(end-start)/2;
        if(target < arr[mid]) {
            end = mid-1;
        }else if(target > arr[mid]) {
            start = mid+1;
        }else {
            return mid;
        }
        }
        return -1;
    }
}

Output - 4

DSA- Linear Search

Saravanan B — Mon, 13 Feb 2023 15:40:06 +0000

linear Search - is algorithm which starts searching from index 0 till the element finds.

This algorithm also worst-case algorithm. If element not available, it iterates through the elements till end.

Best Case - O(1)
Worst case - O(n) where n is the size of the array.

public class LinearSearch {
    public static void main(String[] args) {
        int[] arr = new int[5];
        for(int i=0;i<arr.length;i++) {
            arr[i]=i;
        }
        int target = 2;
        System.out.println("element found in the array at index " +linearSearch(arr, target));
        int targetNotInArray = 100; // to prove worst case
        System.out.println("This will iterate through the array and element "
                + "is not found in array and return false" +
        linearSearch(arr, targetNotInArray));
    }

    static int linearSearch(int[] arr, int target) {
        if (arr.length == 0) { // if the array has no element
            return -1;
        }
        // looping through the array to find element
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == target) {
                return i;
            }
        }

        return -1;
    }
}

Core Java - Inheritance

Saravanan B — Mon, 13 Feb 2023 08:31:22 +0000

Single Inheritance
Implicitly every class inherits the java.lang.object class.

Multilevel Inheritance
In this we have a parent class and child class extending parent class.

while creating object for child class using that object we can call the parent class methods.

If we create a object for child class and object address is same for parent class and child class.

Hierarchical inheritance
A vehicle class has a fuel method a bus and car class extend vehicle class.

Method Overriding
The fuel method return diesal for bus and petrol for car this is method overriding. Still the method name and signature is same.

Class Vehicle{
public String fuel(){
return "null";
}
}

Class bike extends Vehicle{
@override 
public String fuel(){
return "petrol";
}
}

class bus extends Vehicle{
@override 
public String fuel(){
return "diesal";
}
}

class Main{
public static void main(String[] args){
 Bike b = new Bike();
 System.out.println(b.fuel());
 Bus b1 = new Bus();
 System.out.println(b1.fuel());
}
}

Super keyword
Super keyword is used to point out parent class.

public class Parent {
    void f1() {
        System.out.println("inside parent f1");
    }
}

public class Child extends Parent{
    void f1() {
        super.f1();
        System.out.println("inside child f1");
    }
}

public class Test {
    public static void main(String[] args) {
        Child c = new Child();
        c.f1();
    }
}

Constructor Chaining
Is a feature we can access parent and child constructor in single object creation.

public class SuperClass {
    int x;

    public SuperClass() {
        System.out.println("No args constructor");
    }

    public SuperClass(int x) {
        this();
        this.x = x;
        System.out.println("All args Constructor");
    }

}

public class ChildClass extends SuperClass{
    ChildClass(){
        this(10);
        System.out.println("No args child class constrctor");
    }
    ChildClass(int x){
        super(x);
        System.out.println("No args child class constrctor");
    }
    public static void main(String[] args) {
        ChildClass c = new ChildClass();

    }
}