I think OP meant 'happen to the Object'. Just to clear up.

An exception handled within a constructor is a regular exception, but
one thrown by a constructor *should* result in the object not being
allocated, or deallocated immediately. It *always* leaves the object in
an undefined state (Null in my experience but don't rely on it)

For example the following code:

public class Test
{
 public String tester;
 
 public Test() throws Exception
 {
   tester = "Tester object";
   throw(new Exception());    
 }
 
 public static void main(String args[])
 {
   Test t = null;
   try {
     t = new Test();
   } catch (Exception e) { /* ignore */ }
   
   String s = (t == null) ? "Null object" : t.tester;
   System.out.println(s);
 }
}

produces the output "Null object", unless we remove the throws clause
from the constructor (when it's "Tester object" obviously).

As for Finalize, it's not a 'destructor' - just a method Java calls when
it [feels like it and might be] about to destroy that object. You could
throw a RuntimeException from it, but the object would still be
deallocated.

Finalize is an empty method, provided by the API for you to perform
special actions at (or around) GC time. You can call it, and it will do
whatever you override it to do, but the object will not be deallocated.
You're thinking of it backwards. Instead of finalize() destroying the
Object, when the JVM destroys an object it does something like:

doGC(Object o)
{
 try {
   o.finalize();
 } catch (RuntimeException e) {
   /* ... Invoke complex error handling (i.e. ignore) ... */
 }

 /* ... Last check object has no references and so on ... */

 /* ... Do the actual work of destroying the object ... */
}

(p.s. before everyone jumps on that, it's a SIMPLIFIED PARAPHRASED
EXAMPLE :) )

Of course, although there is no way to directly stop an Object being
deallocated from finalize(), there is a trick - simply assign a
reference to the object somewhere. That way, finalize returns, and when
the JVM does it's 'last check' it finds the reference, and the object is
retained. This is part of the reason finalize is dangerous.

Cheers,
Ross