Some basics doubts in Android Programming

1. The super keyword here is used to invoke the parent class's onCreate method. What the ancestor classes will do in that method is not explicitly defined - a FragmentActivity parent, for example, might use certain life-cycle events like onCreate, onStart, and so on to initialize saved fragments (such as a DialogFragment) as the app resumes.

   Your example is unclear - if it helps, given a MyActivity class that extends Activity, this is what will typically take place:

   MyActivity::onCreate start
    Activity::onCreate start
     (Any other ancestors)...
    Activity::onCreate end
   MyActivity::onCreate end
   
   MyActivity::onStart start
    Activity::onStart start
     (Any other ancestors)...
    Activity::onStart end 
   MyActivity::onStart end 
   
   (Other life-cycle events)...  
   

2. I don't know what you're asking here - please clarify.

3. Again, unclear - please clarify.

4. The SQLiteOpenHelper class is provided for convenience - to make your life easier. Take a look at the source code for that class if you'd like to know what it does. If this doesn't answer your question then please clarify.

5. The context object is passed to various methods in the framework because they perform options that require it. If you're looking for a broad discription of what a context object was designed to represent, take a look at the source code - from the documentaion for that class:

   Interface to global information about an application environment. This is an abstract class whose implementation is provided by the Android system. It allows access to application-specific resources and classes, as well as up-calls for application-level operations such as launching activities, broadcasting and receiving intents, etc.

6. That's a very broad question and it certainly isn't android-specific - try googling "java getter setter" or similar. Common examples: you might want to modify the getters/setters in the future (such as to preseve an invariant), you might want to create another class that extends Contact in the future and may need to override the default getter/setter implementations, and so.

7. I'm not sure what you're asking here. SQLiteOpenHelper creates the database (the SQLiteOpenHelper object db) in response to some event (when you request access to the database I would imagine) then invoke's the onCreate method you wrote to initialize the database. If that doesn't answer your question please clarify.

— modified on Mar 24, 2016, 6:21:50 AM

1. Perhaps a simple example would be more effective here:

    class MyActivity1 extends Activity {
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            Log.v("MyActivity1", "onCreate start");
            super.onCreate(savedInstanceState); // call #1
            Log.v("MyActivity1", "onCreate end");
        }
    }
   
    class MyActivity2 extends MyActivity1 {
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            Log.v("MyActivity2", "onCreate start");
            super.onCreate(savedInstanceState); // call #2
            Log.v("MyActivity2", "onCreate end");
        }
    }
   

   If you were to create an activity using MyActivity2 then you would see the following:

    MyActivity2 - onCreate start
    MyActivity1 - onCreate start
    MyActivity1 - onCreate end
    MyActivity2 - onCreate end
   

   that is, call #2 would invoke MyActivity1's onCreate method and call #1 would invoke Activity's onCreate method.

2. I'm still not sure what you're asking, sorry. Are you asking why MyActivity (I'm assuming you're using this class as an activity) can't extend SQLiteOpenHelper? If so, MyActivity extends Activity (or some class derived from Activity, like PrefrenceActivity) because the framework requires it. Consider your MyActivity class, for example - somewhere in your manifest you'll having something along the lines of:

   <activity android:name=".MyActivity">
       ...
   </activity>
   

   The android framework will try to find a class by the name of "MyActivity" in your project and use it to create an instance of your class which it will then treat as an Activity object (I'm assuming reflection is used here). If MyActivity instead extended SQLiteOpenHelper then some code in the framework (something you didn't write) would likely throw an exception when attempting to cast the MyActivity object to Activity, something like:

   ...
   Object object = ... // creates an instance of MyActivity
   Activity activity = (Activity)object; // would throw an exception if MyActivity did not extend Activity
   

3. Does my response in 2 answer your question? If not, please clarify.

4. SQLiteOpenHelper is a convenience class - it takes care of certain calls to SQLiteDatabase for you. For example, here's a portion of a method from SQLiteOpenHelper that creates a database using calls to SQLiteDatabase:

   private SQLiteDatabase getDatabaseLocked(boolean writable) {
       // ...
       if (db != null) {
           // ...
       } else if (mName == null) {
           // ...
       } else {
           try {
               if (DEBUG_STRICT_READONLY && !writable) {
                   final String path = mContext.getDatabasePath(mName).getPath();
                   db = SQLiteDatabase.openDatabase(path, mFactory,
                       SQLiteDatabase.OPEN_READONLY, mErrorHandler);
               } else {
                   db = mContext.openOrCreateDatabase(mName, mEnableWriteAheadLogging ?
                       Context.MODE_ENABLE_WRITE_AHEAD_LOGGING : 0,
                       mFactory, mErrorHandler);
               }
           } catch (SQLiteException ex) {
               // ...
           }
       }
       //...
   }
   

5. In the code you've posted there SQLiteOpenHelper's constructor will recieve the context object. It stores the database name/version so it can use those when it needs to construct the database.

   public class DatabaseHandler extends SQLiteOpenHelper {
       public StorageDbHelper (Context context) {
           // this calls SQLiteOpenHelper's constructor
           super(context, DATABASE_NAME, null, DATABASE_VERSION);
       }
   }
   

6. From SQLiteOpenHelper's source code:

   /**
    * Called when the database is created for the first time. This is where the
    * creation of tables and the initial population of the tables should happen.
    *
    * @param db The database.
    */
   public abstract void onCreate(SQLiteDatabase db);
   

   In other words onCreate is invoked when SQLiteOpenHelper creates the database. Typically at that point you initialize any tables you want to use in your database; that's what you're doing in the SQL command you're executing at that point:

   public class DatabaseHandler extends SQLiteOpenHelper {
       public StorageDbHelper (Context context) {
           // this calls SQLiteOpenHelper's constructor
           super(context, DATABASE_NAME, null, DATABASE_VERSION);
       }
   
       @Override
       public void onCreate(SQLiteDatabase db) {
           String CREATE_CONTACTS_TABLE = "CREATE TABLE " + TABLE_CONTACTS + "("
           + KEY_ID + " INTEGER PRIMARY KEY," + KEY_NAME + " TEXT,"
           + KEY_PH_NO + " TEXT" + ")";
   
           // this command creates the table TABLE_CONTACTS in db (that is,
           // the DATABASE_NAME database SQLiteOpenHelper created for you)
           db.execSQL(CREATE_CONTACTS_TABLE);
       }
   }
   

— modified on Mar 24, 2016, 8:01:05 AM

No problem, I'm glad it helped

Feel free - I can't promise I'll respond, however I'm sure someone here will be able to help you