Java 异常捕获后，控件返回调用方类

嗨，在我的代码中有一个输入文件。代码的任务是将每条记录插入到db2表中。有两个班

主类读取每个记录并调用另一个类的方法将行插入db2表

我发现，当一个插入因重复插入而失败时，控件再次转到调用方类，程序尝试处理文件中的下一条记录

我的理解是，一旦捕获到异常，程序将停止运行，并且不会运行以供将来处理。谁能给我引路。谢谢

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;

public class UpdateInsert {

    public static void main(String[] args) {

        BufferedReader br = null;
        BufferedWriter bw = null;
        Update upd = null;

        try {
            bw = new BufferedWriter(new FileWriter("H:\\exception.txt"));
        } catch (IOException e1) {
            e1.printStackTrace();
        }

        try {
            br = new BufferedReader(new FileReader("H:\\file1.txt"));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }

        String s = "";
        try {
            while ((s = br.readLine()) != null) {
                String[] vals = s.split(",");

                if (vals.length < 3) {
                    bw.write("Invalid record found - " + s);
                    continue;
                }

                if (vals[0].equals(" ") | vals[1].equals(" ")) {
                    bw.write("Invalid record found - " + s);

                } else {
                    upd = new Update();
                    upd.Setc1(vals[0]);
                    upd.Setc2(vals[1]);
                    upd.Setc3(vals[2]);
                    upd.MethodUpdate();

                }

            }

        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            try {
                bw.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            try {
                br.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

}



class Update {
    Statement stmt;
    Connection con;
    String c1 = "";
    String c2 = "";
    String c3 = "";

    void Setc1(String c1) {
        this.c1 = c1;
    }

    void Setc2(String c2) {
        this.c2 = c2;
    }

    void Setc3(String c3) {
        this.c3 = c3;
    }

    void MethodUpdate() {
        String subsys1 = "", creator1 = "", sql = "";
        subsys1 = "XXXX";
        creator1 = "XXXXXXX";

        sql = "'" + c1 + "'" + "," + c2 + "," + "'" + c3 + "'";

        try {
            Connection con = DBConn.getDBConnect();
            stmt = con.createStatement();
            stmt.executeUpdate("INSERT INTO " + subsys1 + "." + creator1
                    + ".MY_TABLE VALUES ( " + sql + ")" + ";");

        } catch (SQLException e) {
            e.printStackTrace();

        }   }}

导入java.io.BufferedReader；
导入java.io.BufferedWriter；
导入java.io.FileNotFoundException；
导入java.io.FileReader；
导入java.io.FileWriter；
导入java.io.IOException；
导入java.sql.Connection；
导入java.sql.SQLException；
导入java.sql.Statement；
公共类更新插入{
公共静态void main（字符串[]args）{
BufferedReader br=null；
BufferedWriter bw=null；
更新upd=null；
试一试{
bw=新的BufferedWriter（新的文件写入程序（“H:\\exception.txt”）；
}捕获（IOE1异常）{
e1.printStackTrace（）；
}
试一试{
br=新的BufferedReader（新的文件读取器（“H:\\file1.txt”）；
}catch（filenotfounde异常）{
e、 printStackTrace（）；
}
字符串s=“”；
试一试{
而（（s=br.readLine（））！=null）{
字符串[]vals=s.split（“，”）；
如果（vals.length<3）{
写入（“找到无效记录-”+s）；
继续；
}
如果（VAL[0]。等于（“”）VAL[1]。等于（“”）{
写入（“找到无效记录-”+s）；
}否则{
upd=新更新（）；
upd.Setc1（VAL[0]）；
upd.Setc2（VAL[1]）；
upd.Setc3（VAL[2]）；
方法更新（）；
}
}
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}最后{
试一试{
bw.close（）；
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
试一试{
br.close（）；
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
}
}
}
类更新{
报表stmt；
连接con；
字符串c1=“”；
字符串c2=“”；
字符串c3=“”；
无效集合c1（字符串c1）{
这1.c1=c1；
}
无效集合c2（字符串c2）{
这1.c2=c2；
}
无效集合c3（字符串c3）{
这1.c3=c3；
}
void MethodUpdate（）{
字符串subsys1=“”，creator1=“”，sql=“”；
subsys1=“XXXX”；
创建者1=“XXXXXXX”；
sql=“”“+c1+”“+”、“+c2+”、“+”、“+c3+”；
试一试{
Connection con=DBConn.getDBConnect（）；
stmt=con.createStatement（）；
stmt.executeUpdate（“插入”+subsys1+“+creator1
+“.MY_表值（“+sql+”）”+“；”）；
}捕获（SQLE异常）{
e、 printStackTrace（）；
}   }}

一旦在方法中捕获异常，程序将不会停止。执行

catch

块，控制流回到调用方法

在您的情况下，如果执行方法

MethodUpdate（）

中的

catch

块，则控件将返回到

while

循环的下一次迭代：

while（（s=br.readLine（））！=null）

本质上，如果捕获到异常，则执行

catch

块，然后执行

catch

块之后的所有语句，控制像往常一样流动。执行

catch

块后，程序不会停止

---

唯一不会执行的语句是

try

块中产生异常的语句之后的语句。

这是因为您在方法中捕获了异常。仔细检查你的代码。你会发现一个

catch

子句，它本质上是为你处理这个问题的。在你的问题中分享你的代码，男士/女士！也许值得一读：