Pattern for database-wrapper in java

Question

I am currently writing a java-class that wraps an SQLite database. This class has two ways to be instantiated:

1. Open an existing database.
2. Create a new database.

This is what I came up with:

public class SQLiteDatabaseWrapper {
    public static SQLiteDatabaseWrapper openExisting(File PathToDB) {
        return new SQLiteDatabaseWrapper(PathToDB);
    }

    public static SQLiteDatabaseWrapper createNew(File PathToDB) {
        CreateAndInitializeNewDatabase(PathToDB);
        return new SQLiteDatabaseWrapper(PathToDB);
    }

    private SQLiteDatabaseWrapper(File PathToDB) {
        // Open connection and setup wrapper    
    }
}

Is this the way to go in Java, or is there any other best practice for this situation?

Answer 1

First and foremost: java methods should start lowercase. It's not enforced by the compiler or language spec, but it's a convention that everyone follows, and you'll get into trouble with tools, IDE's, and most importantly other programmers, if you don't follow it.

Answer 2

Java already has standard interfaces for database abstraction called JDBC. The best practice would be to use the existing standard interfaces. Here is a good JDBC tutorial. You should get a SQLite JDBC driver and use that. SQLite.org has a comprehensive list of database drivers including JDBC drivers. Also, here is a tutorial on connecting to a SQLite database using JDBC.

Answer 3

You could do

public SQLiteDatabaseWrapper(File pathToDB, boolean createNew)
        throws IOException {

    if (!pathToDB.exists()) {
        if (createNew) {
            // Create new database, potentially throws exception
        } else {
            throw new FileNotFoundException();
        }
    }

    // Open connection and setup wrapper
}

public SQLiteDatabaseWrapper(File pathToDB) throws IOException {
    this(pathToDB, false);
}

to avoid relying on static methods for creating an instance of your database wrapper.