Java-Tutorial by stariya

VIEWS: 5 PAGES: 43

									Java is an object-oriented programming language developed by James Gosling and colleagues
at Sun Microsystems in the early 1990s. Unlike conventional languages which are generally
designed either to be compiled to native (machine) code, or to be interpreted from source code at
runtime, Java is intended to be compiled to a bytecode, which is then run (generally using JIT
compilation) by a Java Virtual Machine.

The language itself borrows much syntax from C and C++ but has a simpler object model and
fewer low-level facilities. Java is only distantly related to JavaScript, though they have similar
names and share a C-like syntax.

History

Java was started as a project called "Oak" by James Gosling in June 1991. Gosling's goals were
to implement a virtual machine and a language that had a familiar C-like notation but with greater
uniformity and simplicity than C/C++. The first public implementation was Java 1.0 in 1995. It
made the promise of "Write Once, Run Anywhere", with free runtimes on popular platforms. It
was fairly secure and its security was configurable, allowing for network and file access to be
limited. The major web browsers soon incorporated it into their standard configurations in a
secure "applet" configuration. popular quickly. New versions for large and small platforms (J2EE
and J2ME) soon were designed with the advent of "Java 2". Sun has not announced any plans
for a "Java 3".

In 1997, Sun approached the ISO/IEC JTC1 standards body and later the Ecma International to
formalize Java, but it soon withdrew from the process. Java remains a proprietary de facto
standard that is controlled through the Java Community Process. Sun makes most of its Java
implementations available without charge, with revenue being generated by specialized products
such as the Java Enterprise System. Sun distinguishes between its Software Development Kit
(SDK) and Runtime Environment (JRE) which is a subset of the SDK, the primary distinction
being that in the JRE the compiler is not present.

Philosophy

There were five primary goals in the creation of the Java language:

1. It should use the object-oriented programming methodology.
2. It should allow the same program to be executed on multiple operating systems.
3. It should contain built-in support for using computer networks.
4. It should be designed to execute code from remote sources securely.
5. It should be easy to use by selecting what was considered the good parts of other object-
oriented languages.

To achieve the goals of networking support and remote code execution, Java programmers
sometimes find it necessary to use extensions such as CORBA, Internet Communications
Engine, or OSGi.

Object orientation

The first characteristic, object orientation ("OO"), refers to a method of programming and
language design. Although there are many interpretations of OO, one primary distinguishing idea
is to design software so that the various types of data it manipulates are combined together with
their relevant operations. Thus, data and code are combined into entities called objects. An object
can be thought of as a self-contained bundle of behavior (code) and state (data). The principle is
to separate the things that change from the things that stay the same; often, a change to some
data structure requires a corresponding change to the code that operates on that data, or vice
versa. This separation into coherent objects provides a more stable foundation for a software
system's design. The intent is to make large software projects easier to manage, thus improving
quality and reducing the number of failed projects.

Another primary goal of OO programming is to develop more generic objects so that software can
become more reusable between projects. A generic "customer" object, for example, should have
roughly the same basic set of behaviors between different software projects, especially when
these projects overlap on some fundamental level as they often do in large organizations. In this
sense, software objects can hopefully be seen more as pluggable components, helping the
software industry build projects largely from existing and well-tested pieces, thus leading to a
massive reduction in development times. Software reusability has met with mixed practical
results, with two main difficulties: the design of truly generic objects is poorly understood, and a
methodology for broad communication of reuse opportunities is lacking. Some open source
communities want to help ease the reuse problem, by providing authors with ways to disseminate
information about generally reusable objects and object libraries.

Platform independence

The second characteristic, platform independence, means that programs written in the Java
language must run similarly on diverse hardware. One should be able to write a program once
and run it anywhere.

This is achieved by most Java compilers by compiling the Java language code "halfway" to
bytecode (specifically Java bytecode)—simplified machine instructions specific to the Java
platform. The code is then run on a virtual machine (VM), a program written in native code on the
host hardware that interprets and executes generic Java bytecode. Further, standardized libraries
are provided to allow access to features of the host machines (such as graphics, threading and
networking) in unified ways. Note that, although there's an explicit compiling stage, at some point,
the Java bytecode is interpreted or converted to native machine instructions by the JIT compiler.

There are also implementations of Java compilers that compile to native object code, such as
GCJ, removing the intermediate bytecode stage, but the output of these compilers can only be
run on a single architecture.

Sun's license for Java insists that all implementations be "compatible". This resulted in a legal
dispute with Microsoft after Sun claimed that the Microsoft implementation did not support the
RMI and JNI interfaces and had added platform-specific features of their own. In response,
Microsoft no longer ships Java with Windows, and in recent versions of Windows, Internet
Explorer cannot support Java applets without a third-party plug-in. However, Sun and others have
made available Java run-time systems at no cost for those and other versions of Windows.

The first implementations of the language used an interpreted virtual machine to achieve
portability. These implementations produced programs that ran more slowly than programs
compiled to native executables, for instance written in C or C++, so the language suffered a
reputation for poor performance. More recent JVM implementations produce programs that run
significantly faster than before, using multiple techniques.

The first technique is to simply compile directly into native code like a more traditional compiler,
skipping bytecodes entirely. This achieves good performance, but at the expense of portability.
Another technique, known as just-in-time compilation (JIT), translates the Java bytecodes into
native code at the time that the program is run which results in a program that executes faster
than interpreted code but also incurs compilation overhead during execution. More sophisticated
VMs use dynamic recompilation, in which the VM can analyze the behavior of the running
program and selectively recompile and optimize critical parts of the program. Dynamic
recompilation can achieve optimizations superior to static compilation because the dynamic
compiler can base optimizations on knowledge about the runtime environment and the set of
loaded classes. JIT compilation and dynamic recompilation allow Java programs to take
advantage of the speed of native code without losing portability.

Portability is a technically difficult goal to achieve, and Java's success at that goal has been
mixed. Although it is indeed possible to write programs for the Java platform that behave
consistently across many host platforms, the large number of available platforms with small errors
or inconsistencies led some to parody Sun's "Write once, run anywhere" slogan as "Write once,
debug everywhere".

Platform-independent Java is however very successful with server-side applications, such as
Web services, servlets, and Enterprise JavaBeans, as well as with Embedded systems based on
OSGi, using Embedded Java environments.

Automatic garbage collection

One idea behind Java's automatic memory management model is that programmers should be
spared the burden of having to perform manual memory management. In some languages the
programmer allocates memory to create any object stored on the heap and is responsible for later
manually deallocating that memory to delete any such objects. If a programmer forgets to
deallocate memory or writes code that fails to do so in a timely fashion, a memory leak can occur:
the program will consume a potentially arbitrarily large amount of memory. In addition, if a region
of memory is deallocated twice, the program can become unstable and may crash. Finally, in non
garbage collected environments, there is a certain degree of overhead and complexity of user-
code to track and finalize allocations.

In Java, this potential problem is avoided by automatic garbage collection. The programmer
determines when objects are created, and the Java runtime is responsible for managing the
object's lifecycle. The program or other objects can reference an object by holding a reference to
it (which, from a low-level point of view, is its address on the heap). When no references to an
object remain, the Java garbage collector automatically deletes the unreachable object, freeing
memory and preventing a memory leak. Memory leaks may still occur if a programmer's code
holds a reference to an object that is no longer needed—in other words, they can still occur but at
higher conceptual levels.

The use of garbage collection in a language can also affect programming paradigms. If, for
example, the developer assumes that the cost of memory allocation/recollection is low, they may
choose to more freely construct objects instead of pre-initializing, holding and reusing them. With
the small cost of potential performance penalties (inner-loop construction of large/complex
objects), this facilitates thread-isolation (no need to synchronize as different threads work on
different object instances) and data-hiding. The use of transient immutable value-objects
minimizes side-effect programming.

Comparing Java and C++, it is possible in C++ to implement similar functionality (for example, a
memory management model for specific classes can be designed in C++ to improve speed and
lower memory fragmentation considerably), with the possible cost of extra development time and
some application complexity. In Java, garbage collection is built-in and virtually invisible to the
developer. That is, developers may have no notion of when garbage collection will take place as it
may not necessarily correlate with any actions being explicitly performed by the code they write.
Depending on intended application, this can be beneficial or disadvantageous: the programmer is
freed from performing low-level tasks, but at the same time loses the option of writing lower level
code.
Syntax

The syntax of Java is largely derived from C++. However, unlike C++, which combines the syntax
for structured, generic, and object-oriented programming, Java was built from the ground up to be
virtually fully object-oriented: everything in Java is an object with the exceptions of atomic
datatypes (ordinal and real numbers, boolean values, and characters) and everything in Java is
written inside a class.

Applet

Java applets are programs that are embedded in other applications, typically in a Web page
displayed in a Web browser.

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

public class Hello extends Applet {
public void paint(Graphics gc) {
gc.drawString("Hello, world!", 65, 95);
}
}

This applet will simply draw the string "Hello, world!" in the rectangle within which the applet will
run. This is a slightly better example of using Java's OO features in that the class explicitly
extends the basic "Applet" class, that it overrides the "paint" method and that it uses import
statements.

<!-- Hello.html -->
<html>
<head>
<title>Hello World Applet</title>
</head>
<body>
<applet code="Hello" width="200" height="200">
</applet>
</body>
</html>

An applet is placed in an HTML document using the <applet> HTML element. The applet tag has
three attributes set: code="Hello" specifies the name of the Applet class and width="200"
height="200" sets the pixel width and height of the applet. (Applets may also be embedded in
HTML using either the object or embed element, although support for these elements by Web
browsers is inconsistent.

Servlet

Java servlets are server-side Java EE components that generate responses to requests from
clients.

// Hello.java
import java.io.*;
import javax.servlet.*;

public class Hello extends GenericServlet {
public void service(ServletRequest request, ServletResponse response)
throws ServletException, IOException
{
response.setContentType("text/html");
PrintWriter pw = response.getWriter();
pw.println("Hello, world!");
pw.close();
}
}

The import statements direct the Java compiler to include all of the public classes and interfaces
from the java.io and javax.servlet packages in the compilation. The Hello class extends the
GenericServlet class; the GenericServlet class provides the interface for the server to forward
requests to the servlet and control the servlet's lifecycle.

The Hello class overrides the service(ServletRequest, ServletResponse) method defined by the
Servlet interface to provide the code for the service request handler. The service() method is
passed a ServletRequest object that contains the request from the client and a ServletResponse
object used to create the response returned to the client. The service() method declares that it
throws the exceptions ServletException and IOException if a problem prevents it from responding
to the request.

The setContentType(String) method in the response object is called to set the MIME content type
of the returned data to "text/html". The getWriter() method in the response returns a PrintWriter
object that is used to write the data that is sent to the client. The println(String) method is called to
write the "Hello, world!" string to the response and then the close() method is called to close the
print writer, which causes the data that has been written to the stream to be returned to the client.

Swing application

Swing is the advanced graphical user interface library for the Java SE platform.

// Hello.java
import javax.swing.*;

public class Hello extends JFrame {
Hello() {
setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
add(new JLabel("Hello, world!"));
pack();
}

public static void main(String[] args) {
new Hello().setVisible(true);
}
}

The import statement directs the Java compiler to include all of the public classes and interfaces
from the javax.swing package in the compilation. The Hello class extends the JFrame class; the
JFrame class implements a window with a title bar with a close control.

The Hello() constructor initializes the frame by first calling the setDefaultCloseOperation(int)
method inherited from JFrame to set the default operation when the close control on the title bar
is selected to WindowConstants.DISPOSE_ON_CLOSE—this causes the JFrame to be disposed
of when the frame is closed (as opposed to merely hidden), which allows the JVM to exit and the
program to terminate. Next a new JLabel is created for the string "Hello, world!" and the
add(Component) method inherited from the Container superclass is called to add the label to the
frame. The pack() method inherited from the Window superclass is called to size the window and
layout its contents.

The main() method is called by the JVM when the program starts. It instantiates a new Hello
frame and causes it to be displayed by calling the setVisible(boolean) method inherited from the
Component superclass with the boolean parameter true. Note that once the frame is displayed,
exiting the main method does not cause the program to terminate because the AWT event
dispatching thread remains active until all of the Swing top-level windows have been disposed.

Look and feel

The default look and feel of GUI applications written in Java using the Swing toolkit is very
different from native applications. It is possible to specify a different look and feel through the
pluggable look and feel system of Swing. Clones of Windows, GTK and Motif are supplied by
Sun. Apple also provides an Aqua look and feel for Mac OS X. Though prior implementations of
these look and feels have been considered lacking, Swing in Java SE 6 addresses this problem
by using more native widget drawing routines of the underlying platforms. Alternatively, third party
toolkits such as wx4j or SWT may be used for increased integration with the native windowing
system.

Lack of OO purity and facilities

Java's primitive types are not objects. Primitive types hold their values in the stack rather than
being references to values. This was a conscious decision by Java's designers for performance
reasons. Because of this, Java is not considered to be a pure object-oriented programming
language. However, as of Java 5.0, autoboxing enables programmers to write as if primitive types
are their wrapper classes, and freely interchange between them for improved flexibility. Java
designers decided not to implement certain features present in other OO languages, including:

* multiple inheritance
* operator overloading
* class properties
* tuples

Java Runtime Environment

The Java Runtime Environment or JRE is the software required to run any application deployed
on the Java Platform. End-users commonly use a JRE in software packages and Web browser
plugins. Sun also distributes a superset of the JRE called the Java 2 SDK (more commonly
known as the JDK), which includes development tools such as the Java compiler, Javadoc, and
debugger.




                                      Java Data and Variables

There are 8 primitive data types. he 8 primitive data types are numeric types. The names of the
eight primitive data types are:



             byte     short     int    long     float    double      char     boolean

There are both integer and floating point primitive types. Integer types have no fractional part;
floating point types have a fractional part. On paper, integers have no decimal point, and floating
point types do. But in main memory, there are no decimal points: even floating point values are
represented with bit patterns. There is a fundamental difference between the method used to
represent integers and the method used to represent floating point numbers.


Integer Primitive Data Types
Type          Size                Range
byte          8 bits              -128 to +127
short         16 bits             -32,768 to +32,767
int           32 bits             (about)-2 billion to +2 billion
long          64 bits             (about)-10E18 to +10E18

Floating Point Primitive Data Types
Type                 Size               Range
float                32 bits            -3.4E+38 to +3.4E+38
double               64 bits            -1.7E+308 to 1.7E+308
Examples

int yr = 2006;
double rats = 8912 ;

     For each primitive type, there is a corresponding wrapper class. A wrapper class can be
used to convert a primitive data value into an object, and some type of objects into primitive data.
The table shows primitive types and their wrapper classes:


                 primitive type                                     Wrapper type
byte                                                 Byte
short                                                Short
int                                                  Int
long                                                 Long
float                                                Float
double                                               Double
char                                                 Character
boolean                                              Boolean
 Variables only exist within the structure in which they are defined. For example, if a variable is
created within a method, it cannot be accessed outside the method. In addition, a different
method can create a variable of the same name which will not conflict with the other variable. A
java variable can be thought of as a little box made up of one or more bytes that can hold a value
of a particular data type:

Syntax: variabletype variablename = data;

Source Code ( demonstrating declaration of a variable )
class example
{
  public static void main ( String[] args )
  {
    long x = 123; //a declaration of a variable named x with a datatype of long

        System.out.println("The variable x has: " + x );
    }
}

Source Code


public class MaxDemo {
   public static void main(String args[]) {
   //integers
       byte largestByte = Byte.MAX_VALUE;
       short largestShort = Short.MAX_VALUE;
       int largestInteger = Integer.MAX_VALUE;
       long largestLong = Long.MAX_VALUE;

            //real numbers
            float largestFloat = Float.MAX_VALUE;
            double largestDouble = Double.MAX_VALUE;

             //other primitive types
            char aChar = 'S';
            boolean aBoolean = true;

            //Display them all.
            System.out.println("largest      byte value is " + largestByte + ".");
            System.out.println("largest      short value is " + largestShort + ".");
            System.out.println("largest      integer value is " + largestInteger + ".");
            System.out.println("largest      long value is " + largestLong + ".");
            System.out.println("largest      float value is " + largestFloat + ".");
            System.out.println("largest      double value is " + largestDouble + ".");
        }
}

Sample Run

The largest byte value is 127.
The largest short value is 32767.
The largest integer value is 2147483647.
The largest long value is 9223372036854775807.
The largest float value is 3.4028235E38.
The largest double value is 1.7976931348623157E308.

The Java programming language has includes five simple arithmetic operators like are +
(addition), - (subtraction), * (multiplication), / (division), and % (modulo). The following table
summarizes the binary arithmetic operators in the Java programming language.
The relation operators in Java are: ==, !=, <, >, <=, and >=. The meanings of these operators
are:


                                                                                           Returns
Use
                                                                                           true if


                                                                                             op1
op1 + op2                                                                                    added
                                                                                             to op2
                                                                                         op2
op1 - op2                                                                                subtracted
                                                                                         from op1


                                                                                          op1
op1 * op2                                                                                 multiplied
                                                                                          with op2
                                                                                            op1
op1 / op2                                                                                   divided
                                                                                            by op2


                                                                                         Computes
                                                                                         the
                                                                                         remainder
op1 % op2
                                                                                         of dividing
                                                                                         op1 by
                                                                                         op2
The following java program, ArithmeticProg , defines two integers and two double-precision
floating-point numbers and uses the five arithmetic operators to perform different arithmetic
operations. This program also uses + to concatenate strings. The arithmetic operations are
shown in boldface.

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

            //a few numbers
            int i = 10;
            int j = 20;
            double x = 10.5;
            double y = 20.5;

            //adding numbers
            System.out.println("Adding");
            System.out.println(" i + j = " + (i + j));
            System.out.println(" x + y = " + (x + y));

            //subtracting numbers
            System.out.println("Subtracting");
            System.out.println(" i - j = " + (i - j));
            System.out.println(" x - y = " + (x - y));
             //multiplying numbers
             System.out.println("Multiplying");
             System.out.println(" i * j = " + (i * j));
             System.out.println(" x * y = " + (x * y));

             //dividing numbers
             System.out.println("Dividing");
             System.out.println(" i / j = " + (i / j));
             System.out.println(" x / y = " + (x / y));

             //computing the remainder resulting
             //from dividing numbers
             System.out.println("Modulus");
             System.out.println(" i % j = " + (i % j));
             System.out.println(" x % y = " + (x % y));

      }
}
                                    Java Assignment Operators

It's very common to see statement like the following, where you're adding something to a
variable. Java Variables are assigned, or given, values using one of the assignment operators.
The variable are always on the left-hand side of the assignment operator and the value to be
assigned is always on the right-hand side of the assignment operator. The assignment operator is
evaluated from right to left, so a = b = c = 0; would assign 0 to c, then c to b then b to a.

i = i + 2;

Here we say that we are assigning i's value to the new value which is i+2.

A shortcut way to write assignments like this is to use the += operator. It's one operator symbol
so don't put blanks between the + and =.
i += 2; // Same as "i = i + 2"

The shortcut assignment operator can be used for all Arithmetic Operators i.e. You can use this
style with all arithmetic operators (+, -, *, /, and even %).



Here are some examples of assignments:

//assign 1 to
//variable a
int a = 1;

//assign the result
//of 2 + 2 to b
int b = 2 + 2;
//assign the literal
//"Hello" to str
String str = new String("Hello");

//assign b to a, then assign a
//to d; results in d, a, and b being equal
int d = a = b;

There are 2 Increment or decrement operators -> ++ and --. These two operators are unique in
that they can be written both before the operand they are applied to, called prefix
increment/decrement, or after, called postfix increment/decrement. The meaning is different in
each case.

Example

x = 1;
y = ++x;
System.out.println(y);

prints 2, but

x = 1;
y = x++;
System.out.println(y);

prints 1

Source Code


//Count to ten

class UptoTen {

    public static void main (String args[]) {
      int i;
      for (i=1; i <=10; i++) {
        System.out.println(i);
      }
     }

}

When we write i++ we're using shorthand for i = i + 1. When we say i-- we're using shorthand for i
= i - 1. Adding and subtracting one from a number are such common operations that these
special increment and decrement operators have been added to the language. T
There's another short hand for the general add and assign operation, +=. We would normally
write this as i += 15. Thus if we wanted to count from 0 to 20 by two's we'd write:


Source Code


class CountToTwenty {

    public static void main (String args[]) {
     int i;
     for (i=0; i <=20; i += 2) { //Note Increment Operator by 2
         System.out.println(i);
     }

} //main ends here

}

As you might guess there is a corresponding -= operator. If we wanted to count down from twenty
to zero by twos we could write: -=
class CountToZero {

    public static void main (String args[]) {
      int i;
      for (i=20; i >= 0; i -= 2) { //Note Decrement Operator by 2
        System.out.println(i);
      }
     }

}

                                   Java Relational Operators

A relational operator compares two values and determines the relationship between them. For
example, != returns true if its two operands are unequal. Relational operators are used to test
whether two values are equal, whether one value is greater than another, and so forth. The
relation operators in Java are: ==, !=, <, >, <=, and >=. The meanings of these operators are:


                                                                                          Returns
Use
                                                                                          true if


                                                                                           op1 is
                                                                                           greater
op1 > op2
                                                                                           than
                                                                                           op2
                                                                                           op1 is
                                                                                           greater
op1 >= op2                                                                                 than or
                                                                                           equal
                                                                                           to op2


                                                                                              op1
                                                                                              is
                                                                                              less
op1 < op2
                                                                                              than
                                                                                              to
                                                                                              op2

op1 <= op2                                                                                   op1
                                                                                             is
                                                                                             less
                                                                                               than
                                                                                               or
                                                                                               equal
                                                                                               to
                                                                                               op2


                                                                                               op1
                                                                                               and
op1 == op2                                                                                     op2
                                                                                               are
                                                                                               equal
                                                                                               op1
                                                                                               and
                                                                                               op2
op1 != op2
                                                                                               are
                                                                                               not
                                                                                               equal


Variables only exist within the structure in which they are defined. For example, if a variable is
created within a method, it cannot be accessed outside the method. In addition, a different
method can create a variable of the same name which will not conflict with the other variable. A
java variable can be thought of

The main use for the above relational operators are in CONDITIONAL phrases The following java
program is an example, RelationalProg, that defines three integer numbers and uses the
relational operators to compare them.

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

          //a   few   numbers
          int   i =   37;
          int   j =   42;
          int   k =   42;

          //greater than
          System.out.println("Greater than...");
          System.out.println(" i > j = " + (i > j)); //false
          System.out.println(" j > i = " + (j > i)); //true
          System.out.println(" k > j = " + (k > j)); //false
          //(they are equal)

          //greater than or equal to
          System.out.println("Greater            than or equal to...");
          System.out.println(" i >= j            = " + (i >= j)); //false
          System.out.println(" j >= i            = " + (j >= i)); //true
          System.out.println(" k >= j            = " + (k >= j)); //true

          //less than
          System.out.println("Less           than...");
          System.out.println(" i <           j = " + (i < j)); //true
          System.out.println(" j <           i = " + (j < i)); //false
          System.out.println(" k <           j = " + (k < j)); //false
          //less than or equal to
          System.out.println("Less than        or equal to...");
          System.out.println(" i <= j =        " + (i <= j)); //true
          System.out.println(" j <= i =        " + (j <= i)); //false
          System.out.println(" k <= j =        " + (k <= j)); //true

          //equal to
          System.out.println("Equal to...");
          System.out.println(" i == j = " + (i == j)); //false
          System.out.println(" k == j = " + (k == j)); //true

          //not equal to
          System.out.println("Not equal to...");
          System.out.println(" i != j = " + (i != j)); //true
          System.out.println(" k != j = " + (k != j)); //false
          }
}

                                Java Boolean Operators

The Boolean logical operators are : | , & , ^ , ! , || , && , == , != . Java supplies a
primitive data type called Boolean, instances of which can take the value true or false
only, and have the default value false. The major use of Boolean facilities is to implement
the expressions which control if decisions and while loops.

These operators act on Boolean operands according to this table

A         B              A|B               A&B        A^B         !A
false     false          false             false      false       true
true      false          true              false      true        false
false     true           true              false      true        true
true      true           true              true       false       false
| the OR operator
& the AND operator
^ the XOR operator
! the NOT operator
|| the short-circuit OR operator
&& the short-circuit AND operator
== the EQUAL TO operator
!= the NOT EQUAL TO operator



Example

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

// these are boolean variables
      boolean A = true;
      boolean B = false;

       System.out.println("A|B = "+(A|B));
       System.out.println("A&B = "+(A&B));
         System.out.println("!A = "+(!A));
         System.out.println("A^B = "+(A^B));
         System.out.println("(A|B)&A = "+((A|B)&A));
     }
}
                                    Java Conditional Operators

Java has the conditional operator. It's a ternary operator -- that is, it has three operands -- and it
comes in two pieces, ? and :, that have to be used together. It takes the form



                         Boolean-expression ? expression-1 : expression-2



The JVM tests the value of Boolean-expression. If the value is true, it evaluates expression-1;
otherwise, it evaluates expression-2. For



Example

if (a > b) {
    max = a;
}
else {
    max = b;
}


Setting a single variable to one of two states based on a single condition is such a common use
of if-else that a shortcut has been devised for it, the conditional operator, ?:. Using the conditional
operator you can rewrite the above example in a single line like this:

max = (a > b) ? a : b;



                                       Java If-Else Statement

                  The if-else class of statements should have the following form:

                                            if (condition) {
                                              statements;
                                                   }

                                            if (condition) {
                                              statements;
                                                 } else {
                                              statements;
                                                     }

                                             if (condition) {
                                               statements;
                                         } else if (condition) {
                                             statements;
                                               } else {
                                             statements;
                                                   }

All programming languages have some form of an if statement that allows you to test
conditions. All arrays have lengths and we can access that length by referencing the variable
arrayname.length. We test the length of the args array as follows:


Source Code


// This is the Hello program in Java
class Hello {

        public static void main (String args[]) {

         /* Now let's say hello */
         System.out.print("Hello ");
         if (args.length > 0) {
           System.out.println(args[0]);
         }
    }

}

Compile and run this program and toss different inputs at it. You should note that there's no
longer an ArrayIndexOutOfBoundsException if you don't give it any command line arguments at
all.
What we did was wrap the System.out.println(args[0]) statement in a conditional test,
if (args.length > 0) { }. The code inside the braces,
System.out.println(args[0]), now gets executed if and only if the length of the args array
is greater than zero. In Java numerical greater than and lesser than tests are done with the > and
< characters respectively. We can test for a number being less than or equal to and greater than
or equal to with <= and >= respectively.

Testing for equality is a little trickier. We would expect to test if two numbers were equal by using
the = sign. However we've already used the = sign to set the value of a variable. Therefore we
need a new symbol to test for equality. Java borrows C's double equals sign, ==, to test for
equality. Lets look at an example when there are more then 1 statement in a branch and how
braces are used indefinitely.

Source Code

import java.io.*;
class NumberTest
{
        public static void main (String[] args) throws IOException
        {
                BufferedReader stdin = new BufferedReader ( new
InputStreamReader( System.in ) );
                     String inS;
                     int num;

               System.out.println("Enter an integer number");
               inS = stdin.readLine();
               num = Integer.parseInt( inS ); // convert inS to int
using wrapper classes

                     if ( num < 0 ) // true-branch
                     {
                   System.out.println("The number " + num + " is negative");
                        System.out.println("negative number are less than
zero");
                     }
                     else   // false-branch
                     {
                        System.out.println("The number " + num + " is
positive");
                          System.out.print ("positive numbers are greater ");
                          System.out.println("or equal to zero ");
                     }
                     System.out.println("End of program"); // always executed
          }
}

All conditional statements in Java require boolean values, and that's what the ==, <, >, <=, and
>= operators all return. A boolean is a value that is either true or false. Unlike in C booleans are
not the same as ints, and ints and booleans cannot be cast back and forth. If you need to set a
boolean variable in a Java program, you have to use the constants true and false. false is
not 0 and true is not non-zero as in C. Boolean values are no more integers than are strings.


Else

Lets look at some examples of if-else:

//Example 1
if(a == b) {
c++;
}
if(a != b) {
c--;
}

//Example 2
if(a == b) {
c++;
}
else {
c--;
}

We could add an else statement like so:

Source Code
// This is the Hello program in Java
class Hello {

        public static void main (String args[]) {

         /* Now let's say hello */
         System.out.print("Hello ");
         if (args.length > 0) {
           System.out.println(args[0]);
         }
         else {
           System.out.println("whoever you are");
         }
    }

}

Source Code


public class divisor
{
public static void main(String[] args)
      int a = 10;
      int b = 2;
      if ( a % b == 0 )
      {
            System.out.println(a + " is divisible by "+ b);
      }
      else
      {
            System.out.println(a + " is not divisible by " + b);
      }
}

Now that Hello at least doesn't crash with an ArrayIndexOutOfBoundsException we're still not
done. java Hello works and Java Hello Rusty works, but if we type java Hello Elliotte Rusty
Harold, Java still only prints Hello Elliotte. Let's fix that.
We're not just limited to two cases though. We can combine an else and an if to make an
else if and use this to test a whole range of mutually exclusive possibilities.


Lets look at some examples of if-else-if:

//Example 1
if(color == BLUE)) {
System.out.println("The color is blue.");
}
else if(color == GREEN) {
System.out.println("The color is green.");
}

//Example 2
if(employee.isManager()) {
System.out.println("Is a Manager");
}
else if(employee.isVicePresident()) {
System.out.println("Is a Vice-President");
}
else {
System.out.println("Is a Worker");
}

Source Code


// This is the Hello program in Java
class Hello {

        public static void main (String args[]) {

         /* Now let's say hello */
         System.out.print("Hello ");
         if (args.length == 0) {
           System.out.print("whoever you are");
         }
         else if (args.length == 1) {
           System.out.println(args[0]);
         }
         else if (args.length == 2) {
           System.out.print(args[0]);
           System.out.print(" ");
           System.out.print(args[1]);
         }
         else if (args.length == 3) {
           System.out.print(args[0]);
           System.out.print(" ");
           System.out.print(args[1]);
           System.out.print(" ");
           System.out.print(args[2]);
         }
           System.out.println();
    }
}

                            Java Loops (while, do-while and for loops)

A loop is a section of code that is executed repeatedly until a stopping condition is met. A typical
loop may look like:



while there's more data {
  Read a Line of Data
  Do Something with the Data
}
There are many different kinds of loops in Java including while, for, and do while loops.
They differ primarily in the stopping conditions used.
For loops typically iterate a fixed number of times and then exit. While loops iterate continuously
until a particular condition is met. You usually do not know in advance how many times a while
loop will loop.

In this case we want to write a loop that will print each of the command line arguments in
succession, starting with the first one. We don't know in advance how many arguments there will
be, but we can easily find this out before the loop starts using the args.length. Therefore we
will write this with a for loop. Here's the code:


Source Code


// This is the Hello program in Java
class Hello {

     public static void main (String args[]) {

      int i;

      /* Now let's say hello */
      System.out.print("Hello ");
      for (i=0; i < args.length; i = i++) {
        System.out.print(args[i]);
        System.out.print(" ");
      }
      System.out.println();
 }

}
We begin the code by declaring our variables. In this case we have exactly one variable, the
integer i. i
Then we begin the program by saying "Hello" just like before.


Next comes the for loop. The loop begins by initializing the counter variable i to be zero. This
happens exactly once at the beginning of the loop. Programming tradition that dates back to
Fortran insists that loop indices be named i, j, k, l, m and n in that order.


Next is the test condition. In this case we test that i is less than the number of arguments. When
i becomes equal to the number of arguments, (args.length) we exit the loop and go to the
first statement after the loop's closing brace. You might think that we should test for i being less
than or equal to the number of arguments; but remember that we began counting at zero, not
one.

Finally we have the increment step, i++ (i=i+1). This is executed at the end of each iteration
of the loop. Without this we'd continue to loop forever since i would always be less than
args.length.


                          Java Variables and Arithmetic Expressions
Java Variables are used to store data. Variables have type, name, and value. Variable names
begin with a character, such as x, D, Y, z. Other examples are xy1, abc2, Count, N, sum, Sum,
product etc. These are all variable names.

Different variable types are int, char, double. A variable type tells you what kind of data can be
stored in that variable.

The syntax of assignment statements is easy. Assignment statements look like this:

variableName = expression ;

For example:

int x; // This means variable x can store numbers such as 2, 10, -5.

char y; // This means variable y can store single characters 'a', 'A'.

double z; // This means variable z can store real numbers such as
10.45, 3.13411.

The above are declarations for variables x, y and z.

Important points:

1. Note that a variable has to be declared before being used.

2. The values assigned to a variable correspond to its type. Statements below represent
assignment of values to a variable.

x = 100; // x is an integer variable.
y = 'A'; // y is a character variable.
abc = 10.45; // abc is of type double (real numbers).

3. Both variable declaration and assignment of values can be done in same statement. For
example,

int x;
x = 100; is same as int x = 100;

4. A variable is declared only once.

int x; // Declaration for x.
x = 100; // Initialization.
x = x + 12; // Using x in an assignment statement.

Often in a program you want to give a variable, a constant value. This can be done:

class ConstDemo
{
public static void main ( String[] arg )
{
    final double PI = 3.14;
    final double CONSTANT2 = 100;
......
}
}

The reserved word final tells the compiler that the value will not change. The names of constants
follow the same rules as the names for variables. (Programmers sometimes use all capital letters
for constants; but that is a matter of personal style, not part of the language.)

2. Arithmetic Expressions
--------------------------
An assignment statement or expression changes the value that is held in a variable. Here is a
program that uses an assignment statement:

class example
{
      public static void main ( String[] args )
{
      long x ; //a declaration without an initial value

       x = 123; //an assignment statement
       System.out.println("The variable x contains: " + x );
}
}

Java Arithmetic expressions use arithmetic operators such as +, -, /, *, and %. The % operator
is the remainder or modulo operator. Arithmetic expressions are used to assign arithmetic values
to variables. An expression is a combination of literals, operators, variables, and parentheses
used to calculate a value.

The following code describes the use of different arithmetic expressions.

int x, y, z; // Three integer variables declared at the same time.

x = 10;
y = 12;
z = y / x; // z is assigned the value of y divided by x.
// Here z will have value 1.

z = x + y; // z is assigned the value of x+y                         // Here z will have value 22.

z = y % x // z is assigned the value of remainder when y        // is divided by x. Here z will have
value 2.

Java Boolean expressions are expressions which are either true or false. The different boolean
operators are < (less than), > (greater than),
== (equal to), >= (greater or equal to), <= (less or equal), != (not equal to).

Example:

int x = 10;
int y = 4;
int z = 5;

(x < 10) // This expression checks if x is less than 10.
(y > 1) // This expression checks if y is greater than 1.

((x - y) == (z + 1)); // This expression checks
// if (x - y) equals (z + 1).

A boolean expression can also be a combination of other boolean expressions. Two or more
boolean expressions can be connected using &&
(logical AND) and || (logical OR) operators.

The && operator represents logical AND. The expression is true only if both boolean expressions
are true. The || operator represents logical
OR. This expression would be true if any one of the associated expressions is true.

Example:

int x = 10; int y = 4; int z = 5;

(x <= 10) && (y > 1) // This expression checks if x is less
// than 10 AND y is greater than 1.
// This expression is TRUE.

(x*y == 41) || (z == 5) // This expression checks if x*y is equal
// to 40 OR if z is equal to 5.
// This expression is FALSE

                                Methods (Includes Recursive Methods)

A method is a group of instructions that is given a name and can be called up at any point in a
program simply by quoting that name. Each calculation part of a program is called a method.
Methods are logically the same as C's functions, Pascal's procedures and functions, and
Fortran's functions and subroutines.

When I wrote System.out.println("Hello World!"); in the first program we were using
the System.out.println() method. The System.out.println() method actually requires
quite a lot of code, but it is all stored for us in the System libraries. Thus rather than including that
code every time we need to print, we just call the System.out.println() method.

You can write and call your own methods too. Methods begin with a declaration. This can include
three to five parts. First is an optional access specifier which can be public, private or protected. A
public method can be called from pretty much anywhere. A private method can only be used
within the class where it is defined. A protected method can be used anywhere within the
package in which it is defined. Methods that aren't specifically declared public or private are
protected by default. access specifier. We then decide whether the method is or is not static.
Static methods have only one instance per class rather than one instance per object. All objects
of the same class share a single copy of a static method. By default methods are not static. We
finally specify the return type.

Next is the name of the method.

Source Code


class FactorialTest {                //calculates the factorial of that number.
     public static void main(String args[]) {

       int n;
       int i;
       long result;

       for (i=1; i <=10; i++) {
         result = factorial(i);
         System.out.println(result);
       }

     } // main ends here


     static long factorial (int n) {

     int i;
     long result=1;

     for (i=1; i <= n; i++) {
       result *= i;
     }

     return result;

} // factorial ends here


}

Recursive Methods

Recursion is used when a problem can be reduced into one or several problems of the same
nature, but a smaller size. This process is usually repeated until a boundary situation is reached,
where the problem can be directly solved. Java supports recursive methods, i.e. even if you're
already inside methodA() you can call methodA().
Example (A Recursive Counterpart of the Above Factorial Method)

n! is defined as n times n-1 times n-2 times n-3 ... times 2 times 1 where n is a positive integer. 0!
is defined as 1. As you see n! = n time (n-1)!. This lends itself to recursive calculation, as in the
following method:


public static long factorial (int n) {

    if (n < 0) {
      return -1;
    }
    else if (n == 0) {
      return 1;
    }
    else {
      return n*factorial(n-1);
    }
}

                                                 Arrays

Arrays are generally effective means of storing groups of variables. An array is a group of
variables that share the same name and are ordered sequentially from zero to one less than the
number of variables in the array. The number of variables that can be stored in an array is called
the array's dimension. Each variable in the array is called an element of the array.

Creating Arrays

There are three steps to creating an array, declaring it, allocating it and initializing it.

Declaring Arrays

Like other variables in Java, an array must have a specific type like byte, int, String or double.
Only variables of the appropriate type can be stored in an array. You cannot have an array that
will store both ints and Strings, for instance.

Like all other variables in Java an array must be declared. When you declare an array variable
you suffix the type with [] to indicate that this variable is an array. Here are some examples:

int[] k;
float[] yt;
String[] names;


In other words you declare an array like you'd declare any other variable except you append
brackets to the end of the variable type.
Allocating Arrays

Declaring an array merely says what it is. It does not create the array. To actually create the array
(or any other object) use the new operator. When we create an array we need to tell the compiler
how many elements will be stored in it. Here's how we'd create the variables declared above: new
k = new int[3];
yt = new float[7];
names = new String[50];


The numbers in the brackets specify the dimension of the array; i.e. how many slots it has to hold
values. With the dimensions above k can hold three ints, yt can hold seven floats and names can
hold fifty Strings.
Initializing Arrays

Individual elements of the array are referenced by the array name and by an integer which
represents their position in the array. The numbers we use to identify them are called subscripts
or indexes into the array. Subscripts are consecutive integers beginning with 0. Thus the array k
above has elements k[0], k[1], and k[2]. Since we started counting at zero there is no k[3], and
trying to access it will generate an ArrayIndexOutOfBoundsException. subscripts indexes k k[0]
k[1] k[2] k[3] ArrayIndexOutOfBoundsException
You can use array elements wherever you'd use a similarly typed variable that wasn't part of an
array.
Here's how we'd store values in the arrays we've been working with:

k[0] = 2;
k[1] = 5;
k[2] = -2;
yt[6] = 7.5f;
names[4] = "Fred";


This step is called initializing the array or, more precisely, initializing the elements of the array.
Sometimes the phrase "initializing the array" would be reserved for when we initialize all the
elements of the array.

For even medium sized arrays, it's unwieldy to specify each element individually. It is often helpful
to use for loops to initialize the array. For instance here is a loop that fills an array with the
squares of the numbers from 0 to 100.

float[] squares = new float[101];

for (int i=0; i <= 500; i++) {
  squares[i] = i*2;
}


Shortcuts

We can declare and allocate an array at the same time like this:

int[] k = new int[3];
float[] yt = new float[7];
String[] names = new String[50];


We can even declare, allocate, and initialize an array at the same time providing a list of the initial
values inside brackets like so:
int[] k = {1, 2, 3};
float[] yt = {0.0f, 1.2f, 3.4f, -9.87f, 65.4f, 0.0f, 567.9f};


Two Dimensional Arrays

Declaring, Allocating and Initializing Two Dimensional Arrays

Two dimensional arrays are declared, allocated and initialized much like one dimensional arrays.
However we have to specify two dimensions rather than one, and we typically use two nested for
loops to fill the array. for
The array examples above are filled with the sum of their row and column indices. Here's some
code that would create and fill such an array:


class FillArray {

 public static void main (String args[]) {
        int[][] M;
        M = new int[4][5];

        for (int row=0; row < 4; row++) {
          for (int col=0; col < 5; col++) {
            M[row][col] = row+col;
          }
        }

    }

}

In two-dimensional arrays ArrayIndexOutOfBounds errors occur whenever you exceed the
maximum column index or row index. Unlike two-dimensional C arrays, two-dimensional Java
arrays are not just one-dimensional arrays indexed in a funny way.
Multidimensional Arrays

You don't have to stop with two dimensional arrays. Java lets you have arrays of three, four or
more dimensions. However chances are pretty good that if you need more than three dimensions
in an array, you're probably using the wrong data structure. Even three dimensional arrays are
exceptionally rare outside of scientific and engineering applications.
The syntax for three dimensional arrays is a direct extension of that for two-dimensional arrays.
Here's a program that declares, allocates and initializes a three-dimensional array:


class Fill3DArray {

    public static void main (String args[]) {

        int[][][] M;
        M = new int[4][5][3];

        for (int row=0; row < 4; row++) {
          for (int col=0; col < 5; col++) {
            for (int ver=0; ver < 3; ver++) {
              M[row][col][ver] = row+col+ver;
            }
          }
        }

    }

}

Example 1 : declaring and initializing 1-dimensional arrays

An array groups elements of the same type. It makes it easy to manipulate the information
contained in them.

class Arrays1{

public static void main(String args[]){
// this declares an array named x with the type "array of int" and of
// size 10, meaning 10 elements, x[0], x[1] , ... , x[9] ; the first term
// is x[0] and the last term x[9] NOT x[10].
int x[] = new int[10];

// print out the values of x[i] and they are all equal to 0.
for(int i=0; i<=9; i++)
System.out.println("x["+i+"] = "+x[i]);

// assign values to x[i]
for(int i=0; i<=9; i++)
x[i] = i; // for example

// print the assigned values of x[i] : 1,2,......,9
for(int i=0; i<=9; i++)
System.out.println("x["+i+"] = "+x[i]);

// this declares an array named st the type "array of String"
// and initializes it
String st[]={"first","second","third"};

// print out st[i]
for(int i=0; i<=2; i++)
System.out.println("st["+i+"] = "+st[i]);

}
}

Example 2 : Find the sum of the numbers 2.5, 4.5, 8.9, 5.0 and 8.9

class Arrays2{

public static void main(String args[]){

// this declares an array named fl with the type "array of int" and
// initialize its elements

float fl[] = {2.5f, 4.5f, 8.9f, 5.0f, 8.9f};

// find the sum by adding all elements of the array fl
float sum = 0.0f;
for(int i=0; i<= 4; i++)
sum = sum + fl[i];

// displays the sum
System.out.println("sum = "+sum);
}
}

Check that the sum displayed is 29.8.

Example 3 : declaring and initializing 2-dimensional arrays
class Arrays3{

public static void main(String args[]){

//   this declares a 2-dimensional array named x[i][j] of size 4 (4 elements)
//   its elements are x[0][0], x[0][1], x[1][0] and x[1][1].
//   the first index i indicates the row and the second index indicates the
//   column if you think of this array as a matrix.


int x[][] = new int[2][2];

// print out the values of x[i][j] and they are all equal to 0.0.
for(int i=0; i<=1; i++)
for(int j=0; j<=1; j++)
System.out.println("x["+i+","+j+"] = "+x[i][j]);

// assign values to x[i]
for(int i=0; i<=1; i++)
for(int j=0; j<=1; j++)
x[i][j] = i+j; // for example

// print the assigned values to x[i][j]
for(int i=0; i<=1; i++)
for(int j=0; j<=1; j++)
System.out.println("x["+i+","+j+"] = "+x[i][j]);

// this declares a 2-dimensional array of type String
// and initializes it
String st[][]={{"row 0 column 0","row 0 column 1"}, // first row
{"row 1 column 0","row 1 column 1"}}; // second row

// print out st[i]
for(int i=0; i<=1; i++)
for(int j=0; j<=1; j++)
System.out.println("st["+i+","+j+"] = "+st[i][j]);

}
}

                                      Classes and Objects

Following the principles of Object Oriented Programming (OOP), everything in Java is either a
class, a part of a class, or describes how a class behaves. Objects are the physical instantiations
of classes. They are living entities within a program that have independent lifecycles and that are
created according to the class that describes them. Just as many buildings can be built from one
blueprint, many objects can be instantiated from one class. Many objects of different classes can
be created, used, and destroyed in the course of executing a program. Programming languages
provide a number of simple data types like int, float and String. However very often the data you
want to work with may not be simple ints, floats or Strings. Classes let programmers define their
own more complicated data types.
All the action in Java programs takes place inside class blocks, in this case the HelloWorld class.
In Java almost everything of interest is either a class itself or belongs to a class. Methods are
defined inside the classes they belong to. Even basic data primitives like integers often need to
be incorporated into classes before you can do many useful things with them. The class is the
fundamental unit of Java programs. For instance consider the following Java program:

class HelloWorld {

    public static void main (String args[]) {

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

    }

}

class GoodbyeWorld {

    public static void main (String args[]) {

        System.out.println("Goodbye Cruel World!");

    }

}

Save this code in a single file called hellogoodbye.java in your javahtml directory, and compile it
with the command javac hellogoodbye.java. Then list the contents of the directory. You will see
that the compiler has produced two separate class files, HelloWorld.class and
GoodbyeWorld.class. javac hellogoodbye.java


The second class is a completely independent program. Type java GoodbyeWorld and then
type java HelloWorld. These programs run and execute independently of each other although
they exist in the same source code file.

Class Syntax

Use the following syntax to declare a class in Java:

//Contents of SomeClassName.java
[ public ] [ ( abstract | final ) ] class SomeClassName [ extends SomeParentClass ] [ implements
SomeInterfaces ]
{
     // variables and methods are declared within the curly braces
}

* A class can have public or default (no modifier) visibility.
* It can be either abstract, final or concrete (no modifier).
* It must have the class keyword, and class must be followed by a legal identifier.
* It may optionally extend one parent class. By default, it will extend java.lang.Object.
* It may optionally implement any number of comma-separated interfaces.
* The class's variables and methods are declared within a set of curly braces '{}'.
* Each .java source file may contain only one public class. A source file may contain any number
of default visible classes.
* Finally, the source file name must match the public class name and it must have a .java suffix.

Here is an example of a Horse class. Horse is a subclass of Mammal, and it implements the
Hoofed interface.

public class Horse extends Mammal implements Hoofed
{
      //Horse's variables and methods go here
}

Lets take one more example of Why use Classes and Objects. For instance let's suppose your
program needs to keep a database of web sites. For each site you have a name, a URL, and a
description.

class website {

    String name;
    String url;
    String description;

}
These variables (name, url and description) are called the members of the class. They tell you
what a class is and what its properties are. They are the nouns of the class. members. A class
defines what an object is, but it is not itself an object. An object is a specific instance of a class.
Thus when we create a new object we say we are instantiating the object. Each class exists only
once in a program, but there can be many thousands of objects that are instances of that class.
To instantiate an object in Java we use the new operator. Here's how we'd create a new web site:

     website x = new website();
Once we've got a website we want to know something about it. To get at the member variables of
the website we can use the . operator. Website has three member variables, name, url and
description, so x has three member variables as well, x.name, x.url and x.description. We can use
these just like we'd use any other String variables. For instance:

      website x = new website();
      x.name = "freehavaguide.com";
      x.url = "http://www.freejavaguide.com";
      x.description = "A Java Programming Website";

    System.out.println(x.name + " at " + x.url + " is " +
x.description);


1

                                JAVA Tutorial - Class Declaration

A simple Java class declaration with constructor declaration:

class simple {
// Constructor
  simple(){
  p = 1;
  q = 2;
  r = 3;
}
int p,q,r;
}
In class declaration, you can declare methods of the class:

class simple {
// Constructor
  simple(){
    p = 1;
    q = 2;
    r = 3;
  }
  int p,q,r;
  public int addNumbers(int var1, int var2, int var3)
  {
     return var1 + var2 + var3;
  }
  public void displayMessage()
  {
                System.out.println("Display Message");
  }
}

To invoke the class, you can create the new instance of the class:
// To create a new instance class

Simple sim = new Simple();

// To access the methods of the class

sim.addNumbers(5,1,2)

// To show the result of the addNumbers

System.out.println("The result is " + Integer.toString(addNumbers(5,1,2)));

The complete listing of class declaration:

class simple {
// Constructor
        simple(){
          p = 1;
          q = 2;
          r = 3;
        }
        int p,q,r;
        public int addNumbers(int var1, int var2, int var3)
        {
                 return var1 + var2 + var3;
          }
          public void displayMessage()
          {
                  System.out.println("Display Message");
          }
}

class example1{
        public static void main(String args[])
        {
                // To create a new instance class
                Simple sim = new Simple();
                // To show the result of the addNumbers
                System.out.println("The result is " +
Integer.toString(addNumbers(5,1,2)));
                // To display message
                sim.displayMessage();
        }
}


                                             Interfaces

There is one thing in Java source code that is neither a class nor a member of a class. That's an
interface. An interface defines methods that a class implements. In other words it declares what
certain classes do. However an interface itself does nothing. All the action at least, happens
inside classes. A class may implement one or more interfaces. This means that the class
subscribes to the promises made by those interfaces. Since an interface promises certain
methods, a class implementing that interface will need to provide the methods specified by the
interface. The methods of an interface are abstract -- they have no bodies. Generally, a class
implementing an interface will not only match the method specifications of the interface, it will also
provide bodies -- implementations -- for its methods.



For example, a ScoreCounter class might meet the contract specified by the Counting interface:

interface Counting
{
abstract void increment();
abstract int getValue();
}

So might a Stopwatch, although it might have a totally different internal representation. Both
would have increment() and getValue() methods, but the bodies of these methods might look
quite different. For example, a ScoreCounter for a basketball game might implement increment()
so that it counts by 2 points each time, while a Stopwatch might call its own increment() method
even if no one else does.

A class that implements a particular interface must declare this explicitly:

class ScoreCounter implements Counting {
....
}

If a class implements an interface, an instance of that class can also be treated as though its type
were that interface. For example, it can be labeled with a name whose declared type is that
interface. For example, an instance of class ScoreCounter can be labeled with a name of type
Counting. It will also answer true when asked whether it's an instanceof that interface type: if
myScoreCounter is a ScoreCounter, then myScoreCounter instanceof Counting is true. Similarly,
you can pass or return a ScoreCounter whenever a Counting is required by a method signature.

The generality of interfaces and the inclusion of multiple implementations within a single
(interface) type is an extremely powerful feature. For example, you can use a name of type
Counting to label either an instance of ScoreCOunter or an instance of Stopwatch (and use its
increment() and getValue() methods) without even knowing which one you've got.

                                        Catching Exceptions

An exception is a point in the code where something out of the ordinary has happened and the
regular flow of the program needs to be interrupted; an exception is not necessarily an error. A
method which has run into such a case will throw an exception using the throw(ExceptionClass)
method. When an exception is thrown it must be caught by a catch statement that should sit right
after a try statement.


// This is the Hello program in Java
class Hello {

        public static void main (String args[]) {

         /* Now let's say hello */
         System.out.print("Hello ");
         System.out.println(args[0]);
    }

}

If you run the program without giving it any command line arguments, then the runtime system
generates an exception something like,
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException at
Hello.main(C:\javahtml\Hello.java:7)


Since we didn't give Hello any command line arguments there wasn't anything in args[0].
Therefore Java kicked back this not too friendly error message about an
"ArrayIndexOutOfBoundsException."

we can fix this problem by testing the length of the array before we try to access its first element
(using array.length). This works well in this simple case, but this is far from the only such potential
problem.

What is an Exception ?

Let us see what happens when an exception occurs and is not handled properly

When you compile and run the following program

public class Test{
        public static void main(String str[]){
        int y = 0;
        int x = 1;
        // a division by 0 occurs here.
        int z = x/y;
        System.out.println("after didvision");
    }
}

The execution of the Test stops and this is caused by the division by zero at - x/y - an exception
has been thrown but has not been handled properly.

How to handle an Exception ?

To handle an Exception, enclose the code that is likely to throw an exception in a try block and
follow it immediately by a catch clause as follows

public class Test{
   public static void main(String str[]){
     int y = 0;
     int x = 1;
     // try block to "SEE" if an exception occurs
     try{
       int z = x/y;
       System.out.println("after didvision");
        // catch clause below handles the
       // ArithmeticException generated by
       // the division by zero.
    } catch (ArithmeticException ae)
    {System.out.println(" attempt to divide by 0");}
     System.out.println(" after catch ");
  }
}

The output of the above program is as follows

attempt to divide by 0
after catch

the statement - System.out.println("after didvision") - is NOT executed, once an exception is
thrown, the program control moves out of the try block into the catch block.

The goal of exception handling is to be able to define the regular flow of the program in part of the
code without worrying about all the special cases. Then, in a separate block of code, you cover
the exceptional cases. This produces more legible code since you don't need to interrupt the flow
of the algorithm to check and respond to every possible strange condition. The runtime
environment is responsible for moving from the regular program flow to the exception handlers
when an exceptional condition arises.

In practice what you do is write blocks of code that may generate exceptions inside try-catch
blocks. You try the statements that generate the exceptions. Within your try block you are free to
act as if nothing has or can go wrong. Then, within one or more catch blocks, you write the
program logic that deals with all the special cases.
To start a section of code which might fail or not follow through you start a try clause:

try
{
  // Section of code which might fail
}


The try statement is needed in case of an exception. If the read fails in some way it will throw an
exception of type java.io.IOException. That exception must be caught in this method, or the
method can declare that it will continue throwing that message. Exception handling is a very
powerful tool, you can use it to catch and throw exceptions and thus group all your error handling
code very well and make it much more readable in larger more complex applications. After the try
section there must exist one or more catch statements to catch some or all of the exceptions that
can happen within the try block. Exceptions that are not caught will be passed up to the next
level, such as the function that called the one which threw the exception, and so on. .

try
{
  // Section of code which might fail
}
catch (Exception1ThatCanHappen E)
{
  // things to do if this exception was thrown..
}
catch (Exception2ThatCanHappen E)
{
  // things to do if this exception was thrown..
}


Here's an example of exception handling in Java using the Hello World program above:

Source Code


// This is the Hello program in Java
class ExceptionalHello {

        public static void main (String args[]) {

         /* Now let's say hello */
         try {
           System.out.println("Hello " + args[0]);
         }
         catch (Exception e) {
           System.out.println("Hello whoever you are");
         }
    }

}

You may or may not print an error message. If you write an exception handler and you don't
expect it to be called, then by all means put a
    System.out.println("Error: " + e);


    This has the folowing advantages over handling your errors internally:


            You can react to an error in custom defined way. A read error does not mean that the
    program should crash.
            You can write code with no worry about failure which will be handled by the users of your
    class.
            You can group your error handling code much better.
            You can make your application more transactional focused with nested try catch blocks:

    A simple Java code which demonstrates the exception handling in Java

    Refer to the java API document to see all exception types that can be handled in Java.

    Source Code

    public class excep2
    {
            public static void main(String args[])
            {
                    int i =0 ;
                    //Declare an array of strings
                    String Box [] = {"Book", "Pen", "Pencil"};
                    while(i<4)
                    {
                            try
                            {
                                   System.out.println(Box[i]);

                                    }
                                    catch(ArrayIndexOutOfBoundsException e)
                                    {
                                            System.out.println("Subscript Problem " +
    e);
                                    i++;
                                    }
                                    finally
                                    {
                                              System.out.println("This is always
    printed.");
                                    }
                                    i++;
                         }
               }
    }


                                           File I/O and Streams
You can write data to a file instead of the computer screen. You can write certain data to a file
while still putting other data on the screen. Or you may need access to multiple files
simultaneously. Or you may want to query the user for input rather than accepting it all on the
command line. Or maybe you want to read data out of a file that's in a particular format. In Java
all these methods take place as streams. < > Using File I/O streams. The
System.out.println() statement we've been using all along is an implementation of
Streams.

A program that writes a string to a file

In order to use the Java file classes, we must import the Java input/output package (java.io) in the
following manner

import java.io.*;

Inside the main method of our program, we must declare a FileOutputStream object. In this case,
we wish to write a string to the file, and so we create a new PrintStream object that takes as its
constructor the existing FileOutputStream. Any data we send from PrintStream will now be
passed to the FileOutputStream, and ultimately to disk. We then make a call to the println
method, passing it a string, and then close the connection.

Source Code


/*
* FileOutput
* Demonstration of FileOutputStream and PrintStream classes
*/

import java.io.*;

class FileOutput
{

public static void main(String args[])
{
FileOutputStream out; // declare a file output object
PrintStream p; // declare a print stream object

try
{
// Create a new file output stream connected to "myfile.txt"
out = new FileOutputStream("myfile.txt");

// Connect print stream to the output stream
p = new PrintStream( out );

p.println ("This is written to a file myFile.txt");

p.close();
}
catch (Exception e)
{
System.err.println ("Error writing to the file myFile.txt");
}
}
}

Interactively communicating with the user

Program asking the user for their name and then prints a personalized greeting.
Source Code


import java.io.*;

class PersonalHello {

    public static void main (String args[])
     {

         byte name[] = new byte[100];
         int nr_read = 0;

         System.out.println("Your name Please?");
         try {
           nr_read = System.in.read(name);
           System.out.print("Hello ");
           System.out.write(name,0,nr_read);
         }
         catch (IOException e) {
           System.out.print("I did not get your name.");
         }

     }

}

In code that does any significant input or output you'll want to begin by importing all the various
java.io classes. import.java.io.*; Most of the reading and writing you do in Java will be done with
bytes. Here we've started with an array of bytes that will hold the user's name.
First we print a query requesting the user's name. Then we read the user's name using the
System.in.read() method. This method takes a byte array as an argument, and places
whatever the user types in that byte array. Then, like before, we print "Hello." Finally we print the
user's name.

The program doesn't actually see what the user types until he or she types a carriage return. This
gives the user the chance to backspace over and delete any mistakes. Once the return key is
pressed, everything in the line is placed in the array.

Reading Numbers

Often strings aren't enough. A lot of times you'll want to ask the user for a number as input. All
user input comes in as strings so we need to convert the string into a number.
The getNextInteger() method that will accept an integer from the user. Here it is:

  static int getNextInteger() {

     String line;

     DataInputStream in = new DataInputStream(System.in);
     try {
       line = in.readLine();
       int i = Integer.valueOf(line).intValue();
       return i;
     }
     catch (Exception e) {
       return -1;
     }

  } // getNextInteger ends here


Reading Formatted Data

It's often the case that you want to read not just one number but multiple numbers. Sometimes
you may need to read text and numbers on the same line. For this purpose Java provides the
StreamTokenizer class.
Writing a text file

Sometimes you want to save your output in a file. To do this we'll need to learn how to write data
to a file.
Source Code


// Write the Fahrenheit to Celsius table in a file

import java.io.*;

class FahrToCelsius {

 public static void main (String args[]) {

   double fahr, celsius;
   double lower, upper, step;

   lower = 0.0; // lower limit of temperature table
   upper = 300.0; // upper limit of temperature table
   step = 20.0; // step size

   fahr = lower;

   try {

    FileOutputStream fout = new FileOutputStream("test.out");

    // now to the FileOutputStream into a PrintStream
    PrintStream myOutput = new PrintStream(fout);
       while (fahr <= upper) { // while loop begins here
        celsius = 5.0 * (fahr-32.0) / 9.0;
        myOutput.println(fahr + " " + celsius);
        fahr = fahr + step;
       } // while loop ends here

      } // try ends here
      catch (IOException e) {
        System.out.println("Error: " + e);
        System.exit(1);
      }

    } // main ends here

}

There are only three things necessary to write formatted output to a file rather than to the
standard output:


 1.       Open a FileOutputStream using a line like


       FileOutputStream fout =            new FileOutputStream("test.out");


       This line initializes the FileOutputStream with the name of the file you want to write into.


 2.       Convert the FileOutputStream into a PrintStream using a statement like


       PrintStream myOutput = new PrintStream(fout);


       The PrintStream is passed the FileOutputStream from step 1.


 3.       Instead of using System.out.println() use myOutput.println(). System.out
       and myOutput are just different instances of the PrintStream class. To print to a
       different PrintStream we keep the syntax the same but change the name of the
       PrintStream.

Reading a text file

Now that we know how to write a text file, let's try reading one. The following code accepts a
series of file names on the command line and then prints those filenames to the standard output
in the order they were listed.
// Imitate the Unix cat utility

import java.io.*;
class cat {

    public static void main (String args[]) {

    String thisLine;

    //Loop across the arguments
    for (int i=0; i < args.length; i++) {

    //Open the file for reading
    try {
      FileInputStream fin = new FileInputStream(args[i]);

     // now turn the FileInputStream into a DataInputStream
     try {
       DataInputStream myInput = new DataInputStream(fin);

       try {
         while ((thisLine = myInput.readLine()) != null) { // while loop begins here
          System.out.println(thisLine);
         } // while loop ends here
       }
       catch (Exception e) {
        System.out.println("Error: " + e);
       }
     } // end try
     catch (Exception e) {
       System.out.println("Error: " + e);
     }

     } // end try
     catch (Exception e) {
      System.out.println("failed to open file " + args[i]);
      System.out.println("Error: " + e);
    }
    } // for end here

    } // main ends here

}

                          How to make executable jar files in JDK1.3.1?

Instructions for creating an Executable .jar file

Make or modify the Manifest.MF to YourManifest.MF.

1) YourClassNameWithMain is the class name (case sensitive) without .class extension
2) No extra spaces following the YourClassName withMain.

Manifest-Version:1.0
Main-Class: YourClassNameWithMain
Created-by:1.2(Sun Microsystems Inc.)
On Command line : type the following
jar cvfm YourJarFileName.jar YourManifest.MF*

or

jar cvfm YourJarFileName.jar YourManifest.MF -C classes yourClassPath
Drag-drop the YourJarFileName.jar to your desktop double click it, it runs
If your program only has System.out.println ("whatever"); statements, it will
display nothing. The same will happen when you run it useing java at command line

You need some windows code to see it run

Instructions for creating a .jar file. jar utility comes with your JDK1.2.2 It compresses your file
similar to zip utility, and more Java.

You can use it on any machine installed JDK

Create a folder name it anything
Make that folder your current directory
put all your files for turning in (do not put any extra) in that directory.

Be sure to put your html file, if there is one
At your dos prompt, while you are in the directory that you created , type in:
jar cvf Prj02.jar*

This will take ALL the files in the directory including subdirectories and place them in a .jar file
Prj02 that can be replaced by any of your desired jar file name.

To test it, you can extract the contents of jar file by typing:
jar xvf Prj02.jar

								
To top