Course Code : MCS-024
Course Title : Object Oriented Technologies and Java Programming
Assignment Number : BCA (IV)-024/Assign/14-15
Assignment Marks : 100
Maximum Marks : 25%
Last Dates for Submission : 15th October, 2014 (For July 2014 Session)
15th April, 2015 (For January 2015 Session)
There are eight questions in this assignment which carries 80 marks. Rest of 20 marks is for viva-voce. Answer all the questions. Write and execute the program given in this assignment and submit along with output. Also in your programs give appropriate comments to increase understandability. Please go through the guidelines regarding assignments given in the Programme Guide for the format of presentation.
QUESTION: 1
a) What is Object Oriented Programming? Explain features of Object Oriented Programming. Write a program in java to show data hiding.
Solution:
Object-oriented programming (OOP) is a programming language model organized around “objects” rather than “actions” and data rather than logic. Historically, a program has been viewed as a logical procedure that takes input data, processes it, and produces output data. A type of programming in which programmers define not only the data type of a data structure, but also the types of operations (functions) that can be applied to the data structure. In this way, the data structure becomes an object that includes both data and functions. In addition, programmers can create relationships between one object and another. For example, objects can inherit characteristics from other objects. One of the principal advantages of object-oriented programming techniques over procedural programming techniques is that they enable programmers to create modules that do not need to be changed when a new type of object is added. A programmer can simply create a new object that inherits many of its features from existing objects. This makes object-oriented programs easier to modify.
Objects
Objects are the basic unit of OOP. They are instances of class, which have data members and uses various member functions to perform tasks.
Class
It is similar to structures in C language. Class can also be defined as user defined data type but it also contains functions in it. So, class is basically a blueprint for object. It declare & defines what data variables the object will have and what operations can be performed on the class’s object.
Abstraction
Abstraction refers to showing only the essential features of the application and hiding the details. In C++, classes provide methods to the outside world to access & use the data variables, but the variables are hidden from direct access.
Encapsulation
It can also be said data binding. Encapsulation is all about binding the data variables and functions together in class.
Inheritance
Inheritance is a way to reuse once written code again and again. The class which is inherited is called base calls & the class which inherits is called derived class. So when, a derived class inherits a base class, the derived class can use all the functions which are defined in base class, hence making code reusable.
Polymorphism
Polymorphion makes the code more readable. It is a features, which lets is create functions with same name but different arguments, which will perform differently. That is function with same name, functioning in different
Overloading
Overloading is a part of polymorphion. Where a function or operator is made & defined many times, to perform different functions they are said to be overloaded.
Exception Handling
Exception handling is a feature of OOP, to handle unresolved exceptions or errors produced at runtime.
A program in java to show data hiding.
public class EncapTest{
private String name;
private String idNum;
private int age;
public int getAge(){
return age;
}
public String getName(){
return name;
}
public String getIdNum(){
return idNum;
}
public void setAge( int newAge){
age = newAge;
}
public void setName(String newName){
name = newName;
}
public void setIdNum( String newId){
idNum = newId;
}
}
b) Explain why java is platform independent. Also explain how memory is managed in java.
Solution:
The most important feature of “java is platform Independent”. Here ‘platform’ stands for Operating systems used by end user.
There are lots of Operating Systems and java supports all of them, java language does not depend on particular Operating system or any hardware system. It means every single java program can run on different operating system shows platform independent nature of java. Basically Java runs on JVM (Java Virtual Machine), and JVM (Java Virtual Machine) is platform dependent. Java is one of the most powerful and portable language, because it is compiled as well as interpreted language. After compilation an intermediate code is generate, this code is known as ‘byte code’ and cause of byte code, java is known as platform independent because in actual, byte code has a powerful feature to run on any platform or operating system. Byte code is found in form of ‘.class’ file and
We can run the same ‘.class’ file on any operating system (Windows, Linux, Mac, Unix). To run or execute a java file on different platforms, we need only ‘.class’ file of and application or program.
In java, memory is managed via garbage collector. Few techniques for memory management are:
1. Reference Counting: A count of references to each object is maintained. When garbage collector runs, it deletes objects with zero reference count.
Drawback: Circular references are maintained in memory.
2. Tracing collectors/Copy Collector/Stop and copy collector: Start from a root object and keep a track of all references which have direct/indirect reference to the root object. Then all the live objects are moved to another heap, taking care of references properly.
Drawback: At each point of time, you will have 2 heaps thus consuming twice the memory.
3. Mark sweep collectors/Stop and work collector: Similar to tracing collector except that instead of copying the references to the new heap, they are swept out of memory, after a list of live and dead objects is known.
Mark and sweep is a stop-the-world garbage collection technique; that is all application threads stop until garbage collection completes or until a higher-priority thread interrupts the garbage collector. If the garbage collector is interrupted it must restart which can lead to application thrashing with little apparent result.
QUESTION: 2
a) What is static method? Explain application of static method with example.
Solution:
Static methods use no instance variables of any object of the class they are defined in. If you define a method to be static, you will be given a rude message by the compiler if you try to access any instance variables. You can access static variables, but except for constants, this is unusual. Static methods typically take all they data from parameters and compute something from those parameters, with no reference to variables. This is typical of methods which do some kind of generic calculation. A good example of this is the many utility methods in the predefined Math class.
Static methods are used for methods that do not need to access to an object’s state or only use static fields. For example, the main method is a static method: public static void main(String [] args)
It is the starting point for a Java application and does not need to access an object’s state. In fact, there aren’t any objects created at this point. Any parameters that it needs can be passed as a String array.
To find out more about using the static keyword have a look at Static Fields.
public class HowToAccessStaticMethod{
int i;
static int j;
public static void staticMethod(){
System.out.println("you can access a static method this way");
}
public void nonStaticMethod(){
i=100;
j=1000;
System.out.println("Don't try to access a non static method");
}
public static void main(String[] args) {
//i=100;
j=1000;
//nonStaticMethod();
staticMethod();
}
}
Output of the program is given below:
C:\java>java HowToAccessStaticMethod you can access a static method this way
b) What are different arithmetic and logical operators in java? Write a Java program and show uses of all arithmetic operators.
Solution:
The Arithmetic Operators:
Arithmetic operators are used in mathematical expressions in the same way that they are used in algebra. The following table lists the arithmetic operators:
Operator Description Example
+ Addition - Adds values on either side of the operator A + B will give 30
- Subtraction - Subtracts right hand operand from left hand operand A - B will give -10
* Multiplication - Multiplies values on either side of the operator A * B will give 200
/ Division - Divides left hand operand by right hand operand B / A will give 2
% Modulus - Divides left hand operand by right hand operand and returns remainder B % A will give 0
++ Increment - Increases the value of operand by 1 B++ gives 21
-- Decrement - Decreases the value of operand by 1 B-- gives 19
The Logical Operators:
The following table lists the logical operators: Assume Boolean variables A holds true and variable B holds false, then:
Operator Description Example
&& Called Logical AND operator. If both the operands are non-zero, then the condition (A && B) is false
becomes true.
|| Called Logical OR Operator. If any of the two operands are non-zero, then the (A || B) is true.
condition becomes true.
! Called Logical NOT Operator. Use to reverses the logical state of its operand. If a !(A && B) is true
condition is true then Logical NOT operator will make false.
A Java program and show uses of all arithmetic operators.
public class ArithmeticOperatorsDemo {
public ArithmeticOperatorsDemo() {
int x, y = 10, z = 5;
x = y + z;
System.out.println("+ operator resulted in " + x);
x = y - z;
System.out.println("- operator resulted in " + x);
x = y * z;
System.out.println("* operator resulted in " + x);
x = y / z;
System.out.println("/ operator resulted in " + x);
x = y % z;
System.out.println("% operator resulted in " + x);
x = y++;
System.out.println("Postfix ++ operator resulted in " + x);
x = ++z;
System.out.println("Prefix ++ operator resulted in " + x);
x = -y;
System.out.println("Unary operator resulted in " + x);
// Some examples of special Cases
int tooBig = Integer.MAX_VALUE + 1; // -2147483648 which is
// Integer.MIN_VALUE.
int tooSmall = Integer.MIN_VALUE - 1; // 2147483647 which is
// Integer.MAX_VALUE.
System.out.println("tooBig becomes " + tooBig);
System.out.println("tooSmall becomes " + tooSmall);
System.out.println(4.0 / 0.0); // Prints: Infinity
System.out.println(-4.0 / 0.0); // Prints: -Infinity
System.out.println(0.0 / 0.0); // Prints: NaN
double d1 = 12 / 8; // result: 1 by integer division. d1 gets the value
// 1.0.
double d2 = 12.0F / 8; // result: 1.5
System.out.println("d1 is " + d1);
System.out.println("d2 iss " + d2);
}
public static void main(String args[]) {
new ArithmeticOperatorsDemo();
}
}
c) What is final keyword in java? Explain different uses of final keyword.
Solution:
The final keyword is a way of marking a variable as “read-only”. Its value is set once and then cannot be changed.
For example, if year is declared as
Final int year = 2005;
Variable year will be containing value 2005 and cannot take any other value after words.
The final keyword is used for three purposes:
i. Making constants
ii. Preventing method to be overridden
iii. Preventing a class to be inherited
The final keyword can also be applied to methods, with similar semantics: i.e. the definition will not change. You cannot override a final method in subclasses, this means the definition is the “final” one. You should define a method final when you
are concerned that a subclass may accidentally or deliberately redefine the method (override). If you want to prevent a class to be inherited, apply the final keyword to an entire class definition.
QUESTION: 3
a) What is method overloading? How it is different from method overriding? Write a java program to explain overloading and overriding of methods.
Solution:
If a class has multiple methods by same name but different parameters, it is known as Method Overloading. If we have to perform only one operation, having same name of the methods increases the readability of the program. Suppose you have to perform addition of the given numbers but there can be any number of arguments, if you write the method such as a (int, int) for two parameters, and b (int,int,int) for three parameters then it may be difficult for you as well as other programmers to understand the behaviour of the method because its name differs. So, we perform method overloading to figure out the program quickly.
With method overloading, programmer can have multiple methods with the same name but their functionality changes according to the situations.Whereas method overriding is used in the situation where we want a method with the same name to behave in a different manner in different classes in the hierarchy.
public class OverloadingOverridingTest {
public static void main(String[] args) {
// Example of method overloading in Java
Loan cheapLoan = Loan.createLoan(“HSBC”);
Loan veryCheapLoan = Loan.createLoan(“Citibank”);
// Example of method overriding in Java
Loan personalLoan = new PersonalLoan();
personalLoan.toString();
} }
public class Loan {
private double interestRate;
private String customer;
private String lender;
public static Loan createLoan(String lender) {
Loan loan = new Loan();
loan.lender = lender;
return loan;
}
public static Loan createLoan(String lender, double interestRate) {
Loan loan = new Loan();
loan.lender = lender;
loan.interestRate = interestRate;
return loan;
}
public String toString() {
return “This is Loan by Citibank”;
}
}
public class PersonalLoan extends Loan {
@Override
public String toString() {
return “This is Personal Loan by Citibank”;
}
}
b) What is abstract class? Explain why abstract class is used in java, with the help of an example program.
Solution:
An abstract class is a class that is declared abstract—it may or may not include abstract methods. Abstract classes cannot be instantiated, but they can be sub classed. An abstract method is a method that is declared without an implementation (without braces, and followed by a semicolon), like this:
abstract void moveTo(double deltaX, double deltaY);
If a class includes abstract methods, then the class itself must be declared abstract, as in:
public abstract class GraphicObject {
// declare fields
// declare nonabstract methods
abstract void draw();
}
When an abstract class is subclassed, the subclass usually provides implementations for all of the abstract methods in its parent class. However, if it does not, then the subclass must also be declared abstract.
abstract class A {
abstract void callme();
// concrete methods are still allowed in abstract classes
void callmetoo() {
System.out.println(“This is a concrete method.”);
}
}
class B extends A {
void callme() {
System.out.println(“B’s implementation of callme.”);
}
}
class AbstractDemo {
public static void main(String args[]) {
B b = new B();
b.callme();
b.callmetoo();
}
}
Notice that no objects of class A are declared in the program. As mentioned, it is not possible to instantiate an abstract class. One other point: class A implements a concrete method calledcallmetoo( ). This is perfectly acceptable. Abstract classes can include as much implementation as they see fit.
QUESTION: 4
a) What is inheritance? Explain different types of inheritance supported by java.
Solution:
Inheritance is a mechanism in which one object acquires all the properties and behaviours of parent object.
The idea behind inheritance is that you can create new classes that are built upon existing classes. When you inherit from an existing class, you reuse (or inherit) methods and fields, and you add new methods and fields to adapt your new class to new situations.
Inheritance represents the IS-A relationship.
Types of inheritance supported by java
1. Single: Single inheritance is damn easy to understand. When a class extends another one class only then we call it a single inheritance. The below flow diagram shows that class B extends only one class which is A. Here A is aparent class of B and B would be a child class of A.
ignou.nisecomputers.com
2. Multilevel: Multilevel inheritance refers to a mechanism in OO technology where one can inherit from a derived class, thereby making this derived class the base class for the new class. As you can see in below flow diagram C is subclass or child class of B and B is a child class of A. For more details and example refer – Multilevel inheritance in Java.
ignou.nisecomputers.com
3. Hierarchical: In such kind of inheritance one class is inherited by many sub classes. In below example class B,C and D inherits the same class A. A is parent class (or base class) of B,C & D. Read More at – Hierarchical Inheritance in java with example program.
ignou.nisecomputers.com
4. Hybrid: In simple terms you can say that Hybrid inheritance is a combination of Single and Multiple inheritance. A typical flow diagram would look like below. A hybrid inheritance can be achieved in the java in a same way as multiple inheritances can be!! Using interfaces. Yes you heard it right. By using interfaces you can have multiple as well as hybrid inheritance in Java.
ignou.nisecomputers.com
Note: multiple inheritance is not supported in java. To reduce the complexity and simplify the language, multiple inheritance is not supported in java.
b) What is an exception? Explain haw an exception is handled in Java. Create your own exception class to handle undesirable operation in your program.
Solution:
An exception is an event, which occurs during the execution of a program, that disrupts the normal flow of the program’s instructions. When an error occurs within a method, the method creates an object and hands it off to the runtime system. The object, called an exception object, contains information about the error, including its type and the state of the program when the error occurred. Creating an exception object and handing it to the runtime system is called throwing an exception.After a method throws an exception, the runtime system attempts to find something to handle it. The set of possible “somethings” to handle the exception is the ordered list of methods that had been called to get to the method where the error occurred. The list of methods is known as the call stack.
To understand how exception handling works in Java, you need to understand the three categories of exceptions:
• Checked exceptions: A checked exception is an exception that is typically a user error or a problem that cannot be foreseen by the programmer. For example, if a file is to be opened, but the file cannot be found, an exception occurs. These exceptions cannot simply be ignored at the time of compilation.
• Runtime exceptions: A runtime exception is an exception that occurs that probably could have been avoided by the programmer. As opposed to checked exceptions, runtime exceptions are ignored at the time of compilation.
• Errors: These are not exceptions at all, but problems that arise beyond the control of the user or the programmer. Errors are typically ignored in your code because you can rarely do anything about an error. For example, if a stack overflow occurs, an error will arise. They are also ignored at the time of compilation.
Catching Exceptions and building blocks in java: The basic building blocks are try-catch-finally Any java method catches an exception using a combination of the try and catch keywords as shown below. The try/catch block is placed around the code that might generate an exception. There might be many try/catch blocks. The catch block defines exceptions classes which the code might throw. The parent class is ‘Exception’ but the user can define any exception class inside catch block. The finally block always executes irrespective of the type of exception.
Create your own exception class to handle undesirable operation in your program.
package com.journaldev.exceptions;
import java.io.FileNotFoundException;
import java.io.IOException;
public class ExceptionHandling {
public static void main(String[] args) throws FileNotFoundException, IOException {
try{
testException(-5);
testException(-10);
}catch(FileNotFoundException e){
e.printStackTrace();
}catch(IOException e){
e.printStackTrace();
}finally{
System.out.println(“Releasing resources”);
}
testException(15);
}
public static void testException(int i) throws FileNotFoundException, IOException{
if(i < 0){ FileNotFoundException myException = new FileNotFoundException(“Negative Integer “+i); throw myException; }else if(i > 10){
throw new IOException(“Only supported for index 0 to 10″);
}
}
}
Output of above program is:
java.io.FileNotFoundException: Negative Integer -5
at com.journaldev.exceptions.ExceptionHandling.testException(ExceptionHandling.java:24)
at com.journaldev.exceptions.ExceptionHandling.main(ExceptionHandling.java:10)
Releasing resources
Exception in thread “main” java.io.IOException: Only supported for index 0 to 10
at com.journaldev.exceptions.ExceptionHandling.testException(ExceptionHandling.java:27)
at com.journaldev.exceptions.ExceptionHandling.main(ExceptionHandling.java:19)
QUESTION: 5
a) Write a java program to create a file of given name and directory and copy a file named myjava.java available at desktop.
Solution:
b) What is String class in java? Explain different constructors and method of String class. Also write a java program to find the length of a given string.
Solution:
Java String Class is immutable, i.e. Strings in java, once created and initialized, cannot be changed on the same reference. A java.lang.String class is final which implies no class and extend it. The java.lang.String class differs from other classes, one difference being that the String objects can be used with the += and + operators for concatenation. Two useful methods for String objects are equals( ) and substring( ). The equals( ) method is used for testing whether two Strings contain the same value. The substring( ) method is used to obtain a selected portion of a String.
Constructor is a special type of method that is used to initialize the object.Constructor is invoked at the time of object creation. It constructs the values i.e. provides data for the object that is why it is known as constructor.
There are two types of constructors:
1. default constructor (no-arg constructor): A constructor that have no parameter is known as default constructor.
2. parameterized constructor: A constructor that have parameters is known as parameterized constructor.
Methods with Description
char charAt(int index):Returns the character at the specified index.
int compareTo(Object o): Compares this String to another Object.
int compareTo(String anotherString: Compares two strings lexicographically.
int compareToIgnoreCase(String str): Compares two strings lexicographically, ignoring case differences.
String concat(String str): Concatenates the specified string to the end of this string.
boolean contentEquals(StringBuffer sb): Returns true if and only if this String represents the same sequence of characters as the specified StringBuffer.
static String copyValueOf(char[] data): Returns a String that represents the character sequence in the array specified.
static String copyValueOf(char[] data, int offset, int count): Returns a String that represents the character sequence in the array specified.
boolean endsWith(String suffix): Tests if this string ends with the specified suffix.
boolean equals(Object anObject): Compares this string to the specified object.
A java program to find the length of a given string
import java.io.*;
public class Test{
public static void main(String args[]){
String Str1 = new String(“Welcome to ignou.nisecomputers.com”);
String Str2 = new String(“Tutorials” );
System.out.print(“String Length :” );
System.out.println(Str1.length());
System.out.print(“String Length :” );
System.out.println(Str2.length());
}
}
This produces the following result:
String Length :34
String Length :9
QUESTION: 6
a) What is multithreading? Write a java program to explain how concurrency control is done.
Solution:
Java is a multithreaded programming language which means we can develop multithreaded program using Java. A multithreaded program contains two or more parts that can run concurrently and each part can handle different task at the same time making optimal use of the available resources specially when your computer has multiple CPUs. By definition multitasking is when multiple processes share common processing resources such as a CPU. Multithreading extends the idea of multitasking into applications where you can subdivide specific operations within a single application into individual threads. Each of the threads can run in parallel. The OS divides processing time not only among different applications, but also among each thread within an application. Multithreading enables you to write in a way where multiple activities can proceed concurrently in the same program.
class Pool { // Incomplete
protected java.util.ArrayList items = new ArrayList();
protected java.util.HashSet busy = new HashSet();
protected final Semaphore available;
public Pool(int n) {
available = new Semaphore(n);
initializeItems(n);
}
public Object getItem() throws InterruptedException {
available.acquire();
return doGet();
}
public void returnItem(Object x) {
if (doReturn(x))
available.release();
}
protected synchronized Object doGet() {
Object x = items.remove(items.size()-1);
busy.add(x); // put in set to check returns
return x;
}
protected synchronized boolean doReturn(Object x) {
if (busy.remove(x)) {
items.add(x); // put back into available item list
return true;
}
else return false;
}
protected void initializeItems(int n) {
// Somehow create the resource objects
// and place them in items list.
}
}
b) What is I/O stream in Java? Explain what is byte steam? How byte stream is different from character stream.
Solution:
Java performs I/O through Streams. A Stream is linked to a physical layer by java I/O system to make input and output operation in java. In general, a stream means continuous flow of data. Streams are clean way to deal with input/output without having every part of your code understand the physical.
Java encapsulates Stream under java.io package. Java defines two types of streams. They are,
Byte Stream: It provides a convenient means for handling input and output of byte.
Character Stream: It provides a convenient means for handling input and output of characters. Character stream uses Unicode and therefore can be internationalized.
Java byte streams are used to perform input and output of 8-bit bytes. Though there are many classes related to byte streams but the most frequently used classes are , FileInputStream andFileOutputStream. Following is an example which makes use of these two classes to copy an input file into an output file:
import java.io.*;
public class CopyFile {
public static void main(String args[]) throws IOException
{
FileInputStream in = null;
FileOutputStream out = null;
try {
in = new FileInputStream(“input.txt”);
out = new FileOutputStream(“output.txt”);
int c;
while ((c = in.read()) != -1) {
out.write(c);
}
}finally {
if (in != null) {
in.close();
}
if (out != null) {
out.close();
}
}
}
}
CopyBytes seems like a normal program, but it actually represents a kind of low-level I/O that you should avoid. Since xanadu.txt contains character data, the best approach is to use character streams, as discussed in the next section. There are also streams for more complicated data types. Byte streams should only be used for the most primitive I/O.
CopyCharacters is very similar to CopyBytes. The most important difference is that CopyCharacters uses FileReader and FileWriter for input and output in place of FileInputStream and FileOutputStream. Notice that both CopyBytes and CopyCharacters use an int variable to read to and write from. However, in CopyCharacters, the int variable holds a character value in its last 16 bits; in CopyBytes, the int variable holds a byte value in its last 8 bits. There are two general-purpose byte-to-character “bridge” streams: InputStreamReader and OutputStreamWriter. Use them to create character streams when there are no prepackaged character stream classes that meet your needs. The sockets lesson in the networking trail shows how to create character streams from the byte streams provided by socket classes.
QUESTION: 7
a) What is Java Applet? Create an Applet program to display your details including your academic and personal information. Use appropriate GUI components and images to make your applet more attractive and informative.
Solution:
A Java applet is a special kind of Java program that a browser enabled with Java technology can download from the internet and run. An applet is typically embedded inside a web page and runs in the context of a browser. An applet must be a subclass of the java.applet.Applet class. The Applet class provides the standard interface between the applet and the browser environment.
Swing provides a special subclass of the Applet class called javax.swing.JApplet. The JApplet class should be used for all applets that use Swing components to construct their graphical user interfaces (GUIs). The browser’s Java Plug-in software manages the lifecycle of an applet.
b) What are principles of event delegation model? Explain different sources of events and event listener.
Solution:
the concepts of the event delegation model. This model allows special classes, known as “adapter classes” to be built and be registered with a component in order to handle certain events. Three simple steps are required to use this model:
1. Implement the desired listener interface in your adapter class. Depending on what event you’re handling, a number of listener interfaces are available. These include: ActionListener, WindowListener, MouseListener, MouseMotionListener, ComponentListener, FocusListener, and ListSelectionListener.
2. Register the adapter listener with the desired component(s). This can be in the form of an add XXX Listener () method supported by the component for example include add ActionListener (), add MouseListener (), and add FocusListener ().
3. Implement the listener interface’s methods in your adapter class. It is in this code that you will actually handle the event.
The event delegation model allows the developer to separate the component’s display (user interface) from the event handling (application data) which results in a cleaner and more object-oriented design
Event Source: An event source is the object that generated the event, for example, if you click a button an ActionEvent Object is generated. The object of the ActionEvent class contains information about the event (button click).
Low-Level Events: These events are those that represent a low-level input or windows-system occurrence on a visual component on the screen.
The various low-level event classes and what they generate are as follows:
! A Container Event Object is generated when components are added or removed from container.
! A Component Event object is generated when a component is resized moved etc.
! A Focus Event object is generated when component receives focus for input.
! A Key Event object is generated when key on keyboard is pressed, released etc.
! A Window Event object is generated when a window activity, like maximizing or close occurs.
! A Mouse Event object is generated when a mouse is used.
! A Paint Event object is generated when component is painted.
Event Listeners: An object delegates the task of handling an event to an event listener. When an event occurs, an event object of the appropriate type (as explained below) is created. This object is passed to a Listener. The listener must implement the interface that has the method for event handling. A component can have multiple listeners, and a listener can be removed using remove Action Listener () method.
QUESTION: 8
a) What is InetAddress class in Java? Explain its methods and their uses.
Solution:
The java.net.InetAddress class represents an IP address. The Inet Address class provides methods to get the IP of any host name. This class is used for encapsulating numerical IP address and domain name for that address. Because InetAddress is not having any constructor, its objects are created by using any of the following three methods
static InetAddress getLocalHost() throws UnknownHostException:
returns the InetAddress object representing local host
static InetAddress getByName() throws UnknownHostException:
returns the InetAddress object for the host name passed to it.
static InetAddress getAllByName() throws UnknownHostException:
returns an array of InetAddresses representing all the addresses that a particular name is resolves to.
The InetAddress class has no visible constructors. To create an InetAddress object, you have to use one of the available factory methods. Factory methods are merely a convention whereby static methods in a class return an instance of that class. This is done in lieu of overloading a constructor with various parameter lists when having unique method names makes the results much clearer. In the case ofInetAddress, the three methods getLocalHost (), getByName (), and getAllByName () can be used to create instances of InetAddress.
The getLocalHost ( ) method simply returns the InetAddress object that represents the local host. The getByName ( ) method returns an InetAddress for a host name passed to it. If these methods are unable to resolve the host name, they throw an UnknownHostException.
On the Internet, it is common for a single name to be used to represent several machines. In the world of web servers, this is one way to provide some degree of scaling. The getAllByName( ) factory method returns an array of InetAddresses that represent all of the addresses that a particular name resolves to. It will also throw an UnknownHostException if it can’t resolve the name to at least one address.
b) What is RMI? Explain architecture of RMI.
Solution:
The Remote Method Invocation (RMI) is an API that provides a mechanism to create distributed application in java. The RMI allows an object to invoke methods on an object running in another JVM.The RMI provides remote communication between the applications using two objects stub and skeleton.
The RMI system consists of three layers:
• The stub/skeleton layer – client-side stubs (proxies) and server-side skeletons
• The remote reference layer – remote reference behavior (such as invocation to a single object or to a replicated object)
• The transport layer – connection set up and management and remote object tracking
The application layer sits on top of the RMI system. The relationship between the layers is shown in the following figure.
ignou.nisecomputers.com
A remote method invocation from a client to a remote server object travels down through the layers of the RMI system to the client-side transport, then up through the server-side transport to the server.
A client invoking a method on a remote server object actually makes use of a stub or proxy for the remote object as a conduit to the remote object. A client- held reference to a remote object is a reference to a local stub. This stub is an implementation of the remote interfaces of the remote object and forwards invocation requests to that server object via the remote reference layer. Stubs are generated using the rmic compiler.
The remote reference layer is responsible for carrying out the semantics of the invocation. For example, the remote reference layer is responsible for determining whether the server is a single object or is a replicated object requiring communications with multiple locations. Each remote object implementation chooses its own remote reference semantics-whether the server is a single object or is a replicated object requiring communications with its replicas.
The transport layer is responsible for connection setup, connection management, and keeping track of and dispatching to remote objects (the targets of remote calls) residing in the transport’s address space.
In order to dispatch to a remote object, the transport forwards the remote call up to the remote reference layer. The remote reference layer handles any server-side behavior that needs to occur before handing off the request to the server-side skeleton. The skeleton for a remote object makes an up call to the remote object implementation which carries out the actual method call.
The return value of a call is sent back through the skeleton, remote reference layer, and transport on the server side, and then up through the transport, remote reference layer, and stub on the client side.