INTRODUCTION TO JAVA

The Java Programming language was first developed in 1990 by an engineer at Sun Microsystems named James Gosling.

He was unhappy with the C++ programming language so he created a new language that he called “Oak” after the Oak tree that he could see from his office window.

As the popularity of the World Wide Web grew, Sun recognized that Gosling’s language could be developed to run applications on a web page.

The language was renamed “Java” simply because the name sounded good and was made freely available by Sun in 1995.

Developers around the world quickly adopted this exciting new language, and because of its modular design, began to create new features that could be added to the core language.

Many of these additional features were incorporated into Java when it was updated in 1998 and renamed “Java 2”.

Subsequent updates have enhanced some multimedia features and added support for the Linux operating system.

The essence of Java is a library of files called “classes” that each contain small pieces of ready-made proven code.

Any of these classes can be added into a new program, like bricks in a wall, so that a relatively small amount of new code ever needs to be written. This saves the programmer a vast amount of time and largely explains the huge popularity of Java programming.

Also this modular arrangement makes it much easier to identify any errors than would a large single large program.

JAVA FEATURES

ExpressivityA language L is as expressive as another language M if and only if any expression in L can be translated into an expression with the same meaning in M.

PortabilityThis is the ability to reuse a whole application from one environment to another without any changes at all or simply by making small changes in absolute sense. This portability is of both source code and compiled byte-code. E.g The same .class file can be run anywhere. Write One Run Anywhere (WORA).

Portability leaves open the option to upgrade hardware, or to jump ship to some other operating system if your current vendor misbehaves. It makes it easier to upgrade to

1

future versions of the current operating system. It leaves open the option to reuse or sell your software to some other user with different hardware or operating system.

ModularityA problem is decomposed into smaller and smaller sub-problems until each sub-problem represents one logical task. Each logical task is implemented by a different module (known as a method in Java), or a class

Cohesion and CouplingCoupling is the strength of interaction between objects in system. It measures the interdependence among modules.Cohesion is the degree to which the tasks performed by a single module are functionally related. It measures the logical relationship among the items that comprise an object.

GeneralizationA generalization is a taxonomic relationship between a more general element and a more specific element. The more specific element is fully consistent with the more general element (it has all of its properties, members, and relationships) and may contain additional information.

Object-Oriented ProgrammingTo learn about OOP, you need to understand three main concepts that are the backbone of OOP. These concepts, which are covered in the following sections, are: encapsulation, inheritance, and polymorphism.

EncapsulationEncapsulation enables you to hide, inside the object, both the data fields and the methods that act on that data. (In fact, data fields and methods are the two main elements of an object in the Java programming language.) After you do this, you can control access to the data, forcing programs to retrieve or modify data only through the object's interface. In strict object-oriented design, an object's data is always private to the object. Other parts of a program should never have direct access to that data.

InheritanceInheritance enables you to create a class that is similar to a previously defined class, but one that still has some of its own properties. Consider a car-simulation program. Suppose that you have a class for a regular car, but now you want to create a car that has a high-speed passing gear. To use the object-oriented approach: Create a new class by inheritance. This new class inherits all the data and methods from the tested base class. (You can control the level of inheritance with the public, private, and protected keywords.

PolymorphismThe last major feature of object-oriented programming is polymorphism. By using polymorphism, you can create new objects that perform the same functions as the base object but which perform one or more of these functions in a different way . For example, you may have a shape object that draws a circle on the screen. By using

2

polymorphism, you can create a shape object that draws a rectangle instead. You do this by creating a new version of the method that draws the shape on the screen. Both the old circle-drawing and the new rectangle-drawing method have the same name (such as DrawShape()) but accomplish the drawing in a different way.

Classes as Data TypesAn object is just an instance of a data type. For example, when you declare a variable of type int, you're creating an instance of the int data type. A class is like a data type in that it is the blueprint upon which an object is based. When you need a new object in a program, you create a class, which is a kind of template for the object. Then, in your program, you create an instance of the class. This instance is called an object.

Classes are really nothing more than user-defined data types. As with any data type, you can have as many instances of the class as you want. For example, you can have more than one window in a Windows application, each with its own contents.

For example, think again about the integer data type (int). It's absurd to think that a program can have only one integer. You can declare many integers, just about all you want. The same is true of classes. After you define a new class, you can create many instances of the class. Each instance (called an object) normally has full access to the class's methods and gets its own copy of the data members.

FIRST JAVA PROGAMAll Java programs start as text files that are later used to create “class” files which are actual runnable programs.

This means that Java programs can be written in any simple text editor such as Windows Notepad application.

The Java code that is entered below will generate the output “Welcome to Java”

public class Welcome{ public static void main(String[ ] args) { System.out.println(“Welcome to Java”);

}}

Programs are Java classes and the first line of this code defines the name of this program as “Welcome”.

It is important to note that Java is a case sensitive language where “Welcome” and “welcome” are two different programs.

3

Java programs files are saved with their exact program name, matching character case, and with the extension “.java”.

So the above program is saved as a file named “Welcome.java”.

The Welcome program analysedThe above program can be broken down in three different parts to understand it more clearly.

The Program Containerpublic class Welcome{ }

The program name is declared following the “public class” keywords and followed by a pair of curly brackets.

All of the program code that defines the Welcome class will be contained within these curly brackets.

The Main method

public static void main(String[ ] args)This line is used to define the starting point of nearly all Java programs. This code is used almost throughout all programs, so it may be usefully memorized.

The code declares a method named “main” that will contain the actual program instructions within its curly brackets.

Keywords “public static void” prefix the method name to define how it may be used and will be explained later.

The code “String[] args) is useful when passing values to the method and is also explained later.

The StatementSystem.out.println(“Welcome”);Statements are actual instructions to perform program tasks and must always end with a semi colon.

A method may contain many statements inside its curly brackets to form a statement “block” but here a single statement instructs the program to output a line of text.

Compiling the Welcome programBefore a java program can run, it must first be compiled into a “class” file by the Java compiler that is located in the Java directory bin folder and is an application named “javac.exe”

4

At a command prompt, type javac then hit the <ENTER> key in order to reveal the javac compiler options.

To compile a program at a command prompt type javac followed by a space then the path and file name of the file to be compiled, for instance:

javac c:\MyJava\Welcome.java

Alternatively, change the prompt location to the directory containing the source file. Then type javac followed by a space then the full name of the file to compile, for instance:

javac Welcome.java

If the compiler finds errors in the code it will halt and display a helpful error report indicating the nature of the error.

Typically errors are due to incorrect source code syntax or where the compiler cannot find the source file, due to an incorrectly entered file name or path.

If the compiler does not find errors it will create a new file with the program name and with the file extension “.class”.

Running the Welcome ProgramWhen the Java compiler completes compilation of a program source file program focus returns a standard command prompt without confirming that the compilation was successful.

Now the actual program can finally be run.

The SDK tool used to run Java programs is an application called “java.exe” located in the Java directory bin folder.

At a command prompt simply type java then press the <ENTER> key in order to reveal the java interpreter options.

To run a program at a command prompt type java followed by a space then the path and file name of the program for instance:

javac c:\MyJava\Welcome

Alternatively, change the prompt location to the directory containing the class file. Then type java followed by a space then the program name only.

java Welcome

When a program runs, the Java interpreter reads the program class file and executes its instructions. In this case the statement contained in the program’s main method will output the line of text “Welcome to Java”.

5

After the program has completed executing the program instructions, focus returns to standard command prompt.

Integrated Development Developments (IDE)The continual switching between text editor and command line when creating Java programs can become tedious.

An integrated development environment is a piece of software that makes the process more convenient.

There are many IDEs available for Java but all provide a built-in text editor, in which to write the code and a graphical means to compile and run the code. This not only makes life more pleasant but speeds development time and avoids the use of command lines.

Most IDE editors offer syntax highlighting that will apply different colours to each piece of the program code to denote its relevance. For instance all keywords that are recognized as part of the Java language might be bright red.

Another benefit offered by IDEs is an integrated debugger that can help to find any errors in the program code.

Several Java IDEs are visual development tools that can very quickly build a program interface by allowing components to be dragged into a base window. The IDE environment will then automatically generate the appropriate code to add that component to the program.

Popular Java Visual IDEs include: Jbuilder Visual Café JCreator

JPadPro is an example of a non-visual IDE application.

Comments and BackSlashIt is useful and good practice when writing Java code to add comments that describe what each piece of code is doing.

This makes the code easier to understand when it is revisited after several months or when it is viewed by someone else.

The Java compiler sees any text between the // and end of that line as a single –line comment which it ignores. Also any text, on one or more lines, between /* and */ is also ignored.

Spaces, tabs and new lines in the code are collectively known as “whitespace”. This too is ignored by the compiler so code may be formatted and indented to make it more readable.

6

The backslash character has a special meaning in strings. Inside quoted text strings \n will force a line-break in the output and \t will add a tab spacing to the output. It is also useful as \” will allow quotation marks to be used inside strings without prematurely terminating the string.

These features are added to the Welcome program./* A First Java program – with added features*/public class Welcome{ public static void main(String[ ] args) { // Add a new line, a tab and quotation marks

System.out.println(“Welcome to Java”);

}}

Classes and Objects

ClassesThe most important thing about a class is that it defines a new data type. Once defined, this new type can be used to create objects of that type.Classes are made up of many different parts, such as methods and variables. The class is a template for information about a group of things, even though the individual things may be somewhat different. A superclass is the top-level class of every application. In Java, it is automatically the Object class. This means that if a class does not implicitly declare its superclass, or next higher class level, then it is a subclass of Object. Subclasses extend the superclass and create a new variation of the class. They inherit the characteristics of the preceding class. Defining a ClassSince a class is sort of a template for an object, it is equivalent to a data type such as int. The main difference is that Java already knows what an integer is. However, when you create a class, you must tell Java about the class's characteristics. You define a class by using the class keyword along with the class name, like this:

class MyClass{

}

The name associated with a class has the same restrictions that variable names do; that is, they can be named anything as long as they begin with an alphabetic character, a dollar sign, or an underscore. By convention, however, a class name should begin with a capital letter. This makes the class easily distinguishable from methods, variables, and so on. Java itself follows this convention; it is highly recommended.

7

Class Modifiers alter certain aspects of classes. They are specified in the declaration of a class before the class name. Class modifiers are used to specify two aspects of classes: access and type. Access modifiers are used to regulate internal and external use of classes. Type modifiers declare the implementation of a class. A class can be used as either a template for subclasses or a class in and of itself.

A Public class can be accessed outside their package by using the public statement in the class declaration. If no explicit statement is made at declaration time, the class may be accessed only from within its own package. A compile error is generated if any other security modifier is used in the declaration, such as private or protected, which are reserved for methods.

For example,

public class classname {    //able to be accessed outside of                            //own package}class classname {           //only able to be accessed within                            //own package}

Class Variables and Instance VariablesClass Variables and Instance Variables are declared outside a method definition. Customarily, they are defined just after the first line of the class definition. Class variables are variables that are defined and stored in the class itself. Their values, therefore, apply to the class and to all its instances.

With instance variables, each new instance of the class gets a new copy of the instance variables that class defines. Each instance can then change the values of those instance variables without affecting any other instances. With class variables, there is only one copy of that variable. Every instance of the class has access to that variable, but there is only one value. Changing the value of that variable changes it for all the instances of that class. You define class variables by including the static keyword before the variable itself. For example, take the following partial class definition:

class FamilyMember { static String surname = "Johnson"; String name; int age; ...}

Instances of the class FamilyMember each have their own values for name and age. But the class variable surname has only one value for all family members. Change surname, and all the instances of FamilyMember are affected.

Access Modifiers

8

You can change the rules of access by using the public, protected, and private keywords. A public variable can be accessed by any part of a program, inside or outside of the class in which it's defined. A protected variable can only be accessed from within the class or from within a derived class (a subclass). A private variable cannot even be accessed by a derived class.

Class Methods

A method definition has four basic parts: The name of the method The type of object or primitive type the method returns A list of parameters The body of the method

The method's signature is a combination of the name of the method, the type of object or base type this method returns, and a list of parameters.Here's what a basic method definition looks like:

Modifier returntype methodname(type1 arg1, type2 arg2, type3 arg3..) { ...}

Return TypesThe returntype is the primitive type or class of the value this method returns. It can be one of the primitive types, a class name, or void if the method does not return a value at all. The return type immediately precedes the variable name of a method. The following code declares a method named isBlack to return a variable with type boolean:

boolean isBlack (Color color) {   if (color == black)     return (true);   else     return (false);}

The method body tests whether the color passed is black. If it is, the method uses the return keyword to specify that value to return to the calling method is boolean true. Otherwise, it will use return to return the boolean false.

NB: return keyword is used if a method returns any value.void is a special return type in Java that indicates that there is no return type of any kind. This is used for methods that have no need to return anything to the calling program, or that modify only method arguments or global variables.Note that if this method returns an array object, the array brackets can go either after the return type or after the parameter list; because the former way is considerably easier to read.

int[] makeRange(int lower, int upper) {...}

9

The method's parameter list is a set of variable declarations, separated by commas, inside parentheses. These parameters become local variables in the body of the method, whose values are the objects or values of primitives passed in when the method is called. Inside the body of the method you can have statements, expressions, method calls to other objects, conditionals, loops, and so on.

Method ModifiersThe concept of modifiers presented with classes also can be applied to methods. Method modifiers control access to a method. Modifiers also are used to declare a method's type. However, methods have more modifiers available than do classes. In Java terms, accessibility is security. The five levels of access follow:

Access modifiersLevel Allowable Access

public All other classesprivate No other classesprotected Subclasses or same packageprivate protected Subclasses only<default> Same package

publicThis modifier allows a method to be called by any class inside or outside the package.

privateThe private modifier specifies that no classes, including subclasses, can call this method. This can be used to completely hide a method from all other classes. If no other classes can access the method, it can be changed as needed without causing problems. Here is an example of a method declared private:

private void isBlack (Color color) {    ....}

protectedThe protected modifier specifies that only the class in which the method is defined or subclasses of that class can call the method. This allows access for objects that are part of the same application, but not other applications. Here is an example:

protected void isBlack (Color color) {   ....}

private protectedThe private protected modifier is a special combination of private and protected access modifiers. This modifier specifies that only the class in which the method is defined or subclasses of the class can call the method. It does not allow package access as protected does but also allows subclasses as private does not. Here is an example:

private protected void isBlack (Color color) {   .....}

10

defaultThe method defaults to an access control in which the class itself, subclasses, and classes in the same package can call the method. In this case, no access type is explicit in the method-declaration statement. Here is an example:

void isBlack (Color color) {   ....}

staticThe static modifier is associated only with methods and variables, not classes. The static modifier is used to specify a method that can only be declared once. No subclasses are allowed to implement a method of the same name. This is used for methods, such as main, that are entry points into a program. The operating system would not know which method to call first if there were two main methods. Static methods are used to specify methods that should not be overridden in subclasses. Here's an example:

static void isBlack (Color color) {   ....}

finalThe final modifier indicates that an object is fixed and cannot be changed. When you use this modifier with a class-level object, it means that the class can never have subclasses. When you apply this modifier to a method, the method can never be overridden. When you apply this modifier to a variable, the value of the variable remains constant. You will get a compile-time error if you try to override a final method or class. You will also get a compile-time error if you try to change the value of a final variable. Here is how you can use the final modifier:

class neverChanging {      final int unchangingValue = 21; // a final variable

   // a final method   final int unchangingMethod(int a, int b) {   }}

abstractThe abstract modifier is used to create template methods. Abstract methods define return type, name, and arguments but do not include any method body. Subclasses are then required to implement the abstract method and supply a body. Here is an example of an abstract class:

abstract void isBlack (Color color) { }

This defines a template for a method named isBlack. Notice that no body of isBlack is specified; that is left to subclasses of the class in which the abstract method is declared. The subclasses must implement a body for method isBlack, or they will cause a compile-time error.

Working with ObjectsData space is not pre-allocated in Java. Instead, it is created as needed. Space is used for as long as something is accessing the data, and then memory is automatically deallocated. In Java, an automatic garbage-collection system finds any memory that is not in use and

11

automatically frees it. This is a huge bonus for the programmer because "memory leaks" are a source of considerable problems in standard languages.

Creating an Instancenew creates an object of virtually any type, the exceptions being primitive data types. A variable is then assigned that points to that object. An example of this follows:

String desc;desc = new String(10);

This allocates enough space in memory for a 10-character string and associates it with the variable desc. desc is now considered an object of type String and has all the methods associated with class String. String methods include methods to determine length, compare with other strings, obtain substrings, and many others. In Java, the object associated with the variable desc already has all the methods built into it. This is a result of the methods associated with type String. These methods became a part of object desc when it was created with new, as in the following example:

sizeOfString = desc.length                 //gets the size of descif (desc.compareTo("black")       //tests to see if desc is equal to "black"locOfSubString = desc.indexOf("black");    // returns index to substring

These examples focus on the object, not the functions; thus the name object-oriented programming.

Getting Values To get to the value of an instance variable, you use dot notation. With dot notation, an instance or class variable name has two parts: the object on the left side of the dot, and the variable on the right side of the dot. For example, if you have an object assigned to the variable myObject, and that object has a variable called var, you refer to that variable's value like this:

myObject.var;

This form for accessing variables is an expression (it returns a value), and both sides of the dot are also expressions. This means that you can nest instance variable access. If that var instance variable itself holds an object, and that object has its own instance variable called state, you can refer to it like this:

myObject.var.state;

Dot expressions are evaluated left to right, so you start with myObject's variable var, which points to another object with the variable state. You end up with the value of that state variable. Changing Values Assigning a value to that variable is equally easy—just tack an assignment operator on the right side of the expression:

myObject.var.state = true;

Calling methods

12

Calling a method in objects is similar to referring to its instance variables: method calls also use dot notation. The object whose method you're calling is on the left side of the dot; the name of the method and its arguments is on the right side of the dot:

myObject.methodOne(arg1, arg2, arg3);

Note that all methods must have parentheses after them, even if that method takes no arguments:

myObject.methodNoArgs();

If the method you've called results in an object that itself has methods, you can nest methods as you would variables:

myObject.getClass().getName();

You can combine nested method calls and instance variable references as well: myObject.var.methodTwo(arg1, arg2);

System.out.println(), the method you've been using all through the book this far, is a great example of nesting variables and methods. The System class (part of the java.lang package) describes system-specific behavior. System.out is a class variable that contains an instance of the class PrintStream that points to the standard output of the system. PrintStream instances have a println() method that prints a string to that output stream.

13

Class ExampleThe following class defines three variables and one method called volume:

class Box{double width;double height;double depth;

//volume methodpublic void volume(){System.out.println("Volume is " + width*height*depth);}}

To use the above class, we must create an object of its type. The following class does that and then uses the class variables and the method defined in the class.

class BoxDemo{public static void main(String[] args){

Box myBox=new Box();//assign valuesmyBox.width=10; //call the variablesmyBox.height=20;myBox.depth=15;//display volumemyBox.volume(); //call the method

}}

The class could also be written using a method that returns a double value, as followsclass Box{double width;double height;double depth;

//volume methodpublic double volume(){

return width*height*depth;}}

NB: the calling of the method volume changes. It is assigned to a variablebecause it returns a value. This is shown in the following class:

class BoxDemo{ public static void main(String[] args){

Box myBox=new Box(); double vol;//assign valuesmyBox.width=10;myBox.height=20;

14

myBox.depth=15;//display volumevol = myBox.volume();System.out.println("Volume is "+ vol);

}}

Methods with parametersA method defined with a list of parameters is also called using the same list of values (arguments). Parameters in a method definition are called formal parameters or dummy parameters. The parameters that are passed to a method when it is called (used) are called actual parameters. When a method is called, the actual parameters in the method call statement are evaluated and the values are assigned to the formal parameters in the method's definition

For example, the following application defines a class with a method called square which has one parameter.

class SquareDemo{ double square(double i){ return i*i;}}

class Calculate{public static void main(String[] args){

SquareDemo obj=new SquareDemo(); System.out.println(obj.square(2.0))}

}

Overloading MethodsThis is defining a method with the same name, but with different and unique parameter lists. Java selects which method of the same name to call on the basis of the calling parameters. With Java you can overload any method in the current class or any superclass unless the method is declared static. For example, in the following code, method test has been overloaded four times:

class Overload {  void test() {    System.out.println(“No parameters”);    }

   void test(int a) {    System.out.println(“a: ”+a);    }

   void test(int a, int b) {    System.out.println(“a and b : ”+a + “ ” + b);    }

15

 double test(double a) {    System.out.println(“double a: ”+a); return a*a;    }}

Class OverloadDemo{Public class static void main(String[] args){ Overload ob=new Overload(); double result;

//call all versions of testob.test;ob.test(10);ob.test(10,20);result=ob.test(123.2);System.out.println(“Result of ob.tes(123.2): ”+result);

}}

Creating SubclassesTo create a subclass of another class, use extends to indicate the superclass of this class:

class myClassName extends mySuperClassName {...}

Overriding Methods When you call a method on an object, Java looks for that method definition in the class of that object, and if it doesn't find one, it passes the method call up the class hierarchy until a method definition is found. Method inheritance enables you to define and use methods repeatedly in subclasses without having to duplicate the code itself.

However, there may be times when you want an object to respond to the same methods but have different behavior when that method is called. In this case, you can override that method. Overriding a method involves defining a method in a subclass that has the same signature as a method in a superclass. Then, when that method is called, the method in the subclass is found and executed instead of the one in the superclass.

To override a method, all you have to do is create a method in your subclass that has the same signature (name, return type, and parameter list) as a method defined by one of your class's superclasses. Because Java executes the first method definition it finds that matches the signature, this effectively "hides" the original method definition. The following code shows a simple class with a method called printMe(), which prints out the name of the class and the values of its instance variables.

16

//Method overridingClass MySuper{ void test() { System.out.println(“Superclass test method”); }}

Class MySub extends MySuper{void test(){ System.out.println(“Subclass test method”); }}

The following class can call either the superclass or the subclass methods

Class OverrideDemo{public class static void main(String[] args){ MySuper supObj=new MySuper(); MySub subObj=new MySub(); supObj.test(); subObj.test();

}}

The super keywordsuper is a reference to the superclass. It is often used as a shortcut or explicit way to reference a member in the superclass of the current class. In the following code, a subclass named MySub uses the super keyword to reference the method test in the superclass MySuper:

//Method overridingClass MySuper{ void test(){ System.out.println(“Superclass test method”); }}

Class MySub extends MySuper{void test(){ System.out.println(“Subclass test method”);

17

Super.test(); //this calls the superclass’ test method }}

Abstract Classes and Methods

An abstract class defines a superclass that the structure of a given abstraction without providing the complete implementation of every method. The abstract modifier is used to create template classes. An abstract class can contain such things as variable declarations and methods but cannot contain code for creating new instances, that is, it cannot be instantiated.

An abstract class can contain both concrete and abstract methods. Abstract methods do not include any method body. Subclasses are then required to implement those abstract methods in which they supply a body. The following is an example:

//A simple abstract classabstract class MySuper{ //abstract method abstract void callme(); //concrete method Void callmetoo() { System.out.println(“Concrete method”);}}

class MySub extends MySuper{ void callme(){ System.out.println(“Subclass implementation of call me”);}}

class AbstractDemo{ public class static void main(String[] args) { MySuper superObj = new MySuper(); superObj.callme(); superObj.callmetoo(); System.out.println(“Subclass implementation of call me”);}}

18

VARIABLES AND DATA TYPES, ARRAYS AND DATA OPERATORS

VariablesVariables are locations in memory in which values can be stored. They have a name, a type, and a value. Before you can use a variable, you have to declare it. After it is declared, you can then assign values to it.

Java actually has three kinds of variables: instance variables, class variables, and local variables.

Instance variables are used to define attributes or the state for a particular object.

Class variables are similar to instance variables, except their values apply to all that class’s instances (and to the class itself) rather than having different values for each object.

Local variables are declared and used inside method definitions, for example, for index counters in loops, as temporary variables, or to hold values that you need only inside the method definition itself. They can also be used inside blocks ({ }). Once the method (or block) finishes executing, the variable definition and its value cease to exist.

Use local variables to store information needed by a single method and instance variables to store information needed by multiple methods in the object.

Although all three kinds of variables are declared in much the same ways, class and instance variables are accessed and assigned in slightly different ways from local variables. Note: Unlike other languages, Java does not have global variables—that is, variables that are global to all parts of a program. Instance and class variables can be used to communicate global information between and among objects.

Declaring VariablesTo use any variable in a Java program, you must first declare it. Variable declarations consist of a type and a variable name, examples:

int myAge;String myName;boolean isTired;

Variable definitions can go anywhere in a method definition (that is, anywhere a regular Java statement can go), although they are most commonly declared at the beginning of the definition before they are used:

public static void main (String args[]) {int count;String title;

19

boolean isAsleep;...}

You can string together variable names with the same type:

int x, y, z;String firstName, LastName;

You can also give each variable an initial value when you declare it:

int myAge, mySize, numShoes = 28;String myName = “Laura”;boolean isTired = true;int a = 4, b = 5, c = 6;

If there are multiple variables on the same line with only one initializer (as in the first of the previous examples), the initial value applies to only the last variable in a declaration. You can also group individual variables and initializers on the same line using commas, as with the last example, above.

Local variables must be given values before they can be used (your Java program will not compile if you try to use an unassigned local variable). For this reason, it’s a good idea always to give local variables initial values. Instance and class variable definitions do not have this restriction (their initial value depends on the type of the variable: null for instances of classes, 0 for numeric variables, ‘\0’ for characters, and false for booleans).

Notes on Variable Names Variable names in Java can start with a letter, an underscore (_), or a dollar sign ($).

They cannot start with a number. After the first character, your variable names can include any letter or number.

Symbols, such as %, *, @, and so on, are often reserved for operators in Java, so be careful when using symbols in variable names.

By convention, Java variables have meaningful names, often made up of several words combined. The first word is lowercase, but all following words have an initial uppercase letter:

Button theButton;long reallyBigNumber;boolean currentWeatherStateOfPlanetXShortVersion;

Variable TypesIn addition to the variable name, each variable declaration must have a type, which defines what values that variable can hold. The variable type can be one of three things:

1. One of the eight basic primitive data types2. The name of a class3. An array

20

The eight primitive data types handle common types for integers, floating-point numbers, characters, and boolean values (true or false). They’re called primitive because they’re built into the system and are not actual objects, which makes them more efficient to use. Note that these data types are machine-independent, which means that you can rely on their sizes and characteristics to be consistent across your Java programs.

Integer typesThere are four integer types each with different ranges of values (as listed in the following table). All are signed, which means they can hold either positive or negative numbers. Which type you choose for your variables depends on the range of values you expect that variable to hold; if a value becomes too big for the variable type, it is truncated.3

Type Size Rangebyte 8 bits –128 to 127Short 16 bits –-32,768 to 32,767int 32 bits –2,147,483,648 to 2,147,483,647long 64 bits –9223372036854775808 to 9223372036854775807

Floating types Floating-point numbers are used for numbers with a decimal part. There are two floating-point types: float (32 bits, single-precision) and double (64 bits, double-precision).

Char typeThe char type is used for individual characters. Because Java uses the Unicode character set, the char type has 16 bits of precision, unsigned.

Boolean typeFinally, the boolean type can have one of two values, true or false. All tests of boolean variables should test for true or false.

In addition to the eight basic data types, variables in Java can also be declared to hold an instance of a particular class:

String LastName;Font basicFont;OvalShape myOval;

Each of these variables can then hold only instances of the given class. As you create new classes, you can declare variables to hold instances of those classes (and their subclasses) as well.

Assigning Values to VariablesOnce a variable has been declared, you can assign a value to that variable by using the assignment operator =:

size = 14;tooMuchCaffiene = true;

21

LiteralsLiterals are used to indicate simple values in your Java programs. Literal is a programming language term, which essentially means that what you type is what you get. For example, if you type 4 in a Java program, you automatically get an integer with the value 4. If you type ‘a’, you get a character with the value a.Literals may seem intuitive most of the time, but there are some special cases of literals in Java for different kinds of numbers, characters, strings, and boolean values.

Number LiteralsThere are several integer literals. 4, for example, is a decimal integer literal of type int (although you can assign it to a variable of type byte or short because it’s small enough to fit into those types).

A decimal integer literal larger than an int is automatically of type long. You also can force a smaller number to a long by appending an L or l to that number (for example, 4L is a long integer of value 4).

Negative integers are preceded by a minus sign—for example, -45. Integers can also be expressed as octal or hexadecimal: a leading 0 indicates that a

number is octal—for example, 0777 or 0004. A leading 0x (or 0X) means that it is in hex (0xFF, 0XAF45). Hexadecimal

numbers can contain regular digits (0–9) or upper- or lowercase hex digits (a–f or A–F).

Floating-point literals usually have two parts: the integer part and the decimal part—for example, 5.677777. Floating-point literals result in a floating-point number of type double, regardless of the precision of that number.

You can force the number to the type float by appending the letter f (or F) to that number—for example, 2.56F.

You can use exponents in floating-point literals using the letter e or E followed by the exponent (which can be a negative number): 10e45 or .36E-2.

Boolean LiteralsBoolean literals consist of the keywords true and false. These keywords can be used anywhere you need a test or as the only possible values for boolean variables.

Character LiteralsCharacter literals are expressed by a single character surrounded by single quotes: ’a’, ’#’, ’3’, and so on. Character variables can also be assigned integer values. The variable below (ch1) is assigned to integer 88 (equivalent of letter X):

Int ch1=88;This allows addition of two characters together.

Escape Sequences They allow nonprintable characters to be represented in the java programs. The table below shows the escape sequences:

Escape Meaning\n Newline\t Tab

22

\b Backspace\r Carriage return\f Formfeed\\ Backslash\’ Single quote\” Double quote\ddd Octal\xdd Hexadecimal\udddd Unicode character

If, for example, you want display a string output enclosed in double qotes, you would use the double quote escape sequences as shown below:

System.out.println(“\”Welcome to Java Programming\””);

String LiteralsA combination of characters is a string. Strings in Java are instances of the class String. Because string objects are real objects in Java, they have methods that enable you to combine, test, and modify strings very easily. String literals consist of a series of characters inside double quotes:

“Hi, I’m a string literal.”“” //an empty string

Strings can contain the escape sequences used by the character type such as newline, tab, etc as shown below:

“A string with a \t tab in it”“Nested strings are \”strings inside of\” other strings”“This string brought to you by Java\u2122”

In the last example, the Unicode code sequence for \u2122 produces a trademark symbol (™).Note: Just because you can represent a character using a Unicode escape does not mean your computer can display that character—the computer or operating system you are running may not support Unicode, or the font you’re using may not have a glyph (picture) for that character. All that Unicode escapes in Java provide is a way to encode special characters for systems that support Unicode.

When you use a string literal in your Java program, Java automatically creates an instance of the class String for you with the value you give it. Strings are unusual in this respect; the other literals do not behave in this way (none of the primitive base types are actual objects), and usually creating a new object involves explicitly creating a new instance of a class.

ConstantsVariables are marked as constants using the final keyword. For example,

final int monthsInYear=12;

23

The value 12 in monthsInYear cannot be changed.

Variable ScopesIf you declare a variable inside any method, the variable has a local scope. This means that it's visible only for the code within this method. When the method is finished, the variable automatically gets destroyed. If a variable has to be visible through more than one method in a class, you should declare it on a class level. These variables are "alive" when the class exists in memory. They could be shared and reused by all methods within the class and they can even be visible from external classes.

A block creates a new local scope. Local variables can be declared inside a block, and those variables will cease to exist after the block is finished executing. For example, here's a block inside a method definition that declares a new variable y. You cannot use y outside the block in which it's declared:

void testblock() { int x = 10; { // start of block int y = 50; System.out.println("inside the block:"); System.out.println("x:" + x); System.out.println("y:" + y); } // end of block y=30; //error occurs – y not known}

NB: A variable cannot be declared in an inner scope with a similar name as the outer scope.

Type conversionIt is possible to assign a value of one type to a variable of another type. For example it is possible to assign an int value to a long variable. There are two ways of type conversion:

1. Implicit conversionFor this conversion to be possible the two types must be compatible and the destination type must be larger than the source type. Numerical types are not compatible with char or boolean. Also char and boolean are nor compatible with each other. The following conversions are possible: byte to short, int, long, float or double short to int, long, float or double int to long, float or double long to float or double float to doubleThis is known as Widening Primitive conversion.

2. Type casting (explicit)

24

This conversion is done on incompatible types. For example, converting from int to byte is not automatic because byte is smaller than int. This is known as Narrowing conversion or type casting. The following example casts an int to a byte.

int a;byte b;b=(byte)a;

NB: 1. If an integer number is greater than the range of the destination type, it is

converted to a modulo (remainder after division).2. Floating point numbers when assigned to integers are truncated (fraction lost)

Automatic type promotionIn an expression, an immediate value may exceed the range of either operand. For example:

byte a=40, b=50, c=100;int d=a*b*c;

Java automatically promotes each byte or short operand to int when evaluating an expression. However, automatic promotion can cause confusion to the compiler. For example:

byte b=30;b=b*2; //error

When b*2 is evaluated, it is promoted to int and cannot be assigned to byte b. Otherwise this can be written as:

b=(byte)(b*2);

NB: Java Promotion rules:All byte and short values are promoted to int. If one operand is a long, the whole expression is promoted to long. If one operand is float, the expression is promoted to float, and if one operand is double, the expression is converted to double.

Arrays Arrays in Java are different than they are in other languages. Arrays in Java are actual objects that can be passed around and treated just like other objects. Arrays are a way to store a list of items of the same type. Each slot of the array holds an individual element, and you can place elements into or change the contents or those slots as you need to.

Arrays can contain any type of element value (primitive types or objects). You can have an array of integers, or an array of strings, or an array of arrays, but you can't have an array that contains, for example, both strings and integers. To create an array in Java, you use three steps:

1. Declare a variable to hold the array. 2. Create a new array object and assign it to the array variable. 3. Store things in that array.

25

Declaring Array Variables Array variables indicate the type of object the array will hold (just as they do for any variable) and the name of the array, followed by empty brackets ([]). The following are all typical array variable declarations:

Int monthDays [];Point hits[];int temps[];

An alternate method of defining an array variable is to put the brackets after the type instead of after the variable. They are equivalent, but this latter form is often much more readable. So, for example, these three declarations could be written like this:

Int[]monthDays;Point[] hits;int[] temps;

Creating Array Objects The second step is to create an array object and assign it to that variable. There are two ways to do this:

Using new Directly initializing the contents of that array

Using new operatorThe first way is to use the new operator to create a new instance of an array:

int[] monthDays = new int[31];That line creates a new array of thirty one integers. When you create a new array object using new, you must indicate how many slots that array will hold.

When you create an array object using new, all its slots are initialized for you (0 for numeric arrays, false for boolean, '\0' for character arrays, and null for objects). You can also create and initialize an array at the same time.

Direct InitializationInstead of using new to create the new array object, enclose the elements of the array inside braces, separated by commas:

String[] chiles = { "jalapeno", "anaheim", "serrano", "habanero", "thai" };

Each of the elements inside the braces must be of the same type and must be the same type as the variable that holds that array. An array the size of the number of elements you've included will be automatically created for you. This example creates an array of String objects named chiles that contains five elements.

Accessing Array Elements Once you have an array with initial values, you can test and change the values in each slot of that array. To get at a value stored within an array, use the array subscript expression:

26

myArray[subscript];

The myArray part of this expression is a variable holding an array object. The subscript expression specifies the slot within the array to access. Array subscripts start with 0, as they do in C and C++. So, an array with ten elements has ten array slots accessed using subscript 0 to 9. Note that all array subscripts are checked to make sure that they are inside the boundaries of the array (greater than or equal to 0 but less than the array's length) either when your Java program is compiled or when it is run. It is impossible in Java to access or assign a value to an array slot outside of the boundaries of the array.

Changing Array Elements To assign an element value to a particular array slot, merely put an assignment statement after the array access expression:

myarray[1] = 15;sentence[0] = "The";sentence[10] = sentence[0];

Multidimensional Arrays Java does not support multidimensional arrays. However, you can declare and create an array of arrays (and those arrays can contain arrays, and so on, for however many dimensions you need), and access them as you would C-style multidimensional arrays:

int coords[][] = new int[12][12];coords[0][0] = 1;coords[0][1] = 2;

Expressions and OperatorsExpressions are the simplest form of statement in Java that actually accomplishes something. Expressions are statements that return a value. Operators are special symbols that are commonly used in expressions. Arithmetic and tests for equality and magnitude are common examples of expressions. Because they return a value, you can assign that result to a variable or test that value in other Java statements.Operators in Java include arithmetic, various forms of assignment, increment and decrement, and logical operations. Arithmetic OperatorsJava has five operators for basic arithmetic as shown in the following table:

Operator Meaning Example+ Addition 3 + 4– Subtraction 5 – 7* Multiplication 5 * 5/ Division 14 /7% Modulus 20 % 7++ Increment X++ or ++x+= Addition Assignment X+=1-= Subtraction Assignment X-=1

27

*= Multiplication Assignment X*=1/= Division Assignment X/=1%= Modulus Assignment X%=1-- Decrement X—or --x

Each operator takes two operands, one on either side of the operator. The operands cannot be Boolean type.

The subtraction operator (–) can also be used to negate a single operand.Integer division results in an integer. Because integers don’t have decimal fractions, any remainder is ignored. The expression 31/9, for example, results in 3 (9 goes into 31 only 3 times).

Modulus (%) gives the remainder once the operands have been evenly divided. For example, 31 % 9 results in 4 because 9 goes into 31 three times, with 4 left over.Note that, for integers, the result type of most operations is an int or a long, regardless of the original type of the operands. Large results are of type long; all others are int. Arithmetic operation where one operand is an integer and another is a floating point results in a floating-point result.

The Assignment operators are used to combine arithmetic operations with assignments. For example,

a = a +4; can be rewritten as, a += 4;

The increment operators can be used in both postfix and prefix notation. For example:

y=++x; is equivalent to the following two lines:x=x+1;y=x;

y=x++; is equivalent to the following two lines:y=x;x=x+1;

Comparisons (Relational)Java has several expressions for testing equality and magnitude. All of these expressions return a boolean value (that is, true or false). The following shows the comparison operators:

Operator Meaning Example== Equal to x == 3!= Not equal to x != 3< Less than x < 3

28

> Greater than x > 3<= Less than or equal to x <=3>= Greater than or equal to x >=3

Logical OperatorsExpressions that result in boolean values (for example, the comparison operators) can be combined by using logical operators that represent the logical combinations AND, OR, XOR, and logical NOT.

Operator Meaning& Logical AND| Logical OR^ Logical XOR(Exclusive OR)|| Short Circuit OR&& Short Circuit AND&= AND Assignment|= OR Assignment^= XOR Assignment== Equal to!= Not equal to?: Ternary if then else

For AND combinations, use either the & or &&. The expression will be true only if both operands tests are also true; if either expression is false, the entire expression is false. The difference between the two operators is in expression evaluation. Using &, both sides of the expression are evaluated regardless of the outcome. Using &&, if the left side of the expression is false, the entire expression returns false, and the right side of the expression is never evaluated.

For OR expressions, use either | or ||. OR expressions result in true if either or both of the operands is also true; if both operands are false, the expression is false. As with & and &&, the single | evaluates both sides of the expression regardless of the outcome; with ||, if the left expression is true, the expression returns true and the right side is never evaluated. In addition, there is the XOR operator ^, which returns true only if its operands are different (one true and one false, or vice versa) and false otherwise (even if both are true).

In general, only the && and || are commonly used as actual logical combinations. &, |, and ^ are more commonly used for bitwise logical operations.For NOT, use the ! operator with a single expression argument. The value of the NOT expression is the negation of the expression; if x is true, !x is false.

Bitwise OperatorsAll are inherited from C and C++ and are used to perform operations on individual bits in integers. The following is summarizes the bitwise operators.

29

Operator Meaning& Bitwise AND| Bitwise OR^ Bitwise XOR<< Left shift>> Right shift>>> Zero fill right shift~ Bitwise complement (NOT)<<= Left shift assignment (x = x << y)>>= Right shift assignment (x = x >> y)>>>= Zero fill right shift assignment (x = x >>> y)x&=y AND assignment (x = x & y)x|=y OR assignment (x + x | y)x^=y NOT assignment (x = x ^ y)

The following examples show the bitwise operations on numerical data:

Bitwise NOT(~):42 – 0010 1010 - 1101 0101

Bitwise OR(|):42 – 0010 101015 – 0000 111147 – 0010 1111

Bitwise AND(&):42 – 0010 101015 – 0000 111110 – 0000 1010

The following simple code in java is used to operate on bits using the above:

int a=42;int b=15;int c=a|b;System.out.println(c);

Operator PrecedenceOperator precedence determines the order in which expressions are evaluated. This, in some cases, can determine the overall value of the expression. For example, take the following expression:

y = 6 + 4 / 2

Depending on whether the 6 + 4 expression or the 4/2 expression is evaluated first, the value of y can end up being 5 or 8. In general, increment and decrement are evaluated before arithmetic, arithmetic expressions are evaluated before comparisons, and

30

comparisons are evaluated before logical expressions. Assignment expressions are evaluated last.

The following table shows the specific precedence of the various operators in Java. Operators further up in the table are evaluated first; operators on the same line have the same precedence and are evaluated left to right based on how they appear in the expression itself. For example, in the expression y = 6 + 4 /2, according to this table, that division is evaluated before addition, so the value of y will be 8.

Operator Notes. [] () Parentheses () group expressions; dot (.) is used for access to

methods and variables within objects and classes; [] is used for arrays++ –– ! ~ instanceof

Returns true or false based on whether the object is an instance of the named class or any of that class’s superclasses

new(type) expression

The new operator is used for creating new instances of classes; ()in this case is for casting a value to another type

* / % Multiplication, division, modulus+ – Addition, subtraction<< >> >>> Bitwise left and right shift< > <= >= Relational comparison tests== != Equality& AND^ XOR| OR&& Logical AND|| Logical OR? : Shorthand for if...then...else (discussed on Day 5)= += –= *= %= ^= &= |= <<= >>= >>>=

Various assignments

You can always change the order in which expressions are evaluated by using parentheses around the expressions you want to evaluate first. You can nest parentheses to make sure expressions evaluate in the order you want them to (the innermost parenthetical expression is evaluated first). The following expression results in a value of 5, because the 6 + 4 expression is evaluated first, and then the result of that expression (10) is divided by 2:

y = (6 + 4) / 2

Parentheses also can be useful in cases where the precedence of an expression isn’t immediately clear—in other words, they can make your code easier to read. Adding parentheses doesn’t hurt, so if they help you figure out how expressions are evaluated, go ahead and use them.

31

String Arithmetic One special expression in Java is the use of the addition operator (+) to create and concatenate strings. For example:

System.out.println(name + " is a " + color " beetle");

The output of that line (to the standard output) is a single string, with the values of the variables (here, name and color), inserted in the appropriate spots in the string. The + operator, when used with strings and other objects, creates a single string that contains the concatenation of all its operands. If any of the operands in string concatenation is not a string, it is automatically converted to a string, making it easy to create these sorts of output lines.

CONTROL FLOW STATEMENTSJava control statements include:

1. Selection statements2. Iteration statements (loops)3. Jump statements

Selection StatementsJava supports two selection statements namely if and switch.

if Conditionals The if conditional, which enables you to execute different paths based on a simple test. It has the following syntax:

If(condition) Statement1;else satement2;

For example:if (x < y) System.out.println("x is smaller than y");

The optional else keyword provides the statement to execute if the test is false:

if (x < y) System.out.println("x is smaller than y");else System.out.println("y is bigger");

if (engineState == true ) System.out.println("Engine is already on.");else { System.out.println("Now starting Engine.");

if (gasLevel >= 1)

engineState = true; else System.out.println("Low on gas! Can't start engine.");

32

}This example uses the test (engineState == true). For boolean tests of this type, a common shortcut is merely to include the first part of the expression, rather than explicitly testing its value against true or false:

if (engineState) System.out.println("Engine is on.");else System.out.println("Engine is off.");

Multiple statements are enclosed inside the braces{}. A nested if is an if statement inside another if statement.

An if-else if ladder is a common programming construct. The following is a simple example:

int n=2if(n=0) System.out.println(“n is zero”);else if(n=1) System.out.println(“n is one”);else if(n=0) System.out.println(“n is two”);else System.out.println(“n is not defined”);

Statements are executed top down. When one of the conditions is true, the statements(s) associated with it is executed and the rest of the ladder is bypassed. If none of the conditions is true, the final else statement is executed. If there is no else, no action will be taken when all conditions are false.

The Conditional Operator An alternative to using the if and else keywords in a conditional statement is to use the conditional operator, sometimes called the ternary operator. The conditional operator is a ternary operator because it has three terms. The conditional operator is an expression, meaning that it returns a value (unlike the more general if, which only can result in a statement or block being executed). The conditional operator is most useful for very short or simple conditionals, and looks like this:

test ? trueresult : falseresult

The test is an expression that returns true or false, just like the test in the if statement. If the test is true, the conditional operator returns the value of trueresult; if it's false, it returns the value of falseresult. For example, the following conditional tests the values of x and y, returns the smaller of the two, and assigns that value to the variable smaller:

int smaller = x < y ? x : y;

The conditional operator has a very low precedence; that is, it's usually evaluated only after all its subexpressions are evaluated. The only operators lower in precedence are the assignment operators.

33

switch Conditionals A common programming practice in any language is to test a variable against some value, and if it doesn't match that value, to test it again against a different value, and if it doesn't match that one to make yet another test, and so on. Using only if statements, this can become unwieldy, depending on how it's formatted and how many different options you have to test. For example, you might end up with a set of if statements something like this or longer:

if (oper == '+') addargs(arg1, arg2);else if (oper == '-') subargs(arg1, arg2);else if (oper == '*') multargs(arg1, arg2);else if (oper == '/') divargs(arg1, arg2);

This form of if statement is called a nested if, because each else statement in turn contains yet another if, and so on, until all possible tests have been made. A common shorthand mechanism for nested ifs that you can use in some cases allows you to group tests and actions together in a single statement. This is the switch or case statement:

switch (test) { case valueOne: System.out.println(“n is zero”); break; case valueTwo: resultTwo; break; case valueThree: resultThree; break; ... default: defaultresult;}

In the switch statement, the test (a primitive type of byte, char, short, or int) is compared with each of the case values in turn. If a match is found, the statement, or statements after the test is executed. If no match is found, the default statement is executed. The default is optional, so if there isn't a match in any of the cases and default doesn't exist, the switch statement completes without doing anything. Note that the significant limitation of the switch in Java is that the tests and values can be only simple primitive types (and then only primitive types that are castable to int). You cannot use larger primitive types (long, float), strings, or other objects within a switch, nor can you test for any relationship other than equality. This limits the usefulness of switch to all but the simplest cases; nested ifs can work for any kind of test on any type. Here's a simple example of a switch statement similar to the nested if shown earlier:

int n=2;

34

switch (n) { case 1:

System.out.println(“n is zero”); break; case 2:

System.out.println(“n is one”); break; case 3:

System.out.println(“n is two”); break; default:

System.out.println(“n is not defined”); break;}

Note the break statement included in every line. Without the explicit break, once a match is made, the statements for that match and also all the statements further down in the switch are executed until a break or the end of the switch is found (and then execution continues after the end of the switch). In some cases, this may be exactly what you want to do, but in most cases, you'll want to make sure to include the break so that only the statements you want to be executed are executed. One handy use of falling through occurs when you want multiple values to execute the same statements. In this instance, you can use multiple case lines with no result, and the switch will execute the first statements it finds. For example, in the following switch statement, the string "x is an even number." is printed if x has values of 2, 4, 6, or 8. All other values of x print the string "x is an odd number."

switch (x) { case 2: case 4: case 6: case 8: System.out.println("x is an even number."); break; default: System.out.println("x is an odd number.");}

A nested switch is a switch within a switch. Since each switch is a block, no conflict can arise between inner and outer blocks.

Iteration StatementsThe Java iteration statements are:

for loop while loop, and do-while loop

while Loop (pretest loop)The while loop is used to repeat a statement or block of statements as long as a particular condition is true. while loops look like this:

35

while (condition) { bodyOfLoop;}

The condition is a boolean expression. If it returns true, the while loop executes the statements in bodyOfLoop and then tests the condition again, repeating until the condition is false. You can use a single statement in place of the block. Here's an example of a while loop that outputs ten integers from 10 down to 1: int n=10;

while(n>0){ System.out.println(“n is: “+n);

n--; }

do...while Loop (post test loop)The main difference is that while loops test the condition before looping, making it possible that the body of the loop will never execute if the condition is false the first time it's tested. do loops run the body of the loop at least once before testing the condition. do loops look like this:

do { bodyOfLoop;} while (condition);

Here, the bodyOfLoop part is the statements that are executed with each iteration. It's shown here with a block statement because it's most commonly used that way, but you can substitute the braces for a single statement as you can with the other control-flow constructs. The condition is a boolean test. If it returns true, the loop is run again. If it returns false, the loop exits. Keep in mind that with do loops, the body of the loop executes at least once. Here's a simple example of a do loop that prints a message each time the loop iterates:

int n=10;do{ System.out.println(“n is: “+n);

n--; } while(n>0);The above code can be written as:

int n=10;do{ System.out.println(“n is: “+n);

} while(--n>0);

for Loops The for loop, repeats a statement or block of statements some number of times until a condition is matched. for loops are frequently used for simple iteration in which you repeat a block of statements a certain number of times and then stop, but you can use for loops for just about any kind of loop. The for loop in Java looks roughly like this:

for (initialization; test; increment) {

36

statements;}

The start of the for loop has three parts: initialization is an expression that initializes the start of the loop. If you have a loop

index, this expression might declare and initialize it, for example, int i = 0. Variables that you declare in this part of the for loop are local to the loop itself; they cease existing after the loop is finished executing.

test is the test that occurs after each pass of the loop. The test must be a boolean expression or function that returns a boolean value, for example, i < 10. If the test is true, the loop executes. Once the test is false, the loop stops executing.

increment is any expression or function call. Commonly, the increment is used to change the value of the loop index to bring the state of the loop closer to returning false and completing.

The statement part of the for loop is the statements that are executed each time the loop iterates. Just as with if, you can include either a single statement here or a block; the previous example used a block because that is more common. Here's an example of a for loop that displays the integers 10 down to 1 in descending order:

for (int i = 10; i >0; i--){ System.out.println(“i is: “+i);}

Commas can be used when you want to include more than one statement in the initialization and iteration portions on the for loop. For example:

for (int a=1,b=4; a b; a++,b--){ System.out.println(“a and b: “+a + “ “ + b);}

Jump StatementsJava supports three jump statements namely break, continue and return. These statements transfer program control to another part of the programYou've already seen break as part of the switch statement; it stops execution of the switch, and the program continues.

break statementThe break keyword, when used with a loop, immediately halts execution of the current loop. If you've nested loops within loops, it breaks out of the innermost loop. For example, take a for loop that displays a 100 integers from 0 to 99. You can test the loop and use break to halt the loop if the condition is met:

for (int i = 0; i <100; i++){ if(i==10) break; System.out.println(“i is: “+i);}

System.out.println(“Loop exited”);

continue37

It is similar to break except that instead of halting execution of the loop entirely, the loop starts over at the next iteration. It stops processing the remainder of the code for a particular iteration. Foe example:

for (int i = 0; i <10; i++){ System.out.println(“i is: “+i);

if(i%2===0) break; System.out.println(“”);}

return statementIt is used to explicitly return from a method, that is, it causes the back to the caller of the method. Thus, it immediately terminates the method in which it is executed.

Labeled Loops Both break and continue can have an optional label that tells Java where to break to. Without a label, break jumps outside the nearest loop (to an enclosing loop or to the next statement outside the loop), and continue restarts the enclosing loop. Using labeled breaks and continues enables you to break outside nested loops or to continue a loop outside the current loop. To use a labeled loop, add the label before the initial part of the loop, with a colon between them. Then, when you use break or continue, add the name of the label after the keyword itself:

out: for (int i = 0; i <10; i++) { while (x < 50) { if (i * x == 400) break out; ...

} ... }

In this snippet of code, the label out labels the outer loop. Then, inside both the for and the while loop, when a particular condition is met, a break causes the execution to break out of both loops.

Here's another example: the following program contains a nested for loop. Inside the innermost loop, if the summed values of the two counters is greater than four, both loops exit at once:

foo: for (int i = 1; i <= 5; i++) for (int j = 1; j <= 3; j++) { System.out.println("i is " + i + ", j is " + j); if ((i + j) > 4) break foo; }System.out.println("end of loops");

38

Here's the output from this program: i is 1, j is 1i is 1, j is 2i is 1, j is 3i is 2, j is 1i is 2, j is 2i is 2, j is 3end of loops

As you can see, the loop iterated until the sum of i and j was greater than 4, and then both loops exited back to the outer block and the final message was printed.

Exceptions and Exception handling

A java exception is an object that describes an exceptional (error) condition that has occurred in a piece of code. An exception is an abnormal condition that arises in a code sequence at runtime. When an exceptional condition occurs, an object representing that condition is created and thrown in the method that caused the error. The method may handle the exception itself or pass it on. Either way, the exception is caught and processed.Exceptions can be generated by java runtime system or manually generated by your code. Java exception handling is managed by five keyword ; try, catch, throw, throws and finally.

Exception TypesAll exception types are subclasses of built in class Throwable. Immediate below Throwable are two subclasses that partition exceptions into two distinct branches:1. Exception Class - This class is used for exceptional conditions that user programs

should catch. It is also the class you will subclass to create your own custom exception types. RunTimeException is an important subclass of Exception.

2. Error – This include exceptions to be caught under normal circumstances by your program. It is used by java runtime system to indicate errors having to do with runtime environment itself eg stack overflow.

Uncaught exceptions The following program causes a divide overflow error.

class Exc0{ public static void main(String[] args){ int d=0; int a =42/d; }}

Java runtime system detects the error, constructs a new exception object and then throws this exception. The following output is generated by standard JDK runtime interpreter.

Java.lang.ArithmeticException: /by zero

39

at Exc0.main(Exc0.java:4)

The type of exception thrown (ArithmeticException) is a subclass of Exception class. The stack will show the sequence of method invocation that led up to the error. For example:

class Exc1{ static void subroutine(){ int d=0; int a =42/d; }

public static void main(String[] args){ Exc1.subroutine(); }}

The output becomes:

Java.lang.ArithmeticException: /by zero at Exc1.subroutine(Exc1.java:4)at Exc1.main(Exc1.java:4)

Using Try and Catch

class Exc2{ public static void main(String[] args){ int d,a; try{

d=0;a=42/d;System.out.println("This wil not be printed");

}catch(ArithmeticException e){ System.out.println("Exception: "+e); } System.out.println("After Catching");}}

Multiple Catch clausesA program may raise more than one exception. Thus it is possible to specify two or more catch clauses, each catching a different type of exception. When an exception is thrown, each catch statement is inspected in order, and the first to match is executed. The others are bypassed.

class MultiCatch{ public static void main(String[] args){ try{

int a=args.length;System.out.println("a = " +a);

40

int b=42/a;int c[]={1};c[3]=78;

}catch(ArithmeticException e){ System.out.println("Divide by Zero: "+e); }catch(ArrayIndexOutOfBoundsException e){ System.out.println("Array Index out of Bounds: "+e); } System.out.println("After try catch blocks");}}

NB: In the multiple catch statements, the subclass exceptions must come before their superclasses. The following program produces an error because the class Exception appears before the subclass ArithmeticException.

class SupreSubCatch{ public static void main(String[] args){ try{

int a=0;int b=42/a;

}catch(Exception e){ System.out.println("Generic Exception”); }catch(ArithmeticException e){ System.out.println("Never reached”); } }}

The second catch is never reached.

Nested Try statementsA try statement can be inside the block of another try. Each time a try statement is entered, the context of the exception is pushed on the stack.

ThrowThe previous examples catch exceptions thrown by the java runtime system. It is possible for a java program to throw an exception explicitly, using the throw statement. There are two ways to obtain a throwable object:1. Using a parameter into a catch statement.2. Creating a throwable object with new operator.

NB: Throwable object must be of type Throwable or of its subclasses. Simple types such as int or char or non-throwable classes such as string and object cannot be used as exceptions. An example:

class ThrowDemo{

static void demoProc(){

41

try{throw new NullPointerException("Demo");

}catch(NullPointerException e){ System.out.println("Caught inside Demoproc");

throw e; //rethrow the exception } }

public static void main(String[] args){ try{

demoProc(); }catch(NullPointerException e){ System.out.println("Recaught: "+ e); } }}

The flow of execution stops immediately after the throw statement; any subsequent statement are not executed.

NB: All java built-in run-time exceptions have two constructors; one with no parameter and one that takes a string [parameter.

ThrowsIf a method causes an exception it can not handle , it must specify this behaviour so that the caller of the method can guard themselves against such an exception. A throws clause lists the types of exceptions that a method might throw. For example:

class ThrowDemo1{

static void throwOne() throws IllegalAccessException{ System.out.println("Inside throwOne");

throw new IllegalAccessException("Demo"); }

public static void main(String[] args){ try{

throwOne(); }catch(IllegalAccessException e){ System.out.println("Caught: "+ e); } }}

FinallyFinally create a block of code that will be executed after a try/catch block has completed and before the code following the try/catch block. Therefore, it will execute whether or not an exception is thrown. An Example:

42

class FinallyDemo{

//throw an exception out of method static void procA(){ try{

System.out.println("Inside procA"); throw new RuntimeException("Demo"); }finally{

System.out.println("procA finally"); } }

//return from within a try block static void procB(){ try{

System.out.println("Inside procB"); return; }finally{

System.out.println("procB finally"); } }

//execute a try block normally static void procC(){ try{

System.out.println("Inside procC"); }finally{

System.out.println("procC finally"); } }

public static void main(String[] args){ try{

procA(); }catch(Exception e){ System.out.println("Exception Caught"); } procB(); procC(); }}

When procA is called, an exception is thrown and then finally executed. In procB, the try statement is exited by return, then finally executed.In procC, try executes normally, then finally excutes.

43

Keyboard input in JavaIn stand-alone Java programs, we have a few options:

Use System.in (counterpart of System.out) Course input through the command line Course input through a popup window (JOptionPane)

StringsIt is simplest to just consider String inputFor numeric input, just convert the String to a number

i = Integer.parseInt( s ) for ints d = Double.parseDouble( s ) for doubles

public class AddNumbers{ public static void main( String args[] ) { int x = Integer.parseInt( args[0] ); int y = Integer.parseInt( args[1] ); int sum = x+y; System.out.println("Sum is: "+sum); }}

Create and compile the AddNumbers.java applicationExecute the program for the following numbers

java AddNumbers 555 222 java AddNumbers 1000000000 1000000000 java AddNumbers 2000000000 2000000000

Using System.inInput can be coursed through the System.in objectTo make things simple, we need to “convert” System.in into an object where we could call a readLine() method

Converting System.in to a BufferedReader object1. Conversion involves File IO objects (make sure to import java.io.*):

InputStreamReader reader = newInputStreamReader( System.in );

BufferedReader buf = new BufferedReader( reader );

2. Then, call readLine() on buf to initiate input:String s = buf.readLine();

Example import java.io.*;

public class KInputExample{

44

public static void main(String[] argv) throws IOException { // code needed for keyboard input BufferedReader br = new BufferedReader( new InputStreamReader(System.in));

System.out.println("Type First Number");int x=Integer.parseInt(br.readLine().trim());System.out.println("Type Second Number"); int y=Integer.parseInt(br.readLine().trim()); int sum=x+y;System.out.println("sum is :"+ sum);

}}

1. String values from the keyboard (no conversion necessary):    String dataValue;    // declares the variable to hold the String value    dataValue = in.readLine();    // reads the String from the keyboard                                                //     into the variable dataValue2. integer (int) values from the keyboard (convert from String to int)    int dataValue;    // declares the variable to hold the integer value    dataValue = Integer.parseInt(in.readLine().trim());    // reads the String                                                // from the keyboard, trims off any blank                                                // spaces and converts the String to an int3. double values from the keyboard (convert from String to double)    double dataValue;    // declares the variable to hold the double value    dataValue = Double.parseDouble(in.readLine().trim());    // reads                                              // the String from the keyboard, trims off any                                             // blank spaces, converts the String into a double

If you want to use the input as anything other than a string it needs to be converted into the right variable type. Java provides a way to do this as shown in the examples below

x = Double.parseDouble(temp); // string temp converted to double xy = Float.parseFloat(temp); // string temp converted to float yi = Long.parseLong(temp); // string temp converted to long ij = Integer.parseInt(temp); // string temp converted to int jk = Short.parseShort(temp); // string temp converted to short km = Byte.parseByte(temp); // string temp converted to byte ma = Boolean.valueOf(temp).booleanValue(); // string temp converted to

boolean a

Input Using JOptionPane1. Create a JOptionPane object

JOptionPane is a javax.swing.* class

45

2. Call showInputDialog(s) on the object, where s is a prompt describing what needs to be input

method returns the String that is input through the dialog window window closes upon entry of string

If you use javax.swing.* objects, program termination is not automaticIf a JOptionPane object is created, the program will not stop even if you reach the end of main()You need to terminate explicitly

System.exit( 0 );as the last statement in main()

Exampleimport javax.swing.*;public class JOptionExample{ public static void main(String[] argv) {int x=Integer.parseInt(JOptionPane.showInputDialog("Type First Number"));int y=Integer.parseInt(JOptionPane.showInputDialog("Type Second Number"));int sum=x+y;JOptionPane.showMessageDialog(null,"Sum is : "+sum,"Greetings",JOptionPane.PLAIN_MESSAGE);System.exit(0);

}}

AWT (i.e. ABSTRACT WINDOW TOOLKIT) COMPONENTS/GRAPHIC COMPONENTSThese are the major components you can work with in the AWT:

Containers. Containers are generic AWT components that can contain other components, including other containers. The most common form of container is the panel, which represents a container that can be displayed on screen. Applets are a form of panel (in fact, the Applet class is a subclass of the Panel class).

Canvases. A canvas is a simple drawing surface. Although you can draw on panels (as you've been doing all along), canvases are good for painting images or other graphics operations.

UI components. These can include buttons, lists, simple popup menus, checkboxes, test fields, and other typical elements of a user interface.

Window construction components. These include windows, frames, menubars, and dialogs. These are listed separately from the other UI components because you'll use these less often—particularly in applets. In applets, the browser provides the main window and menubar, so you don't have to use these. Your applet may create a new window, however, or you may want to write your own Java application that uses these components.

The classes inside the java.awt package are written and organized to mirror the abstract structure of containers, components, and individual UI components

46

The Basic User Interface Components The simplest form of AWT component is the basic UI component. You can create and add these to your applet without needing to know anything about creating containers or panels—your applet, even before you start painting and drawing and handling events, is already an AWT container. Because an applet is a container, you can put other AWT components—such as UI components or other containers—into it. The procedure for creating the component is the same:

you first create the component, and then add it to the panel that holds it, at which point it is displayed on the screen.

To add a component to a panel (such as your applet, for example), use the add() method:

public void init() { Button b = new Button("OK"); add(b);}

Labels Labels are, effectively, text strings that you can use to label other UI components. The advantages that a label has over an ordinary text string is that it follows the layout of the given panel, and you don't have to worry about repainting it every time the panel is redrawn. Labels also can be easily aligned within a panel, enabling you to attach labels to other UI components without knowing exact pixel positions. To create a label, use one of the following constructors:

Label() creates an empty label, with its text aligned left. Label(String) creates a label with the given text string, also aligned left. Label(String, int) creates a label with the given text string and the given

alignment. The available alignments are stored in class variables in Label, making them easier to remember: Label.RIGHT, Label.LEFT, and Label.CENTER.

The label's font is determined by the overall font for the component (as set by the setFont() method).

Buttons Buttons are simple UI components that trigger some action in your interface when they are pressed. For example, a calculator applet might have buttons for each number and operator, or a dialog box might have buttons for "OK" and "Cancel." To create a button, use one of the following constructors:

Button() creates an empty button with no label. Button(String) creates a button with the given string object as a label.

Once you have a button object, you can get the value of the button's label by using the getLabel() method and set the label using the setLabel(String) methods.

Checkboxes Checkboxes can be selected or deselected to provide options. Checkboxes are user interface components that have two states: on and off (or checked and unchecked, selected and unselected, true and false, and so on). Unlike buttons,

47

checkboxes usually don't trigger direct actions in a UI but, instead, are used to indicate optional features of some other action. Checkboxes can be created by using the Checkbox class. You can create a checkbox by using one of the following constructors:

Checkbox() creates an empty checkbox, unselected. Checkbox(String) creates a checkbox with the given string as a label. Checkbox(String, null, boolean) creates a checkbox that is either selected or

unselected based on whether the boolean argument is true or false, respectively. (The null is used as a placeholder for a group argument. Only radio buttons have groups, as you'll learn in the next section).

Radio Buttons Radio buttons are a variation on the checkbox. Radio buttons have the same appearance as checkboxes, but only one in a series can be selected at a time. To create a series of radio buttons, first create an instance of CheckboxGroup: CheckboxGroup cbg = new CheckboxGroup();Then create and add the individual checkboxes, using the group as the second argument, and whether or not that checkbox is selected (only one in the series can be selected):

add(new Checkbox("Yes", cbg, true));add(new Checkbox("no", cbg, false));

Choice Menus The choice menu is a more complex UI component than labels, buttons, or checkboxes. Choice menus are popup (or pulldown) menus that enable you to select an item from that menu. The menu then displays that choice on the screen. To create a choice menu, create an instance of the Choice class, and then use the addItem() or add() method to add individual items to it in the order in which they should appear:

Choice c = new Choice();c.addItem("Apples");c.addItem("Oranges");c.addItem("Strawberries");c.addItem("Blueberries");c.addItem("Bananas");

Finally, add the entire choice menu to the panel in the usual way: add(c);

Scrolling Lists A scrolling list is functionally similar to a choice menu in that it lets you pick several options from a list. Scrolling lists differ in two significant ways:

Scrolling lists are not popup menus. They're lists of items in which you can choose one or more items from a list. If the number of items is larger than the list box, a scrollbar is automatically provided so that you can see the other items.

A scrolling list can be defined to accept only one item at a time (exclusive), or multiple items (nonexclusive).

48

To create a scrolling list, create an instance of the List class and then add individual items to that list. The List class has two constructors:

List() creates an empty scrolling list that enables only one selection at a time. List(int, boolean) creates a scrolling list with the given number of visible lines on

the screen (you're unlimited as to the number of actual items you can add to the list). The boolean argument indicates whether this list enables multiple selections (true) or not (false).

After creating a List object, add items to it using the addItem() method and then add the list itself to the panel that contains it. Here's an example:

List lst = new List(5, true);lst.addItem("Hamlet");lst.addItem("Claudius");lst.addItem("Gertrude");lst.addItem("Polonius");lst.addItem("Horatio");lst.addItem("Laertes");lst.addItem("Ophelia");add(lst);

Text Fields Unlike the UI components up to this point, which enable you to select only among several options to perform an action, text fields allow you to enter any values. Text fields enable your reader to enter text. To create a text field, use one of the following constructors:

TextField() creates an empty TextField 0 characters wide. TextField(int) creates an empty text field with the given width in characters. TextField(String) creates a text field 0 characters wide, initialized with the given

string. TextField(String, int) creates a text field with the given width in characters and

containing the given string. If the string is longer than the width, you can select and drag portions of the text within the field and the box will scroll left or right.

For example, the following line creates a text field 30 characters wide with the string "Enter Your Name" as its initial contents.

TextField tf = new TextField("Enter Your Name", 30);add(tf);

Tip: Text fields include only the editable field itself. You usually need to include a label with a text field to indicate what belongs in that text field. Note: Text fields are different from text areas; text fields are limited in size and are best used for one-line items, whereas text areas have scrollbars and are better for larger text windows. Both can be edited and enable selections with the mouse. You'll learn about text areas later today.

49

Text Areas Text areas are like text fields, except they have more functionality for handling large amounts of text. Because text fields are limited in size and don't scroll, they are better for one-line responses and text entry; text areas can be any given width and height and have scrollbars by default, so you can deal with larger amounts of text more easily. To create a text area, use one of the following constructors:

TextArea() creates an empty text area 0 rows long and 0 characters wide. Given that a text area with no dimensions can't be displayed, you should make sure you change the dimensions of this new text area before adding it to a panel (or just use the next constructor instead).

TextArea(int, int) creates an empty text area with the given number of rows and columns (characters).

TextArea(String) creates a text area displaying the given string, 0 rows by 0 columns.

TextArea(String, int, int) creates a text area displaying the given string and with the given dimensions.

The following example creates a TextArea to hold data:String str = "Once upon a midnight dreary, while I pondered, weak and weary,\n" + "Over many a quaint and curious volume of forgotten lore,\n" + "While I nodded, nearly napping, suddenly there came a tapping,\n" + "As of some one gently rapping, rapping at my chamber door.\n" + "\"'Tis some visitor,\" I muttered, \"tapping at my chamber door-\n + ... ;add(new TextArea(str,10,60));

Scrollbars and Sliders Text areas and scrolling lists come with their own scrollbars, which are built into those UI components and enable you to manage both the body of the area or the list and its scrollbar as a single unit. You can also create individual scrollbars, or sliders, to manipulate a range of values. Scrollbars are used to select a value between a maximum and a minimum value. To create a scrollbar, you can use one of three constructors:

Scrollbar() creates a scrollbar with 0, 0 as its initial maximum and initial minimum values, in a vertical orientation.

Scrollbar(int) creates a scrollbar with 0, 0 as its initial maximum and initial minimum values. The argument represents an orientation, for which you can use the class variables Scrollbar.HORIZONTAL and Scrollbar.VERTICAL.

Scrollbar(int, int, int, int, int) creates a scrollbar with the following arguments (each one is an integer, and must be presented in this order):

The first argument is the orientation of the scrollbar: Scrollbar.HORIZONTAL and Scrollbar.VERTICAL.

The second argument is the initial value of the scrollbar, which should be a value between the scrollbar's maximum and minimum values.

50

The third argument is the the overall width (or height, depending on the orientation) of the scrollbar's box. In user interface design, a larger box implies that a larger amount of the total range is currently showing (applies best to things such as windows and text areas).

The fourth and fifth arguments are the minimum and maximum values for the scrollbar.

public void init() { l = new Label("0"); add(l); add(new Scrollbar(Scrollbar.HORIZONTAL, 1, 0, 1, 100)); }

Layout Managers The actual appearance of the AWT components on the screen is determined by two things: the order in which they are added to the panel that holds them, and the layout manager that panel is currently using to lay out the screen. The layout manager determines how portions of the screen will be sectioned and how components within that panel will be placed.

Note that each panel on the screen can have its own layout manager. By nesting panels within panels, and using the appropriate layout manager for each one, you can often arrange your UI to group and arrange components in a way that is both functionally useful and also looks good on a variety of platforms and windowing systems.

The AWT provides five basic layout managers: FlowLayout, GridLayout, GridBagLayout, BorderLayout, and CardLayout. To create a layout manager for a given panel, use the setLayout() method for that panel: public void init() { setLayout(new FlowLayout());}

Setting the default layout manager, like creating the user interface components, is best done during the applet's initialization, which is why it's included here.

Once the layout manager is set, you can start adding components to the panel. The order in which components are added is often significant, depending on which layout manager is currently active. Read on for information about the specific layout managers and how they present components within the panel to which they apply.

The following sections describe the five basic Java AWT layout managers. The FlowLayout Class The FlowLayout class is the most basic of layouts. Using the flow layout, components are added to the panel one at a time, row by row. If a component doesn't fit onto a row, it's

51

wrapped onto the next row. The flow layout also has an alignment, which determines the alignment of each row. By default, each row is aligned centered.

To create a basic flow layout with a centered alignment, use the following line of code in your panel's initialization (because this is the default pane layout, you don't need to include this line if that is your intent): setLayout(new FlowLayout());

To create a flow layout with an alignment other than centered, add the FlowLayout.RIGHT or FlowLayout.LEFT class variable as an argument: setLayout(new FlowLayout(FlowLayout.LEFT));You can also set horizontal and vertical gap values by using flow layouts. The gap is the number of pixels between components in a panel; by default, the horizontal and vertical gap values are three pixels, which can be very close indeed. Horizontal gap spreads out components to the left and to the right, vertical gap to the top and bottom of each component. Add integer arguments to the flow layout constructor to increase the gap (a layout gap of 10 points in both the horizontal and vertical directions setLayout(new FlowLayout(FlowLayout.LEFT), 10, 10);

Grid and Grid Bag Layouts Grid layouts use a layout that offers more control over the placement of components inside a panel. Using a grid layout, you portion off the area of the panel into rows and columns. Each component you then add to the panel is placed in a "cell" of the grid, starting from the top row and progressing through each row from left to right (here's where the order of calls to the add() method are very relevant to how the screen is laid out). By using grid layouts and nested grids, you can often approximate the use of hard-coded pixel values to place your UI components precisely where you want them.

To create a grid layout, indicate the number of rows and columns you want the grid to have when you create a new instance of the GridLayout class: setLayout(new GridLayout(3, 3));

Grid layouts can also have a horizontal and vertical gap between components; to create gaps, add those pixel values: setLayout(new GridLayout(3, 3, 10, 15));

Grid bag layouts, as implemented by the GridBagLayout class, are variations on grid layouts. Grid bag layouts also enable you to lay out your user interface elements in a rectangular grid, but with grid bag layouts you have much more control over the presentation of each element in the grid. Grid bag layouts use a helper class, GridBagConstraints, to indicate how each cell in the grid is to be formatted.

Border Layouts Border layouts behave differently from flow and grid layouts. When you add a component to a panel that uses a border layout, you indicate its placement as a geographic direction: north, south, east, west, and center.The components around all the

52

edges are laid out with as much size as they need; the component in the center, if any, gets any space left over.

To use a border layout, you create it as you do the other layouts: setLayout(new BorderLayout());

Then you add the individual components by using a special add() method: the first argument to add() is a string indicating the position of the component within the layout: add("North", new TextField("Title", 50));add("South", new TextField("Status", 50));

You can also use this form of add() for the other layout managers; the string argument will just be ignored if it's not needed. Border layouts can also have horizontal and vertical gaps. Note that the north and south components extend all the way to the edge of the panel, so the gap will result in less space for the east, right, and center components. To add gaps to a border layout, include those pixel values as before: setLayout(new BorderLayout(10, 10));

Card Layouts Card layouts are different from the other layouts. Unlike with the other three layouts, when you add components to a card layout, they are not all displayed on the screen at once. Card layouts are used to produce slide shows of components, one at a time.

Generally when you create a card layout, the components you add to it will be other container components—usually panels. You can then use different layouts for those individual "cards" so that each screen has its own look.

When you add each "card" to the panel, you can give it a name. Then you can use methods defined on the CardLayout class to move back and forth between different cards in the layout.

For example, here's how to create a card layout containing three cards: setLayout(new CardLayout());Panel one = new Panel()add("first", one);Panel two = new Panel()add("second", two);Panel three = new Panel()add("third", three);show(this, "second");Insets Whereas horizontal gap and vertical gap are used to determine the amount of space between components in a panel, insets are used to determine the amount of space around the panel itself. The insets class provides values for the top, bottom, left, and right insets, which are then used when the panel itself is drawn. To include an inset, override the insets() method in your class (your Applet class or other class that serves as a panel):

53

public Insets insets() { return new Insets(10, 10, 10, 10);}

The arguments to the Insets constructor provide pixel insets for the top, bottom, left, and right edges of the panel. This particular example provides an inset of 10 pixels on all four sides of the panel.

Handling UI Actions and Events For your UI components to do something when they are activated, you need to hook up the UI's action with an operation.

Testing for an action by a UI component is a form of event management. In particular, UI components produce the special kind of event called an action. To intercept an action by any UI component, you define an action() method in your applet or class: public boolean action(Event evt, Object arg) { ...}The action() method should look familiar to the basic mouse and keyboard event methods. Like those methods, it gets passed the event object that represents this event. It also gets an extra object, which can be of any type.

What's that second argument for? The second argument to the action method depends on the UI component that's generating the event. The basic definition is that it's any arbitrary argument—when a component generates an event, it can pass along any extra information that might later be needed. Because that extra information may be useful for you, it's passed on through the action() method.

All the basic UI components (except for labels, which have no action) have different actions and arguments:

Buttons create actions when they are selected, and a button's argument is the label of the button.

Checkboxes, both exclusive and nonexclusive, generate actions when a box is checked. The argument is always true.

Choice menus generate an action when a menu item is selected, and the argument is that item.

Text fields create actions when the user presses Return inside that text field. Note that if the user tabs to a different text field or uses the mouse to change the input focus, an action is not generated. Only a Return triggers the action.

Note that with actions, unlike with ordinary events, you can have many different kinds of objects generating the event, as opposed to a single event such as a mouseDown. To deal with those different UI components and the actions they generate, you have to test for the type of object that sent/created the event in the first place inside the body of your action() method. That object is stored in the event's target instance variable, and you can use the instanceof operator to find out what kind of UI component sent it:

54

public boolean action(Event evt, Object arg) { if (evt.target instanceof TextField) handleText(evt.target); else if (evt.target instanceof Choice) handleChoice(arg);...}Although you can handle UI actions in the body of the action() method, it's much more common simply to define a handler method and call that method from action() instead. Here, there are two handler methods: one to handle the action on the text field (handleText()) and one to handle the action on the choice menu (handleChoice()).

Depending on the action you want to handle, you may also want to pass on the argument from the action, the UI component that sent it, or any other information that the event might contain.

Here's a simple applet that has five buttons labeled with colors. The action() method tests for a button action and then passes off the word to a method called changeColor(), which changes the background color of the applet based on which button was pressed

import java.awt.*;public class ButtonActionsTest extends java.applet.Applet { public void init() { setBackground(Color.white); add(new Button("Red")); add(new Button("Blue")); add(new Button("Green")); add(new Button("White")); add(new Button("Black")); } public boolean action(Event evt, Object arg) { if (evt.target instanceof Button) changeColor((String)arg); return true; } void changeColor(String bname) { if (bname.equals("Red")) setBackground(Color.red); else if (bname.equals("Blue")) setBackground(Color.blue); else if (bname.equals("Green")) setBackground(Color.green); else if (bname.equals("White")) setBackground(Color.white); else setBackground(Color.black); }}

Nesting Panels and Components Adding UI components to individual applets is fun, but applets begin to turn into lots of fun when you begin working with nested panels. By nesting different panels inside your applet, and panels inside those panels, you can create different layouts for different parts

55

of the overall applet area, isolate background and foreground colors and fonts to individual parts of an applet, and manage the design of your UI components much more cleanly and simply. The more complex the layout of your applet, the more likely you're going to want to use nested panels.

Nested Panels Panels, as you've already learned, are components that can be actually displayed on screen; Panel's superclass Container provides the generic behavior for holding other components inside it. The Applet class, which your applets all inherit from, is a subclass of Panel. To nest other panels inside an applet, you merely create a new panel and add it to the applet, just as you would add any other UI component:

setLayout(new GridLayout(1, 2, 10, 10));Panel panel1 = new Panel();Panel panel2 = new Panel();add(panel1);add(panel2);

You can then set up an independent layout for those subpanels and add AWT components to them (including still more subpanels) by calling the add() method in the appropriate panel:

panel1.setLayout(new FlowLayout());panel1.add(new Button("Up"));panel1.add(new Button("Down"));Although you can do all this in a single class, it's common in applets that make heavy use of the panels to factor out the layout and behavior of the subpanels into separate classes, and to communicate between the panels by using method calls.

Events and Nested Panels When you create applets with nested panels, those panels form a hierarchy from the outermost panel (the applet, usually), to the innermost UI component. This hierarchy is important to how each component in an applet interacts with the other components in the applet or with the browser that contains that applet; in particular, the component hierarchy determines the order in which components are painted to the screen.

More importantly, the hierarchy also affects event handling, particularly for user input events such as mouse and keyboard events.

Events are received by the innermost component in the component hierarchy and passed up the chain to the root. Suppose, for example, that you have an applet with a subpanel that can handle mouse events (using the mouseDown() and mouseUp() methods) and that panel contains a button. Clicking on the button means that the button receives the event before the panel does; if the button isn't interested in that mouseDown(), the event gets passed to the panel, which can then process it or pass it further up the hierarchy.

56

Remember the discussion about the basic event methods yesterday? You learned that the basic event methods all return boolean values. Those boolean values become important when you're talking about handling events or passing them on.

An event handling method, whether it is the set of basic event methods or the more generic handleEvent(), can do one of three things, given any random event:

Not be interested in the event (this is usually true only for handleEvent(), which receives all the events generated by the system). If this is the case, the event is passed on up the hierarchy until a component processes it (or it is ignored altogether). In this case, the event handling method should return false.

Intercept the event, process it, and return true. In this case, the event stops with that event method. Recall that this is the case with the basic mouseDown() and keyDown() methods that you learned about yesterday.

Intercept the method, process it, and pass it on to the next event handler. This is a more unusual case, but you may create a user interface by using nested components that will want to do this. In this case, the event method should return false to pass the event on to the next handler in the chain.

More UI Components Once you master the basic UI components and how to add them to panels and manage their events, you can add more UI components. In this section, you'll learn about text areas, scrolling lists, scrollbars, and canvases.

Note that the UI components in this section do not produce actions, so you can't use the action() method to handle their behavior. Instead, you have to use a generic handleEvent() method to test for specific events that these UI components generate. ]

Canvases Although you can draw on most AWT components, such as panels, canvases do little except let you draw on them. They can't contain other components, but they can accept events, and you can create animations and display images on them. Canvases, in other words, could have been used for much of the stuff you learned about earlier this week.

A canvas is a component that you can draw on. To create a canvas, use the Canvas class and add it to a panel as you would any other component: Canvas can = new Canvas();add(can);

More UI Events For many basic events, such as mouseDown() and keyDown(), you can define methods for those events to handle the event directly. You learned a similar mechanism today for UI actions where creating an action() method handled a specific action generated by a UI component.

The most general way of managing events, however, continues to be the handleEvent() method. For events relating to scrollbars and scrolling lists, the only way to intercept these events is to override handleEvent().

57

To intercept a specific event, test for that event's ID. The available IDs are defined as class variables in the Event class, so you can test them by name. The table below shows additonal events that may be useful to you for the components you've learned about today (or that you might find useful in general).

Additional events.

Event ID What It Represents

ACTION_EVENT Generated when a UI component action occursKEY_ACTION Generated when text field action occursLIST_DESELECT Generated when an item in a scrolling list is deselectedLIST_SELECT Generated when an item in a scrolling list is selectedSCROLL_ABSOLUTE Generated when a scrollbar's box has been moved

SCROLL_LINE_DOWN Generated when a scrollbar's bottom or left endpoint (button) is selected

SCROLL_LINE_UP Generated when a scrollbar's top or right endpoint (button) is selected

SCROLL_PAGE_DOWN Generated when the scrollbar's field below (or to the left of) the box is selected

SCROLL_PAGE_UP Generated when the scrollbar's field above (or to the right of) the box is selected

Component examplesExample:Button Class

In this example, two Button objects are created and placed on a Frame. The Font and Label are changed on the first Button , while the second one’s background is changed to red. Text field is also placed on the frame

The WinClosing class is used to terminate the program if the window is closed.

import java.awt.*;import java.awt.event.*;

public class CompTest extends Frame { Button playButton,pauseButton; TextField tf;

public CompTest() {

//two buttons are created several of their properties are

58

// changed using the appropriate set() method

playButton = new Button(); playButton.setFont(new Font("Serif", Font.BOLD,12)); playButton.setLabel("Play");

pauseButton = new Button("Disable");pauseButton.setBackground(Color.red);tf = new TextField(20);

tf.setText("this is some text"); setLayout(new FlowLayout());

add(pauseButton); add(playButton); add(tf);

addWindowListener(new WinClosing());setBounds(100,100,400,120);

setVisible(true);}

public static void main(String args[]){ CompTest tb = new CompTest();}}

// The winclosing class closes terminates the program when the //window is closed

class WinClosing extends WindowAdapter{ public void windowClosing(WindowEvent we) { System.exit(0); }}

Note: The setFont, setEnabled, and setBackground methods are Component classes.

Check Boximport java.awt.*;import java.awt.event.*;

public class TestCheckbox extends Frame implements ItemListener{ Checkbox cb; TextField tf;

public TestCheckbox() {

59

cb = new Checkbox("Bold"); cb.setFont(new Font("Serif", Font.BOLD,12)); cb.setState(true);

// The Checkbox is registered with an ItemListener. in this case //the frame acts as the itemListener cb.addItemListener(this);

tf = new TextField(15);

tf.setFont(new Font("Serif", Font.BOLD,12)); tf.setText("JavaJavaJava"); setLayout(new FlowLayout());

add(cb); add(tf);

addWindowListener(new WinClosing());setBounds(100,100,400,120);

setVisible(true);}

// The itemStateChanged() method must be implemented by the //ItemListener. Since the Frame is acting as the//ItemListener in this example, the method is contained in the //TestCheckBox class

public void itemStateChanged(ItemEvent ie){ // The check box generates ItemEvent objects when its// selected change changes. The checked state of the check box is determined. if the// check box is currently selected, the font style is set to bold// if unchecked , the style is et to plain

Checkbox cbox = (Checkbox) ie.getItemSelectable(); if (cbox.getState() == true){ tf.setFont(new Font("Serif", Font.BOLD,12));}else{ tf.setFont(new Font("Serif", Font.PLAIN,12));}

}public static void main(String args[]){ TestCheckbox tcb= new TestCheckbox();

}}

60

// The winclosing class closes terminates the program when the // window is closed

class WinClosing extends WindowAdapter{ public void windowClosing(WindowEvent we) { System.exit(0); }}

CheckBox Group classimport java.awt.*;import java.awt.event.*;

public class TestCBG extends Frame implements ItemListener{ Checkbox cb1,cb2,cb3; CheckboxGroup cbg; TextField tf;

public TestCBG() { // three check boxes are created They are assigned to a //checkbox group when they are

instantiated. // Initially, none of the checkbox objects are checked cbg = new CheckboxGroup(); cb1= new Checkbox("London", cbg, false);

cb2= new Checkbox("Tokyo", cbg, false); cb3= new Checkbox("Ottawa", cbg, false);

// The checkbox objects are registered with an ItemListener// In this case the Frame acts as the ItemListener

cb1.addItemListener(this); cb2.addItemListener(this); cb3.addItemListener(this);

tf= new TextField(15); tf.setEditable(false); Panel p = new Panel();

p.add(cb1); p.add(cb2); p.add(cb3);

add(p, BorderLayout.CENTER); add(tf, BorderLayout.SOUTH); addWindowListener(new WinClosing()); setBounds(100,100,400,120);

61

setVisible(true); } // The itemStateChanged() method must be implemented by the //ItemListener. Since the Frame is acting as the//ItemListener in this example, the method is contained in the //TestCBG class

public void itemStateChanged(ItemEvent ie){ // The Text field is updated to reflect the currently //selected item Checkbox cbox = (Checkbox) ie.getItemSelectable(); tf.setText("City selected is " + cbox.getLabel());}

public static void main(String args[]){ TestCBG tcbg= new TestCBG();}}

// The winclosing class closes terminates the program when the window is closed

class WinClosing extends WindowAdapter{ public void windowClosing(WindowEvent we) { System.exit(0); }}

Choice classimport java.awt.*;import java.awt.event.*;

public class TestChoice extends Frame implements ItemListener{ Choice c; TextField tf; TestChoice() { // A choice object is created and four selections are addded to it c = new Choice(); c.add("Fish"); c.add("Rice"); c.add("Beans"); c.add("Cheese"); c.select("Rice");

// The choice object is registered with an ItemListener // In this case, the TestChoice class acts as the //ItemListener

62

c.addItemListener(this);

tf= new TextField(15); tf.setEditable(false); tf.setText("Food Selected is "+ c.getSelectedItem());

Panel p = new Panel(); p.add(c); add(p, BorderLayout.CENTER);

add(tf, BorderLayout.SOUTH); addWindowListener(new WinClosing());

setBounds(100,100,400,120); setVisible(true);}

// The itemStateChanged() method must be implemented by the //ItemListener. Since the TestChoice class is acting as the//ItemListener in this example, the method is contained in the //TestChoice class

public void itemStateChanged(ItemEvent ie){ // The Text field is updated to reflect the currently //selected item Choice choice = (Choice) ie.getItemSelectable(); tf.setText("Food selected is " + choice.getSelectedItem());}

public static void main(String args[]){ TestChoice tc= new TestChoice();

}}

// The winclosing class closes terminates the program when the //window is closed

class WinClosing extends WindowAdapter{ public void windowClosing(WindowEvent we) { System.exit(0); }}

List classimport java.awt.*;import java.awt.event.*;

public class TestList extends Frame implements ItemListener{

63

List lst; TextField tf; TestList() { // A list object is created and four selections are added lst = new List(5); lst.add("Fish"); lst.add("Rice"); lst.add("Beans"); lst.add("Beans");

lst.setFont(new Font("Serif", Font.BOLD, 12));

// The List object is registred with an item listener // in this case, the Test List class acts as the Item //listener

lst.addItemListener(this);

tf = new TextField(15); tf.setEditable(false);

tf.setText("Food selected is "+ lst.getSelectedItem());

Panel p = new Panel();

p.add(lst);

add(p,BorderLayout.CENTER); add(tf,BorderLayout.SOUTH);

addWindowListener(new WinClosing());setBounds(100,100,400,120);

setVisible(true);}

// The itemStateChanged() method must be implemented by the //ItemListener. Since the Testlist class is acting as // itemListener in this example, the method// is contained in the TesttList class

public void itemStateChanged(ItemEvent ie){ // The Text Field is updated to reflect the currently //selected item List l = (List) ie.getItemSelectable(); tf.setText("Food selected is "+ l.getSelectedItem());}

public static void main(String args[])

64

{ TestList tlst= new TestList();}

}

// The winclosing class closes terminates the program when the //window is closed

class WinClosing extends WindowAdapter{ public void windowClosing(WindowEvent we) { System.exit(0); }}

Scrollbar classimport java.awt.*;import java.awt.event.*;

public class TestScrollbar extends Frame implements AdjustmentListener{ Scrollbar sb; TextField tf;

TestScrollbar() { // a scrollar object is created and its properties set sb = new Scrollbar(Scrollbar.VERTICAL); sb.setMinimum(1);

sb.setMaximum(100);sb.setValue(50);sb.setUnitIncrement(10);sb.setBlockIncrement(1);

sb.addAdjustmentListener(this);

tf = new TextField(3); tf.setEditable(false); tf.setText(" "+ sb.getValue());

Panel p = new Panel(); p.add(tf); p.add(sb);

add(p);

65

addWindowListener(new WinClosing());setBounds(100,100,400,120);

setVisible(true);}

// Implement the adjustmentValueChanged method

public void adjustmentValueChanged(AdjustmentEvent ae){ // The Text Field is updated to reflect the value of the //scrollbar tf.setText(""+ sb.getValue());}

public static void main(String args[]){ TestScrollbar tsb= new TestScrollbar();

}}// The winclosing class closes terminates the program when the //window is closed

class WinClosing extends WindowAdapter{ public void windowClosing(WindowEvent we) { System.exit(0); }}

TextComponent Classes (TextField and TextArea)

(a) Using TextFieldimport java.awt.*;import java.awt.event.*;

public class TestTextField extends Frame { TextField tf1,tf2; TestTextField() {

// to textfield objects are created, the first // is made read only. The second uses as // Echo character to replace whatever text is inserted

tf1 = new TextField("This text is read only", 20);tf1.setFont(new Font("Serif",Font.PLAIN,12));tf1.setEditable(false);

tf1.select(5,10);

tf2 = new TextField(10);

66

tf2.setEchoChar('*');

Panel p = new Panel();p.add(tf1);p.add(tf2);add(p);addWindowListener(new WinClosing());

setBounds(100,100,400,120);setVisible(true);

}public static void main(String args[]){ TestTextField ttf = new TestTextField();}}

// The winclosing class closes terminates the program // when the window is closedclass WinClosing extends WindowAdapter{ public void windowClosing(WindowEvent we) { System.exit(0); }}(b) Using TextArea classimport java.awt.*;import java.awt.event.*;import java.util.*;

public class TestA extends Frame implements TextListener{ TextArea ta; TextField tf; Date date;

public TestA() {

// A TextArea is created with 5 rows and 25 columns.// A string is added to the TextArea.

//Another string is inserted at position 0, // pushing the original string to the right

ta=new TextArea(5,25);ta.append("Filling Santa's shelves ");

ta.insert("We are Santa's Elves \n",0);

// The TextArea object is registred with a text listener// In this case, the TestA class acts as the Text listener

ta.addTextListener(this);

tf = new TextField(20);

67

tf.setEditable(false);

Panel p = new Panel();p.add(ta);

add(p,BorderLayout.CENTER);add(tf,BorderLayout.SOUTH);

addWindowListener(new WinClosing()); setBounds(100,100,400,200);

setVisible(true);}

//The TextValueChanged() method must be implemented by the//TextListener. Since the TestA class is acting as the Text //listener in this example, this method is contained in the // TestA class

public void textValueChanged(TextEvent te){ // if the contents of the text area are changed. // the text field indicates when the i.e the time the // TextArea was changed

date = new Date();tf.setText("Text changed at "+date.toString());

}

public static void main(String args[]){ TestA tta = new TestA();}}

// The winclosing class closes terminates the program //when the window is closed

class WinClosing extends WindowAdapter{ public void windowClosing(WindowEvent we) { System.exit(0); }}

68

Container Classes (Dialog, FileDialog, Frame, Panel, ScrollPane,Window)(a) Using Dialog class

import java.awt.*;import java.awt.event.*;

public class TestDialog extends Frame implements ActionListener{ Button quitButton,yesButton,noButton;

Dialog d; public TestDialog() {

quitButton = new Button("quit");quitButton.addActionListener(this);

setLayout(new FlowLayout());add(quitButton);

createDialog();addWindowListener(new WinClosing());

setBounds(150,150,200,200);setVisible(true);

}

// CreateDialog() creates a dialog that confirms //the quit command.// Dialog objects are always //the child of a parent object. A reference// to the parent object, in this case the //TestDialog class is passed to the Dialog constructor

public void createDialog(){

d = new Dialog(this); d.setResizable(false);

yesButton = new Button("yes"); yesButton.addActionListener(this);

noButton = new Button("no"); noButton.addActionListener(this);

d.setLayout(new FlowLayout()); d.add(yesButton);

d.add(noButton); d.setSize(200,100);}

public void actionPerformed(ActionEvent ae){ // If the "quit" button is pressed, the confirm dialog

69

// is made visible. If the "yes" button in the dialog // is pressed, the program terminates. If the "no" button // in the dialog is pressed, the dialog is made invisible

if(ae.getActionCommand().equals("quit")){ d.show();}if(ae.getActionCommand().equals("yes")){

System.exit(0); }

if(ae.getActionCommand().equals("no")){

d.setVisible(false); }}

public static void main(String args[]){ TestDialog td = new TestDialog();}}

// The winclosing class closes terminates the program // when the window is closed

class WinClosing extends WindowAdapter{ public void windowClosing(WindowEvent we) { System.exit(0); }}

(b) Using FileDialog classimport java.awt.*;import java.awt.event.*;

public class TestFD extends Frame { FileDialog fd;

TestFD() {

addWindowListener(new WinClosing()); setBounds(100,100,400,400);

setVisible(true);createFileDialog();

}

70

// CreateFileDialog() creates a FileDialog object that lists the//contents of the current directory. The FileDialog object //remains visible until a file is selected

public void createFileDialog(){

fd = new FileDialog(this, "Pick a file"); fd.show();

}

//getString method is used to return the name of the selected //filepublic String getString(){ return fd.getFile();}

public static void main(String args[]){ TestFD tfd = new TestFD(); System.out.println("File selected was "+ tfd.getString());}

}

// The winclosing class closes terminates the program when the //window is closed

class WinClosing extends WindowAdapter{ public void windowClosing(WindowEvent we) { System.exit(0); }}

(c) Using Frame Class import java.awt.*;import java.awt.event.*;

public class TestFrame extends Frame { TestFrame() {

addWindowListener(new WinClosing());setTitle("Simple Frame");setResizable(false);

setBounds(100,100,200,200);setVisible(true);

}public static void main(String args[]){

71

TestFrame tf = new TestFrame(); }}

// The winclosing class closes terminates the program when the window is closed

class WinClosing extends WindowAdapter{ public void windowClosing(WindowEvent we) { System.exit(0); }}

(d) Using Panel Classimport java.awt.*;import java.awt.event.*;

public class TestPanel extends Frame { Button b1,b2; TestPanel() {

b1 = new Button("button 1");b2 = new Button("button 2");

Panel p = new Panel();p.add(b1);p.add(b2);add(p);addWindowListener(new WinClosing());

setBounds(100,100,200,120);setVisible(true);

}

public static void main(String args[]){ TestPanel tp = new TestPanel();}}// The winclosing class closes terminates the program when the window is closed

class WinClosing extends WindowAdapter{ public void windowClosing(WindowEvent we) { System.exit(0); }}

72

(e) Using ScrollPane classimport java.awt.*;import java.awt.event.*;

public class TestSP extends Frame { ScrollPane sp; TestSP() {

sp = new ScrollPane();Panel p = new Panel();for (int i =0;i<10; ++i){

p.add(new Button("button" + i));}

// The panel containing the Button objects is placed// within a scroll pane and the ScrollPane is placed// in the frame. The button objects must be placed in // a panel first, because a ScrollPane can only contain one

//component

sp.add(p);add(sp);

addWindowListener(new WinClosing()); setBounds(100,100,200,120);

setVisible(true);}public static void main(String args[]){ TestSP tsp = new TestSP();}}

// The winclosing class closes terminates the program when the //window is closed

class WinClosing extends WindowAdapter{ public void windowClosing(WindowEvent we) { System.exit(0); }}

(f) Using Window Classimport java.awt.*;import java.awt.event.*;

public class TestWind extends Frame

73

{ TestWind() { addWindowListener(new WinClosing()); setBounds(100,100,250,250);

setVisible(true);createWindow();

}

// The createWindow method creates and displays a Window object.// Window objects are always the child of a parent object. a// reference to the parent object, in this case the TestWind //class is passed to the Window constructor

public void createWindow(){ Window w = new Window(this); w.setSize(100,100); w.setBackground(Color.yellow); w.add(new Label("James")); w.show();}

public static void main(String args[]){ TestWind tw = new TestWind(); }

}

// The winclosing class closes terminates the program when the //window is closed

class WinClosing extends WindowAdapter{ public void windowClosing(WindowEvent we) { System.exit(0); }}

Layout Managers Classes: (BorderLayout, CardLayout,FlowLayout, GridLayout,etc)

(a) Using BorderLayout class

import java.awt.*;import java.awt.event.*;

public class TestBL extends Frame {

74

Button northButton,eastButton,westButton,southButton; Label nameLabel,secondLabel; public TestBL() {

northButton = new Button("north");eastButton = new Button("east");westButton = new Button("west");southButton = new Button("south");

nameLabel = new Label("The Center");secondLabel = new Label("Region");

// The button objects are placed in panels//before being placed on the frame. if the// buttons were placed on the borderlayout regions//directly, they would be sized to fill the // entire region. Placing them in panels// maitains the preferred size of the Button

Panel pN= new Panel();pN.add(northButton);Panel pS= new Panel();pS.add(southButton);Panel pE= new Panel();pE.add(eastButton);Panel pW= new Panel();pW.add(westButton);

Panel pC= new Panel();pC.setBackground(Color.yellow);pC.add(nameLabel);pC.add(secondLabel);

add(pN,BorderLayout.NORTH);add(pS,BorderLayout.SOUTH);add(pE,BorderLayout.EAST);add(pW,BorderLayout.WEST);add(pC,BorderLayout.CENTER);addWindowListener(new WinClosing());

setBounds(100,100,300,150);setVisible(true);

}

public static void main(String args[]){ TestBL tbl = new TestBL();}}

// The winclosing class closes terminates the program when the window is closed

75

class WinClosing extends WindowAdapter{ public void windowClosing(WindowEvent we) { System.exit(0); }}

(b) Using CardLayout Classimport java.awt.*;import java.awt.event.*;

public class TestCard extends Frame implements ActionListener{ Button nextButton, prevButton,firstButton; Panel centerPanel,southPanel; String name; CardLayout c1;

public TestCard(){ c1 = new CardLayout(); nextButton = new Button("next"); prevButton = new Button("previous"); firstButton= new Button("first");

nextButton.addActionListener(this); prevButton.addActionListener(this); firstButton.addActionListener(this);

southPanel = new Panel(); southPanel.add(nextButton); southPanel.add(prevButton); southPanel.add(firstButton);

// 10 label objects are added to a panel using a // card layout layout manager

centerPanel = new Panel();

centerPanel.setLayout(c1);

for (int i=0;i<10;++i) { name = "Label " + i; centerPanel.add(new Label("Label " + i,Label.CENTER), name); } add(southPanel, BorderLayout.SOUTH); add(centerPanel, BorderLayout.CENTER);

addWindowListener(new WinClosing());

76

setBounds(100,100,200,120); setVisible(true);}

public void actionPerformed(ActionEvent ae){ // depending on which button is pressed the //CardLayout object calls the next(), // previous() or first() methods

if(ae.getActionCommand().equals("next")) { c1.next(centerPanel); }

if(ae.getActionCommand().equals("previous")) { c1.previous(centerPanel); }

if(ae.getActionCommand().equals("first")) { c1.first(centerPanel); }} public static void main(String args[]){ TestCard tc = new TestCard();}}// The winclosing class closes terminates the program // when the window is closed

class WinClosing extends WindowAdapter{ public void windowClosing(WindowEvent we) { System.exit(0); }}

(c) Using FlowLayout class

import java.awt.*;import java.awt.event.*;

public class TestFL extends Frame {

public TestFL() { //5 buttons are added to the Frame using a FlowLayout Layout Manager

77

setLayout(new FlowLayout(FlowLayout.CENTER)); for(int i=0;i<6; ++i) { add(new Button("button " + i)); }

addWindowListener(new WinClosing()); setBounds(100,100,300,120); setVisible(true);}public static void main(String args[]){ TestFL tfl = new TestFL();}}

//The winclosing class closes terminates the program when //the window is closed

class WinClosing extends WindowAdapter{ public void windowClosing(WindowEvent we) { System.exit(0); }}

(d) Using the GridLayout classimport java.awt.*;import java.awt.event.*;

public class TestGL extends Frame { Button goButton; Label nameLabel; TextField nameTF;

public TestGL() { goButton = new Button("Go"); goButton.setFont(new Font("Times", Font.BOLD,14)); nameLabel = new Label("Name"); nameTF = new TextField(20);

// Setting the number of rows to 0 means the number of rows //will be increased to match the number of components //added to the layout

setLayout(new GridLayout(0,1));

78

Panel p1 = new Panel();p1.add(nameLabel);add(p1);

Panel p2 = new Panel();p2.add(nameTF);add(p2);

Panel p3 = new Panel();p3.add(goButton);add(p3);

addWindowListener(new WinClosing()); setBounds(100,100,200,200); setVisible(true);}public static void main(String args[]){ TestGL tgl = new TestGL();}}

// The winclosing class closes terminates the // program when the window is closed

class WinClosing extends WindowAdapter{ public void windowClosing(WindowEvent we) { System.exit(0); }}

Menu Classes: Menu. MenuBar, PopupMenu, etc

(a) Using Menu and MenuBar classesimport java.awt.*;import java.awt.event.*;

public class TestMenuBar extends Frame { MenuBar mb; Menu helpMenu, fileMenu; TestMenuBar() { // two Menu objects are created are created // and placed on the menubar helpMenu = new Menu("Help"); helpMenu.add("help");

79

fileMenu = new Menu("File"); fileMenu.add("Save");

mb = new MenuBar();

mb.add(fileMenu); // one of the mnu objects is designated as the // help menu and is placed at the far right of the // MenuBar .It is not added to the MenuBar using add() // in the normal way.

mb.setHelpMenu(helpMenu); setMenuBar(mb); addWindowListener(new WinClosing()); setBounds(100,100,200,120); setVisible(true);}

public static void main(String args[]){ TestMenuBar tmb = new TestMenuBar();}}

// The winclosing class closes terminates the program // when the window is closed

class WinClosing extends WindowAdapter{ public void windowClosing(WindowEvent we) { System.exit(0); }}

Summary of AWT classesComponent classIt is the superclass of all containers and non-menu related components. Because it an abstract class, a Component object is never created. The class contains general purpose methods to manipulate, modify and return information about containers and components

Some Component class methods:(i) Methods to return the current state of a Component

hasfocus() - returns a true if the input focus is owned by the invoking componentIsDisplayable()- returns a true is the invoking component can be displayedisEnabled() - returns a true if the invoking component can accept inputs and generate eventsisFocusTraversable() – Returns a true if the invoking component can accept the input as focus. Focus is traversed from traversable components using the Tab or Shift_Tab keyboard sequences

80

isOpaque()- returns a true if the invoking component is opaque, meaning that it hides any features beneath it. AWT components are opaque.

IsShowing()– Returns a true if the invoking component’s state is valid. A valid component is one that is correctly positioned and sized within its parent container and all of its children are validIsVisible()- Returns a true if the invoking Component will be visible when the screen is painted.(ii) Location Methods

getBounds() – Returns Rectangle object that encompasses the outer boundary of the invoking componentgetX() and getY() – return the x and y positions in pixels of the origin of the invoking componentsetBounds() – is a combination of the setLocation() and setSize() methods. It sets the location and size of the invoking component.setLocation()- Places the upper left hand corner of the invoking component at the designated location.

(iii) Methods to retrieve component propertiesgetBackground() and getForeground() - return the Color object representing the background and foreground ColourgetFont() – Returns the Font object associated with the invoking componentgetName() – gets the name of the invoking componentgetParent() – Returns the parent container of the invoking component

(iv) Methods to set component propertiesrequestFocus() - attempts to bring focus to the invoking component. If the focus is not focus traversable, the attempt will fail.setBackground(Color backgroundColor) and setForeground(Color foregroundColor) set the background and foreground of the invoking component

setFont(Font f) – Sets/Changes the font displayed by the invoking componentsetEnabled(Boolean) – Enables or disables the invoking component.setName(String name) – Sets the name associated with the invoking componentsetVisible(Boolean) – Determines whether the invoking component is visible on the screen or not.transferFocus() - Moves the focus away from the invoking component to the next focus traversable component

(v) Size methods

getHeight() and getWidth() return the current height and height of the invoking component.getMaximumSize(), getMinimumSize(), getPreferredSize() return the maximum,minimum and preferred size as determined by the component’s peer classes.setSize(int width, int height) – Changes the size, if possible of the invoking component to the specified size.

81

getSize() returns a Dimension object containing the current width and height of the invoking component.Component Classes: Button,CheckBox,CheckBox,Choice,Label,List,ScrollBar,TextArea,TextField

A component is a object that resides inside a container and is visible to the user. They can be used to provide information, initiate some action or store data. Under this section, A GUI component is defined as a subclass of Component that is not a Container. GUI components placed inside a container make up a user interface.

GUI components have various properties associated with them:

(a) A component is either enables or disabled. Only enabled components can generate events

(b) A component can be in or out of focus.. There can only be one components with focus at any one time.

(c) A component is either visible or invisible- Most containers are by default visible- Most GUI components are by default invisible

(d) Every component has an internal name that is used by the program to identify the component. The name is accessed by the getname() and setname() methods

(e) A component can have one or more pop up menus associated with it. The popup menus contains menu items that are specific to the component

Button class- Implements a button that can be clicked. The button is used to initiate an action. Every button has an action command associated with it that can b used to identify the button. A button object can generate an ActionEvent object when pressed.

Button () Constructors:

- Button()- Button(String Label)

Action Command methods

- getActionCommand()

- setActionCommand(String actionCmmand)

Every button has an action command associated with it. These methods return or set the action command for the invoking Button object. If no action is set, they return the Button label. The getActionCommand() can also be used by the ActionListener interface to determine which button has been selected.

Action Listener methods

AddActionListener(Action Listener al) and removeActionListener(Action Listener al) – The methods register and remove the invoking Button object with/from the ActionListener object

Label Methods

82

- getLabel(), setLabel(String label) return and set the label on the invoking Button object respecitively.

Canvas classA canvas is a rectangular drawing area

Canvas Constructors

- Canvas()Canvas Methods

- paint(Graphics g) – drawing something on the invoking object using the methods provided in the Graphics class

Checkbox classIt is a box with a label that can be checked or unchecked, similar to an on/off switch. Two or more checkboxes can be grouped together and become mutually exclusive by using a CheckboxGroup object

Checkbox Constructors

Checkbox()

Checkbox(String label)

Checkbox(String label, boolean )

Checkbox(String label, Boolean, CheckboxGroup cg)

Checkbox(String label, CheckboxGroup cg, Boolean)

Note: Assigning the CheckGroup to null makes the checkbox initially independent.

Checkbox Label Methods

getLabel() and setLabel(String label) – returns and sets the label displayed by the invoking Checkbox object.

Checked State methods

getState(), setState(Boolean) checks or unchecks the invoking Checkbox object and return true if the invoking checkbox object is checked.

CheckboxGroup Methods

getCheckboxGroup(), set CheckboxGroup(Checkbox cbg)

ItemListener methods

-addItemListener()

-removeItemListener()

CheckBoxGroup constructor

- CheckBoxGroup()

CheckboxGroup selection methods

83

- getSelectedCheckbox()

- setSelectedCheckBox(CheckBox cb)

toString() method – returns a String representation of the invoking CheckboxGroup object.

Choice classConstructor

- Choice()Methods that add or remove elements

add(),addItem(String item) insert(String item, int index) remove(String item), remove(index) removeAll()

getItemCount() returns the number of selectable items in the invoking Choice object

getItem(int index) returns the item at position index of the choice object

ItemListener methods

addItemListener() removeListener()

Methods that select or return selected items

- select(int index)- getSelectedItem()- getSelectedIndex()

Label ClassConstructors

- Label()- Label(String s)- Label(String s, int alignment)

Alignment constants

- Label.LEFT

-Label.RIGHT

- Label.CENTERAlignment Methods

- getAlignment()- setAlignment(int align)

Text Methods

- getText()- setText()

List ClassConstructors

84

- List()- List(int visibleRows)- List(int visibleRows, Boolean Multipleselections)

Action Listener methods

-addActionListener(), removeActionListener()

Methods that add or remove elements

- add(String item)- replaceItem(String item, int index)- remove(String item), remove(int index)- removeAll()

getItemCount() – returns the number of items in the List Object

ItemListener methods

- addItemListener(), removeItemListener()

Methods that return an element

- getItem(int index)- getItems() returns all the items from the List object as a String array.

Selection methods

-getSelecteItem()

-getSelectedItems()

-getSelectedindex()

-getSelectedIndexes()

- selected(int index)

- deselect(int index)

-isIndexSelected(int index)

ScrollBar classConstructors

- ScrollBar()- ScrollBar(int orientation)- ScrollBar(int orientation, int value, int minimum, int maximum)

The value is initial value of the Scrollbar. The minimum and maximum are the range of values the scrollbar can have. The visible quantity is the range of values represented by the width of the slider. Note that the maximum value that the Scrollbar can reach by moving the slider is equal to maximum – visible.

85

Orientation constants: Scrollbar. HORIZONTAL, Scrollbar. VERTICAL. If they

- If they are not provided to the constructor , the orientatin is set to vertical and the value,visible,minimum and maximum parameters are set to 0.

Adjustment Listener methods

AddAdjustmentListener (AdjustmentListener al removeAdjustmentListener(AdjustmentListener al)

Appearance methods

- getVisibleAmount(),setVisibleAmount(int amount)Orientation methods

- getOrientation()- setOrientation(int orientation)

Range and Increment methods

- getBlockIncrement()- getMaximum()- getMinimum()- setBlockIncrement()- setMaximum(int max)- setMinimum(int min)- setUnitIncrement(int increment)

Methods that return or set the scrollbar

-getValue(), setValue(int value)

- setValues(int value, int visible,int minimum, int maximum)

TextArea classConstructors

TextArea()

TextArea(int rows, int columns)

TextArea(String s)

TextArea(String s, int rows, int cols)

TextArea(String s, int rows, int cols, int scrollbarPolicy)

Scrollbar Policy constants

TextArea.SCROLLBARS_BOTH TextArea.SCROLLBARS_HORIZONTAL_ONLY TextArea.SCROLLBARS_NONE TextArea.SCROLLBARS_VERTICAL_ONLY

Methods to add text

- append(String str)

-insert(String str, int pos)

-replaceRange(String str, int start, int end)

86

Sizing methods

-getRows()

-setRows(int rows)

-getColumns()

-setColumns(int cols)

TextComponent class- This is the parent of both the TextArea and TextField class

Caret methods

Caret is the text cursor

- getCaretPosition()- setCaretPosition(int pos)

Color methods

- getBackground()- setBackground()

Editable Property methods

-isEditable()

- setEditable(Boolean editable)

Selection methods

- getSelectionStart()

- getSelectionEnd()- select(int startindex, int end Index)- selectAll()- setSelectionStart(int startIndex)- setSelectionEnd(int endIndex)

Text methods

-getText()

-setText()

getSelectedText()

Text Listener Methods

AddTextListener(), removeListener()

Text Field ClassTextField() Constructor

- TextField()- TextField(int cols)- TextField(String s)- TextFied(String s, int cols)

ActionListener Methods

87

-addActionListner(ActionListener al), removeActionListener(ActionListener al)

Echo Character methods

- echoCharIsSet()

-getEchoChar()

-setEchoChar()

Sizing Methods

-getColumns()

-setColumns(int columns)

setText method

- setText(String Text)

88