先贴上简化后的源码，可以通过原注释和后面的总结一起理解

public abstract class sqliteOpenHelper {
    /**
  * 创建一个sqlite数据库的帮助类对象用于打开和管理一个数据库
  * 这个方法通常返回非常快速，这个数据库对象并不会在这里直接创建，
  * 知道调用了getWritableDatabase或者getReadableDatabase方法
  */
    public sqliteOpenHelper(Context context,String name,CursorFactory factory,int version) {
        this(context,name,factory,version,new DefaultDatabaseErrorHandler());
    }
 
   /**
  * 和上面的构造函数相同，不过这里多传了一个DatabaseErrorHandler对象，
  * 这个对象用于处理数据库的异常
  */
    public sqliteOpenHelper(Context context,DatabaseErrorHandler errorHandler) {
        if (version < 1) throw new IllegalArgumentException("Version must be >= 1,was " + version);
        if (errorHandler == null) {
            throw new IllegalArgumentException("DatabaseErrorHandler param value can't be null.");
        }
 
        mContext = context;
        mName = name;
        mFactory = factory;
        mNewVersion = version;
        mErrorHandler = errorHandler;
    }
 
 
    public String getDatabaseName() {
        return mName;
    }
 
    /**
  * 1. 创建或打开一个可读可写的数据库，如果是第一次调用，那么数据库会被打开，oncreate,onUpgrade,open都可能调用。
  * 2. 如果打开成功，那么数据库会被缓存，所以你可以在任何时候对其进行读写。
  * 3. 如果不需要再使用这个数据库，那么确保调用close方法将其关闭。
  * 4. 如果发生错误，比如说磁盘已满，或者权限不允许，则正常调用可能会失败，修复问题后可以再次调用。
  * 5. 数据库升级可能会耗费较长时间，所以不应在应用的主线程中调用这个方法，包括ContentProvider。
  */
    public synchronized sqliteDatabase getWritableDatabase() {
        if (mDatabase != null) {
            if (!mDatabase.isOpen()) {
                // darn! the user closed the database by calling mDatabase.close()
                mDatabase = null;
            } else if (!mDatabase.isReadOnly()) {
                return mDatabase;  // The database is already open for business
            }
        }
 
        if (mIsInitializing) {
            throw new IllegalStateException("getWritableDatabase called recursively");
        }
 
        // If we have a read-only database open,someone could be using it
        // (though they shouldn't),which would cause a lock to be held on
        // the file,and our attempts to open the database read-write would
        // fail waiting for the file lock.  To prevent that,we acquire the
        // lock on the read-only database,which shuts out other users.
 
        boolean success = false;
        sqliteDatabase db = null;
        if (mDatabase != null) mDatabase.lock();
        try {
            mIsInitializing = true;
            if (mName == null) {
                db = sqliteDatabase.create(null);
            } else {
                db = mContext.openOrCreateDatabase(mName,mFactory,mErrorHandler);
            }
 
            int version = db.getVersion();
            if (version != mNewVersion) {
                db.beginTransaction();
                try {
                    if (version == 0) {
                        onCreate(db);
                    } else {
                        if (version > mNewVersion) {
                            onDowngrade(db,mNewVersion);
                        } else {
                            onUpgrade(db,mNewVersion);
                        }
                    }
                    db.setVersion(mNewVersion);
                    db.setTransactionSuccessful();
                } finally {
                    db.endTransaction();
                }
            }
 
            onOpen(db);
            success = true;
            return db;
        } finally {
            mIsInitializing = false;
            if (success) {
                if (mDatabase != null) {
                    try { mDatabase.close(); } catch (Exception e) { }
                    mDatabase.unlock();
                }
                mDatabase = db;
            } else {
                if (mDatabase != null) mDatabase.unlock();
                if (db != null) db.close();
            }
        }
    }
 
    /**
  * 创建或者打开一个数据库，这个数据库对象和调用getWritableDatabase打开的数据库是同一个，除非发生某些意外情况，
  * 在这种情况下，一个只读的数据库对象会被返回，如果问题修复，那么下次调用getWritableDatabase将会成功
  * 这时只读的数据库会被关闭，可读可写的数据库会被返回。
  * 其他的和getWritableDatabase()方法一样。
  */
    public synchronized sqliteDatabase getReadableDatabase() {
        if (mDatabase != null) {
            if (!mDatabase.isOpen()) {
                // darn! the user closed the database by calling mDatabase.close()
                mDatabase = null;
            } else {
                return mDatabase;  // The database is already open for business
            }
        }
 
        if (mIsInitializing) {
            throw new IllegalStateException("getReadableDatabase called recursively");
        }
 
        try {
            return getWritableDatabase();
        } catch (sqliteException e) {
            if (mName == null) throw e;  // Can't open a temp database read-only!
            Log.e(TAG,"Couldn't open " + mName + " for writing (will try read-only):",e);
        }
 
        sqliteDatabase db = null;
        try {
            mIsInitializing = true;
            String path = mContext.getDatabasePath(mName).getPath();
            db = sqliteDatabase.openDatabase(path,sqliteDatabase.OPEN_READONLY,mErrorHandler);
            if (db.getVersion() != mNewVersion) {
                throw new sqliteException("Can't upgrade read-only database from version " +
                        db.getVersion() + " to " + mNewVersion + ": " + path); /** * database. 调用已经打开的数据库，实现类在更新表之前应该检查数据库是否是只读的。 */
            }
 
            onOpen(db);
            Log.w(TAG,"Opened " + mName + " in read-only mode");
            mDatabase = db;
            return mDatabase;
        } finally {
            mIsInitializing = false;
            if (db != null && db != mDatabase) db.close();
        }
    }
 
 
    public synchronized void close() {
        if (mIsInitializing) throw new IllegalStateException("Closed during initialization");
 
        if (mDatabase != null && mDatabase.isOpen()) {
            mDatabase.close();
            mDatabase = null;
        }
    }
 
 
    public abstract void onCreate(sqliteDatabase db);
 
 
    public abstract void onUpgrade(sqliteDatabase db,int newVersion);
 
 
    public void onDowngrade(sqliteDatabase db,int newVersion) {
        throw new sqliteException("Can't downgrade database from version " +
                oldVersion + " to " + newVersion);
    }
 
 
    public void onOpen(sqliteDatabase db) {}
}

1. 从始至中，sqliteOpenHelper中只持有一个数据库对象，并且一般情况下，通过getWritableDatabase()和getReadableDatabase()创建或打开时获取到的是同一个sqliteDatabase对象。

2. 如果当前数据库是只读的，那么再次调用getWritableDatabase()获取可读可写数据库对象时会重新打开现有对象。

3. 如果当前不存在数据库对象，并且初始化时没有指定数据库名称，也会创建一个默认数据库。

4. 如果数据库对象不存在，但是指定了数据库的名称，那么系统会先查看是否有指定数据库，如果有则直接打开，没有则先创建再打开数据库。

5. 数据库或降级升级时，会根据版本号进行判断，然后把升级和降级的过程作为一个事务进行操作，确保数据安全。

6. 创建数据库对象的默认版本号为0。