在构造方法中存在异常的惯用处理法

thinking in java 中的一个例子，这个惯用法保证了在构造方法中抛出异常的代码能够正常处理：

package test ;

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

class InputFile {
    private BufferedInputStream in = null ;
    private File file = null ;
    public InputFile(String filepath ) throws IOException {
        file = new File(filepath) ;
        in = new BufferedInputStream(new FileInputStream(file));
        
    }
    public String getFileContent() throws IOException {
        byte[] content = new byte[(int)file.length()] ;
        in.read(content) ;
        return new String(content) ;
    }
    public void dispose() throws IOException{
        in.close(); 
        System.out.println("dispose successful ! ");
    }
}
public class Cleanup{
    public static void main(String[] args) {
        try{
            InputFile input = new InputFile("这里写文件路径") ;
            try{
                String content = input.getFileContent() ;
            }catch(Exception e ){
                e.printStackTrace();
            }
            finally{
                input.dispose(); 
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

在main方法中可以确保文件正常打开才执行dispose方法，也就是关闭文件的方法。

还有将InputFile类构造方法中的异常抛出是有意义的，书上原话为：

“异常被重新抛出，对于构造器而言这么做是很合适的，因为你总不希望去误导调用方，让他以为这个对象已经创建完毕，可以使用了”

上面的编码格式可以扩展广泛一点，基本规则是：“在创建需要清理的对象之后，立即进入一个try-fianlly语句块”：

分为两种情况，1 ： 构造方法可能会失败也就是可能会抛出异常   2 ： 构造方法不会失败

当构造方法不会抛出异常的情况：

class TestClean1 {
    public TestClean1() {
        // 比如打开了很多资源
    }
    /**
     * 执行该类的清理工作
     */
    public void clean(){}
}
class TestClean2 {
    public TestClean2() {
    }
    /**
     * 执行该类的清理工作
     */
    public void clean(){}
}
public class TestCleanup {
    public static void main(String[] args) {
        
        TestClean1 clean1 = new TestClean1() ;
        TestClean2 clean2 = new TestClean2() ;
        try{
            // 在这里执行clean1和2的代码
        }finally{
            clean1.clean();
            clean2.clean();
        }
    }
}

当构造器会出现错误的时候：

class TestClean1 {
    public TestClean1() throws Exception {
        throw new Exception() ;
    }
    /**
     * 执行该类的清理工作
     */
    public void clean(){}
}
class TestClean2 {
    public TestClean2()  throws Exception {
        throw new Exception() ;
    }
    /**
     * 执行该类的清理工作
     */
    public void clean(){}
}
public class TestCleanup {
    public static void main(String[] args) {
        try{
            TestClean1 clean1 = new TestClean1() ;
            try{
                TestClean2 clean2 = new TestClean2() ;
                try{
                    // 执行clean1和clean2的代码
                }finally{
                    clean2.clean();
                }
            }catch(Exception e ){
                System.out.println("clean2构造失败");
                e.printStackTrace();
            }finally{
                clean1.clean();
            }
        }catch(Exception e ){
            System.out.println("clean1构造失败");
            e.printStackTrace();
        }
    }
}

当构造方法抛出异常表示没有正常打开资源，也就不需要清理。上面代码保证了两个对象都能够正确的清理。