Forem: Buddhika Chathuranga

Access Modifiers

Buddhika Chathuranga — Mon, 07 Jun 2021 19:25:24 +0000

In the Java programming language, we can see two main types of modifiers which are access modifiers and non-access modifiers.

Access modifiers

public
protected
default
private

Non-access modifiers

static
final
abstract
synchronized
volatile
transient
native
strictfp

In this article, I am going to talk about access modifiers.

Access modifiers are responsible to define the scope, to where elements such as methods, variables of a code are visible.

private

The private access modifier is accessible only from the class.
Private access modifier is not applicable for classes and interfaces
Applicable to methods, properties, and constructors

package temp;

class A{
    private int x;
}

class B{
    A a = new A();
    System.out.println(a.x);
}

The above code has a syntax error. Because cannot access x from class B, since it is modified as private in class A. So x is accessible only from class A.

default

When the developer not defined access modifiers explicitly, that member has the default access modifier.
default access modifier is visible to all classes in the same package. So-called package-private

package temp;

class A{
    int x;
}

class B{
    A a = new A();
    System.out.println(a.x);
}

Now in the above example, can access x from Class B. Because x is modified as default and A and B both classes are in the same package.

package temp;

class A{
    int x;
}


package temp2;

class C extends B{
    void m(){
        System.out.println(x);
    }
}

In the above code, even class C has extended class B, inside the class C cannot access x. Because x is modified as default and class trying to access x from a different package.

Protected

protected access modifier is visible to the same package
protected access modifier is also visible to other packages, but only via a subclass
applicable for constructor, method, and property

package temp;

class A{
    protected int x;
}


package temp2;

class C extends B{
    void m(){
        System.out.println(x);
    }
}

In the above example from the C class of package temp2 can access x which is defined in A class in package temp because x has the protected access modifier. Also, x will be accessible to the Child classes of C.

public

accessible to everywhere
applicable to classes, interfaces, properties, methods, constructors

package temp;

class A{
    public int x;
}


package temp;

class D{
    void method(){
        A a = new A();
        System.out.println(a.x);
    }
}

In the above code, x variable of the class A is accessible to everywhere of the code. So can access x from class D in the package temp2.

Comparison

public

within class : yes
within package : yes
outside package by inherit : yes
outside the package : yes

protected

within class : yes
within package : yes
outside package by inherit : yes
outside the package : no

default

within class : yes
within package : yes
outside package by inherit : no
outside the package : no

private

within class : yes
within package : no
outside package by inherit : no
outside the package : no

JDBC in simple

Buddhika Chathuranga — Fri, 27 Nov 2020 17:31:27 +0000

In this article, I will straightforwardly explain JDBC. Let's get into the topic directly. First, I will get a simple terminology to explain JDBC.

Imagine we are living in a city called City A. We are low on water. City B has a well that is full of water. But our language (City A language) and their language (City B language) are different. So, first of all, we are going to need a language translator. Then we need a road to go to City B. Then we need a vehicle to go to City B. When we send our vehicle to City B, there should be a tank on the vehicle to bring water to City A.

This terminology explains nothing but JDBC application architecture. Imagine there are a Database and a Java application. We need to get data from the database to our Java application. According to the above terminology, our Java application is nothing but the City A, low on water. The database is nothing but the City B, which is rich in water.

Now we need some application that can convert our Java call into a Database understandable call. In the above terminology, this tool is nothing but the language translator. In JDBC terminology, it is the Driver.

When we get the connection, we need a vehicle to send our database request to the Java application database. This vehicle is nothing but Statement Object.

When we send our vehicle to City B, there should be a tank to fill water. In JDBC terminology, this tank is nothing but Result Set. When the vehicle brings back the tank with water from City B, we can carefully unload the water tank from the vehicle. When the statement object brings back the data we want in the result set, we can fetch that data from the Java application.

Now let's try to summarize this.

Components of the JDBC

Driver - Translate Java calls into Database calls
Connection - Create the connection between the java application and the Database
Statement Object - Transport our database query to the database
Result Set - Contains the data received from the database

Using these components, we can create a simple JDBC application. These are the basics steps to follow to create a JDBC application.

Steps to create a JDBC application

Load and register the driver
Establish the connection to the database
Create the statement object
Send and execute the query
Receive and process data
Close the connection

By following the above steps, we can develop a simple JDBC application.

Resources

https://www.udemy.com/course/complete-jdbc-programming-part-1/

Java finalize() is danger

Buddhika Chathuranga — Fri, 27 Nov 2020 11:51:13 +0000

In every Java object, there is a method called finalize(). You can override this method in any of your classes. The purpose of this method was to implement clean-up codes. When the object is garbage collected by the garbage collector, the garbage collector will invoke this method.

But no one can ensure whether the garbage collector will get a chance to invoke that method. Because we can't force to run the garbage collector even by calling System.GC().

Refer to the following code.

public class Demo{
  private DBConnection dbcon;

  public Demo(DBConnection con){
    this.dbcon = con;
  }

  @Override
  finalize(){
    this.dbcon.close();
  }

  public static void main(String[] args){
    for(int i = 0; i < 1000000; i++){
       Demo demo = new Demo(
         new DBConnection("credentials")
       );
    }
  }
}

A million database connections will be opened when we run this code, but the connection closing logic is implemented inside the finalize method. Since no one can ensure that the garbage collector will trigger before the application ends, a million database connections may be wasted.

So it is not recommended to override the finalize method. Especially when you want to implement a critical piece of code inside the finalize method.

Because of this, Java has deprecated the finalize method from version 9. But still, if you want to do this, there are few workarounds that you can take.

1. Register a shutdownhook

You can use shutdownhook to execute things like resource cleanups, closing log files, etc. Shutdownhook will be executed by the JVM before shutting down the JVM. You can register as many as shutdownhooks you want and those will be executed concurrently, and you can't tell what order it will be executed.

2. Using PhamtomReference

A phantom reference is a kind of reference in Java, where the memory can be reclaimed. The phantom reference is one of the strengths or levels of 'non-strong' reference defined in the Java programming language; the others being weak and soft.

This is the same definition from Wikipedia about the phantom reference in Java. I have no much clarity about phantom reference. Maybe I will explain this will in another article.
Until that https://www.baeldung.com/java-phantom-reference will help you ;).

Java String Pool

Buddhika Chathuranga — Wed, 25 Nov 2020 17:02:57 +0000

We know in Java Strings are stored in the heap memory area. Inside this heap memory, there is a specific memory area called String Pool. When we create string primitives, that will be stored in the string pool memory area thanks to the java string's immutability.

Refer to the following code.

public class StringPoolDemo{
    public static void main(String[] args){
        String a = "hello";
        String b = "hello";
    }
}

Both a, and b string primitives are the same. So without creating two string objects in a heap, JVM can create only one string and connect both reference variables to the same string object. When this happens, string objects will be created inside the special memory area called the heap's string pool.

This string pool is a big hash map. All the strings will be stored as elements of the hash map.

But the story is slightly different when it comes to creating strings using the constructor. Because at that time, the string will behave as an object rather than a primitive. So string object will be created inside the heap. Not in the string pool.

Also, we can add strings into the string pool memory area manually using the String.intern() function.

public class StringPoolDemo{
  public static void main(String[] args){
    String s = "hello world";
    s.intern();
  }
}

When running this code s will be stored inside the string pool memory.

Let's write some code to test this out.

public class StringPoolDemo{
  public static void main(String[] args){
    String a = "hello";
    String b = "hello";

    System.out.println(a.equals(b));  // true
    System.out.println(a == b);       // true
  }
}

In both outputs, we get true as the output. So we can say that both a and b reference to the same string object.

You can use -XX:+PrintStringTableStatistics JVM flag to see how many buckets are available in your JVM string pool and how many of them are used.

If your application has a huge number of string primitives, you can gain considerable efficiency by increasing the string pool size using -XX: StringTableSize=.

Make sure to use a prime number as the value for best performance.

Wanna become a great Java developer . . ?

Buddhika Chathuranga — Fri, 23 Oct 2020 20:24:32 +0000

If you want to become a great Java developer, then you must have a good understanding of the Java virtual machine, the JVM where your Java codes run. Read this article which explains the JIT compiler of Java virtual machine.

https://medium.com/runtimeerror/java-jit-compiler-c538e5e06a2

Did you lose your internship due to COVID-19?

Buddhika Chathuranga — Fri, 09 Oct 2020 06:08:33 +0000

You may be one intern among thousands of interns, who lost their internship due to COVID-19. But you know, still, the opportunity is there. COVID-19 only needs social distance. But still, you can do your intern remotely.

There are many programs which are providing software engineering internships. Google Summer of Code is the most popular event among all of that. So do you know, the Google Summer of Code 2021 is coming? Don't be late. Read this article to learn how to get selected into Google summer of code 2021.

P.S.
If you are fed up with the non-paying internships, Google's summer of code is not among them. They provide amazing stipends. Anyway, experience is the best thing you should collect from the event.

Don't be late. If you start ASAP, the opportunity is bigger.

https://medium.com/runtimeerror/path-to-gsoc-2021-e6a81e62308d

Do you know how the operating system manages to run multiple programs concurrently?

Buddhika Chathuranga — Fri, 09 Oct 2020 05:42:29 +0000

Modern operating systems can run multiple programs at one time. Those operating systems are using an operation call context switching to manage to run multiple programs at once.

Would you like to learn how context switching happens in the operating system? Read this article. I have explained in a very simple manner how context switching happens in a modern operating system.

https://medium.com/runtimeerror/context-switching-in-depth-1d6d4e51ab32

What is the compiler

Buddhika Chathuranga — Fri, 09 Oct 2020 05:35:30 +0000

The compiler is a nothing but a source code translator. There are multiple types of compilers according to how they translate source code to another source code.

When a compiler translates high-level source code into low-level source code we call it a traditional compiler.

When the compiler translates low-level source code, we call it decompiler.

When the compiler translates high-level language into another high-level language we call it a transcompiler or transpiler.

Would you like to learn more about compilers and their architecture? Read this article. I have briefly explained how compilers work in this article.

https://medium.com/runtimeerror/what-is-the-compiler-62c595a828c9

Erlang Run Time System Book

Buddhika Chathuranga — Sun, 17 May 2020 03:12:55 +0000

I just finished reading The Erlang Run-Time System Book. The most awesome book that I got to read 😍. Hats off to the contributors 🎩. If you wish to get started with Erlang or Elixir, highly recommended to read. And please be kind to contribute. If you are a beginner, there are some typos that you can help with 💪.

Find the book here : https://blog.stenmans.org/theBeamBook/