dark horse digital interview questions and answers - Wikitechy

What is Normalization ?

Editor — Mon, 19 Jul 2021 10:33:39 +0000

Normalization is the process of reorganizing data in a database. They have two basic requirements they are:
- No redundancy of data.
- Logical as data dependencies.
To normalize a database, we divide the database into tables and establish relationships between the tables.
Database normalization can essentially be defined as the practice of optimizing table structures.
Optimization is accomplished as a result of a thorough investigation of the various pieces of data that will be stored within the database, in particular concentrating upon how this data is interrelated.

Types of Normalization

1NF
2NF
3NF
BCNF
4NF
5NF

First Normal Form (1NF)

The First Normal Form should be following some rules in table,
- It should only have single(atomic) valued attributes/columns.
- Values stored in a column should be of the same domain
- All the columns in a table should have unique names.
- And the order in which data is stored, does not matter.

Second Normal Form (2NF)

For a table to be in the Second Normal Form,
- It should be in the First Normal form.
- And, it should not have Partial Dependency.

Third Normal Form (3NF)

A table is said to be in the Third Normal Form when,
- It is in the Second Normal form.
- And, it doesn’t have Transitive Dependency.

Boyce and Codd Normal Form (BCNF)

Boyce and Codd Normal Form is a higher version of the Third Normal form. This form deals with certain type of anomaly that is not handled by 3NF. A 3NF table which does not have multiple overlapping candidate keys is said to be in BCNF.
For a table to be in BCNF, following conditions must be satisfied:
- R must be in 3rd Normal Form and, for each functional dependency ( X → Y ), X should be a super Key.

Fourth Normal Form (4NF)

A table is said to be in the Fourth Normal Form when,
- It is in the Boyce-Codd Normal Form.
- And, it doesn’t have Multi-Valued Dependency.

Fifth Normal Form (5NF)

Fifth Normal Form (5NF), also known as project-join normal form (PJ/NF) is a level of database normalization designed to reduce redundancy in relational databases recording multi-valued facts by isolating semantically related multiple relationships.
A relation R is in Fifth Normal Form (5NF) and only if the following conditions are satisfied simultaneously,
- R is already in 4NF.
- It cannot be further non-loss decomposed.

How to count number of characters in a string ?

Editor — Tue, 13 Jul 2021 23:34:34 +0000

How to count number of characters in a string ?

To count the amount of ‘x’ characters that are in a string, and print out the number using java program.

class Wikitechy
{ 
    // Method that return count of the given 
    // character in the string 
    public static int count(String s, char c) 
    { 
        int res = 0; 
  
        for (int i=0; i        { 
            // checking character in string 
            if (s.charAt(i) == c) 
            res++; 
        }  
        return res; 
    } 
      
    // Driver method 
    public static void main(String args[]) 
    { 
        String str= "Welcome to Wikitechy"; 
        char c = 'W'; 
        System.out.println(count(str, c)); 
    } 
}

Output

What is final, finally and finalize ?

Editor — Tue, 13 Jul 2021 23:33:14 +0000

What is final, finally and finalize ?

Final

Final is used to apply limitations on class, method and variable. Final variable value couldn’t be changed final method couldn’t be overridden and final class can’t be inherited.
Final is a keyword.

Sample Code

Once initialized value of variable cannot be changed.

class A 
{ 
    public static void main(String[] args) 
    { 
        int a = 5; 
  
        // final variable 
        final int b = 6; 
  
         
        a++; 
  
        // modifying the final variable :  
        b++; 
    } 
}

If we declare any variable as final, we can’t change its contents since it is final, and if we change it then we have the Compile Time Error.

Finally

Finally is used to place significant code, whether exception is handled or not that time will be executed.
Finally is a block.

Sample Code

// A Java program to demonstrate finally. 
class Wikitechy
{ 
     
    static void A() 
    { 
        try 
        { 
            System.out.println("inside A"); 
            throw new RuntimeException("demo"); 
        } 
        finally
        { 
            System.out.println("A's finally"); 
        } 
    }  
    static void B() 
    { 
        try 
        { 
            System.out.println("inside B"); 
            return; 
        } 
        finally
        { 
            System.out.println("B's finally"); 
        } 
    } 
  
    public static void main(String args[]) 
    { 
        try 
        { 
            A(); 
        } 
        catch (Exception e) 
        { 
            System.out.println("Exception caught"); 
        } 
        B(); 
    } 
}

Output

inside A
A's finally
Exception caught
inside B
B's finally

Finalize

Finalize is using for the processing of clean up to be perform just before object is garbage collected.
Finalize is a method.
Once finalize method completes immediately Garbage Collector destroy that object.

Syntax

protected void finalize throws Throwable
{

}

Sample Code

class Wikitechy 
{ 
    public static void main(String[] args) 
    { 
        String s = new String("RR"); 
        s = null; 
  
        // Requesting JVM to call Garbage Collector method 
        System.gc(); 
        System.out.println("Main Completes"); 
    } 
  
    // Here overriding finalize method 
    public void finalize() 
    { 
        System.out.println("finalize method overriden"); 
    } 
}

Output

Main Completes

What is static and dynamic binding in Java ?

Editor — Tue, 13 Jul 2021 23:07:31 +0000

What is static and dynamic binding in Java ?

Static Binding

The binding which can be determined at compile time by compiler is known as static binding.
The binding of static, private and final methods is compile-time.
The class is determined at the compile time only. So, method cannot be overridden.
Object of local class to be accessed in static.

Sample Code

public class NewClass 
{ 
    public static class superclass 
    { 
        static void print() 
        { 
            System.out.println("print in superclass."); 
        } 
    } 
    public static class subclass extends superclass 
    { 
        static void print() 
        { 
            System.out.println("print in subclass."); 
        } 
    } 
  
    public static void main(String[] args) 
    { 
        superclass A = new superclass(); 
        superclass B = new subclass(); 
        A.print(); 
        B.print(); 
    } 
}

Output

print in superclass.
print in superclass.

Dynamic Binding

When compiler is not able to determination the call/binding at compile time, such binding is known as Dynamic or late Binding.
Method Overriding is the good example for dynamic binding.
In overriding concept have the both parent and child classes should be presented they have same method and in this case the type of the object only determines which method is to be executed.
At the run time is determined to the type of object. So, this is known as dynamic binding.

Sample Code

 
public class NewClass 
{ 
    public static class superclass 
    { 
        void print() 
        { 
            System.out.println("print in superclass."); 
        } 
    } 
  
    public static class subclass extends superclass 
    { 
        @Override
        void print() 
        { 
            System.out.println("print in subclass."); 
        } 
    } 
  
    public static void main(String[] args) 
    { 
        superclass A = new superclass(); 
        superclass B = new subclass(); 
        A.print(); 
        B.print(); 
    } 
} 

Output

print in superclass.
print in subclass.

How HashMap Works in Java ?

Editor — Tue, 13 Jul 2021 23:07:25 +0000

How HashMap Works in Java ?

HashMap is one of the most widly used implementation of Map to store key-value pairs. To implement HashMap with ArrayList.
It is provides two basic HashMap functions they are: get(key) and put(key, value).
While storing code to be checking the duplicate values. While duplicate values are presents to be removed.
Implementation should not be used as a replacement of HashMap. Also while testing the code, make sure that the Object used in the KEY has proper implementation of equals() method.

Example:

 
package com.journaldev.util;

import java.util.ArrayList;
import java.util.List;

public class MyHashMap {

	class Container{
		Object key;
		Object value;
		public void insert(Object k, Object v){
			this.key=k;
			this.value=v;
		}
	}
	
	private Container c;
	private List recordList;
	
	public MyHashMap(){
		
		this.recordList=new ArrayList();
	}
	
	public void put(Object k, Object v){
		this.c=new Container();
		c.insert(k, v);
		//check for the same key before adding
		for(int i=0; i			Container c1=recordList.get(i);
			if(c1.key.equals(k)){
				//remove the existing object
				recordList.remove(i);
				break;
			}
		}
		recordList.add(c);
	}
	
	public Object get(Object k){
		for(int i=0; i			Container con = recordList.get(i);
			//System.out.println("k.toString():"+k.toString()+"con.key.toString()"+con.key.toString());
			if (k.toString()==con.key.toString()) {
				
				return con.value;
			}
			
		}
		return null;
	}
	
	public static void main(String[] args) {
		MyHashMap hm = new MyHashMap();
		hm.put("1", "1");
		hm.put("2", "2");
		hm.put("3", "3");
		System.out.println(hm.get("3"));
		hm.put("3", "4");
		
		System.out.println(hm.get("1"));
		System.out.println(hm.get("3"));
		System.out.println(hm.get("8"));
	}

}

Output:

3
1
4
null

What is Polymorphism in Java ?

Editor — Tue, 13 Jul 2021 23:07:15 +0000

What is Polymorphism in Java ?

Polymorphism in Java is a concept in different ways we can perform a single action.
Poly and morphs. The word “poly” means many and “morphs” means forms. Many forms are known as polymorphism.

There are two types of polymorphism in Java:
- Compile-Time Polymorphism and
- Runtime Polymorphism.

Polymorphism in java we can perform by method overloading and method overriding.

Dynamic Method Dispatch or Runtime Polymorphism in Java

Java supports Runtime Polymorphism is one of the ways is method overriding
A call to an overridden method is resolved at run time, rather than compile time it is called as dynamic method dispatch mechanism.
At run-time, it depends on the type of the object being referred that determines which version of an overridden method will be executed.
A subclass object refers by a superclass variable. This is also known as upcasting. Java uses this statistic to resolve calls to overridden methods at run time.

Example of Java Runtime Polymorphism

 
class Bike{  
  void run(){System.out.println("running");}  
}  
class Splendor extends Bike{  
  void run(){System.out.println("running safely with 60km");}  
  
  public static void main(String args[]){  
    Bike b = new Splendor();//upcasting  
    b.run();  
  }  
} 

Output

running safely with 60km.