What is the difference between applications and applets
a)Application must be run on local machine whereas applet needs no explicit installation on local machine. b)Application must be run explicitly within a java-compatible virtual machine whereas applet loads and runs itself automatically in a java-enabled browser. d)Application starts execution with its main method whereas applet starts execution with its init method. e)Application can run with or without graphical user interface whereas applet must run within a graphical user interface.
What is the difference between the paint() and repaint() methods
The paint() method supports painting via a Graphics object. The repaint() method is used to causepaint() to be invoked by the AWT painting thread.
What is a layout manager and what are different types of layout managers available in java AWT
A layout manager is an object that is used to organize components in a container. The different layouts are available are FlowLayout, BorderLayout, CardLayout, GridLayout and GridBagLayout.
How does applet recognize the height and width
?– Using getParameters() method.
What is JAVAdoc utility?
Javadoc parses comments in JAVA source files and produced HTML pages for the same. Below is the syntax for the same javadoc [ options ] [ packagenames ] [ sourcefiles ] [ @files ] Arguments can be in any order. Options Command-line options that is doctitle, windowtitle, header, bottom etc
Packagenames: –
A series of names of packages, separated by spaces, such as java.lang java.lang.reflect java.awt. You must separately specify each package you want to document. Javadoc uses -sourcepath to look for these package names. Javadoc does not recursively traverse subpackages.
sourcefiles :-
A series of source file names, separated by spaces, each of which can begin with a path and contain a wildcard such as asterisk (*). The path that precedes the source file name determines where javadoc will look for it. (Javadoc does not use -sourcepath to look for these source file names.)
@files: – One or more files that contain packagenames and sourcefiles in any order, one name per line.
What are applets ?
Applets are small applications that are accessed from web server automatically installed, and run from the browser. Once an applet arrives on the client it has limited access to resources thus ensuring security for the end user. An applet is controlled by the software that runs it. Usually, the underlying software is a browser, but it can also be applet viewer. If you run the applet source code from eclipse it runs inside an applet viewer. All applets should inherit from applet class.
Below are sequences of events which occur in applet:
- The init Method: The init method is called when the applet is first loaded. Init method can be used to initialize color, fonts or any type of one type operation needed for the applet.
- The start Method: The start method is called when user visits a browser with an applet on it. In start method applet spawns a thread in which it runs the paint method.
- paint() is called every time when applet has to re-display everything.
What is the importance of init() method in Servlet?
The init method is designed to be called only once. It is called when the servlet is first created, and not called again for each user request. So, it is used for one-time initializations, just as with the init method of applets.
The servlet is normally created when a user first invokes a URL corresponding to the servlet, but you can also specify that the servlet be loaded when the server is first started.
When a user invokes a servlet, a single instance of each servlet gets created, with each user request resulting in a new thread that is handed off to doGet or doPost as appropriate. The init() method simply creates or loads some data that will be used throughout the life of the servlet.
The init method definition looks like this:
public void init() throws ServletException
{
// Initialization code…
}
What is an observer design pattern
The Observer pattern is a behavioral design pattern that allows an object (an Observer) to watch another object (a Subject). The subject and observer to have a publish/subscribe relationship. Observers can register to receive events from the Subject.
Some of the practical uses of observer pattern are:
- When a change to one object requires changing of others, and you don’t know how many objects need to be changed.
- When an object should be able to notify other objects without making assumptions about who these objects are and not tightly coupling them.
- When a report is received or an event occurs, a message needs to be sent to the subscribed handlers.
Examples:
- Programming Swing based GUI applications where the listeners register them with events like button click, property change, etc.
- Programming a stock market application to know when the price of a stock changes.
- Programming a order placement or trading application to know the status changes like pending, filled, shipped, rejected, etc.
So, whenever you want to have the state change or other information, instead of polling every few second, register the observers with a subject.
Here is some pseudo code of this third scenario
STEP 1: Define the Subject and Observer interfaces
This is the subject interface
package com;
public interface ReportExecutor {
public void addHandler(ReportHandler rh);
public void removeHandler(ReportHandler rh);
public void processReport(String message);
}
This is the observer interface
package com;
public interface ReportHandler {
//handles report
public void handleMessage(String message);
}
STEP 2: Define the concrete subject and observers
The concrete subject
package com;
import java.util.ArrayList;
import java.util.List;
public class SalesReportExecutor implements ReportExecutor {
//list of observers that register their interest in SalesReport
private List<reporthandler> reportHandlers = new ArrayList<reporthandler>();
@Override
public void addHandler(ReportHandler rh) {
reportHandlers.add(rh);
}
@Override
public void processReport(String message) {
for (ReportHandler reportHandler : reportHandlers) {
reportHandler.handleMessage(message);
}
}
@Override
public void removeHandler(ReportHandler rh) {
reportHandlers.remove(rh);
}
}
The concrete observers
package com;
public class LoggingReportHandler implements ReportHandler {
@Override
public void handleMessage(String message) {
//handles report by formatting and printing
System.out.println(“Logging report ” + message);
}
}
package com;
public class EmailReportHandler implements ReportHandler {
@Override
public void handleMessage(String message) {
//handles the report by formatting it differently and emailing.
System.out.println(“Emailing report ” + message);
//logic to email report.
}
}
STEP 3: Finally, the JMS listener class that uses the subject. The JMS Listener class listens on a queue for presence of a report.
package com.mgl.mts.fix;
import javax.jms.Message;
import javax.jms.TextMessage;
public class MyAppListener {
public void onMessage(Message message) {
if (message instanceof TextMessage) {
ReportExecutor executor = new SalesReportExecutor();
executor.addHandler(new LoggingReportHandler());
executor.addHandler(new EmailReportHandler());
executor.processReport(message.toString());
} else {
throw new IllegalArgumentException(“Message must be of type TextMessage”);
}
}
}
What is RowSet? or What is the difference between RowSet and ResultSet? or Why do we need RowSet? or What are the advantages of using RowSet over ResultSet
RowSet is a interface that adds support to the JDBC API for the JavaBeans component model. A rowset, which can be used as a JavaBeans component in a visual Bean development environment, can be created and configured at design time and executed at run time. The RowSet interface provides a set of JavaBeans properties that allow a RowSet instance to be configured to connect to a JDBC data source and read some data from the data source. A group of setter methods (setInt, setBytes, setString, and so on) provide a way to pass input parameters to a rowset’s command property. This command is the SQL query the rowset uses when it gets its data from a relational database, which is generally the case. Rowsets are easy to use since the RowSet interface extends the standard java.sql.ResultSet interface so it has all the methods of ResultSet. There are two clear advantages of using RowSet over ResultSet
- RowSet makes it possible to use the ResultSet object as a JavaBeans component. As a consequence, a result set can, for example, be a component in a Swing application.
- RowSet be used to make a ResultSet object scrollable and updatable. All RowSet objects are by default scrollable and updatable. If the driver and database being used do not support scrolling and/or updating of result sets, an application can populate a RowSet object implementation (e.g. JdbcRowSet) with the data of a ResultSet object and then operate on the RowSet object as if it were the ResultSet object.
Why are JSP pages the preferred API for creating a web-based client program
Because no plug-ins or security policy files are needed on the client systems(applet does). Also, JSP pages enable cleaner and more module application design because they provide a way to separate applications programming from web page design. This means personnel involved in web page design do not need to understand Java programming language syntax to do their jobs.