Packages and Interfaces : MCQs & PYQs with Explanation

Option B

In Java, constants that cannot be changed are declared using final, often combined with static for class-level constants, example, static final int P = 33;. Simply using static does not make a variable constant.

Java supports single inheritance for classes, meaning a class can extend only one superclass. However, a class can implement multiple interfaces, allowing it to inherit behavior from multiple sources like multiple inheritance.

class Super {}
interface A {}
interface B {}
class Sub extends Super implements A, B
{
}

Option C

In Object-Oriented Programming (OOP), a pure abstract class is a class where all methods are abstract, meaning they do not have any method body and must be implemented by other classes.
An Interface is a special type of class that contains only abstract methods. It provides a blueprint for other classes.
Any class that implements an interface must provide implementations for all its methods. Therefore, a pure abstract class is generally called an interface.
Syntax:
interface InterfaceName
{
    Return_Type method1();
    Return_Type method2();
}
E.g.:
interface Shape 
{
    void draw();
}
class Circle implements Shape 
{
    public void draw() 
    {
        System.out.println("Drawing Circle");
    }
}
class Driver
{
    public static void main(String args[]) 
    {
        Circle myCircle=new Circle();
        myCircle.draw();
    }
}

Option C

In Java, an abstract class must be declared using the abstract keyword before the class name, and any abstract method inside it must also be declared with the abstract keyword and cannot have a method body.

Option D

Java does not support multiple inheritance with classes, i.e., a class cannot extend more than one class. However, Java allows a class to implement multiple interfaces. This provides a way to achieve multiple inheritance in Java.

When a class implements an interface, it must provide concrete definitions of all abstract methods defined in the interface. If the class does not implement all methods, it must be declared as abstract.

A class can implement multiple interfaces by separating them with a comma in the implements clause.

class Demo implements MyInterfaceP, MyInterfaceQ {
    // Implementation of methods from both interfaces
}

interface MyInterfaceP {
    void methodOne();
}
interface MyInterfaceQ {
    void methodTwo();
}
class MyClass implements MyInterfaceP, MyInterfaceQ {
    public void methodOne() {
        System.out.println("Method One from MyInterfaceP implemented.");
    }
    public void methodTwo() {
        System.out.println("Method Two from MyInterfaceQ implemented.");
    }
}
public class Driver {
    public static void main(String args[]) {
        MyClass obj = new MyClass();
        obj.methodOne();
        obj.methodTwo();
    }
}

Option B

In Object-Oriented Programming, protected members have a specific access rule:

• They can be accessed within the same package.
• They can also be accessed outside the package, but only through inheritance.

If class A has a protected method and class B is in a different package, then class B cannot access that method directly. To access it, class B must inherit (extend) class A. Only through inheritance can class B access the protected method from outside the package.
Package A (Class A)
package mypack1;
public class A 
{
    protected void show() 
    {
        System.out.println("Protected Method of Class A");
    }
}
Package B (Class B inherits A)
package mypack2;
import mypack1.A;
public class B extends A 
{
    public static void main(String[] args) 
    {
        B obj=new B();
        obj.show();   // Accessing protected method through inheritance.
    }
}

Option C

An abstract method is a method that is declared without a body and must be implemented by a subclass. It is used inside an abstract class or interface in Java.
Syntax:
public abstract void abc();

• If a class contains an abstract method, the class must be declared abstract.
• Abstract methods cannot be final, static, or private.
• Subclasses must override abstract methods.

Option B

In Java, the final keyword is a non‑access modifier used to restrict changes. It can be applied to:

• Variables: Makes the variable a constant whose value cannot be reassigned.
• Methods: Prevents the method from being overridden in subclasses.
• Classes: Prevents the class from being extended.

However, final is not used with exceptions in Java. Exceptions are handled with try, catch, throw, throws, etc.

Option D

The abstract class is used for achieving partial abstraction. Unlike abstract class an interface is used for full abstraction.
Interface looks like a class but it is not a class. An interface can have methods and variables just like the class but the methods declared in interface are by default abstract (only method signature, no body). Also, the variables declared in an interface are public, static and final by default.
A class extends another class, an interface extends another interface, but a class implements an interface.
A class can implement more than one interface which is one of the key features of interfaces in Java.
 

interface MyInterface1
{
    void fun1();
}
interface MyInterface2
{
    void fun2();
}
class Demo implements MyInterface1,MyInterface2
{
    public void fun1()
    {
        System.out.println("Inside fun1() Method");
    }
    public void fun2()
    {
        System.out.println("Inside fun2() Method");
    }
    void fun3()
    {
        System.out.println("Inside fun3() Method");
    }
}
class InterfaceExample
{
    public static void main(String args[])
    {
        Demo obj1=new Demo();
        obj1.fun1();
        obj1.fun2();
        obj1.fun3();
        MyInterface1 obj2=new Demo();
        obj2.fun1();
        //obj2.fun2(); Error.
        //obj2.fun3(); Error.
        MyInterface2 obj3=new Demo();
        //obj3.fun1(); Error.
        obj3.fun2();
        //obj3.fun3(); Error.
    }
}
OUTPUT
Inside fun1() Method
Inside fun2() Method
Inside fun3() Method
Inside fun1() Method
Inside fun2() Method

Option C

In Java, access specifiers control the visibility of class members. To make members accessible only within the same package, we use package-private (default) access.

• The package-private is the default access level when no access modifier is specified.
• Members with package-private access can be accessed by any class inside the same package but not from classes in other packages.

Option D

In object-oriented programming (Java), an interface is a reference type that is used to achieve abstraction.

• An interface is implicitly abstract. Even if we do not write the keyword abstract, it is treated as abstract by default.
• Interface methods cannot be declared as final because final methods cannot be overridden, and interface methods are meant to be implemented by classes.
• All methods inside an interface are implicitly public and abstract unless specified otherwise.

Option A

In Java, extends keyword is used for class inheritance where a subclass inherits properties and methods from a superclass. Syntax for inheritance in Java is class Child extends Parent {}.