An association represents a relationship between classes. It represents a mechanism that allows objects to communicate with each other. It describes the connection between different classes.

Association can be unidirectional or bi-directional.

A unidirectional association implies that an object of the class from which the arrow is originating, i.e., the class that has the no-arrowhead side of the association may invoke methods on the class towards which the arrow is pointing.

A bi-directional association means that either object in the association may invoke methods on the other.

WonderFALL news & savings from uCertify!!!!

Fall into crisp, cool autumn savings with uCertify !

This offer is available for the first 100 customers only. Be one of the first to buy any of our PrepKits and get the ONLINE version absolutely FREE! Access the PrepKit from any computer, your iPhone or iPad! How COOL is that?!

Choose from over 300 test prep software for CompTIA, Microsoft, Oracle, IBM, Cisco, CCNA & many more. Nobody beats our breadth and depth of experience.

Buy our PrepKits and Save upto 50%! And yes, get the online and mobile versions absolutely FREE!

http://www.ucertify.me

Simply sign up or login with your existing account and add the Prepkit of your choice and and access it from anywhere. You can add your license information from this link

http://www.ucertify.me/myprofile.php?func=mylicense

iPhone and iPad users signup to http://learn.ucertify.com or login with your existing account and add the Prepkit of your choice and and access it from your iPhone and iPad. You can add your license information from this link

http://learn.ucertify.com/myprofile.php?func=mylicense

Click here now to Save : uCertify’s WonderFALL Sale!

Happy Shopping & Happy Learning!

Your uCertify Team

http://www.ucertify.com

In Java, a narrowing conversion is also known as an explicit type conversion or casting. When the destination data type is narrower than the source data type, an explicit type conversion is required. The general form of this explicit conversion is given below:

(target-type) value

Here, target-type is the desired data type and value is the value to be converted.

For example:

int a, int b;
short c;
c= (short)(a+b);

Here, the sum of two 32-bit integer data type variables a and b is assigned to another variable c, which is of integer type short (16-bit). Therefore, an explicit conversion takes place before assigning the value to c. Otherwise, if this explicit type conversion is not performed, and the sum of variables a and b is directly assigned to variable c, a compile-time error will be generated.

In Java, runtime polymorphism or dynamic method dispatch is a process in which a call to an overridden method is resolved at runtime rather than at compile-time. In this process, an overridden method is called through the reference variable of a superclass. The determination of the method to be called is based on the object being referred to by the reference variable. For example:

class Try {
void disp() {}
}

class Test extends Try {
void disp() {}
public static void main(String args[]){
Try t=new Try();
Test t1=new Test();
Try v;
v=t1;
v.disp(); // call to the disp() method from Test.
}
}

Here, the Test version of the disp() method is called because the reference variable v of the type Try points to the Test object t1.

Coupling is a term that describes the degree to which one module relies on another module for its proper functioning. Coupling is mainly of the following two types:

• Loose coupling: Loose or weak coupling implies that a change in one module does not require changes in the implementation of another module.
• Tight coupling: Tight or strong coupling implies that a module relies on another module so strongly that a small change in one will require an implementation change in the other.

For a good object-oriented design, loose coupling is desirable.

Polymorphism is a feature that allows an interface in Java to be used by many classes for different purposes. The word polymorphism combines poly with morphism, which means many forms. Some examples of polymorphism are overloading and overriding. Polymorphism allows an interface to be used for a general class of actions.

Constructor overloading is a technique in Java in which a class can have any number of constructors that differ in parameter lists. A constructor uses its arguments to initialize the new object’s state. The compiler differentiates these constructors by taking into account the number of parameters in the list and their types.

As constructors are not members of a class, they are not inherited by subclasses. Therefore, each of the subclasses must specifically implement any constructors it needs. However, a subclass can use the constructors of its superclass by using the super keyword.

Inheritance is a process by which objects of a class acquire the properties of the objects of another class. It supports the concept of hierarchical classification. It not only allows objects to be reused, but also allows the creation of new objects by extending the existing ones. By using the inheritance, a generic class can be created that can then be inherited by other more specific classes. In Java terminology, a class that is inherited is called a superclass, and the class that inherits another class is called a subclass. A subclass inherits all the instance variables (attributes) and methods (operations) defined in the superclass.

In Java, a class is declared to inherit another class by using the extends keyword.

Variables that have only one copy per class are known as static variables. They are not attached to a particular instance of a class but rather belong to a class as a whole. They are declared by using the static keyword as a modifier. For example:

static type varIdentifier;

where, the name of the variable is varIdentifier and its data type is specified by type.

Static variables that are not explicitly initialized in the code are automatically initialized with a default value. The default value depends on the data type of the variables. The table given below shows the default values:

A constructor without any parameters is known as a default constructor. When a class is defined without any constructor, the Java compiler provides an implicit default constructor. The implicit default constructor is equivalent to the following implementation:

class name(){
super();
}

When the implicit default constructor of a class is invoked, it implicitly calls the no parameter constructor in the superclass. This action taken by a default constructor ensures that the inherited state of the object is initialized properly. In addition, it initializes all the instance variables in the object to the default value depending on their data type.

The default constructor of a class has the same access modifier with which the class has been declared. For example, the default constructor of a public class is implicitly given the public access. The default constructor of a protected class is implicitly given the protected access. The default constructor of a private class is implicitly given the private access. Otherwise, the default constructor has the default access implied by no access modifier.

UML uses various types of graphical notations to represent different relationships, operations, and attributes. In UML, each modifier is represented by a symbol, as shown in the table below:

The multiplicity of a relationship between two classes defines the number of objects of one class in relation to the number of objects of another class. In UML, the multiplicity of zero to many is represented by an asterisk(*) symbol. A one to many relationship is represented by using the 1..* notation. The following table describes the common multiplicities:

Aggregation is a type of association that specifies a whole/part relationship between the aggregate (whole) and a component part. It differs from composition in that it does not imply ownership. In composition, when the owning object is destroyed, so are the contained objects. Following are the characteristics of aggregation:

1. It does not imply ownership.
2. It is an asymmetric relationship.
3. It is a transitive relationship.
4. It implies stronger coupling behavior (copy, delete, etc.).

When one object is responsible for the lifecycle management of another object, this relationship is known as composition. Composition represents a “has-a” type relationship. Compositions are a critical building block of many basic data structures, including the tagged union, the linked list, and the binary tree, as well as the object used in object-oriented programming. In UML, composition is depicted as a filled diamond and a solid line. It always implies a multiplicity of 1 or 0..1, as no more than one object at a time can have lifetime responsibility for another object. In an “is a” relationship, the derived class is clearly a kind of the base class.

The lowerKey(k) method of the NavigableMap interface returns the greatest key in the map strictly less than k. It returns a null value if no such key is found. The lowerKey(k) method throws the ClassCastException if the specified key cannot be compared with the keys currently in the map. It throws the NullPointerException if the specified key is null and the map does not permit null keys

The lowerEntry(k) method of the NavigableMap interface returns a key value pair with the greatest key in the map strictly less than k. It returns a null value if no such key is found. The lowerEntry(k) method throws the ClassCastException if the specified key cannot be compared with the keys currently in the map. It throws the NullPointerException if the specified key is null and this map does not permit null keys

The descendingMap() method of the NavigableMap interface returns a navigable map according to the descending order of keys. This method returns a map that is similar to the result of the Collections.reverseOrder(comparator()) method. The expression m.descendingMap().descendingMap() returns a map exactly equal to map m.

The descendingKeySet() method of the NavigableMap interface returns a navigable set according to the descending order of keys in the map. The navigable set obtained as a result of the descendingKeySet() method supports element removal via the Iterator.remove, Set.remove, removeAll, retainAll, and clear operations. However, it does not support the add and addAll operations

The File class is an abstract class used for file operations such as creating empty files, deleting files, searching for a file in a directory, making directories, etc. It does not contain any method to read or write data from a file. The File class extends the Object class and implements the Serializable and Comparable interfaces.

The FileReader class provides methods for reading character files. It contains methods for reading a single character, a fixed number of characters, or a whole stream of characters. Since these classes do not provide fast performance, they are usually wrapped within high-level reader objects such as a BufferedReader

The BufferedWriter class is used for fast writing operations of texts to a character-output stream. It can be used to write single characters, arrays, and strings of data. The size of buffer may or may not be specified. The BufferedWriter class has the newLine() method that is used to create platform-specific line separators, as some platforms do not support the new line character (‘\n’) to terminate lines.

The BufferedReader class is used for fast reading operations of texts from a character-input stream. It can be used to read single characters, arrays, and lines of data. The size of buffer may or may not be specified. The readLine() method of the BufferedReader class can be used to get the next line of characters from a file, and the skip(long n) method can be used to skip n number of characters.