How do i check a custom annotation?

today i created a hello world app. It's not a simple hello world app. It uses classes, custom exceptions, threads, generics, custom annotation and more. The problem here is that the AnnotationApplyer class which checks if the annotations is well applyed does not do anything.

I tried to create an annotation that says that the class is a user-defined exception (extends java.lang.Exception class). This does not work, do i made a mistake at checking or something else?

import java.lang.annotation.*;

@UserException // wrong placed annotation for testing
@UserDefined(user = "iasonas")
public abstract class Main {

    public static void main(String[] args) {
        // check annotations
        AnnotationApplyer.check();

        // start the program
        new Greeter().greet();
    }
    
    @UserDefined(user = "iasonas")
    private static class Greeter {
        private final String MSG = "Hello, World!";
        private Printer ms = new MessageService<String>(MSG);
        
        public Greeter () {
        }
        
        public void greet () {
            try {
                ms.print();
            } catch (InvalidMessageException e) {
                System.out.println("Cannot greet. "+e.toString());
            }
        }
    };
};

@UserException // wrong placed annotation for testing
@UserDefined(user = "iasonas")
class AnnotationApplyer {
    public static void check () {
        checkUserException(Main.class, AnnotationApplyer.class, MessageService.class, UserDefined.class);
        checkUserException(UserException.class, Printer.class, InvalidMessageException.class);
        
    }

    public static void checkUserException (Class<?>... classes) {
        for (Class<?> clazz : classes) {
            if (!clazz.isAnnotationPresent(UserException.class)) {
                continue;
            }

            if (!Exception.class.isAssignableFrom(clazz)) {
                System.out.println("Error: "+clazz.getName()+" does not extend java.lang.Exception");
            } else {
                System.out.println("Class "+clazz.getName()+" extends java.lang.Exception!");
            }
        }
    }
}

@Target(ElementType.TYPE)
@interface UserException {

}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@interface UserDefined {
    String user() default "Not specified";
}

class MessageService <T> implements Runnable, Printer {
    private T message;
    private final Thread thread = new Thread(this);
    private int printCounter;
    
    public MessageService () {   
    }
    
    public MessageService (T message) {
        this.message = message;
    }

    public T getMessage () {
        return message;
    }
    
    public void setMessage (T aMsg) {
        this.message = aMsg;
    }

    public int getTimes () {
        return printCounter;
    }
    
    @Override
    public void run () {
        System.out.println(message);
        printCounter++;
    }
    
    @Override
    public synchronized void print () throws InvalidMessageException {
        if (message==null) {
            throw new InvalidMessageException("message is null");
        }
        thread.start();
    }
};

interface Printer {
    void print() throws InvalidMessageException;
};

@UserException // well placed annotation for checking
class InvalidMessageException extends Exception {
    public InvalidMessageException (String m) {
        super(m);
        System.exit(0);
    }
}

You are missing a

@Retention(RetentionPolicy.RUNTIME)

on your UserException annotation. The default value does not ensure that the annotation is still available at runtime.