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.

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.

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.

Enterprise beans use the services provided by the EJB container. However, in order to avoid conflicts with these services, the enterprise beans are prevented from performing the following operations:

1. Managing or synchronizing threads
2. Loading a native directory
3. Accessing the files and directories with the java.io package
4. Using the AWT functionality such as displaying information from a keyboard
5. Using sockets or multicasting, and accepting connections on a socket
6. Setting a socket factory used by Server Socket

Method overloading is a feature that allows a programmer to implement polymorphism in Java. In method overloading, the name of the methods are same, but they differ in number or type of parameters passed to them.

When an overloaded method is invoked, java examines the number or type of parameters passed to the method and matches it with actual arguments to decide which method is to be called.

The example below describes an overloaded method named show():

1. int show(int i) {}
2. void show(String str) {}

Here, method name is the same, but the method at (1) has an int parameter, and the method at (2) has a String parameter.

Note: A parameter is the list of variables passed in a method declaration and arguments are the actual values passed to these parameters when the method is called. Arguments must match with the parameters type and order.

The this keyword refers to the currently executing instance of a class. It is commonly used to access members from within constructors, instance methods, and instance accessors. However, the static member functions do not have a this pointer. For example:

using System;
public class Students
{
public string name;
public string subcode;
//Constructor.
public Students(string name, string subcode)
{
//Use of this keyword to qualify members hidden by similar names.
this.name = name;
this.subcode = subcode;
}
}

The this keyword is used to pass an object as a parameter to other methods. For example:

Cal_Marks(this);

The functions of a Transfer Object are as follows:

1. It reduces network traffic by aggregating fine-grained remote objects and representing them as a single call.
2. It reduces coupling between the tiers.
3. It reduces code duplication.
4. It carries multiple data elements across a tier.
5. It is used to transport data from an enterprise bean to its client.

The functions of a Business Delegate are as follows:

1. It hides the implementation details of a business service, such as lookup and access mechanisms.
2. It provides loose coupling between client and system’s business services.
3. It provides control and protection for the business service.
4. It acts as a proxy for the client to implement the remote service’s interface.
5. It throws application level exceptions and, if needed, caches results locally.
6. It receives a request from a controller, translates it, and forwards it to the business service.
7. It receives a response back from the business service, translates it, and forwards it to the controller.

An intercepting filter is a pluggable component that is used to modify incoming requests from a client to a servlet and send the response back to the client. Many filters can be chained together, so that the output of one filter becomes an input for the next filter. The filter life cycle is controlled by the container. They are added and removed by configuring tags in the deployment descriptor.

Java allows a method to take a variable number of arguments. This capability is referred to as var-args, varargs variable arguments, variable-length argument lists, or variable-arity parameter.

The syntax for using variable argument lists is as follows:

void fun(int… z){}

The declaration of the varargs follows the type with an ellipse (…) and then name of the array.

Limit: A method can have only one varargs, and it must be the last parameter in the method signature. An example of a varargs declaration is as follows:

void fun(int x, char… y)

Numeric promotions are used to convert the operands in a numeric expression to a common type before an operation is performed between the operands. Numeric promotion is a property of the specific definitions of the built-in operations and not a Java language feature. It is applied to the operands of an arithmetic operator. The two types of numeric promotions are as follows:

1. Unary numeric promotion: The unary numeric promotion takes place in accordance with the following rules:
   1. If the operand is one of the following types: byte, short, or char, unary numeric promotion promotes it to a value of type int.
   2. Otherwise, no promotion takes place.
2. Binary numeric promotion: The binary numeric promotion takes place in accordance with the following rules:
   1. If one of the two operands in a numeric expression is a primitive type double value, the other is promoted to a double value.
   2. Otherwise, if one of the two operands in a numeric expression is a primitive type float value, the other is promoted to a float value.
   3. Otherwise, if one of the two operands in a numeric expression is a primitive type long value, the other is promoted to a long value.
   4. Otherwise, both operands are promoted to int values.

An interface is a reference type that defines a contract. An interface body consists of method declarations and constants. All methods and constants in an interface are public. Interfaces are left completely unimplemented, i.e., no method in the interface is implemented. All methods of an interface are abstract and the method body is absent. A class may access one or more interfaces simultaneously. An interface is defined using the syntax below:

access_modifier interface interface_name extends Super_interfaces{
return_type method1(parameter_list);
.
.
.
return_type methodn(parameter_list);
datatype variable1 = value;
.
.
.
datatype variablen = value;
}

The syntax defined above has two components: the interface declaration and the body of the interface. They are discussed in the following sections:

An interface declaration

An interface declaration consists of the following components:

• access_modifier: An interface can be declared by using the public access modifier or without any access modifier. When an interface is declared as public, it can be accessed by any class in any package. If no access modifier is used in the declaration, the interface is accessible only within the package in which it is declared.
• interface interface_name: The keyword interface in the declaration tells the compiler that it is an interface declaration, and name of the interface is the one that follows the interface keyword. The name of an interface must be a valid identifier.
• extends Super_interfaces: An interface can extend other interfaces in the same way as a class extends another class. The only difference between these two is that whereas a class is allowed to extend only one class, an interface can extend any number of interfaces. The extends keyword in an interface declaration tells the compiler that the interface extends the list of interfaces that follows the extends keyword.

The interface body

The interface body contains method declarations for all the methods included in the interface. A method declared within an interface does not have a body, i.e., the method declaration ends with a semicolon. This is because an interface does not provide implementations for the methods declared within it. Apart from method declarations, an interface contains constant declarations.

All the constants defined in an interface are by default static and final. Therefore, there is no need to explicitly use these keywords to declare variables inside the interface body. All methods and variables in an interface are implicitly public if the interface is declared as public. It is also not necessary to declare the methods as abstract as well. The following example demonstrates how to define an interface:

public interface MyInterface{
void method1();
int method2(int k);
int x = 1;
int y = 2;
}

The following table summarizes the differences between method overriding and method overloading: