http:^^www.cs.wisc.edu^~cs537-1^java-tutorial.html

This data set contains WWW-pages collected from computer science departments of various universities

        public:
            int j;
            void f() { /*...*/ }
    }
</font></pre>
In Java:
<pre><font color="0f0fff">
    class C {
        private int i;
        public int j;
        private double d;
        public void f() { /* ... */ }
    }
</font></pre>
As in C++, private members can only be accessed from inside the bodies
of methods (function members) of the class, not ``from the outside.''
Thus if <samp><font color="0f0fff">x</font></samp> is an instance of <samp><font color="0f0fff">C</font></samp>, <samp><font color="0f0fff">x.i</font></samp> is not legal,
but <samp><font color="0f0fff">i</font></samp> can be accessed from the body of <samp><font color="0f0fff">x.f()</font></samp>.
(<samp><font color="0f0fff">protected</font></samp> is also supported; it means the same thing as it does
in C++).
The default (if neither <samp><font color="0f0fff">public</font></samp> nor <samp><font color="0f0fff">private</font></samp> is specified)
is that a member can be accessed from anywhere in the same <em>package</em>,
giving a facility rather like ``friends'' in C++.
You will probably be putting all your classes in one package, so
the default is essentially <samp><font color="0f0fff">public</font></samp>.
<p>
The keyword <samp><font color="0f0fff">static</font></samp> also means the same thing in Java as C++,
which not what the word implies:
Ordinary members have one copy per instance, while <samp><font color="0f0fff">static</font></samp> members
have only one copy, shared by instances.
In effect, a <samp><font color="0f0fff">static</font></samp> member lives in the class itself, rather than
instances.
<pre><font color="0f0fff">
    class C {
        int x = 1;  // by the way, this isn't legal in C++
        static int y = 1;
        void f(int n) { x += n; }
        static int g() { return ++y; }
    }
    C p = new C();
    C q = new C();
    p.f(3);
    q.f(5);
    System.out.println(p.x);  // prints 4
    System.out.println(q.x);  // prints 6
    System.out.println(C.y);  // prints 1
    System.out.println(p.y);  // means the same thing
    System.out.println(C.g());// prints 2
    System.out.println(q.g());// prints 3
</font></pre>
Static members are often used instead of global variables and functions,
which do not exist in Java.
For example,
<pre><font color="0f0fff">
    Math.tan(x);  // tan is a static method of class Math
    Math.PI;      // a static &quot;field&quot; of class Math
    Integer.parseInt(&quot;10&quot;); // used &lt;a href=&quot;#sort&quot;&gt;in the sorting example&lt;/a&gt;
</font></pre>
The keyword <samp><font color="0f0fff">final</font></samp> is roughly equivalent to <samp><font color="0f0fff">const</font></samp> in C++:
<samp><font color="0f0fff">final</font></samp> fields cannot be changed.
It is often used in conjunction with <samp><font color="0f0fff">static</font></samp> to defined named constants.
<pre><font color="0f0fff">
    class Card {
        int suit = CLUBS;     // default
        final static int CLUBS = 1;
        final static int DIAMONDS = 2;
        final static int HEARTS = 3;
        final static int SPADES = 4;
    }
    Card c = new Card();
    c.suit = Card.SPADES;
</font></pre>
Each <samp><font color="0f0fff">Card</font></samp> has its own suit.
The value <samp><font color="0f0fff">CLUBS</font></samp> is shared by all instances of <samp><font color="0f0fff">Card</font></samp> so
it only needs to be stored once, but since it's <samp><font color="0f0fff">final</font></samp>, it doesn't
need to be stored at all!

<a name="arrays"><h2> Arrays </h2></a>
<p>
In Java, arrays are objects.
Like all objects in Java, you can only point to them, but unlike a C++
variable, which is treated like a pointer to the first element
of the array, a Java array variable points to the array object.
There is no way to point to a particular member of an array.
<p>
Each array has a read-only (final) field <samp><font color="0f0fff">length</font></samp> that tells you how
many elements it has.  The elements are numbered starting at zero as in C++:
<samp><font color="0f0fff">a[0] ... a[a.length-1]</font></samp>.
Once you create an array (using <samp><font color="0f0fff">new</font></samp>), you can't change its size.
If you need more space, you have to create a new (larger) array and copy
over the elements (but see the library class
<a htref="#vectors">
<samp><font color="0f0fff">Vector</font></samp>
</a>below).
<pre><font color="0f0fff">
    int x = 3;   // a value 
    int a[];     // a pointer to an array object; initially null
    int[] a;     // means exactly the same thing
    a = new int[10]; // now a points to an array object
    a[3] = 17;   // accesses one of the slots in the array
    a = new int[5]; // assigns a different array to a
                 // the old array is inaccessible (and so
                 // is garbage-collected)
    int[] b = a; // a and b share the same array object
    System.out.println(a.length); // prints 5
</font></pre>
<center>
<!WA18><!WA18><!WA18><!WA18><!WA18><!WA18><IMG ALIGN=TOP SRC="http://www.cs.wisc.edu/~cs537-1/arrays.gif">.
</center>

<a name="strings"><h2> Strings </h2></a>
<p>
Since you can make an array of anything, you can make an an array of
<samp><font color="0f0fff">char</font></samp> or an an array of <samp><font color="0f0fff">byte</font></samp>, but Java has something much better:
the type <samp><font color="0f0fff">String</font></samp>.
The <samp><font color="0f0fff">+</font></samp> operator is <em>overloaded</em> on Strings to mean
concatenation.  What's more, you can concatenate <em>anything</em> with
a string; Java automatically converts it to a string.
Built-in types such as numbers are converted in the obvious way.
Objects are converted by calling their <samp><font color="0f0fff">toString()</font></samp> methods.
Library classes all have <samp><font color="0f0fff">toString</font></samp> methods that do something reasonable.
You can do likewise for classes you define.
This is great for debugging.
<pre><font color="0f0fff">
    String s = &quot;hello&quot;;
    String t = &quot;world&quot;;
    System.out.println(s + &quot;, &quot; + t);       // prints &quot;hello, world&quot;
    System.out.println(s + &quot;1234&quot;);         // &quot;hello1234&quot;
    System.out.println(s + (12*100 + 34));  // &quot;hello1234&quot;
    System.out.println(s + 12*100 + 34);    // &quot;hello120034&quot; (why?)
    System.out.println(&quot;The value of x is &quot; + x);  // will work for any x
    System.out.println(&quot;System.out = &quot; + System.out);
                // &quot;System.out = java.io.PrintStream@80455198&quot;
    String numbers = &quot;&quot;;
    for (int i=0; i&lt;5; i++)
        numbers += &quot; &quot; + i;
    System.out.println(numbers);            // &quot; 1 2 3 4 5&quot;
</font></pre>
Strings have lots of other useful operations:
<pre><font color="0f0fff">
    String s = &quot;whatever&quot;, t = &quot;whatnow&quot;;
    s.charAt(0);            // 'w'
    s.charAt(3);            // 't'
    t.substring(4);         // &quot;now&quot;
    t.substring(4,6);       // &quot;no&quot;
    s.substring(0,4);       // &quot;what&quot;
    t.substring(0,4);       // &quot;what&quot;
    s.compareTo(t);         // a value less than zero (s precedes t in &quot;lexicographic&quot;
                            // (dictionary) order
    t.compareTo(s);         // a value greater than zero (t follows s)
    t.compareTo(&quot;whatnow&quot;); // zero
    t.substring(0,4) == s.substring(0,4);
                            // false (they are different String objects)
    t.substring(0,4).equals(s.substring(0,4));
                            // true (but they are both equal to &quot;what&quot;)
    t.indexOf('w');         // 0
    t.indexOf('t');         // 3
    t.indexOf(&quot;now&quot;);       // 4
    t.lastIndexOf('w');     // 6
    t.endsWith(&quot;now&quot;);      // true
</font></pre>
and more.
<p>
You can't modify a string, but you can make a string variable point to
a new string (as in <samp><font color="0f0fff">numbers += " " + i;</font></samp>).  See <samp><font color="0f0fff">StringBuffer</font></samp> if
you want a string you can scribble on.

<a name="constructors"><h2> Constructors and Overloading </h2></a>
<p>
A constructor is like in C++: a method with the same name as the class.
If a constructor has arguments, you supply corresponding values when using
<samp><font color="0f0fff">new</font></samp>.  Even if it has no arguments, you still need the parentheses
(unlike C++).
There can be multiple constructors, with different numbers or types of
arguments.  The same is true for other methods.  This is called
<em>overloading</em>.  Unlike C++, you cannot overload operators.
The operator `+' is overloaded for strings and (various kinds of) numbers,
but user-defined overloading is not allowed.
<pre><font color="0f0fff">
    class Point {
        int x, y;
        Point(int u, int v) {
            x = u;  // the same as this.x = u
            y = v;
        }
        Point(int x) {
            this.x = x;  // not the same as x = x!
            y = 0;
        }
        Point() {
            x = 0;
            y = 0;
        }
    }
    class Test {
        public static void main(String[] argv) {
            Point p1 = new Point(3,4);
            Point p2 = new Point();  // same as new Point(0,0)
            Point p3 = new Point;    // error!
        }
    }
</font></pre>
<strong>NB:</strong>  The bodies of the methods have to be defined
<em>in line</em> right after their headers as shown above.  You have to
write
<pre><font color="0f0fff">
    class Foo {
        double square(double d) { return d*d; }
    };
</font></pre>
rather than
<pre><font color="0f0fff">
    class Foo {
        double square(double);
    };
    double Foo::square(double d) { return d*d; }
        // ok in C++ but not in Java
</font></pre>
        
<a name="inheritance"><h2> Inheritance, Interfaces, and Casts </h2></a>
<p>
In C++, when we write
<pre><font color="0f0fff">
    class Derived : public Base { ... }
</font></pre>
we mean two things:
<ul>
<li> A <samp><font color="0f0fff">Derived</font></samp> can do anything a <samp><font color="0f0fff">Base</font></samp> can, and perhaps more.
<li> A <samp><font color="0f0fff">Derived</font></samp> does things the way a <samp><font color="0f0fff">Base</font></samp> does them,
unless specified otherwise.
</ul>
The first of these is called <em>interface inheritance</em> or
<em>subtyping</em> and the second
is called <em>method inheritance</em>.
In Java, they are specified differently.
<p>
Method inheritance is specified with the keyword <samp><font color="0f0fff">extends</font></samp>.
<pre><font color="0f0fff">
    class Base {
        int f() { /* ... */ }
        void g(int x) { /* ... */ }
    }
    class Derived extends Base {
        void g(int x) { /* ... */ }
        double h() { /* ... */ }
    }
</font></pre>
Class <samp><font color="0f0fff">Derived</font></samp> has three methods: <samp><font color="0f0fff">f</font></samp>, <samp><font color="0f0fff">g</font></samp>, and <samp><font color="0f0fff">h</font></samp>.  The
method <samp><font color="0f0fff">Derived.f()</font></samp> is implemented in the same way (the same executable
code) as <samp><font color="0f0fff">Base.f()</font></samp>, but <samp><font color="0f0fff">Derived.g()</font></samp> <em>overrides</em> the
implementation of <samp><font color="0f0fff">Base.g()</font></samp>.
We call <samp><font color="0f0fff">Base</font></samp> the <em>super class</em> of <samp><font color="0f0fff">Derived</font></samp> and
<samp><font color="0f0fff">Derived</font></samp> a <em>subclass</em> of <samp><font color="0f0fff">Base</font></samp>.
Every class (with one exception) has exactly one super class (single
inheritance).  If you leave out the <samp><font color="0f0fff">extends</font></samp> specification, Java
treats it like ``<samp><font color="0f0fff">extends Object</font></samp>''.
The primordial class
<samp><font color="0f0fff">Object</font></samp> is the lone exception -- it does not extend anything.  All other 
classes extend <samp><font color="0f0fff">Object</font></samp> either directly or indirectly.
<samp><font color="0f0fff">Object</font></samp> has a method <samp><font color="0f0fff">toString</font></samp>, so every class has a method
<samp><font color="0f0fff">toString</font></samp>; either it inherits the method from its super class
or it overrides it.
<p>
Interface inheritance is specified with <samp><font color="0f0fff">implements</font></samp>.
A class implements an <em>Interface</em>, which is like a class, except that
the methods don't have bodies.
Two examples are given by the built-in interfaces
<a name="runnable">
<samp><font color="0f0fff">Runnable</font></samp>
</a>
and
<samp><font color="0f0fff">DataInput</font></samp>.