return object of the method throws exception does not handle, how to fix it?

I have made an immutable class that implements the responsibilities about Matrix operations
its constructor throws an exception in confronting with invalid input

    public Class Matrix{
      public Matrix(int[][] matrix) throws Exception {
        if (!isValid(matrix))
          throw new Exception("Bad Matrix");
        sth();
        sth();
        sth();
      }


	  public Matrix transpose() {
        int[][] transposeMatrix = new int[column][row];
        sth();
        sth();
        sth();

	    try {
	 	    return new Matrix(transposeMatrix);
	    } catch (Exception e) {
		    // TODO Auto-generated catch block
		    e.printStackTrace();
	    }
     }
  }

in transpose method, a new instance of the Matrix class wants to be instantiated ,it's obvious that this method is responsible to handle the exception and this is the problem now I don't know how to return an instance of Matrix

The problem is that you are throwing Exception in the constructor. Throwing and / or declaring Exception is almost always a really bad idea.

In this case, it is better to throw a specific unchecked exception. Either declare your own exception class, or throw an existing one. IllegalArgumentException would be a good choice.

Since IllegalArgumentException is unchecked, you won't need to declare it in your Matrix constructor's signature, and you won't need to "catch or declare" it everywhere you use the constructor.

As to how you should return a Matrix if you can't construct it. There are two straightforward¹ answers:

1. Don't catch the exception. Let it propagate to the caller ... which provided the invalid input in the first place.

2. Return a null. Note this must be done in the code that calls the constructor, since a constructor cannot return null.

HOWEVER, returning null leads to other problems:

• If the caller of (say) transpose doesn't check the result of the call, and act appropriately, this is liable to lead to NullPointerException down the track.

• If the call does check, there is nothing explaining why the result is null. Indeed, any explanation that you might have included in the exception message will have been discarded (or dumped into the log, etc as a stacktrace) so that there is nothing to tell the end user ... about their bad input.

^{1 - There is a third approach too. Implement a way to represent an invalid matrix as a Matrix instance. For example you could declare a subclass of Matrix and call it InvalidMatrix. Some of the methods of this subclass would raise exceptions; e.g. "you cannot transpose an invalid matrix". This would also entail using a factory method, since the new operation cannot create instances of different classes depending on the arguments.<br>
It could be argued that this violates LSP since an InvalidMatrix cannot be used as a real matrix. But it could also be argued that it doesn't violate LSP, since any Java method or constructor can implicitly throw an unchecked exception. Either way, it is a pragmatic solution.<br>
Note that there examples of this kind of thing in the standard Java SE class library. For instance the unmodifiableList method in Collections (javadoc) creates a List instance that throws an UnsupportedOperationException if you try to modify it.}

There are some statements you can use in the catch block, 1st is throwing Runtime Exception, 2nd is returning empty matrix and 3rd is returning null;

1. throw new RuntimeException();

2. return new Matrix(new int[0][0]);

3. return null;