Java Programming Exam Answers

1. Discuss how enums can implement interfaces in Java. Can an enum extend a class in Java? Just

In Java, enums can implement interfaces, which allows enums to provide implementations for

methods defined by the interface. This feature is useful when we want to ensure that every constant

in the enum provides specific behavior.

Here's an example:

```java

interface Runnable {

void run();

enum Animal implements Runnable {

DOG {

@Override

public void run() {

System.out.println('Dog runs');

},

CAT {

@Override

public void run() {

System.out.println('Cat runs');

}
 Java Programming Exam Answers

public class Main {

public static void main(String[] args) {

Animal.DOG.run();

Animal.CAT.run();

```

In this example, the `Animal` enum implements the `Runnable` interface, and each enum constant

provides its own implementation of the `run` method.

Enums in Java cannot extend other classes because they implicitly extend the `java.lang.Enum`

class. Since Java does not support multiple inheritance, an enum cannot extend any other class.

The primary reason is to maintain a clean and simple type system. Allowing enums to extend

classes would complicate the design and usage of enums.

 Java Programming Exam Answers

4. What are enumerations in Java? How do they differ from traditional constants? Explain the basic

Enumerations (enums) in Java are a special type of class that represents a group of constants

(unchangeable variables, like final variables). Enums are used to define collections of constants in a

type-safe manner.

Traditional constants in Java are typically defined using `static final` fields. However, enums provide

several advantages over traditional constants:

- Type safety: Enums ensure that the values are restricted to the predefined set.

- Namespace: Enums group related constants together in a single type.

- Readability: Code that uses enums is often more readable and self-documenting.

The basic syntax for declaring an enum is as follows:

```java

enum Day {

SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY

```

Here's an example program that demonstrates the use of enums:

```java

enum Day {

SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY

}
 Java Programming Exam Answers

public class Main {

public static void main(String[] args) {

Day today = Day.MONDAY;

switch (today) {

case MONDAY:

System.out.println('Mondays are tough!');

break;

case FRIDAY:

System.out.println('Fridays are great!');

break;

default:

System.out.println('Midweek days are so-so.');

break;

```

In this example, the `Day` enum is used to represent the days of the week, and a switch statement

is used to print different messages based on the current day.

 Java Programming Exam Answers

5. Explain the key concepts of generics: a. Type parameters, b. Generic methods, c. Bounded type p

#### a. Type Parameters

Type parameters allow you to define a generic type. They act as placeholders for the types that will

be used in the class, method, or interface. Type parameters are enclosed in angle brackets (`<>`)

and are typically represented by a single letter, like `T`, `E`, `K`, `V`, etc.

Example:

```java

public class Box<T> {

private T content;

public void setContent(T content) {

this.content = content;

public T getContent() {

return content;

```

#### b. Generic Methods

Generic methods are methods that introduce their own type parameters. These type parameters are

independent of any generic types declared by the class.

Example:
 Java Programming Exam Answers

```java

public class Util {

public static <T> void printArray(T[] array) {

for (T element : array) {

System.out.print(element + ' ');

System.out.println();

```

#### c. Bounded Type Parameters

Bounded type parameters restrict the types that can be used as arguments for a type parameter.

This is done using the `extends` keyword for upper bounds and `super` for lower bounds.

Example:

```java

public <T extends Number> void printNumber(T number) {

System.out.println('Number: ' + number);

```

#### d. Parameterized Types

Parameterized types are types created when a generic type is instantiated with specific type

arguments.

Example:
 Java Programming Exam Answers

```java

Box<Integer> integerBox = new Box<>();

integerBox.setContent(123);

System.out.println(integerBox.getContent());

```
 Java Programming Exam Answers

6. What are annotations in Java? What purpose do they serve? How do annotations differ from com

Annotations in Java are a form of metadata that provide data about a program but are not part of the

program itself. They have no direct effect on the operation of the code they annotate. Annotations

can be used to provide information to the compiler, to be processed by development tools, or to be

processed at runtime.

Annotations differ from comments in that they are structured and can be interpreted by the compiler

and runtime, whereas comments are ignored by the compiler and are meant only for human

readers.

Annotations also differ from traditional metadata, which might be stored in separate files or

databases. Annotations are embedded directly in the code, making it easier to maintain and keep

them in sync with the code.

Example of a custom annotation:

```java

import java.lang.annotation.*;

@Retention(RetentionPolicy.RUNTIME)

@Target(ElementType.METHOD)

@interface MyAnnotation {

String value();

public class Test {

 Java Programming Exam Answers

@MyAnnotation(value = 'example')

public void myMethod() {

System.out.println('Annotated method');

```

In this example, `MyAnnotation` is a custom annotation that can be applied to methods. The

`myMethod` method is annotated with `@MyAnnotation`.