Lesson 2.3 First Applet

Examining Your First Java Applet

Before you begin this section, you should have installed the Java Development Kit, and know how to editing compile and run a Java program. Here, we'll take a closer look at the program, FirstApplet.java that you entered, compiled, and ran in Lesson 1.6.

Program Organization

• Every Java program is a class definition.
• A class definition is a blueprint that is used to construct an object; in the case of an applet, you may want to think of that object as a "program object."

The basic structure for every Java program looks like this:

The file name for this program must be SomeClassName.java and the file can contain only one public class definition. (You can define other classes in the same file, but they cannot be public classes.)

Note that this is different than many other programming languages where the program name and the name of the file are not related. In Java, the name of the file and the name of the program must be identical (including case). The file name and the public class it contains must match exactly.

Back to Top

The Class Header

Let's start by examining the header for FirstApplet, and then we'll come back to its body. The FirstApplet class header is written as:

The first part of this is the declaration public class. This simply tells the compiler:

"Hey! a class definition is coming up!"

• Keywords are always lowercase
• You cannot use keywords as identifiers [the names you supply when you create classes, methods, and attributes]
• You must spell the keywords correctly and use them in the correct context. If you use a keyword inappropriately, or if you misspell it, you will generate a syntax error: a violation of Java's internal rules of grammar.

Name of the Class

While public and class are keywords, FirstApplet is a different kind of beast; FirstApplet is an identifier. An identifier is a word that you make up to name classes, attributes, methods, and variables. You can use any name you like, as long as you follow a few simple rules:

1. You can use letters, digits, the currency symbol [$] and the underscore character in your name.
2. Your identifier cannot start with a digit.
3. You must remember that identifiers are case sensitive . Unlike keywords, you may use uppercase as well as lowercase, but the identifiers cat, Cat, and CAT are not the same!

The biggest difference [when it comes to identifiers] between Java and these other languages is not readily apparent, but pops to the surface when you ask the question, "What's a character?"

Unlike these other languages Java isn't limited to using the ASCII character set [the most widely used computer-character encoding scheme]. Instead, it uses Unicode, the international character set that provides some 65,000 different characters. So, although Java identifiers are limited to characters and digits, those characters and digits can be any valid Unicode character or digit.

Back to Top

Naming Conventions

Much like social conventions, identifier naming conventions allow you to infer a great deal about an object by the way it is named. Also like social conventions, identifier naming conventions can become prissy and pedantic, ignoring the more important considerations of clarity and simplicity. 

It is always more important to make sure that your variable names impart meaning to your audience than that they adhere to some rigid naming rule. To that end, you should follow the "golden rules" that are true in any programming language:

• Try to make your names understandable
• Use names that accurately describe what your identifier does. For instance, the variable names:

quarterlySales = quarterlySales + monthlySales;

are much easier to understand than

x = x + x2;

It is also legal to start an identifier with an underscore, but you should avoid that as well. It is just too easy to miss a leading underscore when you are reading code, and if you use them you'll spend many more fruitless hours staring at code that "should" work, but doesn't for some reason.

Beyond that, however, here are the more-or-less agreed upon naming standards in the Java world:

• Class names: CapitalizeEveryWord
• Method and field names: startLowThenCaps
• Constants: CAPS_WITH_UNDERSCORES

Back to Top

What Does extends Applet Mean?

The next word, extends, is a keyword like public and class. The extends keyword means that what precedes it [in this case the public class FirstApplet ], adds something to, or builds upon, what follows it [in this case, something called Applet ].

That makes sense. If a header is supposed to describe a class, this part of the header is describing its lineage. Sort of like:

This is Steve, and his parents are...

Perhaps, our knowledge of convention might help; and, indeed it does. If you look back at the convention for identifiers, you'll see that only classes begin with a capital [like Applet] followed by lowercase characters. In fact, Applet is a class, one of the classes supplied with the JDK.

The Applet class actually has quite a pedigree, which you can discover by looking at its complete name:

java.applet.Applet

A package describes the place where the specific class we want to use is stored. In this case, the Applet class is in the package, java.applet. [Package names that begin with java are part of the core Java packages, and you are not permitted to modify them.]

If you look back at our class organization at the start of this lesson, you'll see that it starts with the statement:

...some stuff

What goes in place of "...some stuff" is another Java keyword: import. The import statement tells the javac compiler which packages to look in when it is trying to locate a class. 

Specifically, since we told the compiler that FirstApplet extends Applet, we must also tell it where to find the Applet

but that would quickly become tedious. Instead, we can add the following lines to the top of our class file:

and Java will look first in the java.applet package and then in the java.awt package to locate any classes that we use.

Back to Top

The Class Body

In Java, braces {} are used to mark the beginning and end of the class body. Braces are also used to delimit the body of a method, as well as the bodies of loops and selection statements. Just think of braces as markers that say:

{ "this is the beginning of a section"

} "this is the end of a section"

Braces, along with indentation, allow you to quickly see and understand the general struture or "shape" of a program. To facilitate this, every time you use a set of braces, the "stuff" inside the braces should be indented as well.

There are at least two styles of indenting you can use with your braces. Which one you select is a matter of taste. You should be consistent, however. If you use one style in one part of your code, and the other style in another part of your code, it makes your programs harder to read.

Below we'll cover the two most popular styles: Classic Indenting and Vertical-style Indenting.

Classic Indenting

In classic indentation, [also called C-style indentation], the "begin" brace is placed on the same line as the block header, while the "end" brace is lined up with the header. Everything else inside the braces is indented like this:

The advantage of classic style indentation is that you can see more lines of code on your screen at once.

Back to Top

Vertical-style Indenting

As you might expect, each opening brace must be matched with a closing brace, otherwise your program will not compile. Here's an example of vertical-style indentation:

How much should the code inside your braces be indented? Probably between 3 and 4 spaces. The default "hard" tab-stop used by programs like Notepad is normally 8 spaces, which makes your programs too hard to read. If you use MS-DOS Edit as your program editor, you should adjust the tab-stops using the Settings menu.

Back to Top

Other Style Issues

You probably don't want to write code like this, however. You should use whitespace to improve the readability of your programs, not reduce the readability. Try to group related statements together into "paragraphs", and separate such groups from unrelated groups of statement by inserting blank lines and comments.

Since statements can span multiple lines, you may be wondering how the javac compiler tells when a statement is done. Java uses the semicolon [;] to mark the end of a statement, just like C and C++. Note that this is different than Pascal, where a semicolon is used to separate multiple statements.

Back to Top

Comments

You can also create comments that span multiple lines by using the delimiter /* [a forward slash, immediately followed by an asterisk] to start the comment, and the delimiter */ [an asterisk immediately followed by a forward slash] to end the comment. You cannot have multi-line comments inside other multi-line comments, but the single line variety work just fine.

Here's an example of a multi-line comment, along with some whitespace:

/* --------------------------------     FirstApplet.java     Created on 6/10/99     CS 170, OCC     Stephen Gilbert     -------------------------------- */ import java.awt.*; import java.applet.*; public class FirstApplet extends Applet {    // Attributes go here    // Methods go here }

Now that you've learned about the general structure of a Java program, it's time to take a look at the stuff that goes in between the braces.

Remember that a class definition is made up of attributes and methods. But what is an attribute made of? Well, as you'll see in the next section, attributes are frequently objects.

Please continue to the next section of this lesson.

Back to Top