Interview Questions
1. Question: - What is the difference between a static variable, an instance variable and a local variable?
Answer: - Static Variables V/S Instance Variables V/S Local Variables- Class variables are known as static variables. There is only one occurrence of a class variable per JVM per class loader. It means that only one copy of the variables shared with the all instances of the class. When a class is loaded the static variables gets initialized. Instance variables across different objects can have different values. As we know that Instance and Static variables are associated with the objects and the reason they live in the Heap.
- An instance variable refers to an instance of a class. Non-Static variables are known as Instance variables and there is one occurrence of an instance variable in each class instance/object. It means each instance of the class has a separate copy or we can say that every object has its own copy of the instance variables. It is also known as a member variable or a field. Static/Class variables across different objects can have only one value. Instance variables can be used by all the available methods of a class unless the methods are marked with "static" modifier. Instance variables scope depends on their enclosing objects and it can’t live independently. These variables are declared in a class but outside a constructor, method or any code block. When space is assigned for an object in the heap then a slot for every instance variable is created. These variables have default values.
- Local Variables: - As Stack variables live on the stack so they are also known as stack variables. Local variables have a narrower scope than others like instance variables or class variables. The lifetime of a local variable is determined by execution path. Initialization of Stack variables or Local variables is always done by the developer.
2. Question: - What is the use of private constructor?
Answer: - If we want to prevent from sub
classing and if we don’t want other classes to instantiate the object. The
instantiation is done by a public static factory method within the same class.
Use of private constructor:-
- It can be used in the factory method design pattern. i.e. java.util.Collections class
- It can also be used to follow a singleton design pattern.
- It can be used in utility classes i.e. StringUtils.
3. Question: - What is the use of static methods?
Answer: - Static methods
are useful for Creating Singleton classes, factory methods and utility classes.
The best example of utility classes is java.util.Collections and java.lang.Math
classes.
4. Question:- What is Static and Dynamic Class Loading?
Answer:-
Static
V/S Dynamic Class loading
Static Class Loading: Creation of objects
and instance using new keyword is known as static class loading. It means
static class loading is done through the new operator. In Static Class
Loading, retrieval of class definition
and instantiation of the object is completed during compilation time.
Dynamic Class Loading: Class.forName ()
method is used to load classes in case
of Dynamic Class Loading. Dynamic class loading is used when the name of the
class is not known at compile time. Dynamic
loading of a class is a technique for programmatically invoking the functions
of a class loader at run time using available below methods
Class.forName(String)
ClassLoader.findSystemClass(String)
ClassLoader.loadClass(String)
Dynamic
class loading is achieved through reflection.This is done with the help of the
following methods:-
getClass();
getName();
getDeclaredFields();
Example
of Static Class Loading:-
package
com.gaurav.dynamicclassloading;
public class
StaticLoadingDemoTest {
public
String readValue(String value){
return
"readValue() Method called and the parameter value is : "+value;
}
public
static void main(String args[]){
StaticLoadingDemoTest
sldt = new StaticLoadingDemoTest();
System.out.println(sldt.readValue("GAURAV"));
}
}
Example
of Dynamic Class Loading:-
package
com.gaurav.dynamicclassloading;
class TestClassForDynamicLoading
{
public
String display(String strValue) {
System.out
.println("Inside
display method and the parameter value is : "
+
strValue);
return
TestClassForDynamicLoading.class.getName();
}
}
public class
DynamicLoadingDemoTest {
@SuppressWarnings("rawtypes")
public
static void main(String[] args) throws InstantiationException,
IllegalAccessException {
ClassLoader
classLoader = DynamicLoadingDemoTest.class.getClassLoader();
try
{
Class
loadedClass = classLoader
.loadClass("com.gaurav.dynamicclassloading.TestClassForDynamicLoading");
System.out.println("Getting
the simple name of the loadedClass =
"
+
loadedClass.getSimpleName());
System.out
.println("Getting
the fully qualified name of the loadedClass
= "
+
loadedClass.getName());
System.out
.println("Getting
the fully qualified name of the loadedClass Using getCanonicalName() = "
+
loadedClass.getCanonicalName());
System.out.println("********************************************************");
String
className = "com.gaurav.dynamicclassloading.TestClassForDynamicLoading";
Class
loadedClass1 = Class.forName(className);
System.out.println("Getting
the simple name of the loadedClass =
"
+
loadedClass1.getSimpleName());
System.out
.println("Getting
the fully qualified name of the loadedClass
= "
+
loadedClass1.getName());
TestClassForDynamicLoading
tcdl = (TestClassForDynamicLoading) Class.forName(className).newInstance();
tcdl.display("KUMAR
GAURAV");
Class
classLoad = DynamicLoadingDemoTest.class;
System.out.println("Name
of the loaded class -"+classLoad.getName());
}
catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
5. Question:-What is the difference between NoClassDefFoundError and ClassNotFoundException?
Answer:- Difference between NoClassDefFoundError and ClassNotFoundException
1) ClassNotFoundException This Exception is thrown when our application will try to load a class through the passed string name
by using below methods and requested class is not available at Runtime. ClassNotFoundException is thrown
when that required class is not present in the location where classloader is
searching.
Below are the methods which is generally generating the ClassNotFoundException:-
findSystemClass() method of ClassLoader class.
loadClass() method of ClassLoader class.
forName()
method of Class class.
NoClassDefFoundError will be
thrown when a class has been compiled with a specific class available in a jar
in the class path but then that class is no longer available during run
time(missing that jar in the class path during execution). Missing JAR files are the most common
reason for this error. Below are the reasons for getting that error :-
Specified class is not in the classpath
Specified class is not
visible to the classloader.
Specified class
does not exist.
2) ClassNotFoundException is a
checked Exception derived directly from java.lang.Exception class means when we
write our code like
"Class.forName("oracle.driver.Driver")",then we should must
provide try-catch block or we should use throws keyword otherwise code will
throw compilation error where as NoClassDefFoundError is an Error derived from
LinkageError.
Example to generate ClassNotFoundException:-
ClassNotFoundExceptionTest.java
package
com.gaurav.dynamicclassloading;
class
TestClassForClassNotFoundException {
public
String displayValues(String strValue) {
System.out
.println("Inside
display method and the parameter value is : "
+ strValue);
return
TestClassForClassNotFoundException.class.getName();
}
}
public class
ClassNotFoundExceptionTest {
@SuppressWarnings({
"rawtypes", "unused" })
public
static void main(String args[]) {
ClassLoader
classLoader = ClassNotFoundExceptionTest.class
.getClassLoader();
try
{
Class
loadedClass = classLoader
.loadClass("TestClassForClassNotFoundException");
}
catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
Result:-
java.lang.ClassNotFoundException:
TestClassForClassNotFoundException
at
java.net.URLClassLoader$1.run(Unknown Source)
at
java.security.AccessController.doPrivileged(Native Method)
at
java.net.URLClassLoader.findClass(Unknown Source)
at
java.lang.ClassLoader.loadClass(Unknown Source)
at
sun.misc.Launcher$AppClassLoader.loadClass(Unknown Source)
at
java.lang.ClassLoader.loadClass(Unknown Source)
at
com.gaurav.dynamicclassloading.ClassNotFoundExceptionTest.main(ClassNotFoundExceptionTest.java:22)
Example for Generating NoClassDefFoundError:-
Steps for how to get
NoClassDefFoundError :
- Develop the below program.
- Compile it and execute. It will execute. It will work fine and we will get output.
- Set the jdk path upto bin directory in the current location.
- Now Delete the inner class NoClassDefFoundErrorTest$InnerClass.
- Run the program again. We will find NoClassDefFoundError. Below I have attached the screenshot.
public class
NoClassDefFoundErrorTest {
class
InnerClass{
public
void getGreeting(){
System.out.println("Welcome
in India");
}
}
public
static void main(String args[]){
System.out.println("Inside
main()");
NoClassDefFoundErrorTest
nc = new NoClassDefFoundErrorTest();
NoClassDefFoundErrorTest.InnerClass
ic = nc.new InnerClass();
ic.getGreeting();
}
}
Result:-
No comments:
Post a Comment