|
Java Interview Questions and Answers
The superclass constructor runs before the
subclass constructor. The subclass's version of the overridable method
will be invoked before the subclass's constructor has been invoked. If
the subclass's overridable method depends on the proper initialization
of the subclass (through the subclass constructor), the method will most
likely fail. Is that true?
Yes. It is true
Why are the interfaces more flexible than abstract classes?
--An interface-defined type can be implemented by any class in a class
hierarchy and can be extended by another interface. In contrast, an
abstract-class-defined type can be implemented only by classes that
subclass the abstract class.
--An interface-defined type can be used well in polymorphism. The
so-called interface type vs. implementation types.
--Abstract classes evolve more easily than interfaces. If you add a new
concrete method to an abstract class, the hierarchy system is still
working. If you add a method to an interface, the classes that rely on
the interface will break when recompiled.
--Generally, use interfaces for flexibility; use abstract classes for
ease of evolution (like expanding class functionality).
What are new language features in J2SE 5.0?
Generally:
1. generics
2. static imports
3. annotations
4. typesafe enums
5. enhanced for loop
6. autoboxing/unboxing
7. varargs
8. covariant return types
What is covariant return type?
A covariant return type lets you override a superclass method with a
return type that subtypes the superclass method's return type. So we can
use covariant return types to minimize upcasting and downcasting.
class Parent {
Parent foo () {
System.out.println ("Parent foo() called");
return this;
}
}
class Child extends Parent {
Child foo () {
System.out.println ("Child foo() called");
return this;
}
}
class Covariant {
public static void main(String[] args) {
Child c = new Child();
Child c2 = c.foo(); // c2 is Child
Parent c3 = c.foo(); // c3 points to Child
}
}
What is the result of the following statement?
int i = 1, float f = 2.0f;
i += f; //ok, the cast done automatically by the compiler
i = i + f; //error
The compound assignment operators automatically include cast operations
in their behaviors.
What is externalization? Where is it useful?
Use the Externalizable interface when you need complete control over
your Bean's serialization (for example, when writing and reading a
specific file format).
What will be the output on executing the
following code.
public class MyClass {
public static void main (String args[] ) {
int abc[] = new int [5];
System.out.println(abc);
}
}
A Error array not initialized
B 5
C null
D Print some junk characters
Answer : D
It will print some junk characters to the output. Here it will not give
any compile time or runtime error because we have declared and
initialized the array properly. Event if we are not assigning a value to
the array, it will always initialized to its defaults.
What will be the output on executing the following code.
public class MyClass {
public static void main (String args[] ) {
int abc[] = new int [5];
System.out.println(abc[0]);
}
}
A Error array not initialized
B 5
C 0
D Print some junk characters
Answer : C.
Page Numbers :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
Have a Question ?
post your questions here. It
will be answered as soon as possible.
Check
Structs Interview
Questions for more Structs Interview Questions with answers
|
