Generics Interview Questions and Answers
Q1. What are Generics in Java?
Ans: Generics are a characteristic that permit a class to be parameterized into sub-types. Generics offer collect-time safety and save you runtime typecasting errors resulting in ClassCastException. Without generics, a consumer is pressured to use the bottom commonplace base-elegance after which typecast the item, which is especially error-inclined and has no kind-protection.
Q2. What are Generic Methods?
Ans: Generic method are techniques that is type parameterized.
Public class GenericMethodExample
public static void main(String s)
String StrArray = new String "Find", "the", "word", "in", "this",
System.Out.Println(consists of(StrArray, "word"));
Integer intArray = new Integer four, 5, 32, 100, 303, 2002, 465 ;
public static <T> boolean carries(T list, T itemToFind)
for (T listItem : list)
if (itemToFind == null)
if (listItem == null)
go back true;
else if (itemToFind.Equals(listItem))
go back authentic;
go back fake;
Q3. Why Generics is needed?
Ans: Generics helps locating troubles all through bring together time instead of runtime. Generics are parameter for sorts.
Q4. What are generics in c#?
Ans: Generics refers back to the technique of writing the code for a category with out specifying the facts kind(s) that the class works on. It will let you define type-secure records systems, without committing to actual facts kinds. It lets in writing less however greater powerful code and offers flexibility and power but the developer desires to be accountable even as the usage of it.
Q5. What are standards delivered with Java five?
Ans: Generics , Enums , Autoboxing , Annotations and Static Import.
Q6. Example of a Bounded ordinary technique.
Ans: static <T extends Number> T processTheNumber(T range)
T result = wide variety;
return end result;
Q7. Why might not the following code sample compile and the way could you fix it?
Ans: This will enhance a compilation error. It is inaccurate to skip a List<String> to a method accepting List<Object>. A List<Object> can take delivery of Strings, but t1 can best receive List<Object>.
Either ls need to be changed to List<Object>, or lo need to be made Generic: List<? Extends Object> lo
Q8. What are common types? How are they declared and instantiated?
Ans: A time-honored type is a frequent class or interface that is parameterized over kinds.
Declaration of customary types: A time-honored magnificence is said using the layout 'class MyClass ...'. The perspective brackets <> is the type parameter section and specifies the kind parameters T1, T2 ... For the commonplace magnificence.
Instantiation of typical kinds: You instantiate a frequent magnificence the usage of the new key-word as standard, however bypass actual kinds within the parameter segment. Example - 'MyClass myClass = new MyClass();'. In Java 7 and later you may get rid of the type and just have the attitude brackets <>. Example - 'MyClass myClass = new MyClass<>();'. The empty angular brackets <> syntax is generally referred to as the Diamond.
Q9. What is the difference between formal parameter and sort parameter?
Ans: formal parameters utilized in technique declarations, type parameters provide a manner in order to re-use the equal code with specific inputs. The difference is that the inputs to formal parameters are values, whilst the inputs to kind parameters are kinds.
Q10. Is it legal to initialize List like this?
Ans: LinkedList<Integer> l=new LinkedList<int>();
No, Generic parameters can't be primitives.
Ans: Generics brought in Java 1.5, allows sturdy-typing on the gathering items. Generics defines the object types that the gathering can keep.
It provides compile time kind-protection and ensures that best the unique kind is introduced in collection and removes ClassCastException in runtime.
Q12. What is kind erasure?
Ans: The Type facts used for Generic gadgets is only available at assemble time. The compiler removes all the sort statistics when changing to byte-code. This makes the type information unavailable at Runtime and the Generic type is converted to Raw type. The compiler gives exams at assemble time to prevent runtime mistakes for incorrect type statistics.
The case where things can go incorrect is while immediately the use of Raw types in the code. The compiler will improve a warning in this case but it will now not fail.
Q13. How do you create sub-instructions of typical training?
Ans: Similar to ordinary classes and interfaces, you could create sub-styles of common lessons or interfaces through extending or imposing from the regular instructions or interfaces.
For example: in Java collections API, ArrayList implements List and Listimplements Collections. The sub-kind relation is preserved as long as the type argument does not range. So, ArrayList implements List and List implements Collections.
Q14. Which of the subsequent syntax is accurate?
Ans: import static java.Lang.System.*;
static import java.Lang.System.*;
import static java.Lang.System.*; is accurate
Q15. Explain Generics using a sample code.
Ans: List list = new ArrayList();
listing.Upload("No Generics is used ");
String s = (String) listing.Get(0);
In the above instance, ArrayList can preserve any kind of items, however we need to solid every item to its appropriate records kind for the reason that get method's return kind is Object. A string literal is introduced to the list and to get it from the listing we want forged and keep it.
If we shop an worker object as an example at the first index, then the third line of code will throw a run-time Exception.
List<String> list = new ArrayList<String>();
list.Upload("Generics is implemented");
String s = list.Get(zero); // no solid is needed
In the above code, the instance is rewritten using generics, and the list is strongly typed that requires no casting.
Q16. Is the code bring together-time and run-time secure? What do I and K stand for? What is using the extends keyword in each locations? Explain the get approach definition. Explain the wildcard symbols.
Ans: magnificence A<K, I extends List<K>>
public K get(final int index, final I listing)
go back list.Get(idx);
class B extends A<String, LinkedList<String>>
public static void predominant(String...Args)
A<Integer, ArrayList<Integer>> a = new A<>;
B b = new B();
A<?, ?> g;
A<? Extends Integer, ?> f;
g = a;
g = b;
f = a;
Yes, this code is compile-time and run-time safe.
I and K are Generic type parameters used to make sure type protection.
The extends keyword within the first line defines the scope of the I parameter. The I parameter can most effective be a sub-type of List of kind K. K by using default extends Object.
The 2nd extends key-word is used for inheriting elegance A and solving the type parameters of A to String and LinkedList.
The get method takes an index integer and a List of type K as the parameters. It returns the listing value at index, in an effort to have a go back type K because the listing parameter is constant to K.
For instance, whilst get is known as on example b of class B, get will take a LinkedList<String> and go back the String at index.
The wildcard symbols imply that g will have any type inside the bounds of the parameters. That is why a and b may be assigned to it. In the case of f, the primary parameter gets limited to Integer sub-types, so only a can be assigned to it, not b. F may be assigned to g, but no longer the alternative manner round.
Q17. Can Java generics be implemented to primitive sorts?
Ans: No Java generics cannot be implemented to primitive kinds. But you may use wrapper instructions of primitive type to apply Java generics.
Q18. Which of the following syntax are accurate?
LinkedList<Integer> l=new LinkedList<int>();
List<Integer> l=new LinkedList<int>();
LinkedList<Integer> l=new LinkedList<Integer>();
List<Integer> l = new LinkedList<Integer>();
Ans: c and d are correct.
Q19. How are you able to suppress unchecked caution in Java ?
Ans: the usage of @SuppressWarnings("unchecked") annotation.
List<String> myList = new ArrayList();
Q20. Can you create times of prevalent type parameters?
Ans: No you can not create instances of typical type parameters.