A class is a user-defined data type. It's a blueprint or prototype from which objects are created. A well-defined class demonstrates all or at least few of the features of OOP: data abstraction, encapsulation, polymorphism, and inheritance. We'll discuss these defining features shortly.

An object is an instance of a class, which replicates the real world object. For example, consider a computer. You see the computer as one unit, but it is built from many individual components —the motherboard, RAM, processor, hard disk, SMPS, and so on. Instead of looking at these individual components, you tend to look the whole. In the same a way, an object is made up of data members of the class.

Abstraction refers to the act of representing essential features without including the underlying details or explanations. Classes use the concept of abstraction and are defined as lists of abstract attributes.

Encapsulation is the process of storing data and functions in a single unit and is achieved by declaring a class. It can also be called data hiding; since data cannot be accessible to the outside world, only those functions that reside within the class can access it. Encapsulation can be achieved by declaring packages and modules as well as classes.

Inheritance is the process by which an object belonging to one class can acquire the properties of another class. This is an important feature facilitating the reusability of code. It is achieved by deriving a new class from an existing class (base class). The new class (derived class) will have combined features of both the classes. In Chapter 8, "Inheritance," you will learn the types of inheritance and its implementation.

Polymorphism is the ability of something to take more than one form. In OOP, the concept is exhibited in different behaviors in different instances, depending on the data types used in the operation (functions). Polymorphism is extensively used in implementing inheritance. It is also called function overloading, which you learned about in Chapter 5, "Functions."

Creating an instance of our new class means allocating memory for the object in RAM (main memory). An instance of a class can be created in two ways; here's the first:

Syntax

var object_name : class_name = class_name{ };

This first syntax for creating a class instance is known as the JavaFX style. It is similar to declaring an ordinary variable. In this method, you specify that the object belongs to a particular class and then you create the instance.

The second method of creating the instance of the class is to use the Java style, creating the object using the new operator.

Syntax

var object_name : class_name = new class_name( );

Here, you are specifying that the object belongs to a particular class and then creating the object using the new operator.

Now let us create the objects of the class Account in both JavaFX style and Java style:

var account1 : Account = Account{ };    // JavaFX style
var account2 : Account = new Account( ) ; // Java style

Both statements create instances of the class Account. Object account1 is created using JavaFX style and account2 is created using Java style. Note that we have not initialized the attributes explicitly, which means that all the attributes will take their default values, depending on the data type.

So far, you have learned how to declare a class and create objects that are instances of the class. Now let's initialize an object. Listing 6-2 shows the code.

var account1 = Account{
    accountNumber : 121    //  initializing the data member
    accountHolderName : "Praveen"    //  initializing the data member
    balance : 56434.34    //  initializing the data member
};

In the above expression, we are creating the object account1 of class Account and initializing it. The data member of the object are initialized by the colon operator (:) followed by the value.

Members of the class, which as you saw earlier may be either data members or member functions, are accessed using the dot (.) operator.

account1.name    // accessing datamember
        account1.printAccountHolderInformation( ); // accessing member function

In these statements, you are accessing the name data member of class Account through its object account1, and you are accessing member function printAccountHolderInformation() of the same Account class.

Assume you have created four objects. Memory is allocated for four objects, but the member functions are loaded only once in memory. All the objects share the member functions. Figure 6-2 illustrates this structure.

Figure 6.2. Data members of the class sharing the member function

Now let's access the member function of the class Account using the objects account1 and account2:

account1.printAccountHolderInformation( );     //  calling the member function
account2.printAccountHolderInformation( );     //  calling the member function

Finally, let's put all the pieces together—class definition, object creation, and initialization—to form a complete JavaFX class. Listing 6-3 shows the code.

class Account {
    var accountNumber : Integer ;
    var accountHolderName : String;
    var balance : Number;
    function printAccountHolderInformation( ) {
        println("Account Number = {accountNumber} Account Holder Name = {accountHolderName} Balance : {balance} ");
    }
}
var account1 : Account = Account{ /*create an instance and initialize the object */
    accountNumber : 121
    accountHolderName : "Praveen"
    balance : 56434.34

};
var account2 = Account{} ; // create an instance
account1.printAccountHolderInformation( ); // calling the member function
account2.printAccountHolderInformation( ); // calling the member function

After executing Listing 6-3 you'll see the following output.

Output

------
account number = 121 Account Holder Name = Praveen  Balance : 56434.34
account number = 0 Account Holder Name =   Balance : 0.0

The output statement prints the details of the objects account1 and account2. In the output of account2, you can see that the value of account number is zero, the value of accountHolderName is null "", and balance is 0.0. This is because we have not initialized the data members of the object.

It is possible to set a default value for the data members of the class, if you don't initialize the object. If you initialize the object, then the default value is overridden.

var balance : Number = 500.0;     // 500.0 can be either dollars or any currency

In this assignment statement the data member balance of the Account class is initialized with 500.0. This is because the minimum balance of the newly opened account should have 500.0, whether rupees or dollars. If you modify the Account class example, Listing 6-3, by initializing the balance data member with the default value as shown in the assignment statement, executing the code will display the following output.

Output

------
Details of the account2        // just to denote that you are seeing the details of account2
account number = 0 Account Holder Name =   Balance : 500.0

init is a keyword. It's an optional block; if present it is used to initialize the data member of the class, or you can add any initialization statements. You can consider the init block to be the constructor of the class. It is executed as the final step of instance initialization. The following init block shows how to initialize the balance data member of the class Account.

init {
    balance = 500.0;
}

1.    class Distance {
2.        var feet : Integer = 1;    // default value is 1
3.        var inches : Number = 0.0;
4.
5.        init {
6.            println("within init block..");
7.            println("Default value is overridden by object initialization");
8.            println("feet = {feet}  inches = {inches}");
9.            println("Overriding the default value printing the ");
10.            feet = 10;
11.            inches = 4.5;
12.            println("feet = {feet}  inches = {inches}");
13.        }
14.
15.        function showdist() : Void {
16.            println("feet = {feet } inches = {inches } ");
17.        }
18.    }
19.
20.    var dist1 : Distance = Distance {
21.        feet : 5
22.        inches : 10.5
23.    }
24.    println("calling the member function to print the value of data member");
25.    dist1.showdist() ;

------
within init block..
Default value is overridden by object initialization
feet = 5  inches = 10.5
Overriding the default value printing the
feet = 10  inches = 4.5
calling the member function to print the value of data member
feet = 10 inches = 4.5

In Listing 6-4, we declare a Distance class, which has two data members, feet and inches (which have default values of 1 and 0.0, respectively), and a member function named showdist() to display the value of feet and inches. In line 20, the object dist1 is created and initialized. We assign feet a value of 5 and inches a value of 10.5. Because we have initialized the object dist1, the default values of feet and inches are overridden. Now feet holds the value of 5 and inches holds the value of 10.5. Next the JavaFX script runtime will execute the init block. The first statement of the init block is line 6, which is an output statement announcing that now you are in the init block. In line 8, the values of feet and inches are printed, 5 and 10.5. Next we modify the feet and inches values by 10 and 4.5, and then print the overridden value of the object initialization. When object dist1 calls the showDist() function, the modified value in the init block is printed.

As noted earlier, the postinit block is optional. It is executed after instance initialization has completed. Usually, you'll place code in postinit that has to be executed after the object is initialized. One of the best uses of a postinit block is to add event-handling code, such as keyevent() and mouseEvent() functions.

Syntax

postinit {
         //statements that is required after creation and initialization of the object.
       }

It is not mandatory that only a member function of a class can access its objects. In some situations, even functions that are not members can access the object. Listing 6-7 demonstrates how a non member function can access the objects of the class and return the object.

1.    class Distance {
2.          var feet : Integer = 0;
3.          var inches : Number = 0.0;
4.          function showdist() : Void {
5.          println("feet = {feet } inches = {inches } ");
6.        }
7.    } //  end class
8.    /*  Non-member function */
9.    function addDistance(dist1: Distance , dist2 : Distance): Distance {
10.        var feet : Integer = dist1.feet + dist2.feet;
11.        var inches : Number = dist1.inches + dist2.inches;
12.        if(inches >= 12.0 ) {
13.            feet++;
14.            inches -= 12.0;
15.        }
16.        return Distance{ feet : feet  inches : inches }

17.  }
18.
19.    var dist1 : Distance = Distance {
20.        feet : 5
21.        inches : 10.5
22    }
23.    var dist2 : Distance = Distance {
24.        feet : 7
25.        inches : 6.65
26.    }
27.    println("The value of the dist1 object ");
28.    dist1.showdist() ;
29.    println("The value of the dist2 object ");
30.    dist2.showdist() ;
31.    var dist3 = addDistance(dist1 , dist2);
32.    println("The value of the dist3 object ");
33.    dist3.showdist() ;

------
The value of the dist1 object
feet = 5 inches = 10.5
The value of the dist2 object
feet = 7 inches = 6.65
The value of the dist3 object
feet = 13 inches = 5.1499996

Listing 6-7 is a modified version of the previous example, Listing 6-6. Here we have pulled the addDistance function outside the class and make the member function return the object as the return value of the function.