ExamVeda
Login
Home

Interfaces and Abstract Classes -Java Programming MCQ Questions and Answers

Learn competitive java programming mcq questions and answers on Interfaces and Abstract Classes with easy and logical explanations. Page-5 section-1

Each section contains 100 MCQs on Interfaces and Abstract Classes .
41 
interface Base{
      boolean m1 ();
      byte m2(short s);
}

which two code fragments will compile?
1. interface Base2 implements Base {}

2. abstract class Class2 extends Base
    { public boolean m1(){ return true; }}

3. abstract class Class2 implements Base {}

4. abstract class Class2 implements Base
    { public boolean m1(){ return (7 > 4); }}

5. abstract class Class2 implements Base
    { protected boolean m1(){ return (5 > 7) }}
Discuss
Answer & Solution
Answer: Option C
Solution:

(3) is correct because an abstract class doesn't have to implement any or all of its interface's methods. (4) is correct because this method is correctly implemented ((7 > 4) is a boolean).

(1) is incorrect because interfaces doesn't implement anything. (2) is incorrect because classes don't extend interfaces. (5) is incorrect because interface methods are implicitly public, so the methods being implemented must be public.

42
Which two of the following are legal declarations for abstract classes and interfaces?
1. final abstract class Test {}
2. public static interface Test {}
3. final public class Test {}
4. protected abstract class Test {}
5. protected interface Test {}
6. abstract public class Test {}
Discuss
Answer & Solution
Answer: Option E
Solution:

(3), (6). Both are legal class declarations.

(1) is wrong because a class cannot be abstract and final "there would be no way to use such a class". (2) is wrong because interfaces and classes cannot be marked as static. (4) and (5) are wrong because classes and interfaces cannot be marked as protected.

43 
interface Test{
      int p = 10; //line 1
      public int q = 20; //line 2
      public static int r = 30; //line 3
      public static final int s = 40; //line 4
}

Which of the above line will give compilation error?
Discuss
Answer & Solution
Answer: Option E
No explanation is given for this question. Let's Discuss on Board
44
What will happen after compiling this program code?
abstract class MyClass{ //line 1
      private int a, b;

      public void call(int a, int b){
            this.a = a;
            this.b = b;
            System.out.print(a+b);
      }
}

public class Test{
      public static void main(String args[]){
            MyClass m = new MyClass(); //line 2
            m.call(12,25);
      }
}
Discuss
Answer & Solution
Answer: Option C
Solution:

Abstract class is not concrete class which means object cannot be created for abstract class, its requires extending it and then create the object of extended class.

45
Runnable is a _____ .
Discuss
Answer & Solution
Answer: Option C
No explanation is given for this question. Let's Discuss on Board
46
What is the output for the below code?
interface A{
      public void printValue();
}

public class Test{
      public static void main (String[] args){
            A a1 = new A(){
                         public void printValue(){
                               System.out.println("A");
                         }
                   };
            a1.printValue();
      }
}
Discuss
Answer & Solution
Answer: Option B
Solution:

The A a1 reference variable refers not to an instance of interface A, but to an instance of an anonymous (unnamed) class. So there is no compilation error.

47
What will be the output?
public interface InfA{
      protected String getName();
}

public class Test implements InfA{
      public String getName(){
            return "test-name";
      }
      public static void main (String[] args){
            Test t = new Test();
            System.out.println(t.getName());
      }
}
Discuss
Answer & Solution
Answer: Option B
Solution:

Illegal modifier for the interface method InfA.getName(); only public and abstracts are permitted.

48
What will be the output for the below code?
public interface TestInf{
      int i =10;
}

public class Test{
      public static void main(String... args){
            TestInf.i=12;
	    System.out.println(TestInf.i);
      }
}
Discuss
Answer & Solution
Answer: Option A
Solution:

All the variables declared in interface is implicitly static and final , therefore can't change the value.

49
What will be the output when the following program is compiled and executed?
abstract class TestAbstract{
      String my_name;
      String myName(){
            my_name = "Examveda";
            return my_name;
      }
      abstract void display();
}

public class Test extends TestAbstract{
      void display(){
            String n = myName();
	    System.out.print("My name is "+ n);
      }

      public static void main(String args[]){
            Test t = new Test();
	    t.display();
      }
}
Discuss
Answer & Solution
Answer: Option A
Solution:

The options B, C and D are incorrect options as in Java we can declare an abstract class comprising of abstract and non-abstract methods that will not lead to any compilation error. Therefore, option A is the correct answer implying that the 't' instance of Test class invokes the display method, which is implemented in the Test class. The display method invokes myName() method declared int the TestAbstract class and prints the name.

50
What happens if the following program is compiled and executed?
interface MyInterface{
      void display();
}

interface MySubInterface extends MyInterface{
      void display();
}

public class Test implements MySubInterface{
      public void display(){
            System.out.print("Welcome to Examveda.");
      }
      public static void main(String args[]){
            Test t = new Test();
	    t.display();
      }
}
Discuss
Answer & Solution
Answer: Option C
Solution:

The program will compile and execute successfully as you can declare methods with same name in an interface and the method of either interface can be used, implying the option a is incorrect. The option B and D are incorrect as the methods of an interface are implicitly public and abstract.