How should I handle exceptions thrown from the constructor

I have come across this problem:

I am making an object, let's say, Person;

public class Person
{
    public Person(String name, int age)
    {
        if (age < 0)
        {
            throw new AgeException("Age can not be lesser than 0");
        }
    }
}

Every initialization of the object means that I would have to deal with a try-catch block.
Seems kind of wrong to me, like:

public static main(String[] args)
{
    try
    {
        Person p = new Person("SwagiWagi", 18);
    }
    catch (AgeException ex)
    {
        int age = -18;
        
        if (age < 0)
        {
            age = 18;
        }
        
        try
        {
            Person p = new Person("SwagiWagi", 18);
        }
        catch (AgeException ex)
        {
           System.out.println("This does not look right.");
        }
    }
}

This doesn't seem right, it's messy and unclear code.

What should I do?

Yes, in my opinion, throwing and catching too many exceptions is messy.

Instead, try an approach without having to throw exceptions at all.

Scanner sc = new Scanner(System.in);
    
int age = sc.nextInt();
while (age < 0) {
    System.out.println("Age entered is less than 0. Please enter again.");
    age = sc.nextInt();
}

Person p = new Person("SwagiWagi", age);

You will always have a positive age in this case.

Note: The input entered should be a number or .nextInt() will throw an exception, which is something you will have to handle.

At some point you should ask yourself: At which point SHOULD the program crash and not try to fix the problems? Sometimes it's just better if the program terminates because it can't properly run if a critical parameter has an invalid value.

You could simply declare, that the main-method throws an AgeException, but the program would still crash, because any unhandled exception terminates the program. If you want to make sure the program keeps running, you must handle all declared exceptions.

Also, what you are doing here seems very wrong to me:

public static main(String[] args)
{
    try
    {
        Person p = new Person("SwagiWagi", 18);
    }
    catch (AgeException ex)
    {
        int age = -18;
        
        if (age < 0)
        {
            age = 18;
        }
        
        try
        {
            Person p = new Person("SwagiWagi", 18);
        }
        catch (AgeException ex)
        {
           System.out.println("This does not look right.");
        }
    }
}

In the first try block you want to catch a faulty input from the user or whatever gives the parameter for the Person object. And in the catch block you try to "correct" that input and check that with ANOTHER try-catch block for the SAME exception.

Whatever initially passed the faulty parameter should do it right in the first place. Handling exceptions should be used more like a way to detect problems during runtime, not to fix them.

If there is a way to simply correct the problem like asking the user to again input a correct value, you should of course do that, but that can be done without exceptions.
If it is not possible, like the argument is being given by some other program or thread you have no control over, there is no way to do that, so the program should crash.