DEV Community: Yiğit Erkal

Java Interview - abstract

Yiğit Erkal — Thu, 28 Apr 2022 10:20:45 +0000

Let's talk about the abstract keyword in Java and what can be asked during the Java interview related to abstract?

Explain About Abstract Classes in Java?

Sometimes we may come across a situation where we cannot provide implementation to all the methods in a class. We want to leave the implementation to a class that extends it. In such case we declare a class as abstract. To make a class abstract we use key word abstract. Any class that contains one or more abstract methods is declared as abstract. If we don’t declare class as abstract which contains abstract methods we get compile time error.

For example; if we take a vehicle class we cannot provide implementation to it because there may be two wheelers , four wheelers etc. At that moment we make vehicle class abstract. All the common features of vehicles are declared as abstract methods in vehicle class. Any class which extends vehicle will provide its method implementation. It’s the responsibility of subclass to provide implementation. The important features of abstract classes are :

1) Abstract classes cannot be instantiated.
2) An abstract classes contains abstract methods, concrete methods or both.
3) Any class which extends abstract class must override all methods of abstract class.
4) An abstract class can contain either 0 or more abstract methods.

From this point, it is better to compare Abstract classes with Interfaces since the most common questions are related to comparison between them.

Abstract Class vs. Interface 🤼‍♂️

Interface support multiple inheritance Abstract class does not support multiple inheritance

It means you can extend an interface with one or more (hence multiple inheritance) interfaces like:

interface Interface_A { }
interface Interface_B { }
interface Interface_C { }

interface MyInterface extends Interface_A, Interface_B, interface_C { }

Let's try to extend an abstract class:

class Class_A { }

abstract class MyAbstractClass extends Class_A { }

Empty methods can be defined in the interface, but both empty methods and filled methods can be defined in abstract classes.
Using abstract classes provides an advantage in terms of speed.
When we write a new method in the Interface, it is necessary to fill this method one by one in all the classes we implement from this interface, but the situation is different in abstract classes, when we define a method and fill it in, all classes derived from our abstract class gain this feature.

❗❗❗ This behavior has changed with Java 8. Please take a look at "default" methods in interfaces.

All the objects in the Interface must be "public", while in Abstract classes it is not necessary to have all the elements "public".
Interface does not contain constructor methods. An abstract class can contain constructor methods.
Interface methods cannot be static. Abstract class non-abstract methods can be defined as static.

Tools - JSON Visio

Yiğit Erkal — Wed, 27 Apr 2022 22:01:45 +0000

JSON Visio is data visualization tool for your json data which seamlessly illustrates your data on graphs without having to restructure anything, paste directly or import file.

Prepare your JSON data and just paste it on the left side as

and here is the output.

🪄 Wingardium Leviosa 🪄

Java - Reflection

Yiğit Erkal — Wed, 27 Apr 2022 21:37:17 +0000

Reflection feature helps us to access classes, methods, variables and other properties of objects. Moreover, it is used to get, control and manage information such as class, method, properties and annotation such as name, parameter. We do this already by defining a variable and when we put "." with the completion of the IDE.

Student student = new Student()
student.
// IDE offers us features such as methods or variables here

To start with, a simple Student class

  public class Student {
  public final static int id = 4;
  private String name;
  private int age;
  public Metallica () {
    this ("James", 54);
  }

  //... other getters and setter
}

and here is our test class to test what is reflection

Class<?> myClass = Class.forName("com.org.Student");
Object obj = myClass.newInstance();

// varargs can be used for getDeclaredConstructor 
Constructor<?> cons =  myClass.getDeclaredConstructor(String.class, Integer.TYPE);

for (Field field: myClass.getDeclaredFields())
(
   System.out.println("Field:" + field.getName());
)

Field:id Field:name Field:age

Although there is no access to a private field other than getter and setter, we obtained the names of those variables 💡 So this is more beneficial in test and debug.

In the same way we can get the modifiers...

 int modifier = cons.getModifiers();
 System.out.println("Modifer: " + Modifier.toString(modifier));

Modifier: public

Because our Student class implemented as public.

Moreover, we can invoke public, private and static methods via invoke() in order to get the required information from them.

Java Interview - constructor

Yiğit Erkal — Tue, 26 Apr 2022 21:42:02 +0000

Let's talk about the constructors in Java and what can be asked during the Java interview related to constructors?

What is Constructor in Java?

We use constructors to initialize all variables in the class when an object is created. As and when an object is created it is initialized automatically with the help of constructor in java.

We have two types of constructors:
1) Default Constructor
2 Parameterized Constructor

public className(){}
public className(parameters list){}

How to Call One Constructor From the Other Constructor?

With in the same class if we want to call one constructor from other we use this() method. Based on the number of parameters we pass appropriate this() method is called.

Restrictions for using this method:
1) This must be the first statement in the constructor
2) We cannot use two this() methods in the constructor

Difference Between This() and Super() in Java?

this() is used to access one constructor from another with in the same class while super() is used to access superclass constructor. Either this() or super() exists it must be the first statement in the constructor.

Can We Override Constructors in Java?

Only methods can be overridden in java. Constructors can’t be inherited in java. So, there is no point of overriding constructors in java.

Java Interview - static

Yiğit Erkal — Tue, 26 Apr 2022 20:19:11 +0000

Let's talk about the static keyword in Java and what can be asked during the Java interview related to static?

What are the Static Blocks and Static Initializers?

Static blocks are also called as Static Initialization Blocks, a class can have any number of static blocks and they can appear anywhere inside java class. We declare static blocks when we want to initialize static fields in our class. Static blocks gets executed exactly once when the class is loaded. Static blocks are executed even before the constructors are executed.

public class Solution{  
    public static void main(String[] args){  
        System.out.println("Main Method");  
    }
    static {  
        System.out.println("Static block - 1");  
    }
}

Static block - 1 Main Method

Can We Synchronize Static Methods in Java?

Yes ✅ Synchronized methods are used to protect access to resources that are accessed concurrently. When a resource that is being accessed concurrently belongs to each instance of your class, you use a synchronized instance method; when the resource belongs to all instances (i.e. when it is in a static variable) then you use a synchronized static method to access it.

Can Static Methods Access Instance Variables in Java?

No ❌ Instance variables can’t be accessed in static methods. When we try to access instance variable in static method we get compilation error. The error is as follows:
Cannot make a static reference to the non static field name

How Do We Access Static Members in Java?

Static variables are owned by class rather than by its individual objects. Referring static variables outside the class is by ClassName.myStaticVariable but inside the class it is similar to other instance variables.

Can We Override Static Methods in Java?

No ❌ It is because method overriding is based upon dynamic binding at runtime and static methods are bonded using static binding at compile time.

Can We Define Static Methods Inside Interface?

✅ Since Java8 you can have static methods in an interface (with body). Defining a static method within an interface is identical to defining one in a class. Moreover, a static method can be invoked within other static and default methods.

Can constructors be static in Java?

In general, a static method means that “The Method belongs to the class and not to any particular object” but a constructor is always invoked with respect to an object, so it makes no sense for a constructor to be static.

Spring - @RequestMapping

Yiğit Erkal — Sat, 23 Apr 2022 12:21:54 +0000

TL;DR

It is used to map web requests to Spring Controller methods.

In Spring Web applications, @RequestMapping is one of the most used annotations. HTTP requests are mapped to MVC and REST controller handler methods with this annotation.

URL handler using @RequestMapping annotation as it follows here:

@RequestMapping(value = "/get/{id}", method = RequestMethod.GET)

The alternative approach in other words possible short version is:

@GetMapping("/get/{id}")

We can also implement other mappings mentioned below:

To sum up, it is a better approach to use RequestMapping or alternative mapping in class level controllers since all your requests and responses will be handled in controller. Here is a full code example:

@Controller
@RequestMapping(value = "/orders", method = RequestMethod.GET)
public class DemoController {


  @RequestMapping(value = "/{orderId}", method = RequestMethod.GET)
  @ResponseBody
  public String getOrder(@PathVariable final String orderId) {
    return "Order ID: " + orderId;
  }

  @RequestMapping(value = "/addProduct", method = RequestMethod.POST)
  public String addProductPost(@ModelAttribute("product") 
Product product) {
    // some code
}

 // other mappings
 // ...
}

Spring - @RequestBody and @ResponseBody

Yiğit Erkal — Sat, 23 Apr 2022 11:50:17 +0000

@RequestBody

Annotation indicating a method parameter should be bound to the body of the HTTP request. With the @RequestBody annotation, POST or PUT requests are handled. It is generally used to convert a request into an object in JSON or XML format.

For example:

@RequestMapping(value = "/isConverted", method = RequestMethod.POST)
@ResponseBody
public String isConvertedFromJson(@RequestBody User user) {
    return user.getUserName();
}

@ResponseBody

It can be put on a method and indicates that the return type should be written straight to the HTTP response body. Not placed in a Modal or View name. With the @ResponseBody annotation, we can return values of multiple types such as String, application/json or application/xml.

For example:

@RequestMapping(value = "/produceString", method = RequestMethod.GET)
@ResponseBody
public String produceString() {
     return "Hello World";
}

Spring - @PathVariable

Yiğit Erkal — Mon, 18 Apr 2022 15:18:47 +0000

A Spring annotation called @PathVariable specifies that a method parameter should be tied to a URI template variable.

@GetMapping("/api/products/{id}")
@ResponseBody
public String getProductsById(@PathVariable String id) {
    return "ID: " + id;
}

A simple GET request to /api/products/{id} will invoke getProductsById with the extracted id value:

http://localhost:8080/api/products/333 
---- 
ID: 333

We may also specify the path variable name:

@GetMapping("/api/products/{id}")
@ResponseBody
public String getProductsById(@PathVariable("id") String productId) {
    return "ID: " + productId;
}

One Class to Rule Them All 🪄

Best practice to handle not required path variables is to combine with Java Optional. In this way, you are both able to handle exceptions and the logic.

@GetMapping(value = { "/api/products", "/api/products/{id}" })
@ResponseBody
public String getProducts(@PathVariable Optional<String> id) {
    if (id.isPresent()) {
        return "ID: " + id.get();
    } else {
        return "ID missing";
    }
}

Now if we don't specify the path variable id in the request, we get the default response:

http://localhost:8080/api/employeeswithoptional 
----
ID missing

Spring - @RequestParam

Yiğit Erkal — Sun, 17 Apr 2022 19:24:24 +0000

Simple terms, we can extract query parameters, form parameters, and even files from a request using @RequestParam.

Let's say that we have an endpoint /api/product that takes a query parameter called id:

@GetMapping("/api/product")
@ResponseBody
public String getProduct(@RequestParam String id) {
    return "ID: " + id;
}

and a simple GET request would invoke getProduct:

http://localhost:8080/api/product?id=123
----
ID: 123

Both the variable name and the argument name are the same in the previous example. However, there are times when we wish they were different.

In this case we use name attribute

@PostMapping("/api/product")
@ResponseBody
public String addProduct(@RequestParam(name = "id") String pId,
 @RequestParam String name) { 
    return "ID: " + pId + " Name: " + name;
}

We can also do @RequestParam(value = “id”) or just @RequestParam(“id”).

Moreover, we can configure our @RequestParam to be optional, though, with the required attribute:

@GetMapping("/api/product")
@ResponseBody
public String getProduct(@RequestParam(required = false) String id) { 
    return "ID: " + id;
}

Finally, we can also have multiple parameters without defining their names or count by just using a Map:

@PostMapping("/api/product")
@ResponseBody
public String updateProduct(@RequestParam Map<String,String> allParams) {
    return "Parameters are " + allParams.entrySet();
}

Spring - Circular Dependency

Yiğit Erkal — Sun, 17 Apr 2022 14:24:43 +0000

Circular dependencies are the scenarios when two or more beans try to inject each other via constructor.

Bean A → Bean B → Bean C → Bean D → Bean E → Bean A

or in a simpler way

Bean A → Bean B → Bean A

What if everything is 👌

We instead have something like this:

Bean A → Bean B → Bean C

Spring will create bean C, then create bean B (and inject bean C into it), then create bean A (and inject bean B into it).

With a circular dependency, however, Spring is unable to determine which of the beans should be produced first because they are interdependent. Spring will throw a BeanCurrentlyInCreationException while loading context in these circumstances.

When implementing constructor injection in Spring, this can happen. We shouldn't have this problem if we utilize other sorts of injections because dependencies will be injected only when they're needed, not when the context is loaded. ❗

Is there way to fix it? 🤔

Redesign (LOL)
Use @lazy Telling Spring to lazy initialize one of the beans is a straightforward method to stop the cycle. As a result, rather than fully initializing the bean, it will generate a proxy that will be injected into the other bean. When the injected bean is first required, it will be fully created.

@Component
public class CircularDependencyA {

    private CircularDependencyB circB;

    @Autowired
    public CircularDependencyA(@Lazy CircularDependencyB circB) {
        this.circB = circB;
    }
}

Use Setter/Field Injection Spring creates the beans, but the dependencies are not injected until they are needed in this way

Spring - Dependency Injection

Yiğit Erkal — Sun, 17 Apr 2022 14:04:34 +0000

Dependency Injection is the most important feature of Spring framework. It is a design pattern where the dependencies of a class are injected from outside. It ensures loose-coupling between classes.

In a Spring MVC application, the controller class has dependency of service layer classes and the service layer classes have dependencies of DAO layer classes. Suppose class A is dependent on class B.

In normal coding, you will create an object of class B using ‘new’ keyword and call the required method of class B. However, what if you can tell someone to pass the object of class B in class A? Dependency injection does this. You can tell Spring, that class A needs class B object and Spring will create the instance of class B and provide it in class A. In the above example, we can see that we are passing the control of objects to Spring framework, this is called Inversion of Control (IOC) and Dependency injection is one of the principles that enforce IOC.

class ClassA {
  ClassB classB = new ClassB();

  int doCalculation() {
    return classB.calculate();
  }
}

Here comes the @Autowired keyword

❗Before Spring 4.3, we had to add an @Autowired annotation to the constructor. With newer versions, this is optional if the class has only one constructor.

Thanks to the @Autowired annotation, we can inject the values in a bean into another bean and use them while preserving their values in Spring. There are multiple ways inject but among "Property Based", "Setter Based" and "Constructor Based" we will use "Constructor Based" to benefit from Dependency Injection. You may google them for further details and the see the differences.

This is why we use constructor based injection "All required dependencies are available at initialization time"

Code please...

We'll see that an instance of MyBeanToInject is injected by Spring as an argument to the MyService constructor:

public class MyService {
    private MyBeanToInject myBeanToInject;
    @Autowired
    public MyService(MyBeanToInject myBeanToInject) {
        this.myBeanToInject = myBeanToInject;
    }
}

To sum up 🏁

Advantages:

A basic benefit of dependency injection is decreased coupling between classes and their dependencies.
By removing a client's knowledge of how its dependencies are implemented, programs become more reusable, testable and maintainable.
Dependency injection reduces boilerplate code, since all dependency creation is handled by a singular component

Disadvantages:

Overuse can cause management problems and other problems.
Many compile time errors are passed to runtime

Hibernate - HQL vs SQL

Yiğit Erkal — Sun, 17 Apr 2022 11:57:02 +0000

Hibernate Query Language (HQL) is same as SQL (Structured Query Language) but it doesn't depends on the table of the database. Instead of table name, we use class name in HQL. Therefore, it is database independent query language.

Characteristics of HQL

Similar to SQL: HQL's syntax is very similar to standard SQL. If you are familiar with SQL then writing HQL would be pretty easy.
Fully object-oriented: HQL doesn't use real names of table and columns. It uses class and property names instead. HQL can understand inheritance, polymorphism and association.
Reduces the size of queries

Let's see the difference of the syntax 🍎🍏

In SELECT statement:

SQL ResultSet rs=st.executeQuery("select * from diet"); HQL Query query= session.createQuery("from diet");

In WHERE statement

SQL ResultSet rs=st.executeQuery("select * from diet where id=301"); HQL Query query= session.createQuery("from diet where id=301 ");

In UPDATE statement

SQL String query = "update User set name=? where id = ?"; PreparedStatement preparedStmt = conn.prepareStatement(query); preparedStmt.setString (1, "diet2"); preparedStmt.setlnt(2, 5); preparedStmt.executeUpdate(); HQL Query q = session.createQuery("update User set name=:n where id=:i"); q.setParameter("n", "diet2"); q.setParameter("i",55); int status = q.executeUpdate();

In INSERT statement

SQL String sql = "INSERT INTO Stock VALUES (100, 'abc')"; int result = stmt.executeUpdate(sql); HQL Query query = session.createQuery("insert into Stock(stock_code, stock_name) select stock_code, stock_name from backup_stock"); int result = query.executeUpdate();

❗ HQL only support insert from another table so you have to do this by creating and persisting new entity.

To sum up

HQL is similar to SQL and is also case insensitive.
HQL and SQL both fire queries in a database. In the case of HQL, the queries are in the form of objects that are translated to SQL queries in the target database.
SQL works with tables and columns to manipulate the data stored in it while HQL works with classes and their properties to finally be mapped to a table structure in a database.
HQL supports concepts like polymorphism, inheritance, association, etc. It is a powerful and easy-to-learn language that makes SQL object oriented.
SQL lets you modify the data through insert, update, and delete queries. You can add tables, procedures, or views to your database. The permissions on these added objects can be changed.