Easy to Learn Java: Programming Articles, Examples and Tips

Start with Java in a few days with Java Lessons or Lectures

Home

Code Examples

Java Tools

More Java Tools!

Java Forum

All Java Tips

Books

Submit News
Search the site here...
Search...
 
Search the JavaFAQ.nu
1000 Java Tips ebook

1000 Java Tips - Click here for the high resolution copy!1000 Java Tips - Click here for the high resolution copy!

Java Screensaver, take it here

Free "1000 Java Tips" eBook is here! It is huge collection of big and small Java programming articles and tips. Please take your copy here.

Take your copy of free "Java Technology Screensaver"!.

Easy Learn Java: Programming Articles, Examples and Tips - Page 473


Previous 1060 Stories (530 Pages, 2 Per Page) Next

Easy Java Lecture 3: OOP programming concepts: theory. Teach/learn online

Go to all tips in Java Lectures by Anatoliy Malyarenko

Object-oriented programming concepts: theory

by Anatoliy Malyarenko

Abstract

  • Contents of the lecture.
  • What is an object?
  • What is a message?
  • What is a class?
  • What is inheritance?
  • What is an interface?

What is an object?


Objects are key to understanding object-oriented technology. You can look around you now and see many examples of real-world objects: your dog, your desk, your television set, your bicycle.

These real-world objects share two characteristics: they all have state and behaviour. For example, dogs have state (name, colour, breed, hungry) and behaviour (barking, fetching, and wagging tail). Bicycles have state (current gear, current pedal cadence, two wheels,
number of gears) and behaviour (braking, accelerating, slowing down, changing gears).

Software objects are modeled after real-world objects in that they too have state and behaviour. a software object maintains its state in one or more variables. a variable is an item of data named by an identifier. a software object implements its behaviour with methods. A
method is a function (subroutine) associated with an object.

Definition 1. An object is a software bundle of variables and related methods.

You can represent real-world objects by using software objects. you might want to represent real-world dogs as software objects in an animation program or a real-world bicycle as a software object in the program that controls an electronic exercise bike. You can also use
software objects to model abstract concepts. For example, an event is a common object used in gui window systems to represent the action of a user pressing a mouse button or a key on the keyboard.

The following illustration is a common visual representation of a software object:

Everything that the software object knows (state) and can do (behaviour) is expressed by the variables and the methods within that object. A software object that modeled your real world bicycle would have variables that indicated the bicycle's current state: its speed is 10
mph, its pedal cadence is 90 rpm, and its current gear is the 5th gear. These variables are formally known as instance variables because they contain the state for a particular bicycle object, and in object-oriented terminology, a particular object is called an instance.

The following figure illustrates a bicycle modeled as a software object.

In addition to its variables, the software bicycle would also have methods to brake, change the pedal cadence, and change gears.
(The bike would not have a method for changing the speed of the bicycle, as the bike's speed is just a side effect of what gear it's
in, how fast the rider is pedaling, whether the brakes are on, and how steep the hill is.) These methods are formally known as instance methods because they inspect or change the state of a particular bicycle instance.

The object diagrams show that the object's variables make up the center, or nucleus, of the object. Methods surround and hide the object's nucleus from other objects in the program. Packaging an object's variables within the protective custody of its methods is called encapsulation. This conceptual picture of an object -- a nucleus of variables packaged within a protective membrane of methods -- is an ideal representation of an object and is the ideal that designers of object-oriented systems strive for. however, it's not the whole story.

Often, for practical reasons, an object may wish to expose some of its variables or hide some of its methods. In the java programming language, an object can specify one of four access levels for each of its variables and methods. The access level determines which other objects and classes can access that variable or method. Encapsulating related variables and methods into a neat software bundle is a simple yet powerful idea that provides two primary benefits to software developers:

Modularity: The source code for an object can be written and maintained independently of the source code for other objects. Also, an object can be easily passed around in the system. you can give your bicycle to someone else, and it will still work.

Information hiding: An object has a public interface that other objects can use to communicate with it. the object can maintain private information and methods that can be changed at any time without affecting the other objects that depend on it. You don't need to understand the gear mechanism on your bike to use it.

What is a message?

A single object alone is generally not very useful. instead, an object usually appears as a component of a larger program or application that contains many other objects. Through the interaction of these objects, programmers achieve higher-order functionality and more complex
behaviour. Your bicycle hanging from a hook in the garage is just a bunch of titanium alloy and rubber; by itself, the bicycle is incapable of any activity. the bicycle is useful only when another object (you) interacts with it (pedal).

Software objects interact and communicate with each other by sending messages to each other. When object A wants object B to perform one of b's methods, object A sends a message to object B:


Sometimes, the receiving object needs more information so that it knows exactly what to do; for example, when you want to change gears on your bicycle, you have to indicate which gear you want. This information is passed along with the message as parameters.

The next figure shows the three components that comprise a message:

  1. The object to which the message is addressed (YourBicycle)
  2. The name of the method to perform (changeGears)
  3. Any parameters needed by the method (lowerGear)

These three components are enough information for the receiving object to perform the desired method. No other information or context is required.

Messages provide two important benefits:

  • An object's behaviour is expressed through its methods, so (aside from direct variable access) message passing supports all possible interactions between objects.
  • Objects don't need to be in the same process or even on the same machine to send and receive messages back and forth to each other.

What is a class?

In the real world, you often have many objects of the same kind. for example, your bicycle is just one of many bicycles in the world. Using object-oriented terminology, we say that your bicycle object is an instance of the class of objects known as bicycles. Bicycles have some state (current gear, current cadence, two wheels) and behaviour (change gears, brake) in common. However, each bicycle's state is independent of and can be different from that of other bicycles.

When building bicycles, manufacturers take advantage of the fact that bicycles share characteristics, building many bicycles from the same blueprint. It would be very inefficient to produce a new blueprint for every individual bicycle manufactured.

In object-oriented software, it's also possible to have many objects of the same kind that share characteristics: rectangles, employee records, video clips, and so on. Like the bicycle manufacturers, you can take advantage of the fact that objects of the same kind are similar
and you can create a blueprint for those objects. A software blueprint for objects is called a class.

Definition 2. a class is a blueprint, or prototype, that defines the variables and the methods common to all objects of a certain kind.

The class for our bicycle example would declare the instance variables necessary to contain the current gear, the current cadence, and so on, for each bicycle object. The class would also declare and provide implementations for the instance methods that allow the rider to change gears, brake, and change the pedaling cadence, as shown in the next figure.

After you've created the bicycle class, you can create any number of bicycle objects from the class. When you create an instance of a class, the system allocates enough memory for the object and all its instance variables. Each instance gets its own copy of all the instance variables defined in the class.

In addition to instance variables, classes can define class variables. A class variable contains information that is shared by all instances of the class. For example, suppose that all bicycles had the same number of gears. In this case, defining an instance variable to hold the number of gears is inefficient; each instance would have its own copy of the variable, but the value would be the same for every instance. In such situations, you can define a class variable that contains the number of gears. all instances share this variable.

If one object changes the variable, it changes for all other objects of that type. a class can also declare class methods. You can invoke a class method directly from the class, whereas you must invoke instance methods on a particular instance.

Objects vs. classes

You probably noticed that the illustrations of objects and classes look very similar. And indeed, the difference between classes and objects is often the source of some confusion.

In the real world, it's obvious that classes are not themselves the objects they describe: a blueprint of a bicycle is not a bicycle. however, it's a little more difficult to differentiate classes and objects in software. This is partially because software objects are merely electronic
models of real-world objects or abstract concepts in the first place. But it's also because the term "object" is sometimes used to refer to both classes and instances.

In the figures, the class is not shaded, because it represents a blueprint of an object rather than an object itself. In comparison, an object is shaded, indicating that the object exists and that you can use it.

What is inheritance?

Generally speaking, objects are defined in terms of classes. you know a lot about an object by knowing its class. Even if you don't know what a penny-farthing is, if i told you it was a bicycle, you would know that it had two wheels, handle bars, and pedals.

Object-oriented systems take this a step further and allow classes to be defined in terms of other classes. For example, mountain bikes, racing bikes, and tandems are all kinds of bicycles. In object-oriented terminology, mountain bikes, racing bikes, and tandems are all
subclasses of the bicycle class. Similarly, the bicycle class is the superclass of mountain bikes, racing bikes, and tandems. This relationship is shown in the following figure.

Each subclass inherits state (in the form of variable declarations) from the superclass. Mountain bikes, racing bikes, and tandems share some states: cadence, speed, and the like. Also, each subclass inherits methods from the superclass. mountain bikes, racing bikes, and
tandems share some behaviours: braking and changing pedaling speed, for example.

However, subclasses are not limited to the state and behaviours provided to them by their superclass. Subclasses can add variables and methods to the ones they inherit from the superclass. Tandem bicycles have two seats and two sets of handle bars; some mountain
bikes have an extra set of gears with a lower gear ratio.

Subclasses can also override inherited methods and provide specialised implementations for those methods. for example, if you had a mountain bike with an extra set of gears, you would override the "change gears" method so that the rider could use those new gears.

You are not limited to just one layer of inheritance. The inheritance tree, or class hierarchy, can be as deep as needed. methods and variables are inherited down through the levels. In general, the farther down in the hierarchy a class appears, the more specialised
its behaviour.

The object class is at the top of class hierarchy, and each class is its descendant (directly or indirectly). a variable of type object can hold a reference to any object, such as an instance of a class or an array. object provides behaviours that are required of all objects running in the java virtual machine. For example, all classes inherit object's tostring method, which returns a string representation of the object.

Inheritance offers the following benefits:

  • Subclasses provide specialised behaviours from the basis of common elements provided by the superclass. Through the use of inheritance, programmers can reuse the code in the superclass many times.
  • Programmers can implement superclasses called abstract classes that define "generic" behaviours. The abstract superclass defines and may partially implement the behaviour, but much of the class is undefined and unimplemented. Other programmers fill in the details with specialised subclasses.

What is an interface?

In english, an interface is a device or a system that unrelated entities use to interact. According to this definition, a remote control is an interface between you and a television set, the english language is an interface between two people, and the protocol of behaviour
enforced in the military is the interface between people of different ranks.

Within the java programming language, an interface is a device that unrelated objects use to interact with each other. An interface is probably most analogous to a protocol (an agreed on behaviour). In fact, other object-oriented languages have the functionality of interfaces, but they call their interfaces protocols.

The bicycle class and its class hierarchy defines what a bicycle can and cannot do in terms of its "bicycleness." but bicycles interact with the world on other terms. For example, a bicycle in a store could be managed by an inventory program. an inventory program doesn't
care what class of items it manages as long as each item provides certain information, such as price and tracking number. Instead of forcing class relationships on otherwise unrelated items, the inventory program sets up a protocol of communication. This protocol comes in the
form of a set of constant and method definitions contained within an interface. The inventory interface would define, but not implement, methods that set and get the retail price, assign a tracking number, and so on.

To work in the inventory program, the bicycle class must agree to this protocol by implementing the interface. When a class implements an interface, the class agrees to implement all the methods defined in the interface. Thus, the bicycle class would provide the implementations for the methods that set and get retail price, assign a tracking number, and so on.

You use an interface to define a protocol of behaviour that can be implemented by any class anywhere in the class hierarchy. Interfaces are useful for the following:

  • Capturing similarities among unrelated classes without artificially forcing a class relationship.
  • Declaring methods that one or more classes are expected to implement. Revealing an object's programming interface without revealing its class.

by Anatoliy Malyarenko


17051 bytes more | comments? | Printer Friendly Page  Send to a Friend | Score: 3
Posted by Javaaddict on Tuesday, September 12, 2006 (20:00:00) (9752 reads)

Easy Java lecture 2: A quick intro to Java programming. Teach/learn online

Go to all tips in Java Lectures by Anatoliy Malyarenko
All Java Lectures contents page | Java lecture 1: Your first cup of Java | Java lecture 2: A quick introduction to Java programming | Java Lecture 3: Object-oriented programming concepts: theory. | Java Lecture 4: Object-oriented programming concepts: example. | Java Lecture 5: Variables | Java Lecture 6: Operators | Java Lecture 7: Expressions, statements, and blocks | Java Lecture 8: Control flow statements | Java Lecture 9: The life cycle of an object | Java Lecture 10: Characters and strings | Java Lecture 11: Numbers and arrays | Java Lecture 12: Classes | Java Lecture 12a: Introduction to Painting Concepts | Java Lecture 13: Inheritance in Java. Part I | Java Lecture 13: Inheritance in Java. Part II | Java Lecture 14: Interfaces and packages. Part I. | Java Lecture 14: Interfaces and packages. Part II. | Java Lecture 15: Swing I. Part I |

A quick introduction to Java programming

by Anatoliy Malyarenko

Abstract

  • Contents of the lecture.
  • Comments in Java code.
  • Defining a class.
  • The main method.
  • Using classes and objects.
  • Importing classes and packages.
  • Defining an applet subclass.
  • Implementing applet methods.
  • Running an applet.

A closer look at HelloWorld

Now that you've seen a Java application (and perhaps even compiled and run it), you might be wondering how it works and how similar it is to other Java applications. Remember that a Java application is a stand-alone Java program -- a program written in the Java language that runs independently of any browser.

We dissect the "Hello World" application you've already seen. Here, again, is its code:

Code:

/**
* File: HelloWorld.java
* Description: First application
* Author: your name
* Mail: your e-mail address
*/
public class HelloWorldApp {
   public static void main(String[] args) {
      // Display "Hello World!"
      System.out.println("Hello World!");
   }
}

Comments in Java code
The bold characters in the following listing are comments.

Code:

/**
* File: HelloWorld.java
* Description: First application
* Author: your name
* Mail: your e-mail address
*/
public class HelloWorldApp {
   public static void main(String[] args) { // Display "Hello World!"
      System.out.println("Hello World!");
   }
}

The Java language supports three kinds of comments:

/* text */
The compiler ignores everything from /* to */.

/** documentation */
This indicates a documentation comment (doc comment, for short).
The compiler ignores this kind of comment, just like it ignores comments that use /* and */. The JDK
javadoc tool uses doc comments when preparing automatically generated documentation.

// text
The compiler ignores everything from // to the end of the line.

Defining a class

The first line in the following listing begins a class definition block.

Code:

/**
* File: HelloWorld.java
* Description: First application
* Author: your name
* Mail: your e-mail address
*/
class HelloWorldApp {
   public static void main(String[] args) {
      // Display "Hello World!"
      System.out.println("Hello World!");
   }
}
A class -- the basic building block of an object-oriented language such as Java -- is a template that describes the data and behaviour associated with instances of that class. When you instantiate a class you create an object that looks and feels like other instances of the same class. The data associated with a class or object is stored in variables; the behaviour associated with a class or object is implemented with methods. Methods are similar to the functions or procedures in procedural languages such as C.

A traditional example from the world of programming is a class that represents a rectangle. The class would contain variables for the origin of the rectangle, its width, and its height. The class might also contain a method that calculates the area of the rectangle. An instance of the rectangle class would contain the information for a specific rectangle, such as the dimensions of the floor of your office, or the dimensions of this page.

In the Java language, the simplest form of a class definition is:

Code:


class name {
   . . .
}

The keyword class begins the class definition for a class named name. The curly brackets begin and end the class definition block. The "Hello World" application has no variables and has a single method named main.

The main method

The first line in the following listing begins the definition of a main method.

Code:

/**
* File: HelloWorld.java
* Description: First application
* Author: your name
* Mail: your e-mail address
*/
class HelloWorldApp {
   public static void main(String[] args) {
      // Display "Hello World!"
      System.out.println("Hello World!");
   }
}

Every Java application must contain a main method whose signature looks like this:

    public static void main(String[] args)

The method signature for the main method contains three modifiers:

  • public indicates that the main method can be called by any object.
  • static indicates that the main method is a class method.
  • void indicates that the main method doesn't return any value.

How the main method gets called?

The main method in the Java language is similar to the main function in C and C++. When the Java interpreter executes an application (by being invoked upon the application's controlling class), it starts by calling the class's main method. The main method then calls all the other methods required to run your application.

If you try to invoke the Java interpreter on a class that does not have a main method, the interpreter refuses to run your program and displays an error message similar to this:

In class NoMain: void
main(String argv[]) is not defined

Arguments to the main method

As you can see from the following code snippet, the main method accepts a single argument: an array of elements of type String.

    public static void main(String[] args)

This array is the mechanism through which the runtime system passes information to your application. Each String in the array is called a command-line argument. Command-line arguments let users affect the operation of the application without recompiling it. For example, a sorting program might allow the user to specify that the data be sorted in descending order with this command-line argument:

-descending

The "Hello World" application ignores its command-line arguments, so there isn't much more to discuss here.

Using classes and objects

The "Hello World" application is about the simplest Java program you can write that actually does something. Because it is such a simple program, it doesn't need to define any classes except for HelloWorldApp. However, most programs that you write will be more complex and require you to write other classes and supporting Java code.

The "Hello World" application does use another class -- the System class -- that is part of the API (application programming interface) provided with the Java environment. The System class provides system-independent access to system-dependent functionality.

The bold code in the following listing illustrates the use of a class variable of the System class, and of an instance method.

Code:

/**
* File: HelloWorld.java
* Description: First application
* Author: your name
* Mail: your e-mail address
*/
class HelloWorldApp {
   public static void main(String[] args) {
      // Display "Hello World!"
      System.out.println("Hello World!");
   }
}

Using a class method or variable

Let's take a look at the first segment of the statement:

    System.out.println("Hello World!");

The construction System.out is the full name of the out variable in the System class.

Notice that the application never instantiates the System class and that out is referred to directly from the class name. This is because out is a class variable -- a variable associated with the class rather than with an instance of the class. You can also associate methods with a class -- class methods.

To refer to class variables and methods, you join the class name and the name of the class method or class variable together with a period (".").

Using an instance method or variable

Methods and variables that are not class methods or class variables are known as instance methods and instance variables. To refer to instance methods and variables, you must reference the methods and variables from an object.

While System's out variable is a class variable, it refers to an instance of the PrintStream class (a class provided with the Java development environment) that implements the standard output stream.

When the System class is loaded into the application, it instantiates PrintStream and assigns the new PrintStream object to the out class variable. Now that you have an instance of a class, you can call one of its instance methods:

    System.out.println("Hello World!");

As you can see, you refer to instance methods and variables similarly to the way you refer to class methods and variables. You join an object reference (out) and the name of the instance method or variable (println) together with a period (".").

The Java compiler allows you to cascade references to class and instance methods and variables together, resulting in constructs like the one that appears in the sample program:

    System.out.println("Hello World!");

This line of code displays "Hello World!" to the application's standard output stream.

Summary

A class method or class variable is associated with a particular class. The runtime system allocates a class variable once per class, no matter how many instances exist of that class. You access class variables and methods through the class.

An instance method or instance variable is associated with a particular object (an instance of a class). Every time you create an object, the new object gets a copy of every instance variable defined in its class. You access instance variables and methods through objects.

The anatomy of an applet

Now that you've seen a Java applet, you're probably wondering how it works. Remember that a Java applet is a program that adheres to a set of conventions that allows it to run within a Java-compatible browser.

Here again is the code for the "Hello World" applet.

Code:

import java.applet.Applet;
import java.awt.Graphics;
public class HelloWorld extends Applet {
   public void paint(Graphics g) {
      g.drawString("Hello world!", 50, 25);
   }
}

Importing classes and packages

The first two lines of the following listing import two classes used in the applet: Applet and Graphics.

Code:

import java.applet.Applet;
import java.awt.Graphics;

public class HelloWorld extends Applet {
   public void paint(Graphics g) {
      g.drawString("Hello world!", 50, 25);
   }
}

If you removed the first two lines, the applet could still compile and run, but only if you changed the rest of the code like this:

Code:

public class HelloWorld extends
      java.applet.Applet {
   public void paint(java.awt.Graphics g) {
      g.drawString("Hello world!", 50, 25);
   }
}

As you can see, importing the Applet and Graphics classes lets the program refer to them later without any prefixes. The java.applet. and java.awt. prefixes tell the compiler which packages it should search for the Applet and Graphics classes. Both the java.applet and java.awt packages are part of the core Java API -- API that every Java program can count on being in the Java environment. The java.applet package contains classes that are essential to Java applets. The java.awt package contains the most frequently used classes in the Abstract Window Toolkit (AWT), which provides the Java graphical user interface (GUI).

You might have noticed that the example at p. 0 uses the System class without any prefix, and yet does not import the System class. The reason is that the System class is part of the java.lang package, and everything in the java.lang package is automatically imported into every Java program.

Besides importing individual classes, you can also import entire packages. Here's an example:

Code:

import java.applet.*;
import java.awt.*;

public class HelloWorld extends Applet {
   public void paint(Graphics g) {
      g.drawString("Hello world!", 50, 25);
   }
}

In the Java language, every class is in a package. If the source code for a class doesn't have a package statement at the top, declaring the package the class is in, then the class is in the default package. Almost all of the example classes in these lectures are in the default package.

Within a package, all classes can refer to each other without prefixes. For example, the java.awt Component class refers to the java.awt Graphics class without any prefixes, without importing the Graphics class.

Defining an applet subclass

The first bold line of the following listing begins a block that defines the HelloWorld class.

Code:

import java.applet.*;
import java.awt.*;
public class HelloWorld extends Applet {
   public void paint(Graphics g) {
      g.drawString("Hello world!", 50, 25);
   }
}

The extends keyword indicates that HelloWorld is a subclass of the class whose name follows: Applet.

From the Applet class, applets inherit a great deal of functionality. Perhaps most important is the ability to respond to browser requests. For example, when a Java-capable browser loads a page containing an applet, the browser sends a request to the applet, telling the applet to initialize itself and start executing.

An applet isn't restricted to defining just one class. Besides the necessary Applet subclass, an applet can define additional custom classes. When the applet attempts to use a class, the application that's executing the applet first looks on the local host for the class. If the class isn't available locally, it's loaded from the location that the Applet subclass originated from.

Implementing applet methods

The lines of the following listing implement the paint method.

Code:

import java.applet.*;
import java.awt.*;
public class HelloWorld extends Applet {
   public void paint(Graphics g) {
      g.drawString("Hello world!", 50, 25);
   }
}

Every applet must implement one or more of the init, start, and paint methods.
Besides the init, start, and paint methods, applets can implement two more methods that the browser calls when a major event occurs (such as leaving the applet's page):

stop and destroy. Applets can implement any number of other methods, as well.

Returning to the above code snippet, the Graphics object passed into the paint method represents the applet's on-screen drawing context. The first argument to the Graphics drawString method is the string to draw on-screen. The second and third arguments are the (x, y) position of the lower left corner of the text on-screen. This applet draws the string "Hello world!" starting at location (50, 25). The applet's coordinate system starts at (0, 0), which is at the upper left corner of the applet's display area.

Running an applet

The bold lines of the following listing comprise the <APPLET> tag that includes the "Hello World" applet in an HTML page.

Code:

<HTML>
   <HEAD>
      <TITLE>MyApplet Example1</TITLE>
   </HEAD>
   <BODY>
      <H1>MyApplet</H1>
      <HR>
      <P>
         <APPLET CODE="HelloWorld.class"
            WIDTH="300" HEIGHT="300">
         </APPLET>
      </P>
      <HR>
   </BODY>
</HTML>

The above <APPLET> tag specifies that the browser should load the class whose compiled code is in the file named HelloWorld.class. The browser looks for this file in the same directory as the HTML document that contains the tag.

When the browser finds the class file, it loads it over the network, if necessary, onto the computer the browser is running on. The browser then creates an instance of the class. If you include an applet twice in one page, the browser loads the class file once and creates two instances of the class.

The WIDTH and HEIGHT attributes are like the same attributes in an <IMG> tag. They specify the size in pixels of the applet's display area. Most browsers do not let the applet resize itself to be larger or smaller than this display area. For example, every bit of drawing that the "Hello World" applet does in its paint method occurs within the 150 ? 25-pixel display area that the above <APPLET> tag reserves for it.
16861 bytes more | comments? | Printer Friendly Page  Send to a Friend | Score: 0
Posted by jalex on Sunday, September 10, 2006 (01:00:00) (8434 reads)

Previous 1060 Stories (530 Pages, 2 Per Page) Next

530| 529| 528| 527| 526| 525| 524| 523| 522| 521| 520| 519| 518| 517| 516| 515| 514| 513| 512| 511| 510| 509| 508| 507| 506| 505| 504| 503| 502| 501| 500| 499| 498| 497| 496| 495| 494| 493| 492| 491| 490| 489| 488| 487| 486| 485| 484| 483| 482| 481| 480| 479| 478| 477| 476| 475| 474|
473
| 472| 471| 470| 469| 468| 467| 466| 465| 464| 463| 462| 461| 460| 459| 458| 457| 456| 455| 454| 453| 452| 451| 450| 449| 448| 447| 446| 445| 444| 443| 442| 441| 440| 439| 438| 437| 436| 435| 434| 433| 432| 431| 430| 429| 428| 427| 426| 425| 424| 423| 422| 421| 420| 419| 418| 417| 416| 415| 414| 413| 412| 411| 410| 409| 408| 407| 406| 405| 404| 403| 402| 401| 400| 399| 398| 397| 396| 395| 394| 393| 392| 391| 390| 389| 388| 387| 386| 385| 384| 383| 382| 381| 380| 379| 378| 377| 376| 375| 374| 373| 372| 371| 370| 369| 368| 367| 366| 365| 364| 363| 362| 361| 360| 359| 358| 357| 356| 355| 354| 353| 352| 351| 350| 349| 348| 347| 346| 345| 344| 343| 342| 341| 340| 339| 338| 337| 336| 335| 334| 333| 332| 331| 330| 329| 328| 327| 326| 325| 324| 323| 322| 321| 320| 319| 318| 317| 316| 315| 314| 313| 312| 311| 310| 309| 308| 307| 306| 305| 304| 303| 302| 301| 300| 299| 298| 297| 296| 295| 294| 293| 292| 291| 290| 289| 288| 287| 286| 285| 284| 283| 282| 281| 280| 279| 278| 277| 276| 275| 274| 273| 272| 271| 270| 269| 268| 267| 266| 265| 264| 263| 262| 261| 260| 259| 258| 257| 256| 255| 254| 253| 252| 251| 250| 249| 248| 247| 246| 245| 244| 243| 242| 241| 240| 239| 238| 237| 236| 235| 234| 233| 232| 231| 230| 229| 228| 227| 226| 225| 224| 223| 222| 221| 220| 219| 218| 217| 216| 215| 214| 213| 212| 211| 210| 209| 208| 207| 206| 205| 204| 203| 202| 201| 200| 199| 198| 197| 196| 195| 194| 193| 192| 191| 190| 189| 188| 187| 186| 185| 184| 183| 182| 181| 180| 179| 178| 177| 176| 175| 174| 173| 172| 171| 170| 169| 168| 167| 166| 165| 164| 163| 162| 161| 160| 159| 158| 157| 156| 155| 154| 153| 152| 151| 150| 149| 148| 147| 146| 145| 144| 143| 142| 141| 140| 139| 138| 137| 136| 135| 134| 133| 132| 131| 130| 129| 128| 127| 126| 125| 124| 123| 122| 121| 120| 119| 118| 117| 116| 115| 114| 113| 112| 111| 110| 109| 108| 107| 106| 105| 104| 103| 102| 101| 100| 99| 98| 97| 96| 95| 94| 93| 92| 91| 90| 89| 88| 87| 86| 85| 84| 83| 82| 81| 80| 79| 78| 77| 76| 75| 74| 73| 72| 71| 70| 69| 68| 67| 66| 65| 64| 63| 62| 61| 60| 59| 58| 57| 56| 55| 54| 53| 52| 51| 50| 49| 48| 47| 46| 45| 44| 43| 42| 41| 40| 39| 38| 37| 36| 35| 34| 33| 32| 31| 30| 29| 28| 27| 26| 25| 24| 23| 22| 21| 20| 19| 18| 17| 16| 15| 14| 13| 12| 11| 10| 9| 8| 7| 6| 5| 4| 3| 2| 1|


Home Code Examples Java Forum All Java Tips Books Submit News, Code... Search... Offshore Software Tech Doodling

RSS feed Java FAQ RSS feed Java FAQ News     

    RSS feed Java Forums RSS feed Java Forums

All logos and trademarks in this site are property of their respective owner. The comments are property of their posters, all the rest 1999-2006 by Java FAQs Daily Tips.

Interactive software released under GNU GPL, Code Credits, Privacy Policy