Java Labs Page 8 - Annotations, Reflection & Inner Classes

Lab 22: Annotations

Expert

Coding Challenge

Your Task: Learn to use built-in annotations and create custom annotations for metadata.

Detailed Requirements:
1. Built-in annotations:
   • @Override - method overrides superclass method
   • @Deprecated - marks element as deprecated
   • @SuppressWarnings - suppress compiler warnings
   • @FunctionalInterface - single abstract method interface

2. Create custom annotation:
   @interface MyAnnotation { String value(); }

3. Meta-annotations:
   • @Retention(RetentionPolicy.RUNTIME)
   • @Target(ElementType.METHOD)

Expected Output:

--- Built-in Annotations ---
Using @Override on toString()
Dog says: Woof!

--- Custom Annotation ---
Method has @Info annotation
Author: John Doe
Version: 1.0

Requirements Checklist

Use @Override annotation

Use @Deprecated or @SuppressWarnings

Create custom annotation with @interface

Add @Retention meta-annotation

Add @Target meta-annotation

Apply custom annotation to method

import java.lang.annotation.*;

// TODO: Create custom annotation
// @Retention(RetentionPolicy.RUNTIME)
// @Target(ElementType.METHOD)
// @interface Info {
//     String author();
//     String version() default "1.0";
// }

class Animal {
    public void speak() {
        System.out.println("Animal speaks");
    }
}

class Dog extends Animal {
    // TODO: Use @Override annotation
    // @Override
    public void speak() {
        System.out.println("Dog says: Woof!");
    }
}

public class AnnotationDemo {
    
    // TODO: Apply custom annotation
    // @Info(author = "John Doe", version = "1.0")
    public static void myMethod() {
        System.out.println("Method with annotation");
    }
    
    // TODO: Use @Deprecated
    // @Deprecated
    public static void oldMethod() {
        System.out.println("This method is deprecated");
    }
    
    @SuppressWarnings("unused")
    public static void main(String[] args) {
        System.out.println("--- Built-in Annotations ---");
        System.out.println("Using @Override on toString()");
        
        // TODO: Create Dog and call speak()
        // Dog dog = new Dog();
        // dog.speak();
        
        System.out.println("\n--- Custom Annotation ---");
        
        // TODO: Read annotation using reflection
        // try {
        //     java.lang.reflect.Method method = AnnotationDemo.class.getMethod("myMethod");
        //     if (method.isAnnotationPresent(Info.class)) {
        //         System.out.println("Method has @Info annotation");
        //         Info info = method.getAnnotation(Info.class);
        //         System.out.println("Author: " + info.author());
        //         System.out.println("Version: " + info.version());
        //     }
        // } catch (Exception e) {
        //     e.printStackTrace();
        // }
    }
}

Output

// Click "Run Code" to compile and execute

Hints & Tips

• Custom: @interface MyAnnotation { String value(); }

• Retention: @Retention(RetentionPolicy.RUNTIME)

• Target: @Target(ElementType.METHOD)

• Default: String version() default "1.0";

Progress: 0/6

Score: 0/100

0%

Lab Results

Review feedback below

Lab 23: Reflection API

Expert

Coding Challenge

Your Task: Use Java Reflection API to inspect and manipulate classes, methods, and fields at runtime.

Detailed Requirements:
1. Get Class object:
   • Class<?> clazz = MyClass.class;
   • Class<?> clazz = obj.getClass();
   • Class<?> clazz = Class.forName("MyClass");

2. Inspect class members:
   • clazz.getDeclaredFields() - all fields
   • clazz.getDeclaredMethods() - all methods
   • clazz.getConstructors() - constructors

3. Create instance dynamically:
   • clazz.getDeclaredConstructor().newInstance()

4. Invoke methods:
   • method.invoke(object, args)

Expected Output:

--- Class Information ---
Class name: Person
Fields: name age 
Methods: getName setName getAge setAge greet 

--- Create Instance ---
Created: Person[name=John, age=25]

--- Invoke Method ---
Hello, my name is John!

Requirements Checklist

Get Class object using .class or getClass()

Use getDeclaredFields() to list fields

Use getDeclaredMethods() to list methods

Create instance with newInstance()

Use method.invoke() to call method

Handle ReflectiveOperationException

import java.lang.reflect.*;

class Person {
    private String name;
    private int age;
    
    public Person() {}
    public Person(String name, int age) { this.name = name; this.age = age; }
    
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
    
    public void greet() { System.out.println("Hello, my name is " + name + "!"); }
    
    public String toString() { return "Person[name=" + name + ", age=" + age + "]"; }
}

public class ReflectionDemo {
    public static void main(String[] args) {
        System.out.println("--- Class Information ---");
        
        // TODO: Get Class object
        // Class<?> clazz = Person.class;
        // System.out.println("Class name: " + clazz.getSimpleName());
        
        // TODO: List all fields
        // System.out.print("Fields: ");
        // for (Field field : clazz.getDeclaredFields()) {
        //     System.out.print(field.getName() + " ");
        // }
        // System.out.println();
        
        // TODO: List all methods
        // System.out.print("Methods: ");
        // for (Method method : clazz.getDeclaredMethods()) {
        //     System.out.print(method.getName() + " ");
        // }
        // System.out.println();
        
        
        System.out.println("\n--- Create Instance ---");
        
        // TODO: Create instance using reflection
        // try {
        //     Constructor<?> constructor = clazz.getConstructor(String.class, int.class);
        //     Object person = constructor.newInstance("John", 25);
        //     System.out.println("Created: " + person);
        //     
        //     System.out.println("\n--- Invoke Method ---");
        //     
        //     // Invoke greet() method
        //     Method greetMethod = clazz.getMethod("greet");
        //     greetMethod.invoke(person);
        //     
        // } catch (ReflectiveOperationException e) {
        //     e.printStackTrace();
        // }
        
    }
}

Output

// Click "Run Code" to compile and execute

Hints & Tips

• Get class: Class<?> c = MyClass.class;

• Fields: c.getDeclaredFields()

• Methods: c.getDeclaredMethods()

• Create: c.getConstructor(types).newInstance(args)

• Invoke: method.invoke(object, args)

Progress: 0/6

Score: 0/100

0%

Lab Results

Review feedback below

Lab 24: Inner Classes

Advanced

Coding Challenge

Your Task: Master different types of inner classes in Java for better encapsulation and code organization.

Detailed Requirements:
1. Member Inner Class:
   • Defined inside class, non-static
   • Access: outer.new Inner()

2. Static Nested Class:
   • Defined with static keyword
   • Access: new Outer.StaticNested()

3. Local Inner Class:
   • Defined inside a method

4. Anonymous Inner Class:
   • No name, defined and instantiated at once
   • Often used with interfaces

Expected Output:

--- Member Inner Class ---
Inner class accessing outer: Hello from Outer
Inner value: 10

--- Static Nested Class ---
Static nested class value: 42

--- Local Inner Class ---
Local class says: Hello Local!

--- Anonymous Inner Class ---
Anonymous greeting: Hello World!

Requirements Checklist

Create member inner class

Instantiate inner class with outer.new Inner()

Create static nested class

Create local inner class in method

Create anonymous inner class

Use interface with anonymous class

// Interface for anonymous class demo
interface Greeter {
    void greet(String name);
}

class Outer {
    private String message = "Hello from Outer";
    
    // TODO: Member inner class
    // class Inner {
    //     private int value = 10;
    //     
    //     public void display() {
    //         System.out.println("Inner class accessing outer: " + message);
    //         System.out.println("Inner value: " + value);
    //     }
    // }
    
    // TODO: Static nested class
    // static class StaticNested {
    //     private int value = 42;
    //     
    //     public void display() {
    //         System.out.println("Static nested class value: " + value);
    //     }
    // }
    
    // Method with local inner class
    public void methodWithLocalClass() {
        // TODO: Local inner class
        // class LocalInner {
        //     public void sayHello() {
        //         System.out.println("Local class says: Hello Local!");
        //     }
        // }
        // LocalInner local = new LocalInner();
        // local.sayHello();
    }
}

public class InnerClassDemo {
    public static void main(String[] args) {
        System.out.println("--- Member Inner Class ---");
        
        // TODO: Create outer and inner class instances
        // Outer outer = new Outer();
        // Outer.Inner inner = outer.new Inner();
        // inner.display();
        
        
        System.out.println("\n--- Static Nested Class ---");
        
        // TODO: Create static nested class instance
        // Outer.StaticNested nested = new Outer.StaticNested();
        // nested.display();
        
        
        System.out.println("\n--- Local Inner Class ---");
        
        // TODO: Call method with local class
        // outer.methodWithLocalClass();
        
        
        System.out.println("\n--- Anonymous Inner Class ---");
        
        // TODO: Create anonymous inner class implementing Greeter
        // Greeter greeter = new Greeter() {
        //     @Override
        //     public void greet(String name) {
        //         System.out.println("Anonymous greeting: Hello " + name + "!");
        //     }
        // };
        // greeter.greet("World");
        
    }
}

Output

// Click "Run Code" to compile and execute

Hints & Tips

• Member inner: class Outer { class Inner { } }

• Create inner: Outer.Inner i = outer.new Inner();

• Static nested: new Outer.StaticNested();

• Anonymous: new Interface() { @Override... };

Progress: 0/6

Score: 0/100

0%

Lab Results

Review feedback below

Java Programming Labs

Annotations, Reflection & Inner Classes - Module 8

Requirements Checklist

Lab Results

Requirements Checklist

Lab Results

Requirements Checklist

Lab Results