Java 用异常处理实现迭代器接口

我需要创建一个类库，使我能够读取不同的文件（.dat文件，其中包含不同的数据表示），并创建包含其内容的对象（每行一个对象）

我还必须创建一个单元测试来开始读取文件，这样我就不必先读取整个文件并将内容保存在数组中。我想使用工厂模式

下面是我对实现迭代器接口的类的实现

package klassenbibliothek;
public class MyReader implements Iterator<Object>
{
    BufferedReader reader;
    MyReader(BufferedReader myReader)
    { 
        reader = myReader;
    }

    @Override
    public boolean hasNext() // aus Stackoverflow, von mir abgeändert
    {
        try {
            return reader.ready();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } 
        finally
        {
            throw new NoSuchElementException();
        }
    }

    @Override
    public String next() 
    {
        //return SubstancesFileObjectCreator(reader.readLine());
        try {
            return reader.readLine();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        finally
        {
            // return null;
            throw new NoSuchElementException();
        }
    }
}

类实体FileObjectCreator

package klassenbibliothek;
public abstract class AbstractFileObjectCreator
{
    public abstract AbstractFileObject createFileObject(String line);
}

package klassenbibliothek;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class SubstancesFileObjectCreator extends AbstractFileObjectCreator
{
    MyReader myReader;

    public void makeReader() throws IOException
    { 
        String dataFileName = "C:/temp/Substances.dat";
        BufferedReader bReader = new BufferedReader(new        FileReader(dataFileName));
        myReader = new MyReader(bReader);
    }

    @SuppressWarnings("null")
    public AbstractFileObject createFileObject(String line)
    {
        AbstractFileObject mySubstance = null;

        String lineValues[] = myReader.next().split("\t");
        if(lineValues[0].equals("R"))
        {
            boolean dutyToDeclare_local;
            boolean isUnwanted_local;
            boolean isProhibited_local;
            boolean isReach_local;
            boolean isDeleted_local;
            boolean isHidden_local;
            String nodeidRaw = lineValues[1];
            float nodeid = Float.parseFloat(nodeidRaw);
            String casNrRaw = lineValues[2];
            String euIndexCodeRaw = lineValues[3];
            String einecsCodeRaw = lineValues[4];
            String dutyToDeclareRaw = lineValues[5];
            if(dutyToDeclareRaw.equals(1))
            {
                dutyToDeclare_local = true;
            } 
            else
            {
                dutyToDeclare_local = false;
            }
            String isUnwantedRaw = lineValues[6];
            if(isUnwantedRaw.equals("1"))
            {
                isUnwanted_local = true;
            }
            else
            {
                isUnwanted_local = false;
            }
            String isProhibitedRaw = lineValues[7];
            if(isProhibitedRaw.equals("1"))
            {
                isProhibited_local = true;
            }
            else
            {
                isProhibited_local = false;
            }
            String isReachRaw = lineValues[8];
            if(isReachRaw.equals("1"))
            {
                isReach_local = true;
            }
            else
            {
                isReach_local = false;
            }
            String isDeletedRaw = lineValues[9];
            if(isDeletedRaw.equals("1"))
            {
                isDeleted_local = true;
            }
            else
            {
                isDeleted_local = false;
            }
            String isHiddenRaw = lineValues[10];
            if(isHiddenRaw.equals("1"))
            {
                isHidden_local = true;
            }
            else
            {
                isHidden_local = false;
            }
            mySubstance = new Substance(nodeid, casNrRaw, euIndexCodeRaw, einecsCodeRaw, dutyToDeclare_local, isUnwanted_local, isProhibited_local, isReach_local, isDeleted_local, isHidden_local);
            // und weiter...
        }
        else
        {
            String languageCode = lineValues[1];
            String name = lineValues[2];
            // Synonym-Objekt erzeugen und zu Substance-Objekt hinzufügen
            Synonym newSynonym = new Synonym(languageCode, name);
            mySubstance.addAppendix(newSynonym);
            while(myReader.hasNext())
            {
                String lineValues_synonyms[] = myReader.next().split("\t");
                String lineValuesZero = lineValues_synonyms[0];
                if(lineValuesZero.equals("R"))
                {
                    break; // nicht so gut glaube ich!!!
                }
                String languageCode_next = lineValues_synonyms[1];
                String name_next = lineValues_synonyms[2];
                Synonym newSynonym_next = new Synonym(languageCode_next, name_next);
                mySubstance.addAppendix(newSynonym_next);
            }

        }
        return mySubstance;
    }
}

类AbstractFileObject

package klassenbibliothek;

public abstract class AbstractFileObject
{
    boolean isDeleted;

    public AbstractFileObject(boolean isDeleted)
    {
        this.isDeleted = isDeleted;
    }

    public boolean getIsDeleted()
    {
        return isDeleted;
    }

    public abstract void addAppendix(Object newAppendix);
}

类物质

public class Substance extends AbstractFileObject
{
    private float nodeid;
    private String casNr;
    private String euIndexCode;
    private String einecsCode;
    private boolean dutyToDeclare;
    private boolean isUnwanted;
    private boolean isProhibited;
    private boolean isReach;
    private boolean isDeleted;
    private boolean isHidden;

    private ArrayList<Synonym> synonymList;

    public Substance(float nodeid, String casNr, String euIndexCode, String einecsCode,
        boolean dutyToDeclare, boolean isUnwanted, boolean isProhibited, boolean isReach,
        boolean isDeleted, boolean isHidden)
    {
        super(isDeleted);
        this.nodeid = nodeid;
        this.casNr = casNr;
        this.euIndexCode = euIndexCode;
        this.einecsCode = einecsCode;
        this.dutyToDeclare = dutyToDeclare;
        this.isUnwanted = isUnwanted;
        this.isProhibited = isProhibited;
        this.isReach = isReach;
        //this.isDeleted = isDeleted;
        this.isHidden = isHidden;
    }
    // getter and setter
}

单元测试

package klassenbibliothek.test;
import static org.junit.Assert.*;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;

public class SubstancesTest {
    @Test
    public void test() {
        //fail("Not yet implemented");
        long startTimeNanos = System.nanoTime();

        /*
         * While... iterator over data file
         */
    }
}

---

我是否以正确的方式使用工厂模式？我很困惑。

最后，积木是用来清理的。他们不应该特别抛出这样的异常。将异常抛出移出finally块。

如果在finally块之前有try块，则始终执行finally块。所以你的总是抛出一个NoTouchElementException（）

---

您应该在其中执行某些操作，而不是抛出异常。

从finally块中删除抛出异常，并将其放入catch块或其他位置。Finally block用于释放您可能在程序中使用的资源。

“为什么我会收到此错误消息“Finally block未正常完成”？我没有返回什么，我只是抛出一个异常。”而抛出一个exeception会阻止Finally正常完成。你知道什么是变态吗？您知道什么是

finally

块吗？如果无论发生什么都必须始终抛出异常，那么您将重写

迭代器的
next
方法，然后，方法next应该抛出一个异常
NoSuchElementException
，然后它将不会覆盖
迭代器
类的
next
方法。确定这是有意义的。但是我不知道我应该在finally块中添加。我必须使用exception handlung，并且该方法必须返回一个字符串，那么我应该在finally块中放入什么，它不会与next（）和hasNext（）方法的平均值冲突？正如Necreaux所说：finally块通常用于清理。关闭东西，可能记录一些东西。。。您也不需要使用finally块！它们是可选的。我想你是德国人，因为包裹上有德国名字。如果是这样，这是一本关于try-catch finally和java的优秀读物：
finally
        {
            // return null;
            throw new NoSuchElementException();
        }

finally
        {
            // return null;
            throw new NoSuchElementException();
        }