1)

A

Ans

Object-oriented programming (OOP) is a programming paradigm that represents concepts as "objects" that have data fields (attributes that describe the object) and associated procedures known as methods. Objects, which are usually instances of classes, are used to interact with one another to design applications and computer programs

An object-oriented program may be viewed as a collection of interacting objects, as

opposed to the conventional model, in which a program is seen as a list of tasks

(subroutines) to perform. In OOP, each object is capable of receiving messages,

processing data, and sending messages to other objects. Each object can be viewed as

an independent "machine" with a distinct role or responsibility. Actions (or "methods")

on these objects are closely associated with the object. For example, OOP data

structures tend to "carry their own operators around with them" (or at least "inherit" them

from a similar object or class)—except when they must be serialized.

Simple, non-OOP programs may be one "long" list(or commands). More complex

programs often group smaller sections of these statements intofunctions or subroutines

—each of which might perform a particular task. With designs of this sort, it is common

for some of the program's data to be 'global', i.e., accessible from any part of the

program. As programs grow in size, allowing any function to modify any piece of data

means that bugs can have wide-reaching effects.

In contrast, the object-oriented approach encourages the programmer to place data

where it is not directly accessible by the rest of the program. Instead, the data is

accessed by calling specially written functions, commonly called methods, which are

bundled in with the data. These act as the intermediaries for retrieving or modifying the

data they control. The programming construct that combines data with a set of methods

for accessing and managing those data is called an object. The practice of using

subroutines to examine or modify certain kinds of data was also used in non-

OOPmodular programming, well before the widespread use of object-oriented

programming.

An object-oriented program usually contains different types of objects, each

corresponding to a particular kind of complex data to manage, or perhaps to a real-

world object or concept such as a bank account, a hockey player, or a bulldozer. A

program might contain multiple copies of each type of object, one for each of the real-

world objects the program deals with. For instance, there could be one bank account

object for each real-world account at a particular bank. Each copy of the bank account

object would be alike in the methods it offers for manipulating or reading its data, but the

data inside each object would differ reflecting the different history of each account.

Objects can be thought of as wrapping their data within a set of functions designed to

ensure that the data are used appropriately, and to assist in that use. The object's

methods typically include checks and safeguards specific to the data types the object

contains. An object can also offer simple-to-use, standardized methods for performing

particular operations on its data, while concealing the specifics of how those tasks are

accomplished. In this way alterations can be made to the internal structure or methods

of an object without requiring that the rest of the program be modified. This approach

can also be used to offer standardized methods across different types of objects. As an

example, several different types of objects might offer print methods. Each type of

object might implement that print method in a different way, reflecting the different kinds

of data each contains, but all the different print methods might be called in the same

standardized manner from elsewhere in the program. These features become especially

useful when more than one programmer is contributing code to a project or when the

goal is to reuse code between projects.

Object-oriented programming has roots that can be traced to the 1960s. As hardware

and software became increasingly complex, manageability often became a concern.

Researchers studied ways to maintain software quality and developed object-oriented

programming in part to address common problems by strongly emphasizing discrete,

reusable units of programming logic[citation needed]. The technology focuses on data rather

than processes, with programs composed of self-sufficient modules ("classes"), each

instance of which ("objects") contains all the information needed to manipulate its own

data structure ("members"). This is in contrast to the existing modular programming that

had been dominant for many years that focused on the function of a module, rather than

specifically the data, but equally provided for code reuse, and self-sufficient reusable

units of programming logic, enabling collaboration through the use of linked modules

(subroutines).

As to the advantages of object-orientation over non-object-oriented software:

component-specific behavior - making details on how to handle a particular component the responsibility of the smaller component-specific machine ensures any time that component is handled, its machine will do so appropriately;

polymorphic expressions - because component-specific machines performs operations tailored to its particular component, the same message sent to different machines can act differently;

type abstraction - it often makes sense for several different types of components to use the same vocabulary for the operations their machines do;

separation of concerns - leaving component-specific details to their machines means the process machine only needs to handle the more general, larger concerns of its process and the data required to manage it; plus, it's less likely to be affected by changes in other components;

adaptability - components that focus on their area of speciality can be adapted to unforeseen use simply by changing the components it uses, or making it available to another process machine;

code reuse - components with a narrow focus and greater adaptability can leverage their development cost by being put to use more often.

b)

"Poly" means "many" and "morph" means "form". Polymorphism is the ability of an object (or reference) to assume (be replaced by) or become many different forms of object.Example: function overloading, function overriding, virtual functions. Another example can be a plus ‘+’ sign, used for adding two integers or for using it to concatenate two strings.

Subtype polymorphism, often referred to as simply polymorphism in the context of object-oriented

programming, is the ability to create a variable, a function, or an object that has more than one form. In

principle, polymorphism can arise in other computing contexts and shares important similarities with the

concept of degeneracy in biology.

The purpose of polymorphism is to implement a style of programming called message-passing in the

literature[citation needed], in which objects of various types define a common interface of operations for users.

In strongly typed languages, polymorphism usually means that type A somehow derives from type B, or

type C implements an interface that represents type B. In weakly typed languages types are implicitly

polymorphic.

Operator overloading of the numeric operators (+, -, *, and /) allows polymorphic treatment of the various

numerical types: integer, unsigned integer, float, decimal, etc.; each of which have different ranges, bit

patterns, and representations. Another common example is the use of the "+" operator which allows

similar or polymorphic treatment of numbers (addition), strings (concatenation), and lists (attachment).

This is a lesser used feature of polymorphism.

The primary usage of polymorphism in industry (object-oriented programming theory) is the ability

of objects belonging to different types to respond tomethod, field, or property calls of the same name,

each one according to an appropriate type-specific behavior. The caller (calling code) likewise its

programmer, does not have to know the exact type of the callee (called object), thus the exact behavior is

determined at run-time (this is called late binding or dynamic binding).

The different objects involved only need to present a compatible interface to the clients' (calling routines).

That is, there must be public or internal methods, fields, events, and properties with the same name and

the same parameter sets in all the superclasses, subclasses and interfaces. In principle, the object types

may be unrelated, but since they share a common interface, they are often implemented as subclasses of

the same superclass. Though it is not required, it is understood that the different methods will also

produce similar results (for example, returning values of the same type).

Polymorphism (which is strictly referring to subtype polymorphism in the context of this article) is not the

same as method overloading or method overriding,[1] (which is known instead as ad-hoc polymorphism [2]).

Polymorphism is only concerned with the application of specific implementations to an interface or a more

generic base class. Method overloading refers to methods that have the same name but different

signatures inside the same class. Method overriding is where a subclass replaces the implementation of

one or more of its parent's methods. Neither method overloading nor method overriding is by itself an

implementation of polymorphism.[3]

2)

A

A Platform-Independent Model (PIM) in software engineering is a model of a software

system or business system, that is independent of the specific technological platform

used to implement it.

The term platform-independent model is most frequently used in the context of

the model-driven architecture approach.Platform independent is program running on

different processors like intel, AMD, Sun Micro Systems etc.; This model-driven

architecture approach corresponds the Object Management Group vision of Model

Driven Engineering.

The main idea is that it should be possible to use a Model Transformation Language to

transform a Platform-independent model into a Platform-specific model. In order to

achieve this transformation, one can use a language compliant to the newly

defined QVT standard. Examples of such languages are VIATRA or ATLAS

Transformation Language. It means execution of the program is not restricted by the

type of o/s used.

Java solves the problem of platform-independence by usingbyte code. The Java compiler does not produce nativeexecutable code for a particular machine like a C compilerwould. Instead it produces a special format called bytecode. Java byte code written in hexadecimal, byte by byte,looks like this:

CA FE BA BE 00 03 00 2D 00 3E 08 00 3B 08 00 01 08 00 20 08

This looks a lot like machine language, but unlike machinelanguage Java byte code is exactly the same on everyplatform. This byte code fragment means the same thing on aSolaris workstation as it does on a Macintosh PowerBook.Java programs that have been compiled into byte code stillneed an interpreter to execute them on any given platform.The interpreter reads the byte code and translates it intothe native language of the host machine on the fly. The mostcommon such interpreter is Sun's program java (with a littlej). Since the byte code is completely platform independent,

only the interpreter and a few native libraries need to beported to get Java to run on a new computer or operatingsystem. The rest of the runtime environment including thecompiler and most of the class libraries are written in Java.

All these pieces, the javac compiler, the java interpreter,the Java programming language, and more are collectivelyreferred to as Java.

b)

*Write a program to find Fibonacci series of a given no. Example : Input - 8 Output - 1 1 2 3 5 8 13 21 */class Fibonacci{

public static void main(String args[]){int num = Integer.parseInt(args[0]); //taking no. as command

lineargument.

System.out.println("*****Fibonacci Series*****");int f1, f2=0, f3=1;for(int i=1;i<=num;i++){

System.out.print(" "+f3+" ");f1 = f2;f2 = f3;f3 = f1 + f2;

}}

}c)

see .htm file

d)

Classpath is a parameter—set either on the command-line, or through an environment variable—that tells the Java Virtual Machine or the Java compiler where to look for user-defined classes andpackages.

Suppose we have a package called org.mypackage containing the classes:

HelloWorld (main class)

SupportClass

UtilClass

and the files defining this package are stored physically under the directory D:\myprogram (on Windows)

or /home/user/myprogram (on Linux).

The file structure will look like this:

Microsoft Windows Linux

D:\myprogram\

|

---> org\

|

---> mypackage\

|

--->

HelloWorld.class

--->

SupportClass.class

--->

UtilClass.class

/home/user/myprogram/

|

---> org/

|

---> mypackage/

|

--->

HelloWorld.class

--->

SupportClass.class

--->

UtilClass.class

When we invoke Java, we specify the name of the application to run: org.mypackage.HelloWorld.

However we must also tell Java where to look for the files and directories defining our package. So to

launch the program, we use the following command:

Microsoft Windows Linux

java -classpath D:\myprogram

org.mypackage.HelloWorld

java -classpath /home/user/myprogram

org.mypackage.HelloWorld

where:

-classpath D:\myprogram sets the path to the packages used in the program (on Linux, -classpath

/home/user/myprogram)

org.mypackage.HelloWorld is the name of the main class

Note that if we ran Java in D:\myprogram\ (on Linux, /home/user/myprogram/) then we would not need to

specify the classpath since Java implicitly looks in the current working directory for files containing

classes.

[edit]Adding all JAR files in a directory

In Java 6 and higher, one can add all jar-files in a specific directory to the classpath using wildcard

notation.

Windows example:

java -classpath ".;c:\mylib\*" MyApp

Linux example:

java -classpath '.:/mylib/*' MyApp

[edit]Setting the path through an environment variable

The environment variable named CLASSPATH may be alternatively used to set the classpath. For the

above example, we could also use on Windows:

Sometimes you have to check the JAVA_HOME also, if it is pointing towards the right JDK version

set CLASSPATH=D:\myprogram

java org.mypackage.HelloWorld

[edit]Setting the path of a Jar file

Now, suppose the program uses a supporting library enclosed in a Jar file called supportLib.jar, physically

in the directory D:\myprogram\lib\.

The corresponding physical file structure is :

D:\myprogram\

|

---> lib\

|

---> supportLib.jar

|

---> org\

|

--> mypackage\

|

---> HelloWorld.class

---> SupportClass.class

---> UtilClass.class

We should use the following command-line option:

java -classpath D:\myprogram;D:\myprogram\lib\supportLib.jar

org.mypackage.HelloWorld

or alternatively:

set CLASSPATH=D:\myprogram;D:\myprogram\lib\supportLib.jar

java org.mypackage.HelloWorld

[edit]Setting the path in a Manifest file

Suppose that our program has been enclosed in a Jar file called helloWorld.jar, put directly in the D:\

myprogram directory. We have the following file structure:

D:\myprogram\

|

---> helloWorld.jar

|

---> lib\

|

---> supportLib.jar

The manifest file defined in this Jar file has this definition:

Main-Class: org.mypackage.HelloWorld

Class-Path: lib/supportLib.jar

Note: It's important that the manifest file ends with either a new line or carriage return.

Also, note that the classpath string in this case describes the location of the supportLib.jar file relative to

the location of the helloWorld.jar file, and not as an absolute file path (as it might be when setting the -

classpath parameter on the command line, for example). Thus, the actual locations of the jar file and its

support library are irrelevant so long as the relative directory structure between the two is preserved.

To launch the program, we can use the following command:

java -jar D:\myprogram\helloWorld.jar

It is not necessary to define the Classpath to the program classes, or the support library classes, because

it is already defined in the manifest file.

Caution, it is useless to define the Main class at launch, the manifest of the JAR file must contain a line of

the form

Main-Class: classname

in order for the -jar option to work JavaDoc.

The syntax for specifying multiple library JAR files in the manifest file is to separate the entries with a

space:

Class-Path: lib/supportLib.jar lib/supportLib2.jar

3

A

xceptions are the customary way in Java to indicate to a calling method that an abnormal condition has occurred. This article is a companion piece to this month's Design Techniques installment, which discusses how to use exceptions appropriately in your programs and designs. Look to this companion article for a tutorial on the nuts and bolts of what exceptions are and how they work in the Java language and virtual machine.

When a method encounters an abnormal condition (an exception condition) that

it can't handle itself, it may throw an exception. Throwing an exception is like

throwing a beeping, flashing red ball to indicate there is a problem that can't be

handled where it occurred. Somewhere, you hope, this ball will be caught and the

problem will be dealt with. Exceptions are caught by handlers positioned along

the thread's method invocation stack. If the calling method isn't prepared to catch

the exception, it throws the exception up to itscalling method, and so on. If one of

the threads of your program throws an exception that isn't caught by any method

along the method invocation stack, that thread will expire. When you program in

Java, you must position catchers (the exception handlers) strategically, so your

program will catch and handle all exceptions from which you want your program

to recover.

Exception classes

In Java, exceptions are objects. When you throw an exception, you throw an

object. You can't throw just any object as an exception, however -- only those

objects whose classes descend fromThrowable. Throwable serves as the base

class for an entire family of classes, declared in java.lang, that your program can

instantiate and throw. A small part of this family is shown in Figure 1.

As you can see in Figure 1, Throwable has two direct

subclasses,Exception and Error. Exceptions (members of the Exception family)

are thrown to signal abnormal conditions that can often be handled by some

catcher, though it's possible they may not be caught and therefore could result in

a dead thread. Errors (members of theError family) are usually thrown for more

serious problems, such asOutOfMemoryError, that may not be so easy to handle. In

general, code you write should throw only exceptions, not errors. Errors are

usually thrown by the methods of the Java API, or by the Java virtual machine

itself.

The Exception class does not define any methods of its own. It inherits methods provided by Throwable.

All exceptions have the methods defined by Throwable available to them. They are shown in the following list.

Throwable fillInStackTrace( )

Returns a Throwable object that contains a completed stack trace.Throwable getCause( )

Returns the exception that underlies the current exception.String getLocalizedMessage( )

Returns a localized description.String getMessage( )

Returns a description of the exception.StackTraceElement[ ] getStackTrace( )

Returns an array that contains the stack trace.Throwable initCause(Throwable causeExc)

Associates causeExc with the invoking exception as a cause of the invoking exception.

void printStackTrace( )

Displays the stack trace.void printStackTrace(PrintStream stream)

Sends the stack trace to the stream.void printStackTrace(PrintWriter stream)

Sends the stack trace to the stream.void setStackTrace(StackTraceElement elements[ ])

Sets the stack trace to the elements passed in elements.String toString( )

Returns a String object containing a description of the exception.

The following program creates a custom exception type.

class MyException extends Exception { private int detail;

MyException(int a) { detail = a; }

public String toString() { return "MyException[" + detail + "]"; }}

public class Main { static void compute(int a) throws MyException { System.out.println("Called compute(" + a + ")"); if (a > 10) throw new MyException(a); System.out.println("Normal exit"); }

public static void main(String args[]) { try { compute(1); compute(20); } catch (MyException e) { System.out.println("Caught " + e); } }}

B

Abstract classes in Java are classes which cannot be instantiated, meaning you cannot create new instances of an abstract class. The purpose of an abstract class is to function as a base for subclasses. This text gets into the purpose of abstract classes in more detail towards the end of this text.

Here is a list of the topics covered in this text:

Declaring an Abstract Class

You declare that a class is abstract by adding the abstract keyword to the class declaration. Here is an example:

public abstract class MyAbstractClass {

}

That is all there is to it. Now you cannot create instances of MyAbstractClass. Thus, the following Java code is no longer valid:

MyAbstractClass myClassInstance = new MyAbstractClass(); //not valid

If you try to compile the code above, the Java compiler will generate an error.

Abstract Methods

An abstract class can have abstract methods. You declare a method abstract by adding the abstract keyword in front of the method declaration. Here is how that looks:

public abstract class MyAbstractClass {

public abstract void abstractMethod();

}

An abstract method has no implementation. It just has a method signature.

If a class has an abstract method, the whole class must be declared abstract. Not all methods have to be abstract, even if the class is abstract. An abstract class can have a mixture of abstract and non-abstract classes.

Subclasses of an abstract class must implement (override) all abstract methods of its abstract superclass. The non-abstract methods of the superclass are just inherited as they are. They can also be overridden, if needed.

Here is an example subclass of MyAbstractClass:

public class MySubClass extends MyAbstractClass {

public void abstractMethod() {

System.out.println("My method implementation");

}

}

Notice how MySubClass has to implement the abstract method abstractMethod() from its superclass MyAbstractClass.

The only time a subclass of an abstract class is not forced to implement all abstract methods of its superclass, is if the subclass is also an abstract class.

The Purpose of Abstract Classes

The purpose of abstract classes is to function as base classes which can be extended by subclasses to create a full implementation. For instance, imagine that a certain process requires 3 steps:

1. The step before the action.2. The action.3. The step after the action.

If the steps before and after the action are always the same, the 3-step process could be implemented in an abstract superclass like this:

public abstract MyAbstractProcess {

public void process() {

stepBefore();

action();

stepAfter();

}

public void stepBefore() {

//implementation directly in abstract superclass

}

public abstract void action(); // implemented by subclasses

public void stepAfter() {

//implementation directly in abstract superclass

}

}

Notice how the action() method is abstract. Subclasses of MyAbstractProcess can now extend MyAbstractProcess and just override the action() method.

When the process() method of the subclass is called, the full process is executed, including the action() method of the subclass.

Of course, the MyAbstractProcess did not have to be an abstract class to function as a base class. Nor did the action() method have to be abstract either. You could have just used an ordinary class. However, by making the method to implement abstract, and thus the class too, you signal clearly to the

programmer, that this class should not be used as it is, but be used as a base class for a subclass, and that the abstract method should be implemented in the subclass.

The above example did not have a default implementation for the action() method. In some cases your superclass might actually have a default implementation for the method that subclasses are supposed to override. In that case, you cannot make the method abstract. You can still make the superclass abstract though, even if it contains no abstract methods.

Here is a more concrete example that opens a URL, processes it and closes the connection to the URL afterwards.

public abstract class URLProcessorBase {

public void process(URL url) throws IOException {

URLConnection urlConnection = url.openConnection();

InputStream input = urlConnection.getInputStream();

try{

processURLData(input);

} finally {

input.close();

}

}

protected abstract void processURLData(InputStream input)

throws IOException;

}

Notice how the processURLData() method is abstract. Subclasses of URLProcessorBasehas to implement this method.

Subclasses of URLProcessorBase can process data downloaded from URL's without worrying about opening and closing the network connection to the URL. This is done by the URLProcessorBase. Subclasses only need to worry about processing the data from the InputStream passed to the processURLData() metod. This makes it easier to implement classes that processes data from URL's.

Here is an example subclass:

public class URLProcessorImpl extends URLProcessorBase {

@Override

protected void processURLData(InputStream input) throws IOException {

int data = input.read();

while(data != -1){

System.out.println((char) data);

data = input.read();

}

}

}

Notice how the subclass only implements the processURLData() method, and nothing more. The rest of the code is inherited from the URLProcessorBase superclass.

Here is an example of how to use the URLProcessorImpl class:

URLProcessorImpl urlProcessor = new URLProcessorImpl();

urlProcessor.process(new URL("http://jenkov.com"));

The process() method is called, which is implemented in the URLProcessorBasesuperclass. This method in turn calls the processURLData() in the URLProcessorImplclass.

Abstract classes improve the situation by preventing a developer from instantiating the base class, because a developer has marked it as having missing functionality. It also provides compile-time safety so that you can ensure that any classes that extend your abstract class provide the bare minimum functionality to work, and you don't need to worry about putting stub methods (like the one above) that inheritors somehow have to magically know that they have to override a method in order to make it work.Interfaces are a totally separate topic. An interface lets you describe what operations can be performed on an object. You would typically use interfaces when writing methods, components, etc. that use the services of other components, objects, but you don't care what the actual type of object you are getting the services from is.Consider the following method:

public void saveToDatabase(IProductDatabase database) {

database.addProduct(this.getName(), this.getPrice());

}

You don't care about whether the database object inherits from any particular object, you just care that it has an addProduct method. So in this case, an interface is better suited than making all of your classes happen to inherit from the same base class.Sometimes the combination of the two works very nicely. For example:

abstract class RemoteDatabase implements IProductDatabase {

public abstract String[] connect();

public abstract void writeRow(string col1, string col2);

public void addProduct(String name, Double price) {

connect();

writeRow(name, price.toString());

}

}

class SqlDatabase extends RemoteDatabase {

//TODO override connect and writeRow

}

class OracleDatabase extends RemoteDatabase {

//TODO override connect and writeRow

}

class FileDatabase implements IProductDatabase {

public void addProduct(String name, Double price) {

//TODO: just write to file

}

}

Multilevel inheritance is a java feature where the properties of a class are inherited by a class which extends one or more classes which extend its features... 

Example: 

public class A { public String getName(){ return "Vijay"; } } 

public class B extends A { public int getAge() { return 24; } } 

public class C extends B { public String getAddress(){ return "Utter Pradesh,INDIA"; } } 

public class D extends C { public void print { System.out.println(getName()); System.out.println(getAge()); System.out.println(getAddress()); } } 

This method would print the following in the console: Vijay24Pradesh,INDIA 

Here in class D you are calling methods that are available inside classes A, B & C. Though D extends only class C, it would in turn inherit the properties of the classes extended by C and its parents. 

This is multi level inheritance.

4

a

The final keyword is used to create constants, i.e. data which is always for reading and never needs to change, once initialized. A simple example would be MaxAge, in a software to manage details of employees in a company. Lets say the maximum age of retirement is 60, so we know that no employee can have age greater than 60. So I will write – 

final int MaxAge = 60;

Now anywhere in other part of software I can use the value simply for validation as follows:

If (age > MaxAge) // age is already declared somewhere as intSystem.out.println(“There is an error. Invalid Age.”); // Oops error in age!

The static keyword is used to create variables which are shared by all instances (objects) of the class. The scope of usage of such a variable is class, i.e. it can be accessed only with the class unless it is declared public. Their lifetime is same as that of the program, which means they always exist and you don't need to create object to access them. A good example can be a variable to count the total number of errors in a class and its objects. The following is one example:

static int TotalErrors = 0;

Then we can write anywhere code like the following –

If (age > MaxAge){System.out.println(“There is an error. Invalid Age!”);TotalErrors++; // There was an error so increment it}

Did that make any sense?Actually I am a C++ guy, so if it did not make any sense, just forgive me. I tried my best. =)

@To XTremeHell [In response to his assertion that const and final are different]

Sorry sir, you need to go back to read the textbooks again. Java's "final" and C++ "const" are indeed ABSOLUTELY same. The value of const need not be known at compile time. See the C++ code below:-

int var = 0;DoSomethingWithVar(&var); // The function modifies var.const int myReadOnlyValue = var;

The point is "myReadOnlyValue" is a constant. Now can you tell me XTremeHell, how the compiler is supposed to know the value of myReadOnlyValue, even though it is a constant?

B

In the 'normal' cases a simple question is enough to find out if we need inheritance or aggregation.

If The new class is more or less as the original class. Use inheritance. The new class is now a subclass of the original class.

If the new class must have the original class. Use aggregation. The new class has now the original class as a member.

However, there is a big gray area. So we need several other tricks.

If we have used inheritance (or we plan to use it) but we only use part of the interface, or we are forced to override a lot of functionality to keep the correlation logical. Then we have a big nasty smell that indicates that we had to use aggregation.

If we have used aggregation (or we plan to use it) but we find out we need to copy almost all of the functionality. Then we have a smell that points in the direction of inheritance.

To cut it short. We should use aggregation if part of the interface is not used or has to be changed to avoid an illogical situation. We only need to use inheritance, if we need almost all of the functionality without major changes. And when in doubt, use Aggregation.

An other possibility for, the case that we have an class that needs part of the functionality of the original class, is to split the original class in a root class and a sub class. And let the new class inherit from the root class. But you should take care with this, not to create an illogical separation.

Lets add an example. We have a class 'Dog' with methods: 'Eat', 'Walk', 'Bark', 'Play'.

class Dog Eat; Walk; Bark; Play;end;We now need a class 'Cat', that needs 'Eat', 'Walk', 'Purr', and 'Play'. So first try to extend it from a Dog.

class Cat is Dog Purr; end;Looks, alright, but wait. This cat can Bark (Cat lovers will kill me for that). And a barking cat violates the principles of the universe. So we need to override the Bark method so that it does nothing.

class Cat is Dog Purr; Bark = null;end;Ok, this works, but it smells bad. So lets try an aggregation:

class Cat has Dog; Eat = Dog.Eat; Walk = Dog.Walk; Play = Dog.Play; Purr;end;Ok, this is nice. This cat does not bark anymore, not even silent. But still it has an internal dog that wants out. So lets try solution number three:

class Pet Eat; Walk; Play;end;

class Dog is Pet Bark;end;

class Cat is Pet Purr;end;This is much cleaner. No internal dogs. And cats and dogs are at the same level. We can even introduce other pets to extend the model. Unless it is a fish, or something that does not walk. In that case we again need to refactor. But that is something for an other time.

C

Difference Between Interface and Abstract Class

23/04/2008

1. Main difference is methods of a Java interface are implicitly abstract and

cannot have implementations. A Java abstract class can have instance

methods that implements a default behavior.

2. Variables declared in a Java interface is by default final. An  abstract class

may contain non-final variables.

3. Members of a Java interface are public by default. A Java abstract class can

have the usual flavors of class members like private, protected, etc..

4. Java interface should be implemented using keyword “implements”; A Java

abstract class should be extended using keyword “extends”.

5. An interface can extend another Java interface only, an abstract class can

extend another Java class and implement multiple Java interfaces.

6. A Java class can implement multiple interfaces but it can extend only one

abstract class.

7. Interface is absolutely abstract and cannot be instantiated; A Java abstract

class also cannot be instantiated, but can be invoked if a main() exists.

8. In comparison with java abstract classes, java interfaces are slow as it

requires extra indirection.

D

Java provides the StringBuffer and String classes, and the String class is used to manipulate character strings that cannot be changed. Simply stated, objects of type String are read only and immutable. The StringBuffer class is used to represent characters that can be modified.

The significant performance difference between these two classes is that StringBuffer is faster than String when performing simple

concatenations. In String manipulation code, character strings are routinely

concatenated. Using the String class, concatenations are typically performed as

follows:

String str = new String ("Stanford ");

str += "Lost!!";

If you were to use StringBuffer to perform the same concatenation, you would

need code that looks like this:

StringBuffer str = new StringBuffer ("Stanford ");

str.append("Lost!!");

Developers usually assume that the first example above is more efficient because they think that the second example, which uses theappend method for

concatenation, is more costly than the first example, which uses the + operator to

concatenate two Stringobjects.

The + operator appears innocent, but the code generated produces some

surprises. Using a StringBuffer for concatenation can in fact produce code that

is significantly faster than using a String. To discover why this is the case, we

must examine the generated bytecode from our two examples. The bytecode for the example using String looks like this:

0 new #7 <Class java.lang.String>

3 dup

4 ldc #2 <String "Stanford ">

6 invokespecial #12 <Method java.lang.String(java.lang.String)>

9 astore_1

10 new #8 <Class java.lang.StringBuffer>

13 dup

14 aload_1

15 invokestatic #23 <Method java.lang.String valueOf(java.lang.Object)>

18 invokespecial #13 <Method java.lang.StringBuffer(java.lang.String)>

21 ldc #1 <String "Lost!!">

23 invokevirtual #15 <Method java.lang.StringBuffer append(java.lang.String)>

26 invokevirtual #22 <Method java.lang.String toString()>

29 astore_1

The bytecode at locations 0 through 9 is executed for the first line of code,

namely:

String str = new String("Stanford ");

Then, the bytecode at location 10 through 29 is executed for the concatenation:

str += "Lost!!";

Things get interesting here. The bytecode generated for the concatenation creates a StringBuffer object, then invokes itsappend method: the

temporary StringBuffer object is created at location 10, and its append method

is called at location 23. Because the String class is immutable,

a StringBuffer must be used for concatenation.

After the concatenation is performed on the StringBuffer object, it must be

converted back into a String. This is done with the call to the toString method

at location 26. This method creates a new String object from the

temporary StringBufferobject. The creation of this

temporary StringBuffer object and its subsequent conversion back into

a String object are very expensive.

In summary, the two lines of code above result in the creation of three objects:

1. A String object at location 0

2. A StringBuffer object at location 10

3. A String object at location 26

Now, let's look at the bytecode generated for the example using StringBuffer:

0 new #8 <Class java.lang.StringBuffer>

3 dup

4 ldc #2 <String "Stanford ">

6 invokespecial #13 <Method java.lang.StringBuffer(java.lang.String)>

9 astore_1

10 aload_1

11 ldc #1 <String "Lost!!">

13 invokevirtual #15 <Method java.lang.StringBuffer append(java.lang.String)>

16 pop

The bytecode at locations 0 to 9 is executed for the first line of code:

StringBuffer str = new StringBuffer("Stanford ");

The bytecode at location 10 to 16 is then executed for the concatenation:

str.append("Lost!!");

Notice that, as is the case in the first example, this code invokes the append method of a StringBuffer object. Unlike the first example, however,

there is no need to create a temporary StringBuffer and then convert it into

a String object. This code creates only one object, the StringBuffer, at

location 0.In conclusion, StringBuffer concatenation is significantly faster

than String concatenation. Obviously, StringBuffers should be used in this

type of operation when possible. If the functionality of the String class is

desired, consider using aStringBuffer for concatenation and then performing

one conversion to String.

5

A

File Handling in Java

For file handling in java, the package known as java.io is available. This package

contains all the required classes needed to perform input and output (I/O) in Java.

Streams

The sequence of data can be defined as a stream. Java defines two types of streams

which are given below :

1. Byte

2. Characters

Byte Stream

For dealing input and output of bytes, byte stream is employed. For reading and writing

binary data it is incorporated. Binary Stream uses two abstract classes for input and

output. These are InputStream class and OutputStream class respectively. To read data

from the source InputStream is used and to write data to a destination OutputStream is

used.

The class hierarchy of the Byte Stream is given below :

The byte stream classes are given below :

Byte Stream Classes Detail

InputStream

The InputStream is an abstract super class .All the classes

representing an input 

stream of bytes is the subclass of this super class.

OutputStream

The  OutputStream is an abstract super class .All the

classes representing an output

 stream of bytes is the subclass of this super class.

FileInputStream In a file system, it gets input bytes from a file.

FileOutputStream Using it you can write data to a File or to a FileDescriptor.

ByteArrayInputStreamA ByteArrayInputStream has an internal buffer. This buffer

can retain bytes read from the stream

ByteArrayOutputStreamData can be written into a byte array using the output

stream of ByteArrayOutputStream.

SequenceInputStreamThe input streams can be logically concatenated using

SequenceInputStream.

StringBufferInputStream

 The string's content supplies bytes read to an input

stream which is created by an application.

The StringBufferInputStream class allows an application to

do this.

FilterInputStream

It has some additional input stream used as basic data

source, These input streams can provide 

transformation of data and extra functionality.

FilterOutputStreamAll the classes that filter output streams is the subclasses

of the FilterOutputStream superclass.

DataInputStreamIt allows an application to read java's data type using an

input stream which is independent of machine.

DataOutputStreamIt allows an application to write java's data type(primitive)

to an output stream.

BufferedInputStream

It provides additional functionality to the input stream such

as capability to buffer. It also supports reset and mark

methods.

BufferedOutputStream The buffered output stream is applied by this class.

PrintStream It provide ability to the other output stream to print several

data values' representation.

PipedInputStream

The data byte written on piped output stream is provided

by PipedInputStream. But before that it must connect to

the piped output stream.

PipedOutputStreamFor creating communication pipe, piped output stream

should be connected to piped output stream.

PushbackInputStreamTo sum up the ability to "push back" or "unread" one byte

to other input stream, a PushbackInputStream is used.

RandomAccessFileFor accessing a file randomly (for reading or writing) this

class is incorporated.

Methods defined by InputStream

After creating InputStream object, you can perform additional operations on the stream

using given below methods :

  Methods       Description 

public void

close() throws

IOException{} 

The output stream of a file is closed using this function. Before that

it releases any resource. This function throws IOException.

protected void

finalize()throws

IOException {} 

This function clears the connection to the file. It throws an

IOException.

public int

read(int

This function reads the data from the InputStream and return int

which is next byte of data. It also returns 

r)throws

IOException{} -1 if end of file is reached.

public int

read(byte[] r)

throws

IOException{} 

This method reads data equal to length of r from the input stream

using array. The total number of bytes read is returned after

finishing reading. When end of file reached it returns -1.

public int

available()

throws

IOException{} 

This function returns the number of bytes available for reading from

file input stream. The return type is int.

Method defined by OutputStream

Once you have OutputStream object in hand then there is a list of helper methods which

can be used to write to stream or to do other operations on the stream.

   Methods      Description  

public void close() throws

IOException{} 

This function closes the output stream of the file

and throws IOException.

protected void finalize()throws

IOException{}

This function closes the connection to the file

and throws IOException.

public void write(int w)throws

IOException{}

Using this function, you can write specified bytes

to the output stream.

public void write(byte[] w)  This function is used to write bytes of length

equal to w to the output stream from the the

mentioned byte array.

Character Stream

For handling the input and output of characters Character Stream is  incorporated,

which streamlines internationalization.

The hierarchical distribution of Character stream is different from Byte Stream. The

hierarchical tree of Character Stream is topped by the Reader and Writer abstract

classes. Reader abstract class is used for input while Writer abstract class is used for

output.

The method defined by Reader abstract class is given below :

Function / Method  Description

abstract void close( ) throws

IOExceptionThe input source is closed using this function.

void mark(int numChars) throws

IOException

This function set a mark in the input stream at the

current point. This Point will remain valid till

numChars characters are read.

boolean markSupported( )If the stream support mark( )/reset( ) , this function

returns true.

int read( ) throws IOException

The input streams' next available character is

return by this function as an integer

representation.

int read(char buffer[ ]) throws This function reads the characters from buffer

IOExceptionequal to the length of buffer.length and it returns

the number of successful characters read.

abstract int read(char buffer[ ],int

offset, int numChars) throws

IOException

This function returns the count of the characters

successfully read from buffer starting from

buffer[offset] up to numChars.

boolean ready( ) throws

IOException

If the input is pending, it returns true otherwise

false.

void reset( ) throws IOExceptionThis function resets the input pointer to the

previously set mark.

long skip(long numChars) throws

IOException

This function skips the number of input characters

equal to numChars. It returns the count of actually

skipped characters.

The method defined by Writer abstract class is given below :

Function / Method  Description 

Writer append(char ch) throws

IOException

This function adds ch at the end of the

output stream which invoked it. It also

returns reference to the stream.

Writer append(CharSequence chars)

throws IOException

This  function adds the chars to the end of

the output stream which invoked it. It also

returns a reference to the stream.

Writer append(CharSequence chars,

int begin, int end) throws IOException

This function adds a sub range of chars to

the end of the output stream. It returns a

reference to the stream.

abstract void close( ) throws

IOExceptionThe output stream is closed by this function.

abstract void flush( ) throws

IOExceptionThis function flushes the buffer of output.

void write(int ch) throws IOException

This function writes the character to the

output stream. The characters are in the low-

order 16 bits of ch .

void write(char buffer[ ]) throws

IOException

Using this function you can write to the

output stream -a complete array of

characters .

abstract void write(char buffer[ ],int

offset, int numChars) throws

IOException

This function is used to writes a sub range of

numChars characters from the array buffer to

the output stream beginning at buffer[offset].

void write(String str) throws

IOException

Using this function you can writes str to the

output stream.

void write(String str, int offset, int

numChars)

Using this function, from the string str ,you

can write a sub range of numChars

characters.

The File Class

In spite of classes available to support file I/O, Java has a class named as File, which

contains information about a file.  For manipulating a file or the computer's file system,

this class is very effective and efficient. This class is used for creation of files and

directories, file searching, file deletion etc.

Once you have File object in hand then there is a list of helper methods which can be

used manipulate the files, which are given below :

   Methods      Description  

public String

getName()

This function returns the file or directory's name specified by

the pathname.

public String

getParent()

This function returns the parent directory pathname string.

The pathname of the directory is passed to know it's parent

pathname string. If the pathname doesn't have parent

directory, it returns null.

public File getParent

File()

This function returns the parent directory abstract pathname

and it returns null if it doesn't have parent directory.

public String

getPath()

To convert the abstract pathname into a pathname string, we

use this function.

public boolean

isAbsolute()

This function return true if this abstract pathname is absolute

otherwise returns false.

public String

getAbsolutePath() 

To find the absolute pathname string of the provided abstract

pathname, we incorporate this method.

public boolean

canRead() 

This function is used to check if the application can read the

file provided by this abstract

 pathname. This function returns true if the file name provided

by the abstract pathname exists otherwise return false.

public boolean

canWrite() 

This function is used to check if the application can modify to

the file provided through this abstract

 pathname. This function returns true if the file name provided

by the abstract pathname exists and allowed to write,

otherwise return false.

public boolean

exists() 

This function returns true if the file name provided by the

abstract pathname exists otherwise return false.

public boolean

isDirectory() 

This function returns true if the file represented by the abstract

pathname is a directory otherwise returns false.

public boolean

isFile() 

This function is used to test whether the file represented by

the abstract pathname exist and also checks whether it is a

normal file. If it is , it will return true otherwise return false.

public long

lastModified() 

This function is used to return the last modification time of the

file represented by the abstract pathname.

public long length() 

This function finds the length of the file of the file represented

by the abstract pathname and return it. It returns unspecified if

the pathname represented is a directory.

public boolean

createNewFile()

 throws IOException

This function is used to create a new file which has the name

provided by its abstract pathname. It will return true if the file

created successfully otherwise returns false.

public boolean

delete() 

This function is used to delete the file/directory represented by

the  abstract pathname.

public void

deleteOnExit() 

This function is used to delete the file represented by the 

abstract pathname when the virtual machine terminates.

public String[] list()  

This function returns an array of strings naming the files and

directories in the directory specified by its abstract

pathname.  

public String[]

list(FilenameFilter

filter) 

This function returns an array of strings naming the files and

directories in the directory specified by its abstract pathname

that satisfy the specified filter.

public File[]

listFiles() 

This functions returns an array of abstract pathnames

represented by the files in the directory.

public File[]

listFiles(FileFilter

filter) 

This function returns an array of abstract pathnames

represented by the files and directories

 in the directory represented by this abstract pathname that

satisfy the

specified filter.

public boolean

mkdir() 

This function creates the directory named by this abstract

pathname. this function returns true if the file created

successfully otherwise false.

public boolean

mkdirs() 

This method creates the directory named by this abstract

pathname, including any 

necessary but nonexistent parent directories. Returns true if

and only ifbr> the directory was created, along with all

necessary parent directories; 

false otherwise

public boolean

renameTo(File dest) 

This function renames the file represented by this abstract

pathname. 

public boolean

setLastModified(long

time) 

This function is used to set the last modification time of the

file/ directory specified by the abstract

pathname.

public boolean

setReadOnly()  

This function sets the file provided through abstract pathname

to read-only mode. If it succeeded, it returns true otherwise

returns false.

public String

toString() 

This function is used to return the pathname string of the

abstract pathname provided.

FileReader Class

FileReader class inherits from the InputStreamReader class. For reading streams of

characters, this class is used.

Once you have FileReader object in hand then there is a list of helper methods which

can be used manipulate the files :

Method /

FunctionDescription

public int

read()

throws

IOException

This function reads a single character at a time and returns the count

of number of character read.

public int This function is used to read characters. An array is used to read

read(char []

c, int offset,

int len)

characters.

package com.mkyong.file;

 

import java.io.File;

import java.io.FileWriter;

import java.io.BufferedWriter;

import java.io.IOException;

 

public class AppendToFileExample

{

public static void main( String[] args )

{

try{

String data = " This content will append to the end of the file";

 

File file =new File("javaio-appendfile.txt");

 

//if file doesnt exists, then create it

if(!file.exists()){

file.createNewFile();

}

 

//true = append file

FileWriter fileWritter = new FileWriter(file.getName(),true);

BufferedWriter bufferWritter = new BufferedWriter(fileWritter);

bufferWritter.write(data);

bufferWritter.close();

 

System.out.println("Done");

 

}catch(IOException e){

e.printStackTrace();

}

}

}

b)

A checked exception is any subclass of Exception (or Exception itself), excluding class RuntimeException and its subclasses.

Making an exception checked forces client programmers to deal with the possibility that the exception will be thrown. eg, IOException thrown by java.io.FileInputStream's read() method

Unchecked exceptions are RuntimeException and any of its subclasses. Class Error and its subclasses also are unchecked.

With an unchecked exception, however, the compiler doesn't force client programmers either to catch the exception or declare it in a throws clause. In fact, client programmers may not even know that the exception could be thrown. eg, StringIndexOutOfBoundsException thrown by String's charAt() method.

Checked exceptions must be caught at compile time. Runtime exceptions do not need to be. Errors often cannot be, as they tend to be unrecoverable.

public void storeDataFromUrl(String url){

try {

String data = readDataFromUrl(url);

} catch (BadUrlException e) {

e.printStackTrace();

}

}

public String readDataFromUrl(String url)

throws BadUrlException{

if(isUrlBad(url)){

throw new BadUrlException("Bad URL: " + url);

}

String data = null;

//read lots of data over HTTP and return

//it as a String instance.

return data;

}

As you can see the readDataFromUrl() method throws a BadUrlException. I have created BadUrlException myself. BadUrlException is a checked exception because it extends java.lang.Exception:

public class BadUrlException extends Exception {

public BadUrlException(String s) {

super(s);

}

}

If storeDataFromUrl() wants to call readDataFromUrl() it has only two choices. Either it catches the BadUrlException or propagates it up the call stack. The storeDataFromUrl() listed above catches the exception. This storeDataFromUrl() implementation propagates the BadUrlException instead:

public void storeDataFromUrl(String url)

throws BadUrlException{

String data = readDataFromUrl(url);

}

Notice how the try catch block is gone and a "throws BadUrlException" declaration is added instead. Now, let's see how it looks with unchecked exceptions. First I change the BadUrlException to extend java.lang.RuntimeException instead:

public class BadUrlException extends RuntimeException {

public BadUrlException(String s) {

super(s);

}

}

Then I change the methods to use the now unchecked BadUrlException:

public void storeDataFromUrl(String url){

String data = readDataFromUrl(url);

}

public String readDataFromUrl(String url) {

if(isUrlBad(url)){

throw new BadUrlException("Bad URL: " + url);

}

String data = null;

//read lots of data over HTTP and

//return it as a String instance.

return data;

}

Notice how the readDataFromUrl() method no longer declares that it throws BadUrlException. The storeDataFromUrl() method doesn't have to catch the BadUrlException either. The storeDataFromUrl() method can still choose to catch the exception but it no longer has to, and it no longer has to declare that it propagates the exception.

6

A

ava provides built-in support for multithreaded programming. A multithreaded program contains two or more parts that can run concurrently. Each part of such a program is called a thread, and each thread defines a separate path of execution.

A multithreading is a specialized form of multitasking. Multitasking threads require less overhead than multitasking processes.

I need to define another term related to threads: process: A process consists of the memory space allocated by the operating system that can contain one or more threads. A thread cannot exist on its own; it must be a part of a process. A process remains running until all of the non-daemon threads are done executing.

Multithreading enables you to write very efficient programs that make maximum use of the CPU, because idle time can be kept to a minimum.

Life Cycle of a Thread:A thread goes through various stages in its life cycle. For example, a thread is born, started, runs, and then dies. Following diagram shows complete life cycle of a thread.

Above mentioned stages are explained here:

New: A new thread begins its life cycle in the new state. It remains in this state until the program starts the thread. It is also referred to as a born thread.

Runnable: After a newly born thread is started, the thread becomes runnable. A thread in this state is considered to be executing its task.

Waiting: Sometimes a thread transitions to the waiting state while the thread waits for another thread to perform a task.A thread transitions back to the runnable state only when another thread signals the waiting thread to continue executing.

Timed waiting: A runnable thread can enter the timed waiting state for a specified interval of time. A thread in this state transitions back to the runnable state when that time interval expires or when the event it is waiting for occurs.

Terminated: A runnable thread enters the terminated state when it completes its task or otherwise terminates.

Thread Priorities:Every Java thread has a priority that helps the operating system determine the order in which threads are scheduled.

Java priorities are in the range between MIN_PRIORITY (a constant of 1) and MAX_PRIORITY (a constant of 10). By default, every thread is given priority NORM_PRIORITY (a constant of 5).

Threads with higher priority are more important to a program and should be allocated processor time before lower-priority threads. However, thread priorities cannot guarantee the order in which threads execute and very much platform dependentant.

Creating a Thread:Java defines two ways in which this can be accomplished:

You can implement the Runnable interface. You can extend the Thread class, itself.

Create Thread by Implementing Runnable:The easiest way to create a thread is to create a class that implements the Runnable interface.To implement Runnable, a class need only implement a single method called run( ), which is declared like this:

public void run( )

You will define the code that constitutes the new thread inside run() method. It is important to understand that run() can call other methods, use other classes, and declare variables, just like the main thread can.

After you create a class that implements Runnable, you will instantiate an object of type Thread from within that class. Thread defines several constructors. The one that we will use is shown here:

Thread(Runnable threadOb, String threadName);

Here threadOb is an instance of a class that implements the Runnable interface and the name of the new thread is specified by threadName.After the new thread is created, it will not start running until you call its start( ) method, which is declared within Thread. The start( ) method is shown here:

void start( );

here are two ways of creating a thread. 

1. Extending the Thread class 

Ex: public class ThreadExample extends Thread { ..... } 

2. Implementing the Runnable Interface 

Ex: public class ThreadExample implements Runnable { ........... }

notify() is used to unblock one waiting thread; notifyAll() is used to unblock all of them. Using notify() is preferable (for efficiency) when only one blocked thread can benefit from the change (for example, when freeing a buffer back into a pool). notifyAll() is necessary (for correctness) if multiple threads should resume (for example, when releasing a "writer" lock on a file might permit all "readers" to resume).

b)

Layout managers are software components used in widget toolkits which have the

ability to lay out widgets by their relative positions without using distance units. It is often

more natural to define component layouts in this manner than to define their position

in pixels or common distance units, so a number of popular widget toolkits include this

ability by default. Widget toolkits that provide this function can generally be classified

into two groups:

Those where the layout behavior is coded in special graphic containers. This is the

case in XUL and the .NET Framework widget toolkit (both in Windows Forms and

in XAML).

Those where the layout behavior is coded in layout managers, that can be applied to

any graphic container. This is the case in the Swing widget toolkit that is part of

the Java API.

Explain different layout manager in Java.  

A layout manager organizes the objects in a container Different layouts are used to organize or to arrange objects

1. Border Layout:

- It has five areas for holding components: north, east, west, south and center - When there are only 5 elements to be placed, border layout is the right choice

2. Flow Layout:

- Default layout manager. - It lays out the components from left to right

3. Card Layout:

- Different components at different times are laid out - Controlled by a combo box, determining which panel the Card layout displays

4. Grid Layout:

- A group of components are laid out I equal size and displays them in certain rows and columns

5. Grid Bag Layout:

- Flexible layout for placing components within a grid of cells - Allows certain components to span more than one cell - The rows of the grid are not of the same height and height

7

A

A Java applet is an applet delivered to users in the form of Java bytecode. Java applets

can be part of a web page and executed by the Java Virtual Machine (JVM) in

a process separate from the web browser, or run in Sun's AppletViewer, a stand-alone

tool for testing applets. Java applets were introduced in the first version of the Java

language in 1995, and are written in programming languages that compile to Java

bytecode, usually in Java, but also in other languages such as Jython,[8] JRuby,[9] or Eiffel (via SmartEiffel).[10]

Java applets run at very fast speeds comparable to, but generally slower than, other

compiled languages such as C++, but until approximately 2011 many times faster

than JavaScript.[11] In addition they can use 3D hardware acceleration that is available

from Java. This makes applets well suited for non-trivial, computation intensive

visualizations. As browsers have gained support for hardware accelerated graphics

thanks to the canvas technology (or specifically WebGL in the case of 3D graphics), as

well as just in time compiled JavaScript, the speed difference has become less

noticeable.

Since Java's bytecode is cross-platform or platform independent, Java applets can be

executed by browsers for many platforms, including Microsoft Windows, Unix, OS

X and Linux. It is also trivial to run a Java applet as an application software with very

little extra code so that it can be run directly from the integrated development

environment (IDE).

import java.applet.Applet;import java.awt.*;

// Applet code for the "Hello, world!" example.// This should be saved in a file named as "HelloWorld.java".public class HelloWorld extends Applet { // This method is mandatory, but can be empty (i.e., have no actual code). public void init() { } // This method is mandatory, but can be empty.(i.e.,have no actual code). public void stop() { } // Print a message on the screen (x=20, y=10). public void paint(Graphics g) { g.drawString("Hello, world!", 20,10); // Draws a circle on the screen (x=40, y=30). g.drawArc(40,30,20,20,0,360); }}

mport java.applet.*;import java.awt.*;import java.awt.event.*;

public class Mouse1 extends Applet implements MouseListener, MouseMotionListener {

int width, height; int mx, my; // the mouse coordinates boolean isButtonPressed = false;

public void init() { width = getSize().width; height = getSize().height; setBackground( Color.black );

mx = width/2; my = height/2;

addMouseListener( this ); addMouseMotionListener( this ); }

public void mouseEntered( MouseEvent e ) { // called when the pointer enters the applet's rectangular area } public void mouseExited( MouseEvent e ) { // called when the pointer leaves the applet's rectangular area }

public void mouseClicked( MouseEvent e ) { // called after a press and release of a mouse button // with no motion in between // (If the user presses, drags, and then releases, there will be // no click event generated.) } public void mousePressed( MouseEvent e ) { // called after a button is pressed down isButtonPressed = true; setBackground( Color.gray ); repaint(); // "Consume" the event so it won't be processed in the // default manner by the source which generated it. e.consume(); } public void mouseReleased( MouseEvent e ) { // called after a button is released isButtonPressed = false; setBackground( Color.black ); repaint(); e.consume(); } public void mouseMoved( MouseEvent e ) { // called during motion when no buttons are down mx = e.getX(); my = e.getY(); showStatus( "Mouse at (" + mx + "," + my + ")" ); repaint(); e.consume(); } public void mouseDragged( MouseEvent e ) { // called during motion with buttons down mx = e.getX(); my = e.getY(); showStatus( "Mouse at (" + mx + "," + my + ")" ); repaint(); e.consume(); }

public void paint( Graphics g ) { if ( isButtonPressed ) { g.setColor( Color.black ); } else { g.setColor( Color.gray ); } g.fillRect( mx-20, my-20, 40, 40 ); }}

b)

8

JavaBeans are reusable software components for Java. Practically, they are classes written in the Java programming language conforming to a particular convention. They are used to encapsulate many objects into a single object (the bean), so that they can be passed around as a single bean object instead of as multiple individual objects. A JavaBean is a Java Object that isserializable, has a 0-argument constructor, and allows access to properties using getter and setter methods.

A Java Bean is a software component that has been designed to be reusable in a variety of different environments. There is no restriction on the capability of a Bean. It may perform a simple function, such as checking the spelling of a document, or a complex function, such as forecasting the performance of a stock portfolio. A Bean may be visible to an end user. One example of this is a button on a graphical user interface. A Bean may also be invisible to a user. Software to decode a stream of multimedia information in real time is an example of this type of building block. Finally, a Bean may be designed to work autonomously on a user's workstation or to work in cooperation with a set of other distributed components. Software to generate a pie chart from a set of data points is an example of a Bean that can execute locally. However, a Bean that provides real-time price information from a stock or commodities exchange would need to work in cooperation with other distributed software to obtain its data.

We will see shortly what specific changes a software developer must make to a class so that it is usable as a Java Bean. However, one of the goals of the Java designers was to make it easy to use this technology. Therefore, the code changes are minimal.

Advantages of Java Beans

A software component architecture provides standard mechanisms to deal with software building blocks. The following list enumerates some of the specific benefits that Java technology provides for a component developer:

A Bean obtains all the benefits of Java's "write-once, run-anywhere" paradigm.  The properties, events, and methods of a Bean that are exposed to an application 

builder tool can be controlled. A Bean may be designed to operate correctly in different locales, which makes it 

useful in global markets. Auxiliary software can be provided to help a person configure a Bean. This software is 

only needed when the design-time parameters for that component are being set. It does not need to be included in the run-time environment.

The configuration settings of a Bean can be saved in persistent storage and restored at a later time.

A Bean may register to receive events from other objects and can generate events that are sent to other objects.