Computers Simplified

Android Applications Life-cycle

2011-11-30T02:41:00.001-08:00

An android application does not have a main() method. The class android.Activity contains all the life-cycle methods for an android application. The android application life-cycle methods contained in the android.Activity are called at appropriate times when an android application is started, suspended, restarted, closed, etc. Android applications run in their own Unix process and, hence, cannot affect other running applications, directly.

Running android applications can be in one of the following three states, at one time:

1. Active: The application is running and visible to the user.

2. Paused: The application is running but does not have the focus i.e. partly obscured.

3. Stopped: The application is running but is completely hidden from view.

Android Application Life-cycle Methods:

An android application is transitioned among above listed states by Android calling the below listed methods on the current Activity at the appropriate times:

void
onCreate(Bundle savedInstanceState)

void
onStart()

void
onResume()

void
onRestart()

void
onPause()

void
onStop()

void
onDestroy()

onCreate() method is the first activity of any android application. This is the most important method in the lifecycle of an android application. This method acts like a constructor in an android application. Here we normally do our constructor like work. In fact onCreate() is the method that even the simplest of android application would need.

Java Enum

2011-11-30T01:55:00.001-08:00

In Java an enumerated type is a type that specifies a sequence of named constants. Not to mention that theses constants are related. The days of week or months of year can be good examples of enums. Prior to Java 5 Java developers had to use sets of named integer constants to simulate enum type behavior. Starting with Java 5 the developers got the built-in support of enums in Java.

An enum in Java is an enumerated type that is declared with the reserved key word enum. Consider the following piece of code:

enum DaysOfWeek { 

FRIDAY, 

SATURDAY, 

SUNDAY, 

MONDAY, 

TUESDAY, 

WEDNESDAY, 

THURSDAY 

}

It is a convention to write enum members in Capital Letters. Please note that unlike enumerated types in other languages like C++ and C#, enums in Java are not integer based. They are pure classes. Each member of the enum is a public static final field, representing an instance of its enum class.

Enum ensure compile-time type safety by preventing a developer from assigning illegal values to an enum type. Consider the following piece of code:

enum DaysOfWeek { 

FRIDAY, 

SATURDAY, 

SUNDAY, 

MONDAY, 

TUESDAY, 

WEDNESDAY, 

THURSDAY 

}

enum Fruits { 

MANGO,

ORANGE,

APPLE,

BANANA,

APRICOT,

PINEAPPLE

}

DaysOfWeek today = Fruits.MANGO; //compile-time error

The above code would signal errors at compile time. Please note that if the enums were int-based in Java the above could would have compiled successfully. The fact that they are pure Java objects, prevented the above code from compiling successfully.

The enums in Java, like other objects, provide a toString() method that returns a meaningful description of a constant’s value.

C# readonly fields

2011-11-29T03:08:00.001-08:00

The concept of constant variables is present in almost all of the programming languages. Just to recall, constant variables are those variables whose values are fixed and cannot be changed.

readonly fields is a relatively new concept in C#. Sometimes we may have some variable whose value we need to fix, but the value is not known until runtime. In these situations C# readonly fields come to help us. A readonly field is more flexible than a simple constant variable. Please note that in C# we use the const keyword to declare a variable as constant. A readonly field helps us in situations where we need a field to be constant but also need to carry out some calculations to determine its initial value.

The rule is very simple. We can assign values to readonly fields inside a constructor. Do not do it anywhere else or an error will result. A readonly field can be static or non-static. A static readonly field is shared among all instances of the class and it can also be used without creating an instance of the class. On the other hand a non-static readonly field is an instance field and is tied to a single object of the class.

Example:

public class ReadOnlyEx

{

public readonly int count;

public ReadOnlyEx()

{

count = 1;

}

The above code is legal. Now consider the following piece of code:

public class ReadOnlyEx

{

public readonly int count;

public ReadOnlyEx()

{

......

}

public SomeMethod() 

{

count = 1; //Compile time error

}

}

The above code is not valid. It will generate a compile time error. readonly fields can only be assigned a value inside constructors. If you do not provide a value to a readonly field inside a constructor, it will contain the default value, depending on its data type or the value you assigned to it while declaring the field, if any. This rule applies to both statice readonly fields and the non-static readonly fields.

C# Enum

2011-11-28T23:56:00.001-08:00

A C# enum (enumeration) is a user-defined integer TYPE. When we declare an enum in C# we have to supply a set of acceptable values (integers) that the instances of the enum type can hold. We have the freedom of naming those given values to make it more developer friendly. You will appreciate the real power of a C# enum from the fact that when, somewhere in your code, you attempt to assign an illegal value to an enum type, the code does not compile.

We benefit from a C# enum in a number of ways. Enums make our code more readable and, therefore, easier to maintain. With enums we no longer need to use those “magic” numbers in our code, we replace those magic numbers by descriptive names. Enums make our code easier to type, too. Whenever we need to supply a value to an enum type, the Visual Studio.NET’s IntelliSense helps us by providing a list of acceptable values to choose from.

We can define an enumeration as follows:

public enum DaysOfWeek

{

Friday = 0,

Saturday = 1,

Sunday = 2,

Monday = 3,

Tuesday = 4,

Wednesday = 5,

Thursday = 6

}

In the above DaysOfWeek enum type , we assign an integer value to represent each day of the week. To access the DaysOfWeek enum we use the ‘.’ notation. For example to DaysOfWeek.Friday would return the value 0 and DaysOfWeek.Thursday would return the integer value 6.

We can retrieve the string representation of an elements of an enum by calling the ToString() method. For example the following line of code would print Friday on the console:

Console.WriteLine(DaysOfWeek.Friday.ToString());

One more fact worth appreciating is that behind the curtains C# enums are instantiated as structs. To recall, the structs are value types and unlike reference types, that are created on the heap area of memory, they are created on the stack, as do ints, floats and chars etc., and are faster than the reference types. All the enums in C# are derived from the base class System.Enum.