Download slides_java

A Quick Intro to Java for C and
C++ Programmers
Scott Hudson
HCI 631
Fall 2000
About this lecture



Will be assuming you are a fluent C
or C++ programmer.
This is going to be a quick
introduction to the language.
I'm not going to teach anything
much about object-oriented
programming.
2
What is Java

Java is a programming language
designed by James Gosling at Sun
Designed to be "squirted" across a
network into a device, the primary device
right now being a web browser
– Interpreted from byte codes (virtual
machine approach)
– Dynamically loaded
–

=> very portable (except...)
3
What is Java


"A pretty good object oriented
language with C++ camouflage on"
Once was "The latest thing" and
massively hyped
4
Why was there hype about Java?

At the right place at the right time
(important need on the web)
(Supposed to be) Highly portable (finally
is)
– Seen by lots of companies as a way to
break the Microsoft monopoly (didn’t work)
–
=> huge amounts of money involved
=> major corporate politics/warfare
(Sun & Netscape vs. Microsoft)
5
Beyond the Hype (and loss thereof)

Not much fundamentally new here
–

we have seen almost all the concepts in
other languages before
But, its fairly well designed
more than can be said for a lot of things
– Its better than C++ for many/most uses
– It was built by someone who knew the
"landscape" of programming languages
and has some taste
–
6
Beyond the Hype (and loss thereof)

In my opinion its the best current
language with wide platform
support (backing of many solid
implementations)
7
Goals


Downloadable into a wide range of
devices/platforms
Good OO language to replace C++
Relatively small/simple/clean language
– Camouflaged as C++ for sneak attack
when C++ was the dominant language
C++ programmers will feel at home
–

Lots of checking and safety
8
Major differences from C++


Generally simplified
No pointers
Actually everything is a pointer
(reference), but their are no dangling
pointers!
– No pointer dereferencing (where you used
to say "->" you now always use ".")
–

Garbage collection added
–
Big big win
9
What's been added from C (all in C++)





O-O concepts & information hiding
Stronger typing
Real constants (not just macros)
Overloading (two functions with the
same name, but different parameter
types)
New comment style ("//" to eol)
10
What's been added beyond C++





More checking
Exceptions (they were in C++, but..)
(Limited) signature based typing
("interfaces" -- a big win)
Runtime type identification (plus
other reflection capabilities)
Built in threads and synchronization
11
What's been added beyond C++ (cont.)






Packages (collections of classes in
a namespace)
Dynamic runtime loading
Strings (as objects)
A root class (Object)
Unicode characters (16 bit chars)
64 bit longs, bytes, booleans
–
(literals true and false)
12
What's been added beyond C++ (cont.)


A (small) container library
(hashtables, etc.)
Special "doc" comments /** ... */ +
post-processing to produce
hyperlinked API documentation
–
html + special @directives in the
comments
13
Things that are missing (but we probably
won't miss):




Virtual functions (everything is
virtual!)
Virtual base classes
Virtual destructors
Implicit constructor invocation (and
other constructor/destructor
weirdness)
14
Things that are missing (but we probably
won't miss):






Arcane type conversion rules (and
generally loose typing)
16 different meanings for const
extern (now have strong load-time
checking)
->* operator (member pointers)
:: (scope operator)
15
Things that are missing (but we probably
won't miss):






void *
Null terminated strings
Declaration vs. definition (always
done together, need not declare
before use)
(Brain dead) multiple inheritance
Templates
16
Things that are missing (but we probably
won't miss):


Operator functions
Macros, include files, and
conditional compilation (the
preprocessor)
17
Other things that are missing (that we
might miss):





Independent functions
Pointers to functions
Default parameters
Unsigned types
Bare metal performance(?)
18
So is it too slow?


Can get roughly 4x of C code
performance (on many things you
care about) using JIT compilers
Plenty fast for interactive apps
–

Spend a lot of time in native drawing code
anyway
Faster development time => more
optimization time => faster code!
19
More details on differences with C++
Lexical level


Designed to look almost exactly like
C++ (which is almost identical to C)
Minor differences, but not worth
mentioning
20
More details on differences with C++
Syntactic level

Designed to look a lot like C++
which was designed as a superset of C
– but cleaned up most egregious parts
–

Changes:
inheritance syntax
– initialization in constructors
– split definition vs. declaration (and scope
operator)
– protection declaration
–
21
More details on differences with C++
Control Flow

All C/C++ flow control constructs
except goto
added labeled break and continue to
handle the few remaining legit uses
– if/else for while do/while switch/case/break
– return break continue
–

throw try/catch/finally to support
exceptions
22
Exception syntax
try { …
throwable except = new my_exception();
throw(except); …
} catch (my_exception ex) {
… do something to recover …
} catch (Exception ex) {
…
}
finally {
… code that is always executed …
}
23
More details on differences with C++
Control Flow (cont.)

Now have real booleans
can't test integers and pointers directly
– "if (ptr)" must be "if (ptr != null)"
–
24
Classes


The major construct in Java (like
most object oriented languages) is
the class.
Classes are a type definition: They
define the data and operations of
an object.
–
You can create several instances of
objects; several things with that data and
those operations
25
Classes


For C programmers you can think
of this for now as a struct with the
functions operating on the struct
"inside" the struct.
For C++ programmers you can
think of this as a class.
26
class point_list {
int x;
int y;
point_list next;
double distance_to(point_list other)
{
double dx, dy;
dx = (double)(x - other.x);
dy = (double)(y - other.y);
return Math.sqrt(dx*dx + dy*dy);
}
double distance_to_next()
{
if (next == null)
return 0;
else
return distance_to(next);
}
}
27
What have we got here.

Three instance variables
–

C++ == fields
Two methods
C++ == member functions
– Note: There are no functions in Java, just
methods (notice that we had to say
Math.sqrt() to get a square root).
–
28
What have we got here.

If we had two points: pt1 and pt2,
then we could compute the
distance between them as
pt1.distance_to(pt2)

Except... we have some problems
here what are they? (p, v, c, after)
29
Problem #1: self containment

Looks like a point_list contains a
point_list
class point_list {...
point_list next;

But, recall everything is a pointer,
so this is a pointer (reference) to a
point_list, so we are ok
30
Like C++ Two forms of data: primitive and
objects
Primitive types:
byte
8 bit signed integer
short
16 bit signed integer
int
32 bit signed integer
long
64 bit signed integer
boolean true of false
char
16 bit unicode character
float
single precision
double double precision
31
If its not a primitive its an object


Note: this includes strings & arrays
Declaring instance variables of
object types actually declares
references to objects of that class
null is a possible value
– need to be initialized to refer to object
–

Referenced with “.” instead of “->”
(back to problems)
32
Problem #2: Visibility


Classes also provide information
hiding and the default is to not allow
full access to instance variables or
methods.
So a better version would be...
33
public class point_list {
protected int x;
protected int y;
protected point_list next;
public double distance_to(point_list other)
{
double dx, dy;
dx = (double)(x - other.x);
dy = (double)(y - other.y);
return Math.sqrt(dx*dx + dy*dy);
}
public double distance_to_next()
{
if (next == null)
return 0;
else
return distance_to(next);
}
}
34
Specifying protection
Members can be:




public
protected
Accessible to all
Accessible to classes
within the same package
and subclasses
Accessible only within the
private
class itself
<unlabeled> Inside package: protected
Outside package: private
(no subclass access outside package).
35
Specifying protection
Classes can be:



public, unlabeled, or private
Almost all classes are public
(anybody can use them)
Can have private or local classes
only accessible in package
– rare
– can protect constructors instead
–
36
Point of style

Its a good idea for all but the
simplest classes to not have any
public instance variables.
Instead have a protected variable with
read and write access methods.
– This lets you change your mind later
without breaking all the code that uses
yours.
–
37
Point of style
protected int _x;
public int x() {return _x;}
public void set_x(int val)
{_x = val;}

Seems tedious, but…
This has saved my sorry butt many times!
(back to problems)
38
Problem #3: no constructor


Haven't provided a way to create
any useful objects of this type
Java initializes instance variables:
int et al.
boolean
float, double
char
Object
0
false
0.0
‘\0’
null
39
Initialization

You can also explicitly initialize
instance vars
protected int x = 0;
protected int y = 0;
protected point_list next = null;
40
Declaring constructors

Typically, you want provide a
constructor.
–

If you don't provide a constructor, one (that
does nothing and takes no parameters)
will be provided for you.
Constructor looks like a method
with the same name as the class
but no return type:
41
Declaring constructors
public point_list(
int xv,
int yv,
point_list nxt)
{
x = xv; y = yv; next = nxt;
}
42
Declaring multiple constructors

Often want to provide several
constructors
–
Java does not do default parameters
public point_list(int xv, int yv)
{ this(xv,yv, null); }
public point_list()
{ this(0,0); }
43
Declaring multiple constructors

Notice that we can "chain"
constructors together using "this()".
We can also invoke the super class
constructor using "super()".
– Must be the first thing in the constructor.
–
(back to problems)
44
Some misc. basics

All parameters are pass-by-value.
–


However, for all object types we are
passing references by values, so...
Can return at most one value.
Arithmetic, etc. operations
(precedence, etc.) are the same as
C/C++, except...
45
Some misc. basics

Arithmetic, etc. operations are the
same as C/C++, except...
Use of comma operator is limited to for
statements.
– Can apply bitwise operations to booleans
(but not mixed int/boolean) to get nonshortcutting operations.
– == and != mean "refer to the same object".
–
46
Some misc. basics

Like C++ can declare variables
anywhere a statement is legal
–

Same scoping rules
–

including inside parens of for statements
scope limited to enclosing block: {... }
Don't have to declare before use.
47
Hierarchical Types and Inheritance

The big wins in object-oriented
programming come from
hierarchical typing and inheritance.
48
Hierarchical Types and Inheritance

Two things of importance:
Inheritance: the ability to derive the
implementation of something from some
existing code (AKA getting someone else
to do the work for you).
– Substitutability: the ability to write code
that doesn't care about exactly what type it
operates over (so you can substitute
related but different types).
–
49
Inheritance

In Java (like most OO languages)
you can base the implementation of
a class on another class.
Basically, you take what is in the other
class (the base or superclass) and then
extend it to do new and/or different things.
– The new class (the derived class or
subclass) preserves the API of the
superclass
–
50
Inheritance

The new class preserves the API of
the superclass
–

so it does everything the superclass did
Consequently, an instance of a
subclass can be substituted for an
instance of a superclass
–
a variable that references the superclass
can safely be used to reference the
subclass
51
Declaring inheritance in class
declarations

Suppose we wanted to create a
colored_point_list which keeps a
color value with each point...
52
Declaring inheritance
public class colored_point_list
extends point_list {
protected Color _pt_color;
public Color pt_color() {return _pt_color;}
public void set_pt_color(Color val)
{_pt_color = val;}
public colored_point_list(
int xv, int yv, point_list nxt, Color clr)
{ super(xv,yv,nxt);
set_color(clr);
}
}
53
Declaring inheritance

Note the extends clause
Gives the base class we are derived from
– If there is no extends clause we
automatically inherit from Object (the Java
root class).
– Java only supports single inheritance, so
you only get to list one thing.
–
54
Declaring inheritance

Note also that we call the
superclass constructor (might as
well let them do the work here)
using the special form:
"super(...);"

Like "this()" this must be the first
thing in the constructor.
55
Get substitutability

If we have a piece of code which
declares a variable of type
point_list, we can safely let it
operate on an object of type
colored_point_list.
56
Another (different) use of “Super”

Can use “super” to refer to a
method in the superclass that has
been overridden by the subclass
public class grid8_point_list extends point_list {
public void set_x(int val)
{
int rounded = (val / 8)*8 + ((val%8 >= 4)?1:0);
super.set_x(rounded);
}
...
}
57
Notes on this example
public class grid8_point_list extends point_list {
public void set_x(int val)
{
int rounded = (val / 8)*8 + ((val%8 >= 4)?1:0);
super.set_x(rounded);
}
...
}


Boy it’s a good thing we put that
set_x() in there
We call set_x() don’t set x directly
58
This

Sometimes you need to refer to the
object itself in one of its methods
(pass it somewhere).
–
Reserved word this is used for this
purpose. As in:
manager.put_in_table(this);

Note that instance variable
references such as "_x" above are
really shorthand for "this._x".
59
Abstract classes

Its not necessary to completely
define a class
This is useful to define the API to
something without requiring a particular
implementation (see also interfaces).
– This is useful also if you have a lot of
common functionality to put in a base
class but details (i.e., implementation of
particular methods) have to be provided
by various subclasses.
–
60
Abstract classes


(Must) declare the class "abstract"
Declare each missing method
“abstract” and put a semicolon
where the body would be.
abstract public class stack {
abstract public void push(Object obj);
abstract public Object pop();
abstract public boolean empty();
}
61
Abstract classes

Can't instantiate an abstract class
(but can declare variables).
62
Interfaces

Syntactically an interface
declaration looks a lot like a class
declaration (replace "class" with
"interface").
–

But, no variables and methods don't have
bodies.
Basically interfaces define an API,
but no implementation
63
Interfaces

Interfaces are used as a "promise".
Class can say:
"implements”interface_name" after
extends clause
– This means that the class promises to
implement the API of the interface.
– It doesn't say anything about how its going
to do it, just that it will
– The compiler checks that it does.
–
64
Interfaces

Can inherit from (“implement”)
multiple interfaces.
65
Substitutability for interfaces

Can declare variables and
parameters with interface types
Variable can then refer to object of any
type that implements the interface
Has promised to implement the API (&
compiler has checked) so this is
completely type safe!
– Gives you a lot of flexibility to
reimplement, etc.
– Advice: use this whenever you can
–
66
Packages

Classes are organized into
collections of related things
–

what constitutes one package is entirely
up to you.
Each source file belongs to a
particular package
–
listed at the top with the package
declaration: package sub_arctic.lib;
67
Packages

Note: its possible to leave the
package declaration out which
indicates the special "unnamed
package”
–
don't do this! it just gets confusing to
everyone concerned
68
Packages

Package names have multiple parts
(‘subpackages”) separated by "."
–


java.awt and java.awt.image
But, these don't have a special
relationship between them
Packages are primarily to
segregate the name space
–
class names must be unique within the
package, but not across all packages
69
Packages

Also have an effect on protection
rules
–
recall: protected members can be
accessed by classes in same package
70
Imports


You can use package names to
disambiguate types.
Recall we had an example that
used the class Color.
Comes from the library package java.awt
and its full name is java.awt.Color.
– If you get tired of writing out the full name,
you can "import" the class:
import java.awt.Color;
–
71
Imports


If you get two classes with the
same name from different
packages you use full names to
disambiguate.
Since compiler knows how to find
packages, this eliminates the need
for #includes
–
you can also import from compiled code
without the source!)
72
Packages

java.lang.* is imported
automatically.
73
Static members


Instance variables belong to (have
a copy in) each instance.
Can also declare variables that
belong to the whole class.
–
Do this with static:
class a_class {
protected static int count = 0;
public a_class() {count++;}
}
74
Static members

There is only one copy of the static
variable
–

belongs to the class (shared by all
instances).
You can also have static methods.
–
These can be invoked without an instance
(using the class name):
Math.sqrt(3.1415d)
75
Initialization of statics

You can use conventional
initializers (after =)
–

Executed when the class is loaded
Also have special static initialization
blocks (outside of methods):
static {... some code ...}
– Also executed when class is loaded
– Java loader takes care of loading classes
you depend on first
76
Final members

You can declare classes, methods,
and variables final.
–
For variables this means they can't be
assigned to after initialization (AKA
constants):
public static final double PI2 = Math.PI*Math.PI;
For methods, this means you cannot
override the method in subclasses.
– For classes this means all the methods
are final.
–
77
Final members


You can declare final variables in
interfaces
Java idiom: to collect a bunch of
reusable constants together put
them in an interface and
"implement" them in the classes
where they are used.
78
Strings

In Java, strings are objects of class
String
not array's of char, although there are
operations to get back and forth
– Special literal e.g: "abc" represents a
String object.
–

Character escapes such as \n
similar to C.
79
Strings

Strings are immutable
–

operations create new strings, don't
modify existing ones.
"+" is used for string concatenation,
and is treated specially
Any + with at least one String operand is
treated as string concatenation
– The other operand is converted to a string
(this also works for String parameters)
–
80
Conversion to Strings


For primitive types there is a
standard (and obvious) conversion
For Objects, the toString() method
is called
Object provides one (prints class name
and unique id)
– Or you can override
–
81
Arrays


Arrays are also objects in Java
Can declare as "int foo[]"
or "int[] foo"
–
both declare a variable which refers to an
array of ints (initialized to null)
82
Arrays

Array size is not part of the type
that gets established by the instance
int[] foo = new int[52];
...
foo = new int[42]
–

Each array object has a read-only
field: length
foo.length == 42
83
Arrays

Note that arrays are collections of
Object references.
–

All set to null by default.
Can initialize arrays to refer to
particular object with special form
similar to C/C++
int[] foo = {3, 5, 9};
Object[] bar = {"one", new
Stack(), new Integer()};
84
Array types

Arrays are hierarchically typed
If sub is a subclass of base then
sub[] is a subclass of base[]

So you could have:

base[ ] base_var = new sub[42];
85
Checking types at runtime

Can determine if an object qualifies
as a particular type at runtime using
expression: "obj instanceof aclass"
– "null instanceof aclass"
is always false.
86
Checking and converting types at runtime

Can convert to a sub- or superclass with a C style cast
expression: "(aclass)expr"
–
Does runtime type check and throws an
exception if this is not a legal conversion
(i.e., object being cast is not of that type or
a subclass thereof).
87
Output to stdout

java.lang.System has lots of useful
stuff for accessing the local
environment including:
System.out, System.err, and System.in
(for stdout, stderr, and stdin).
– Two operations of particular interest:
System.out.print() and System.out.println()
print anything convertible to a string with
or without a newline.
–
88
Threads


Threads are built into the language
Concurrent threads can greatly
simplify program structure and
design for a number of things
89
Threads


They also make testing and
debugging nearly impossible
So unless your programs all work
without testing (and/or there is no
reasonable way around it), I advise:
Just say no!
90
Threads

Note: if you feel compelled to use
threads with subArctic read that
section in the manual!
–
non-obvious things you have to do or you
will get (nasty & hidden!) concurrency
bugs
91
Good luck...
... and, as always, if you or any of
your programming team are caught
or killed, I will disavow that I ever
taught you anything about Java.
92
93