If you have purchased this book, you are probably planning to program with Java. There are many reasons for using Java as your programming language. You might want to learn an object-oriented programming language, and maybe you've heard that Java is simple to use. You might have come across some interesting applets while browsing the Internet (if you're using a Java-capable browser), and perhaps you want to learn to write applets of your own and add them to your Internet or intranet HTML documents. You might want to learn how to add Internet functionality to your C applications or how to use Java to write full-fledged applications that are portable. This book helps you accomplish any and all of these goals.
This overview introduces the many features of Java and explains why they are important to you, the Java programmer. It is worthwhile for you to understand the richness and usefulness of Java before getting into the specifics of the Java environment and language.
Java is an interpreted language that is similar, superficially, to C++, but different in many important ways. Java was originally intended to be an extension of the C compiler but has been completely rebuilt from the ground up to be a smaller, portable, purely object-oriented language that eliminates many of the sources of bugs and complexities common in C++.
Java has been around since 1991, developed by a small team of Sun Microsystems developers in a project originally called the Green project. The intent of the project was to develop a platform-independent software technology that would be used in the consumer electronics industry. The language that the team created was originally called Oak.
The first implementation of Oak was in a PDA-type device called Star Seven (*7) that consisted of the Oak language, an operating system called GreenOS, a user interface, and hardware. The name *7 was derived from the telephone sequence that was used in the team's office and that was dialed in order to answer any ringing telephone from any other phone in the office. This PDA-type device was intended to be sold to consumer electronics manufacturers who would distribute the boxes under their company name. In 1993, the team, then incorporated as FirstPerson, Inc., decided to gear their technology toward a new implementation for which demand was building in the entertainment industry-interactive television. They proposed their technology to Time Warner as an operating system for set-top boxes and video-on-demand technology that would decode the data stream that Time Warner would be sending to television sets around the country. In June of 1993, Time Warner selected Silicon Graphics' technology over Sun's. A later deal fell apart and FirstPerson decided to disband. Half of the members of the original FirstPerson team continued to work with the Oak technology, however, applying it to multimedia and network computing.
Around the time the FirstPerson project was floundering in consumer electronics, a new craze was gaining momentum in America; the craze was called "Web surfing." The World Wide Web, a name applied to the Internet's millions of linked HTML documents was suddenly becoming popular for use by the masses. The reason for this was the introduction of a graphical Web browser called Mosaic, developed by ncSA. The browser simplified Web browsing by combining text and graphics into a single interface to eliminate the need for users to learn many confusing UNIX and DOS commands. Navigating around the Web was much easier using Mosaic.
It has only been since 1994 that Oak technology has been applied to the Web. In 1994, two Sun developers created the first version of HotJava, then called WebRunner, which is a graphical browser for the Web that exists today. The browser was coded entirely in the Oak language, by this time called Java. Soon after, the Java compiler was rewritten in the Java language from its original C code, thus proving that Java could be used effectively as an application language. Sun introduced Java in May 1995 at the SunWorld 95 convention.
Web surfing has become an enormously popular practice among millions of computer users. Until Java, however, the content of information on the Internet has been a bland series of HTML documents. Web users are hungry for applications that are interactive, that users can execute no matter what hardware or software platform they are using, and that travel across heterogeneous networks and do not spread viruses to their computers. Java can create such applications.
On the Internet, Java programs are called applets. Applets are Java applications that are embedded inside HTML files and can be downloaded into a Java-capable browser with the click of a mouse. Applets are different from regular Java applications. A Java application simply has a single main() method that indicates to the Java runtime system that it is an application. A Java applet is an application that includes several additional methods that the runtime system uses that tell it how to handle the applet, such as what to do when a user clicks an applet icon and how it looks on a page.
Before your browser's runtime Java interpreter downloads and executes the applet's code, the Java interpreter verifies the code's integrity. Java is more than a tool to help you write applets, however. It is a new, powerful programming environment.
Sun describes Java as a "simple, object-oriented, interpreted, robust, secure, architecture-neutral, portable, high-performance, multithreaded, and dynamic language."
Each of the features mentioned in this quotation from Sun's Web page is an important part of the Java development environment as well as a critical requirement for Web programming. The combination of these features makes Java a powerful and useful programming language that empowers you, the programmer, with the tools you need to easily create powerful programs for today's distributed environments.
Java is simple to use for three main reasons: First, Java is familiar to you if you know C. Second, Java eliminates components of C that cause bugs and memory leaks and replaces their functionality with more efficient solutions and automated tasks, so you have a lot less debugging to worry about than you would using C or C++. Third, Java provides a powerful set of pre-tested class libraries that give you the ability to use their advanced features with just a few additional lines of code.
Java is an object-oriented programming language that uses software objects called classes and is based upon reusable, extensible code. This means that you can use Java's classes, which are sets of variables and methods, as templates to create other classes with added functionality without rewriting the code from the parent classes or superclasses. If you plan your application's class hierarchy well, your application will be small and easy to develop. The hierarchy of classes is explained later in this chapter.
Java is robust because the language removes the use of pointers and the Java runtime system manages memory for you. The problems with pointers in C and C++ was that pointers directly addressed memory space. In a distributed environment like the Internet, when code is downloaded to diverse systems, there is no way of knowing for sure that memory space addressed by pointers is not occupied by the system. Overwriting this memory space could crash a system. Java also gives you automatic bounds checking for arrays, so they cannot index address space not allocated to the array. Automatic memory management is done using the Garbage Collector, which is explained in detail in Chapter 4, "Creating Your Own Objects."
Java is interpreted, so your development cycle is much faster. As you learn later when the Java interpreter is discussed, you need only to compile for a single, virtual machine and your code can run on any hardware platform that has the Java interpreter ported to it.
Java is secure, so you can download Java programs from anywhere with confidence that they will not damage your system. Java provides extensive compile-time checking, followed by a second, multilayered level of runtime checking. Java's security structure is described in detail in Chapter 19, "Security Issues."
Java is architecture neutral, so your applications are portable across multiple platforms. Java's applications are written and compiled into bytecode for Java's virtual machine, which emulates an actual hardware chip. Bytecode is converted to binary machine code by the Java interpreter installed at the client, so applications need not be written for individual platforms and then ported from platform to platform. Java additionally ensures that your applications are the same on every platform by strictly defining the sizes of its basic data types and the behavior of its arithmetic operators. Operator overloading, the process of modifying the behavior of operators, is prohibited by Java.
Java is "high performance" because its bytecode is efficient and has multithreading built in for applications that need to perform multiple concurrent activities. Although threads still require the use of classes, Java balances the addition of thread synchronization between the language and class levels. Java's bytecode is efficient because it is compiled to an intermediate level that is near enough to native machine code that performance is not significantly sacrificed when the Java bytecode is run by the interpreter.
Java is dynamic, so your applications are adaptable to changing environments because Java's architecture allows you to dynamically load classes at runtime from anywhere on the network, which means that you can add functionality to existing applications by simply linking in new classes. For example, if your applet is being run by a browser that doesn't have one of the classes included in your applet's bytecode, the browser can download the appropriate class from the server that is storing your applet, check the bytecode, and execute it. This is assuming your browser has not been configured with strict security. Chapter 19 covers browser security.
This chapter introduces you to the basic concepts and functions of the Java programming language and gives you brief examples to illustrate important points. The later, more advanced chapters guide you through extensive samples of code, and so the examples in this chapter are short. By the end of this chapter, you should have a basic understanding of the Java language and be ready to explore in detail Java's class libraries in Chapter 3, "An Introduction to Java Classes."
Java programming will be fairly easy for you if you have had experience with C++ because Java is designed to look and feel like C++. If you are an experienced C programmer, you will have to let go of some old habits to program Java, however, as you will discover later in this chapter. Please do not be concerned if you have little or no experience in programming-this book assumes no prior knowledge of C++. You may need to read through the chapters more slowly and carefully than an experienced programmer.
Java's class structure is made up of the following major components: classes, hierarchy, variables, methods, and inheritance.
The key to understanding Java's object-oriented design is understanding what classes are and what you can do with them. Classes are templates that you use to create actual objects. The instructions contained in a class are used to create one or more objects, which can be called instances of classes in Java. When you create an object from a class, you instantiate the object, which means you create an instance of the class. The words instances and objects are used interchangeably throughout the discussions of classes in this book, depending on the context of the sentence in which they're used.
In object-oriented programming, you can think of an object as you would any real-world object, for example, a rectangle. The actual rectangle would be an instance of the class Rectangle.
A very rudimentary declaration of a class is as follows:
class classname {
//class instructions
}
The instructions in a class are made of two basic components: variables that hold data, and methods that manipulate the data.
Before you begin creating the classes in your application, you must design the class structure. Java's class structure is organized into a hierarchy.
Classes are organized into a hierarchy to allow you to easily reuse code. When you write a Java program, first determine which objects you'll need to use in your code. Then determine what variables and methods the object's class must store. When you know what instructions your classes contain, plan your hierarchy.
Without planning your hierarchy first, you would begin creating a class for each object individually and undoubtedly would find that you are repeating instructions from class to class. In a hierarchy, instructions common to groups of objects are separated out in parent classes, or superclasses, and can be used by all of their subclasses. Therefore, when you plan your hierarchy, you would group objects by the instructions that they have in common and organize them into a hierarchy.
Superclasses are used as templates to create subclasses with variables and methods that make each subclass unique. Each superclass can be a parent to one or many other subclasses. Unlike in C++, a subclass can have only one superclass. Therefore, the Java class hierarchy looks something like the one shown in Figure 1.1.
Figure 1.1: Java class hierarchy.
If a superclass is not defined when a class is declared, the class is automatically made a subclass of Java's Object class. Every class in a Java program is a descendant of Object. Object itself has no superclass.
Classes store information that describe objects in instance variables. When objects are created from a class, they contain new instances of the class' variables. These instance variables can have values that are different from one object to the next. Values of instance variables are called data. When an instance variable's data is changed, it affects only the individual object. There is a way in Java to assign a variable to a class that, if changed, is changed in all instances of the class. Such a variable is called a static variable, which you learn about later in this chapter in the section called "Static Methods and Variables."
The basic declaration statement of a variable is this:
datatype variablename;
Two variables that might be declared for a rectangle are length and width. They could be declared in one line because they have the same data type. (You explore data types in Table 1.1 of this chapter.) Their declaration statement might be this:
int length, width;
If you created an object from a class with only these two variables declared, the object would simply hold this data. It would not know to draw lines with these values to form a rectangle. Methods must be declared to use the data in variables.
Methods are functions that must be associated with individual classes. In C and C++ and other procedural languages, functions can be placed anywhere in the code. In Java, they must be stored within classes. Instances of methods are created when instances of classes are created. Unlike variables, methods are not duplicated in objects-their code is stored only in the class.
When an object's method is invoked from its class, it uses the data of variables in the object.
Every method returns a value if it is not declared as void. To declare a method, you use the following statement:
returntype methodname (parameter list) {
//method code
}
At this point in the chapter, you won't get into coding the method that draws the rectangle. After you've learned the basic coding elements of Java later in this chapter, exercises in coding methods will be more useful.
Variables and methods that are stored in classes in the class hierarchy are inherited by subclasses, so you do not need to re-create them. Objects created from a subclass will contain not only the instances of the variables and methods of the subclass, but also its superclass' variables and methods, as well as those of the parent of its superclass, and so on. When a variable or method is referenced in an object, it is retrieved in a specific order: Java first searches for it in the current class, then, if it is not found, it searches the parent class, and so on.
In summary, objects in your Java program are created from classes that contain variables and methods to describe the object. Classes are organized into a hierarchy in which classes inherit functionality from parent classes, which allows for reusable code. These basic concepts of the structure of Java's object-oriented programming language will become clearer to you as you read through the rest of the sections.
Your Java code is used to create classes, objects, interfaces, and packages. You'll learn how to create each of these in Chapter 4. This section outlines the elements of the code you need to use to create them.
Your code is written in a series of statements, which can be organized into blocks. These statements contain data and operators, which are components of expressions. You can annotate your code using comments, which makes the code more understandable.
Any line of code before a semicolon is known as a statement and is executed by the Java interpreter when it hits the semicolon; after executing that statement, the interpreter moves to the next statement. Each statement contains instructions for using data and operators.
An expression is a part of a statement that uses data and operators to return a value.
A block is a collection of statements enclosed in curly braces. Any variables that you declare and that assign values within a block are erased when the flow of execution leaves the block. The block in which the variable's value exists is called the scope of the variable.
Comments are used to annotate the code so that a reader can understand the purpose of certain lines and blocks of code. Comments are ignored by the Java compiler. Multiline comments are preceded by /* and are ended with */. Single line comments are preceded by //. The double slash "comments out" text only to the end of a line. A comment would appear as follows:
/* This declares the length variable for the Rectangle class */
int length;
or
int length; //Declares the length variable for the Rectangle class
To represent data values in your code you use literals. Literals are described by types, named by identifiers, and stored in variables, which were outlined earlier in the chapter and are explored further in this section.
When you use literals in your code, they appear in their raw form rather than as a result of an expression. Several types of literals are commonly used: numbers, integers, floating points, characters, Booleans, and strings.
Table 1.1 outlines Java's strict definitions of these data types.
| Literal Type | Typename | Rule |
| Number | Num | Can_ be integer, floating point, or character. |
| Integer | Can be decimal, hexadecimal, or octal. | |
| Byte | 8-bit integers between -128 and 127. | |
| Short | 16-bit integers between -32768 and 32767. | |
| Int | 32-bit integers between -2147483648 and 2147483647. | |
| Long | 64-bit integers between -9223372036854775808 and 9223372036854775807 or have L or l appended to them. | |
| Hex | Preceded by 0x or 0X. | |
| Oct | Preceded by 0. | |
| Floating point | Any number with a decimal point. Can be made exponential by appending an e or E, followed by the exponent. | |
| Float | 32-bit. | |
| Double | 64-bit. | |
| Character | Char | 16-bit integers represented by a single character and enclosed in single quotes. |
| In Java, the Unicode character map is used. The following special characters must be represented by escape sequences: | ||
| backspace \b | ||
| backslash \\ | ||
| carriage return \r | ||
| double quote \" | ||
| formfeed \f | ||
| hex number \xhh | ||
| horizontal tab \t | ||
| newline \n | ||
| octal number \000 | ||
| question mark \q | ||
| single quote \' | ||
| vertical tab \v | ||
| Boolean | Boolean | Can only be true or false. Are not represented by 0 or 1. |
| String | String | Zero or more characters enclosed in double quotes. |
Literals are described by identifiers. Identifiers are sequences of letters and digits, and can also be used to describe variables, methods, and classes. Identifiers can consist of any letter from a to z, underscore, dollar sign, digits from 0 to 9 (except as the first character); identifiers are case-sensitive.
Java has several reserved keywords that are its own identifiers,
which cannot be used as identifiers in any way other than that
defined by Java, as listed in Table 1.2. Though these words are
reserved, not all are used in the most recent release.
| Abstract | else | int | short |
| boolean | extends | interface | static |
| break | final | long | super |
| byte | finally | native | switch |
| case | float | new | synchronized |
| cast | for | null | this |
| catch | future | operator | throw |
| char | generic | outer | throws |
| class | goto | package | transient |
| const | if | private | try |
| continue | implements | protected | var |
| default | import | public | void |
| do | inner | rest | volatile |
| double | instanceof | return | while |
Operators are used to compare values. Java has strict definitions of operators. It doesn't allow for overloading, which is a C developer's common practice of changing the behavior of operators.
Java provides two types of operators: binary and unary. Binary operators are used to compare two values. Unary operators use a single value, for example:
a >= b
a++
The first example uses a binary operator, >=, which compares variables a and b. The second is a unary operator, ++, which increments the value of a by one.
All of Java's binary and unary operators can be found in Table
1.3. They are organized according to the precedence with which
they are performed.
| Operator | Description |
| ., (), [] | Precedence overriding decimal, parentheses, brackets |
| !, ~, ++, -- | Boolean negation, bitwise complement, increment, decrement |
| *, /, % | Multiplication, division, modulus |
| +, - | Addition, subtraction or unary negation |
| <<, >>, >>> | Left shift, right shift, zero-fill right shift |
| <, <=, >, >= | Less than, less than or equal to, greater than, greater than or equal to |
| ==, != | Equals, is not equal to |
| & | Bitwise or Boolean AND |
| ^ | Bitwise or Boolean XOR |
| | | Bitwise or Boolean OR |
| && | Evaluation AND, Logical AND |
| || | Evaluation OR, Logical OR |
| ?: | If…then…else |
| =, +=, -=, *=, /=, %=, &=, ^=, |=, <<=, >>= | Assignment operators |
| , | Comma |
There are four types of statements to use for variables: declarations, assignments, initializers, and casts.
You must always declare variables before you can use them in your Java program. Variable declarations assign data types to variables. A declaration statement in Java consists of a data type followed by an identifier. Any of the data types listed in the previous table can be used to declare variables, for example:
Boolean IsReady;
float miles;
int x, y, z;
short pages;
Assignments are statements that assign values to variables. These, like declarations, are required before variables can be used. They are called by setting an identifier equal to a value. This value, of course, must be compatible with the data type assigned to the variable identifier. Initializers are assignment statements that are combined with the declaration statement, for example:
Boolean IsReady = false
float miles = 3.62
short pages = 240
If you want certain variable values to remain constant in your code, you can use the final keyword, which ensures that the variable cannot be changed by the code. Its form is this:
final int pages = 500
Casts are statements you use if you need to place a value of one type into a variable of another type. In C++, automatic coercion allows you to do this without declaring that you were aware of this change. In Java, you must explicitly call such an instruction with a cast statement. Cast statements are generally called as follows:
datatype identifier = (datatype) identifier
Java allows casts only between compatible data types.
In this section, you have learned about the data and operators that are used in expressions that are parts of statements. You now understand that statements are organized with blocks and annotated with comments. You have also examined some basic statements that deal with variable declarations. These are the fundamental elements of Java coding.
Now that you understand the basic structure and elements of the Java language, you'll see how statements flow through a Java program in this section. By default, the Java interpreter executes statements in sequential order. This section introduces you to some more complex types of statements that alter this flow of execution.
if, if...else, ?:, and switch are four conditional statements that are used often in code. They evaluate an expression and, based on the value of the expression, they control which statements are executed.
The if statements consist of if followed by a test expression. If the test expression returns a true value, the statement or block of statements after the expression is executed. They are structured as follows:
if (test expression) statement;
if...else statements are similar to if statements, but include a false statement that is executed if the test expression returns a false value. They are structured as follows:
if (test expression) true-statement;
else false-statement;
The ?: is a ternary operator that allows you to assign one of two values based on the evaluation of an expression as true or as false. Its form is as follows:
(test expression) ? true-value : false-value
The switch statement evaluates an expression's value and jumps to a statement identified by the literal value of the expression. It saves coding time if there are several values in your statement. Its form is as follows:
switch (expression) {
case value: statements
case value: statements
default: statements
}
Loops provide you with the ability to repeat certain statements until a condition is met. Java provides three types of loop statements: while, do...while, and for. Three other statements commonly used with loops are break, continue, and labels, but these can be used with other types of Java statements (such as conditionals) as necessary.
The while loop evaluates a condition to see if it is true, and then executes statements and checks the condition again. If the condition is still true, while executes the statements and checks again. This process continues until the condition is evaluated as false. The form is this:
while (expression) true-statements
The do...while loop is similar to while, but do...while executes statements before the condition is evaluated. When you use do...while, loop statements are always executed at least once. The form is this:
do statements while (expression)
The for loop allows you to test a range of values in your expression. Its form is generally this:
for (initializer; expression; increment)
statements
The break statement is used to exit loop and conditional statements before meeting a test condition. The continue statement directs execution back to the beginning of a loop without completing all of the loop statements. A label is used to identify a statement so execution can be directed to it with a break or continue statement. A colon (:) must be appended to a label name.
An example of a label is as follows:
variable declarations;
Label:
while (test expression) {
statement;
if(test expression) {
continue Label;
}
statement;
}
Arrays create slots that allow you to store a list of variables. Arrays are allocated using the new operator to create the array and assigning it to a variable with =. Arrays are declared as follows:
datatype variable[] = new datatype[number-of-slots];
The first half of the statement declares the variable that holds the array. Your array declarations should end in square brackets. The second half creates the array and assigns it to the variable.
The new modifier automatically initializes your array to false for Boolean arrays, 0 for numeric arrays, \0 for character arrays, and null for all other types of arrays. You can choose to initialize the array on the same line as the declaration, as shown here:
datatype [] = {element1, element2, element3, etc.}
Every Java application is essentially a class that contains the main() method. This section discusses briefly how to create and use classes, objects, and interfaces in Java applications. You'll learn about many additional elements of the Java programming language that are important to know when using classes and objects.
The first step in creating an object in your application is to create its class. The following form is used to define a class:
class classname [extends classname] [implements interface] {
[variable declaration;]
[method declaration;]
}
In this form, the classname is the name of the new class; extends classname is where the parent class of a subclass would be named, after the word extends. The implements interface defines an interface used by the class (interfaces are covered later in the chapter). If you do not want the compiler to allow your class to be subclassed, you can precede your class statement with the word final. If you wish to create a class that must be subclassed, you would precede the class with the word abstract.
You explored variable declaration in detail in the first section. Keep in mind that variables must be initialized before being used in methods. Now you'll learn how methods are declared. Methods generally use the following form:
[Modifiers] return-type method-name (parameter-list) {
[statements;]
}
The return type specifies the type of data or class that is returned when the method is run. The void return type is used when no value is returned. When naming the method, you must follow the same rules for naming classes and variables described earlier in the chapter. You must always enclose the parameter list in parentheses even if the parentheses are empty. The parameter list contains the types and variable names of all variables that you want to pass to the method. The statements are the code of your method.
You use overloaded methods in your code when you need to call a method with different sets of parameter lists. Methods that allow flexibility in the parameters they use can be called from different parts of your program with different variables. Java's API classes, discussed in Chapter 3, use overloaded methods. To allow a different type of parameter information to be passed to your method, repeat the method in your code with the alternate parameter list included, as follows:
returnvalue methodname (parameter list 1)
returnvalue methodname (parameter list 2)
When the method is called and parameters are passed to it, Java determines which version of the method has a parameter list that most closely matches the parameters passed and executes it.
Static methods and variables are similar to the methods and variables already discussed, but they are a part of the class and do not require you to create an object to use them. Static variables are common to all instances created from the class they are stored in. When the value of a static variable in a class is changed, it is likewise changed for all instances of the class.
You might want to use static methods to provide utilities for the rest of your application. Statics can also be used with initializers to create constant data that is used by all instances of the class. All static statements-whether they are variables, methods, or initializers-are preceded by the word static.
Constructors are methods that you use when you create objects. They take the function of initializers a step further. They have the same name as the class and return no value. A default constructor is automatically created by the Java compiler if you don't specify one in your code. It is called when an object is created without parameters. Constructors, like methods, can be overloaded.
After you have a class that has variables and methods stored, you can create objects from it. You can think of an object as an area of memory that is allocated for an object's instance variables. To create the object and automatically allocate memory for it, always use the operator new. This new operator creates the object of the type specified and calls the constructor that is appropriate for the parameters passed in the parameter list. A reference is then made by Java to the new object. The form of an object creation is generally as follows:
classname reference-variable;
reference-variable = new classname (parameter-list)
The first line declares a variable that holds the reference to the object (references are explained in the next section). The second line creates a new object and assigns the variable to it. If parameters are passed, the appropriate constructor is called. If no parameters are passed, the object's default constructor is called.
References, which are created when objects are created, can be used to access variables and methods in other objects. References are used by other methods from other objects in the following form:
reference-variable.instance-variable
reference-variable.instance-method
Variables and methods stored in other objects are called by using the reference variable followed by a dot and the name of the foreign variable or method.
You use the reference value in comparisons. The operators used in references are ==, !=, and instanceof. The == and != operators can be used to tell whether two references refer to the same object or whether a reference does not refer to any object (such a case would return a null value). The instanceof operator is used to determine whether an object was created from a certain class or one of its subclasses. If a statement comparing an object to a class using instanceof returns true, that object is in fact an instance of the specified class.
If you are a C programmer, note that pointers are replaced by references in Java. This is explained in greater detail later in the book.
When a subclass is defined, it must indicate the superclass it is being created from. This is done with the extends modifier. The form of a subclass declaration is this:
class subclassname extends superclassname {
//new instructions
}
If a subclass uses a method from a superclass but adds functionality to it, it overrides the method. In Java, you do not need to duplicate the code in the other class. Just refer to the original method in the superclass with super.
Every class has the following three special variables: null, this, and super.
The null variable has a reference that points to nothing. You may use this reference to assign no value to a variable's identifier. null variables are empty containers that represent the absence of an object. To create an empty container, the following form is used:
datatype variablename = null;
The this variable has a reference to the actual object. A class can refer to itself using this. To refer to itself, a class uses the following form:
methodname(this);
The super variable has a reference to the superclass type of the class. You might wish to reference the superclass type when creating objects. Just precede your variables with the word super:
super (x,y)
Encapsulation is used to hide methods and variables in your classes from being accessed from foreign methods. To encapsulate variables and methods in your classes, precede their declarations with the keyword private. Private variables and methods can be seen only within a class. Subclasses or external methods cannot see them.
The private modifier is one of three types of access modifiers that control the way foreign methods see your variables, methods, and classes. The others are public and protected.
Any foreign methods are able to access variables and methods preceded by the word public. There can be only one public class per source file. This class must have the same name as the source file. Applets, which are explained in detail in a later chapter, must contain at least one public class that is a subclass of the Java.Applet package.
Protected variables and methods can be used only within a class or its subclasses. Foreign methods cannot access protected variables and methods.
Interfaces in Java are unlike interfaces in any other language. They provide a second form of inheritance. Because Java does not allow you to inherit from more than one superclass, Java lets you implement interfaces, which provides you with the functionality that inheritance from multiple superclasses would. Using interfaces, your object can use methods and variables from classes that are outside of its class hierarchy.
Interfaces are structured as entirely abstract classes with variables that are static and final and contain methods without code to implement them. Interfaces can inherit from an unlimited number of other interfaces. They are structured the same way in which classes are structured, except with the keyword interface instead of class:
interface interfacename [extends interfacename] {
[variable declaration;]
[method declaration;]
}
Interfaces are implemented by classes and can extend other interfaces. Classes that implement interfaces include the code for the methods of interfaces. These classes can implement more than one interface.
Interfaces can be used to conjoin several unrelated classes and have them respond to the same methods. For example, using interfaces, several shape classes such as rectangle, triangle, and circle can respond to a method called MoveLeft(), which would repaint the shape a certain distance to the left of the original location. In such a case, MoveLeft() would be declared in the interface, but its code would be stored in the class that implements the interface.
Java provides you with several libraries of classes which are called packages. You can use any of the classes in these packages by importing them into your application. Additionally, you may wish to package related classes you create so they can be reused in other applications. Packages are presented in detail in Chapter 3.
Now that you have a basic understanding of creating and working with classes, objects, and interfaces, you should be ready for Chapter 2, "Getting Started," that introduces you to the Java development environment. Before proceeding to Chapter 2, read through this section; it explains the differences between Java and C++. It is important that you understand what Java has changed and the reasons for these changes.
Java functionality differs from that of C and C++ in many ways. As I discussed earlier in this chapter, these changes are intended to create an object-oriented language that eliminates many of the opportunities for bugs and memory leaks that are common in C and C++. If you have experience in C or C++ programming, some of Java's changes may take some getting used to. The following list touches on the most important of these changes:
This concludes the introduction to the Java language. As you read through the rest of this book, you may need to refer to some sections in this chapter to be sure you understand the basic elements of Java that have been outlined for you. In the next chapter, you'll learn about Java's packages in detail, as well as more complex programming elements that these packages make easier.