Programming with Java, part II

ArticleCategory: [Choose a category, translators: do not translate this, see list below for available categories]

AuthorImage:[Here we need a little image from you]

TranslationInfo:[Author + translation history. mailto: or http://homepage]

original in es Jose M. Fernández

es to en Javier Cano

AboutTheAuthor:[A small biography about the author]

Abstract:[Here you write a little summary]

ArticleIllustration:[One image that will end up at the top of the article]

ArticleBody:[The main part of the article]

Lexical issues

Java comments can be in one of the next three styles:

1. //comments
   Characters from // until end of line are ignored.
2. /* comment */
   All characters between /* and */ are ignored. These comments can have an extension of several lines.
3. /** comment **/
   Same as /* */ comments, but these should only be used before the declarations because the tool javadoc uses them to automatically create the documentation.
   

Identifiers are the names given to the variables, classes and methods to identify them to the Compiler. It is possible to use any string of letters (upper and lower case), numbers and the underline and dollar symbols. They can not begin with a number.

Java uses some special characters as separators. The most frequently used is the ; separator, but we will also find:

Data types, Variables, Operators.

In the previous article we mentioned that Java was completely object oriented, nevertheless, due to efficiency considerations, Java defines eight "simple" data types that are not objects. Besides, for portability reasons, all data types have a very defined range.

Simple data types can be distributed in four groups:

Variables:

Generally, a variable is declared in this way:

identifier type [=value] [,identifier [=value]......];

           

Examples:

int  a = 4, b, c=7;

char c;

myclass class;

           

Most of the programming languages define two scope categories, global and local. But this does not fit well with the Java object oriented model. On this model, the two main scopes are those defined by a class and a method.

Type conversion:

• the two data types will be compatible.
• Destination type should be bigger than source type.

(type) value

int a;

char b;

a=(int) b;

           

At the conversion of a floating point type to an integer type, it loses the fraction component:

int a;

double d= 125.43;

a=(int) d;

byte   b;

int i=257; 

b=(byte) i;

           

byte b;

double d= 340.123;

b=(byte) d;

Operators:

Arithmetic Operators:

int a=38;

double d=41.95;

int c=a%10;<

double  e=d%10;

The operators with assignment are useful at constructions such as:

a = a + 4; equivalent to a+=4;

a = a % 2; equivalent to a%=2;

Normally, we can say that sentences like:

var=var op expression; can be replaced with var op= expression;

Bit level operators:

Relational operators:

Boolean logic operators:

The general format of the ternary operator is:

Expession1 ? expession2 : expression3

If Expression1 is true, expresion2 will be executed; if it is false, expression3 will be executed.

Operators precedence:

Flow-Control sentences

if ( condition ) 

  sentence1;

else 

  sentence2;

If (condition ) 

  sentence;

else if (condition) 

  sentence;

else if (condition) 

  sentence;

.

.

else 

  sentence;

switch (expression){

  case value1:

    sentence;

    break;

  case value2:

    sentence;

    break;

    .

    ...

  default :

    sentence;

}

while (condition) {

  sentence;

}

do {

  sentences;

} while (condition)

for (initialization, condition, iteration) {

              

  sentences;

}

Classes, Methods, Inheritance

CLASSES :

A class is a model (pattern) for an object, and an object is an instance of a class. Java does not support global functions or variables, so all program actions (methods) have to be defined into a class.

A class is defined using the reserved word "class". A common class definition could be:

Class class_name {

  Type instance1_of_variable;

  Type instance2_of_variable;

  .

  .

  ...

  type instance_variable;

  type method_name(parameter_list){

    //body of the method

  }

  .

  .

  ..

  type name_of_the_method(parameter_list){





    //body of the method

  }

}

Two steps are required in order to get the objects of a class:

1. To declare a variable of the type of the class. This variable does not define an object, it is a variable which we can use to reference an object.
2. To dynamically assign memory to the object and get a reference of it.

            

variable = new name_of_the_class();

METHODS:

type name_of_the_method (parameter_list) {



  //method_body

}

The parameter list is a pair sequence of type-identifier, separated by a colon. The parameters are variables that receive the value of the arguments given to the method. If the method has no parameters, then the list will be empty.

Methods returning a value different from "void" use:

            

return valor;

Java provides methods with plenty of flexibility and power, so from here, up to the end of the article, we will review each of the most important aspects of methods.

However, before going on, let's review all the previous concepts with a simple example.

Let's create a class to calculate the capacity of a rectangular box (like a pool):

class capacity {

    double length;

    double width;

    double height;

    void CalcVolume () {

        double volume ;

        volume = length*width*height;

        System.out.println("Volume: " +

                           volume);

    }

}

class example {

  public static void main(String Arg[]){  

    capacity p1=new capacity();

    capacity p2=new capacity();

    p1.length = 16;

    p1.width=3;

    p1.height=2;



     //

    p2.length = 25;

    p2.width=6;

    p2.height=3;



    //

    p1.CalcVolume();



    //

    p2.CalcVolume();



  }



}  

           

Methods with parameters. Value return.

The majority of the methods are used with parameters that allow one to generalize them. Besides, methods can also return values, so we can build methods that can work with a wide range of data that can be used in different situations.

We will improve our example:

class capacity {

  double CalcVolume (double l, 

                     double a,

                     double p) {

    double volume=l*a*p ;

    return volume;

  }

}

class example {

  public static void main(String Arg[]){  

    capacity p1=new capacity();

    capacity p2=new capacity();



    double vol;



    vol=p1.CalcVolume(10,3,2);



    System.out.println("Volume: " + vol);  



    //



    vol=p2.CalcVolume(25,5,2);



    System.out.println("Volume: " + vol);  

  }

} 

           

A constructor included in a class has exactly the same name as the class. Its syntax is similar to that of a method. It is automatically executed after creating the object, before the new operator finishes.

Constructors do not return any type, as implicitly they return the type of the class. The constructor carries on with the initialization of the all the object state. By this way, the code that creates an instance of the object has a ready object to make use of it. As default, instance variables are initialized by constructors. As it happens with methods, constructors can have parameters to make them more useful. Let's modify our example to contemplate all this new aspects.

Class capacity {

  double length;

  double width;

  double height;



  //

  capacity(double l, 

           double a, 

           double p){  

    length=l;

    width=a;

    height=p;

  }



  //

  void CalcVolume () {

    double volume ;

    volume=large*wide*high;

    return volume;

  }

} 

           

class example {

  public static void main(String Arg[]) {  

    capacity p1=new capacity(10,5,2);

    capacity p2=new capacity(25,6,2);

    double vol;

    vol=p1.CalcVolume();

    System.out.println("Volume: " + vol);  



    //

    vol=p2.CalcVolume();

    System.out.println("Volume: " + vol);  

  }

}

Nevertheless, the method "finalize()" is used to add a finisher to a class. This method is executed when the interpreter destroys the object. In this method we will include the actions to get executed before destroying the object.

Method Overload.

Polymorphism (multiple methods for one interface) is one of the basic PILLARS in OOP. Java implements polymorphism by means of the method overload.

Different methods with the same name can be defined in a class, but they must have a different parameter list or at least different returned types. When an overloaded method is called the Java interpreter uses the type and/or the arguments passed with the call, to distinguish the version of the method to be used.

Each version of the overloaded method can perform different tasks, although this makes polymorphism completely impossible, so method overload should preferably imply some relation. Same way methods get overloaded, constructors can also be overloaded.

Argument passing.

Generally, programming languages allow two different ways to pass the arguments:

• By value: it is a copy of the argument value on the parameter-variable routine.
• By reference: it is passed the reference (the memory address) of the value, so if the value is modified by the routine, the variable at the calling process gets also modified.

Access Control.

Another basic PILLAR in OOP is ENCAPSULATION. It means linking data with the code that uses it. Moreover, ENCAPSULATION provides access control, that is to say, a part of the program has the ability to access the members of a class.

Access specifications in Java are 'public', 'private' and 'protected'.

When a method or a instance-variable is defined as 'public', it is accessible from any part of the program. If defined as 'private', it is only accessible by other methods of its own class. By default all methods or instance-variables (members) are 'public' (to its own packet¿?).

The 'protector' specifier is used when working with HERENCIAS(inheritances¿?), which is the next topic.

INHERITANCE.

To achieve a class B inheriting the properties of an A superclass, we will put in the B definition:

Class B extends A {

    // class definition

}

Java does not allow multiple inheritance from different superclasses to one subclass.

If there are members defined as 'private' in the superclass, they can not be accessed by the inherited classes. When a subclass needs to reference an immediate superclass, the reserved word 'super' can be used. In that way we can call the builder/constructor or members of the superclass that have been hidden by the subclass.

When a method of a subclass has the same name and type as the method of the superclass, it is said that the method is overwritten. This property establishes the base of one of the more powerful aspects of Java, named "Dynamic selection method". This means that the decision of which method should be used on each call, is performed at execution time in place to depend on the referenced variable type.

In the next article we will see all the power of inheritance, with abstract classes, interfaces, etc.

References

• JAVA reference manual. Patrick Naughton Herbert Schildt. Mcgraw-Hill.
• Programming with JAVA. Tim Ritchey. Prentice Hall.
• Java Tutorial. Spanish manual in HTML format obtained from the address www.fie.us.es/info/internet/JAVA. Agustín Froufe.
• The Java Tutorial. English manual in HTML format obtained from the address www.javasoft.com. Sun.
• JDK own installation tutorials.
• Java client-server.Cédric Nicolas, Chistophe Avare y Frederic Najman. Gestión 2000.