Acceda al código del bloque Try-Catch en otra clase

You'll need a member in class A y un captador:

public class A {
   private String attributeName;

   public String getAttributeName() {
       return attributeName;
   }

   public void method(){
        ...

        try {
            //code is written here.
            attributeName = lAttribute.getName(); 
        }
        catch() { 
        } 
   } 
}

Entonces:

public class B {
    A a = new A();

    // somewhere
    String str = a.getAttributeName();
}

There's no way to access a method's private variables like you did in the original example, as they only exist on the stack during the method call.

Editar: I noticed another question:

How could I handle all those exception in another class.

I assume you want to call your method somewhere else and catch the exceptions there. In that case you can use the throws keyword to communicate that your method will pass exceptions to the caller:

public class A {

    public void method() throws IOException {

        //code is written here.
        String attributeName = lAttribute.getName(); 
    } 

    public void anotherMethod() {
        try {
            method();
        } catch(IOException ex) {
            ...
        } 
    }
}

then if some other piece of code calls method it will be forced to either handle or further propagate the exception.

How could I handle all those exception in another class.

In your calling class you can catch Throwable (which will catch all exceptions and errors)

try {
....
}
catch (Throwable t) {
//do something with the throwable.
}

if you do not want to catch Errors (Ive only done this when messing around with ImageIO and had memory problems) in Java then catch Exception instead

Any way to handle try block code for reuse in another class

here you could create a method in another class and then call it within your try /catch block

public class XYX {
    public void methodForTry() throws Exception {
    //do something
    }
}


try {
    new XYZ().methodForTry();
}
catch (Exception e){
}

You may or may not want to create new XYZ here. It depends what state this object may or may not hold.

As to the last questions I think Tudor's answer covers this

Your question may be about extracting the code template

try { ... do stuff ... } 
catch (MyFirstException e) { ...handle ... }
catch (MySecondException e) { ...handle ... }
... more catch ...

Where you only want to change the ... do stuff ... part. In that case you'd need cierres, which are coming with Java 8, and today you'd need something quite cumbersome, of this sort:

public static void tryCatch(RunnableExc r) {
  try { r.run(); } 
  catch (MyFirstException e) { ...handle ... }
  catch (MySecondException e) { ...handle ... }
  ... more catch ...
}

sin que importe RunnableExc sería un

interface RunnableExc { void run() throws Exception; }

and you'd use it this way:

tryCatch(new RunnableExc() { public void run() throws Exception {
   ... do stuff ...
}});

Por qué no return que?

public String method() {
String attributeName
    try {
        //code is written here.
        attributeName = lAttribute.getName(); 
    } catch(...) { 
    } 
return attributeName;
}


public class B {
A a = new A();
String attributeName = a.method();
}