Java

Question 1

Final

Answer 1

final class can't be inherited
final method can't be overridden
final variable value can't be changed

Question 2

Finally

Answer 2

code will be executed whether exception is handled or not.

Question 3

Finalize

Answer 3

used to perform clean up processing just before object is garbage collected

Question 4

static

Answer 4

modifier associated with the class rather than with any object.

Question 5

Generics

Answer 5

“a type or method to operate on objects of various types while providing compile-time type safety”

Java Generic methods and generic classes enable programmers to specify, with a single method declaration, a set of related methods, or with a single class declaration, a set of related types, respectively.

Generics also provide compile-time type safety that allows programmers to catch invalid types at compile time.

type erasure:

• all the extra information added using generics into source code will be removed from byte code generated from it
• inside byte code will be the old java syntax without generics. This helps in generating and executing code written prior to Java 5 (before generics)

Question 6

StringBuilder vs. StringBuffer

Answer 6

StringBuffer is synchronized
StringBuilder is not synchronized (faster)

Both are mutable (String is immutable)

Question 7

ArrayList vs. Vector

Answer 7

ArrayList is synchronized
Vector is not synchronized

ArrayList grows by 50%
Vector doubles in size

ArrayList can only use Iterator
Vector can use Iterator and Enumerator

Question 8

Checked exceptions vs. Unchecked exceptions

Answer 8

Checked exceptions:

• checked at compile time
• can anticipate and try to recover from
• should try to catch
• if a method throws a checked exception, then the method must either handle the exception, or it must specify the exception using throws keyword.
• parent class is Exception
• IOException
• SQLException
• DataAccessException
• ClassNotFoundException
• InvocationTargetException
• MalformedURLException

Unchecked exceptions:

• handling is NOT verified during compile time.
• occur because of bad programming.
• parent class is RuntimeException.
• NullPointerException
• ArrayIndexOutOfBound
• IllegalArgumentException
• IllegalStateException

Question 9

Error

Answer 9

a subclass of Throwable

• indicates serious problems that a reasonable application should not try to recover from.
• most are abnormal conditions.
• some of the common Errors are OutOfMemoryError and StackOverflowError.

Question 10

static binding

Answer 10

a binding that occurs during compilation.

also called early binding because it happens before a program runs.

actual object is not used for binding.

Example: method overloading.

Question 11

volatile

Answer 11

variables are stored in main memory (not CPU cache)

changes to them are visible across threads

Question 12

synchronized

Answer 12

keyword used in method declarations and code blocks

instance methods are synchronized over the instance of the class owning the method. Only one thread per instance of the class can execute this method.

static methods are synchronized on the Class object associated with the class. Only one Class object exists per JVM per class, so only one thread can execute inside a static synchronized method per class, irrespective of the number of instances it has.

all synchronized blocks synchronized on the same object can only have one thread executing inside them at the same time. All other threads attempting to enter the synchronized block are blocked until the thread inside the synchronized block exits the block.

synchronized block within method:
public void performSynchronizedTask() {
    synchronized (this) {
        setCount(getCount()+1);
    }
}

synchronized block within static method:
public static void performStaticSyncTask(){
synchronized (SynchronizedBlocks.class) {
setStaticCount(getStaticCount() + 1);
}
}

Question 13

atomic

Answer 13

operation can be safely performed in parallel on multiple threads without using the synchronized keyword or locks

Question 14

thread contention

Answer 14

a condition where one thread is waiting for a lock/object that is currently being held by another thread. Therefore, this waiting thread cannot use that object until the other thread has unlocked that particular object.

Question 15

race condition

Answer 15

occurs when two or more threads can access shared data, and they try to change it at the same time.
Because the thread scheduling algorithm can swap between threads at any time, you don’t know the order in which the threads will attempt to access the shared data. Therefore, the result of the change in data is dependent on the thread scheduling algorithm, i.e. both threads are “racing” to access/change the data.

Question 16

sleep vs. wait

Answer 16

sleep:
- sleep() doesn’t releases any lock or monitor while waiting
- used to hold the process for few seconds or the time you wanted
- used to introduce pause on execution, generally

wait:
- wait() releases the lock or monitor
- thread goes in waiting state
- won’t come back automatically until we call the notify() or notifyAll()
- used for inter-thread communication

Question 17

process vs. thread

Answer 17

process:
- has a self-contained execution environment
- generally has a complete, private set of basic run-time resources
- each process has its own memory space.

thread:
- sometimes called lightweight processes
- both processes and threads provide an execution environment, but creating a new thread requires fewer resources than creating a new process.
- threads exist within a process — every process has at least one.
- threads share the process’s resources, including memory and open files.

Question 18

abstract class vs. interface

Answer 18

A class must be declared abstract when it has one or more abstract methods.

An interface differs from an abstract class because an interface is not a class. An interface is essentially a type that can be satisfied by any class that implements the interface.

Question 19

Memoization

Answer 19

an optimization technique used primarily to speed up computer programs by storing the results of expensive function calls and returning the cached result when the same inputs occur again.

Question 20

inheritance vs. composition

Answer 20

inheritance:

• “is-a” relationship
• tightly coupled
• no access control
• use when superclass will not be changed

public class Animal {
    // variables, methods etc.
}

public class Cat extends Animal{
}

composition:

• “has-a” relationship
• uses instance variables of other objects
• loosely coupled
• access can be restricted
• unit testing is easy - we know all the methods used from the other class
• generally should be used over inheritance

public class Job {
    // variables, methods etc.
}

public class Person {
    //composition has-a relationship
    private Job job;

    //variables, methods, constructors
}

Question 21

access modifiers

Answer 21

Default:

• no access modifier is specified
• accessible to the classes in the same package only

Public:
-can be accessed from anywhere

Private:
-accessible only inside the same class

Protected:
-accessible only to the classes in the same package and to the subclasses (can be different packages

Question 22

polymorphism

Answer 22

• perform a single action in different ways
• the capability of a method to do different things based on the object that it is acting upon
• allows you define one interface and have multiple implementations

public class Animal {
   public void sound(){
      System.out.println("Animal is making a sound");   
   }
}

public class Horse extends Animal{
     @Override
     public void sound(){
          System.out.println("Neigh");
     }
}

public class Cat extends Animal{
    @Override
    public void sound(){
        System.out.println("Meow");
    }
}

public static void main(String args[]){
    Animal obj = new Horse();
    obj.sound();
}

which sound() method will be called is determined at runtime

Question 23

method overloading

Answer 23

• two or more methods in one class have the same method name but different parameters
• compile-time (reference type determines which overloaded method will be used)

Question 24

method overriding

Answer 24

• two methods have the same method name and parameters (i.e., method signature).
• one of the methods is in the parent class and the other is in the child class.
• allows a child class to provide a specific implementation of a method that is already provided its parent class.
• run-time (real object type determines which overridden method will be used at runtime)
• polymorphism applies to overriding, not overloading

Question 25

powers of 2

Answer 25

Power of Two Binary Hexadecimal Decimal Value
2⁰ 0001 1 1
2¹ 0010 2 2
2² 0100 4 4
2³ 1000 8 8
2⁴ 0001 0000 10 16
2⁵ 0010 0000 20 32
2⁶ 0100 0000 40 64
2⁷ 1000 0000 80 128
2⁸ 0001 0000 0000 100 256
2⁹ 0010 0000 0000 200 512
2¹⁰ 0100 0000 0000 400 1,024