Java Generics
practice.

What will be the output of the following Java program?

import java.util.*;
public class genericstack <E>
{
    Stack <E> stk = new Stack <E>();
public void push(E obj)
    {
        stk.push(obj);
}
public E pop()
    {
        E obj = stk.pop();
  return obj;
}
}
class Output
{
    public static void main(String args[])
    {
        genericstack <Integer> gs = new genericstack<Integer>();
        gs.push(36);
        System.out.println(gs.pop());
    }
}

What will be the output of the following Java program?

import java.util.*;
public class genericstack <E>
{
    Stack <E> stk = new Stack <E>();
public void push(E obj)
    {
        stk.push(obj);
}
public E pop()
    {
        E obj = stk.pop();
  return obj;
}
}
class Output
{
    public static void main(String args[]) 
    {
        genericstack <Integer> gs = new genericstack<Integer>();
        gs.push(36);
        System.out.println(gs.pop());
    }
}

Which of these is wildcard symbol?

What will be the output of the following Java program?

import java.util.*;
class Output
{
    public static void addNumbers(List<? super Integer> list)
    {
        for (int i = 1; i <= 10; i++)
        {
            list.add(i);
        }
    }
    public static void main(String args[])
    {
       List<Double> ld = Arrays.asList();
       addnumbers(10.4);
       System.out.println("getList(2)");
    }
}

Which of these is an correct way making a list that is upper bounded by class Number?

What will be the output of the following Java program?

public class BoxDemo
{
    public static <U> void addBox(U u, 
       java.util.List<Box<U>> boxes)
      {
        Box<U> box = new Box<>();
        box.set(u);
        boxes.add(box);
      }
    public static <U> void outputBoxes(java.util.List<Box<U>> boxes)
    {
        int counter = 0;
        for (Box<U> box: boxes)
        {
            U boxContents = box.get();
            System.out.println("Box #" + counter + " contains [" + boxContents.toString() + "]");
            counter++;
        }
    }
    public static void main(String[] args)
    {
        java.util.ArrayList<Box<Integer>> listOfIntegerBoxes = new java.util.ArrayList<>();
        BoxDemo.<Integer>addBox(Integer.valueOf(10), listOfIntegerBoxes);
        BoxDemo.outputBoxes(listOfIntegerBoxes);
    }
}

What will be the output of the following Java code?

import java.util.*;
public class genericstack <E>
{
    Stack <E> stk = new Stack <E>();
public void push(E obj)
    {
        stk.push(obj);
}
public E pop()
    {
        E obj = stk.pop();
  return obj;
}
}
class Output
{
    public static void main(String args[])
    {
        genericstack <Integer> gs = new genericstack<Integer>();
        gs.push(36);
        System.out.println(gs.pop());
    }
}

Which of these type parameters is used for a generic methods to return and accept a number?

Which of the following cannot be Type parameterized?

What will be the output of the following Java program?

import java.util.*;
class Output
{
    public static double sumOfList(List<? extends Number> list)
    {
        double s = 0.0;
        for (Number n : list)
            s += n.doubleValue();
        return s;
    }
    public static void main(String args[])
    {
        List<Integer> li = Arrays.asList(1, 2, 3);
        System.out.println(sumOfList(li));
    }
}

What will be the output of the following Java program?

import java.util.*;
class Output 
{
    public static double sumOfList(List<? extends Number> list)
    {
        double s = 0.0;
        for (Number n : list)
            s += n.doubleValue();
        return s;
    }
    public static void main(String args[]) 
    {
       List<Double> ld = Arrays.asList(1.2, 2.3, 3.5);
       System.out.println(sumOfList(ld));
    }
}

What will be the output of the following Java program?

import java.util.*;
public class genericstack <E> 
{
    Stack <E> stk = new Stack <E>();
public void push(E obj)
    {
        stk.push(obj);
}
public E pop()
    {
        E obj = stk.pop();
  return obj;
}
}
class Output 
{
    public static void main(String args[])
    {
        genericstack <Integer> gs = new genericstack<Integer>();
        gs.push(36);
        System.out.println(gs.pop());
    }
}

Which of the following allows us to call generic methods as a normal method?

What will be the output of the following Java program?

import java.util.*;
public class genericstack <E>
{
    Stack  stk = new Stack <E>();
public void push(E obj) 
    {
        stk.push(obj);
}
public E pop() 
    {
        E obj = stk.pop();
  return obj;
}
}
class Output
{
    public static void main(String args[])
    {
        genericstack <String> gs = new genericstack();
        gs.push("Hello");
        System.out.println(gs.pop());
    }
}

Which of these type parameters is used for a generic methods to return and accept any type of object?

Which of the following keywords are used for lower bounding a wild card?

What will be the output of the following Java program?

import java.util.*;
public class genericstack <E>
{
    Stack <E> stk = new Stack <E>();
public void push(E obj)
    {
        stk.push(obj);
}
public E pop() 
    {
        E obj = stk.pop();
  return obj;
}
}
class Output
{
    public static void main(String args[])
    {
        genericstack <Integer> gs = new genericstack<Integer>();
        gs.push(36);
        System.out.println(gs.pop());
    }
}

What is use of wildcards?

Which of these types cannot be used to initiate a generic type?

What will be the output of the following Java code?

import java.util.*;
public class genericstack <E>
{
    Stack <E> stk = new Stack <E>();
public void push(E obj) 
    {
        stk.push(obj);
}
public E pop()
    {
        E obj = stk.pop();
  return obj;
}
}
class Output
{
    public static void main(String args[])
    {
        genericstack <String> gs = new genericstack<String>();
        gs.push("Hello");
        System.out.println(gs.pop());
    }
}