Applets

Why no applets in these notes

These notes were originally written using applets almost entirely.
However, all applet examples are being changed to applications.

The only really portable applets are written in Java 1.1 because
this is the minimum assumption about what is installed on a user's computer.
Java has moved far beyond that. I'm not
interested in programs that are limited to the older,
and seriously inferior, AWT. Yes, Java plugins can be used
for the more recent versions, but it can still be a problem.
To get around this, many books that teach applets
suggest using the appletviewer program
thereby negating the supposed applet advantages.

In a controlled environment, such as a large company, it's
possible to use later versions of applets, but they aren't
the best idea for general examples.

Many current applets should instead be animated GIFs,
JavaScript, or Flash.

Assuming the later versions of Java are used, most
applet source will look similar to application code.
However, there are some divergences that are annoying:
the common practice of init instead of a contructors,
the fixed size as opposed to using pack,
lack of I/O capability (without permissions), ...
It's even worse when using Java 1.1 because the lack of a
content pane distorts the program.

Java WebStart is a better solution to web distributed software.

The primary use of Java has turned out to be applications, not
applets as predicted by the initial hype.

Converting Applets to Applications

To make an applet into an application, add
a main()method to the applet's class
-- you don't have to create a new class.
It may seem a little strange that adding a main
method to a class will make it into an application, but that's
the most common way of doing it.
An application is any program that
has a main() method. This new main()
does what a browser does.

Although SampleApplet is the name of the class,
we need to create an instance of it. An applet is a kind of panel,
so it can be used for the contentPane in a JFrame.

Usually only applets which do animation have a start() method.
If your applet doesn't have a start() method, you don't need
this call, although it won't cause problems because JApplet has defined a version
that does nothing.
Similarly with init() which is commonly used in applets, altho
a constructor would be a better choice. If there is no init(),
there's no need to call it.

Some applets may use features that require additional work.

An applet can call getCodeBase()
to find out where it was loaded from to get additional classes, images, or other data,
then use the return value to get more things.
If an applet does this, then you must define getCodeBase().

If an applet gets parameters from the web page, you will have to
provide a getParameter() method.

The showStatus() method must be supplied if used by the applet.

The <applet...> HTML tag

You need to specify the following values in an applet tag.

Size. width="nn" height="mm", where nn and mm
are the width and the height of the area the applet will occupy
on the web page. Applets are not resizeable (except when run with the
appletviewer application, but if you're using appletviewer,
why are you writing an applet? Specifying the size is a nasty problem.
Because applets can be run on web pages in many different environments,
you don't know the pixel exact dimentions of the particular widgets, so
you have to estimate the largest size that will be required and specify
that in your applet tag. I often add System.out.println to
print that applet size (use getSize()), then add a little.\
I hope you are using a layout that will expand gracefully.

Class file location. There are several possibities.

Simple class files

Specify code="Xxxx.class"

Jar file

If you're using packages (eg, with NetBeans), you will need to
specify the .jar file as an archive and then give the
class which contains the applet, qualified by the package name.
Specify code="yourPackage.Xxxx.class" archive="yourPackage.jar"