Title: A Quick Intro to Java for C and C Programmers
1A Quick Intro to Java for C and C Programmers
- Scott Hudson
- HCI 631
- Fall 2000
2About 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.
3What 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
- gt very portable (except...)
-
4What is Java
- "A pretty good object oriented language with C
camouflage on" - Once was "The latest thing" and massively hyped
5Why 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 (didnt work) - gt huge amounts of money involved
- gt major corporate politics/warfare (Sun
Netscape vs. Microsoft)
6Beyond 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 -
7Beyond the Hype (and loss thereof)
- In my opinion its the best current language with
wide platform support (backing of many solid
implementations)
8Goals
- 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
9Major 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
"-gt" you now always use ".") - Garbage collection added
- Big big win
10What'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)
11What'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
12What'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)
13What's been added beyond C (cont.)
- A (small) container library (hashtables, etc.)
- Special "doc" comments / ... /
post-processing to produce hyperlinked API
documentation - html special _at_directives in the comments
14Things 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)
15Things 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)
- -gt operator (member pointers)
- (scope operator)
-
16Things 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
-
17Things that are missing (but we probably won't
miss)
- Operator functions
- Macros, include files, and conditional
compilation (the preprocessor)
18Other things that are missing (that we might
miss)
- Independent functions
- Pointers to functions
- Default parameters
- Unsigned types
- Bare metal performance(?)
19So 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 gt more optimization time
gt faster code!
20More 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
21More 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
22More details on differences with CControl 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
23Exception 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
24More details on differences with CControl Flow
(cont.)
- Now have real booleans
- can't test integers and pointers directly
- "if (ptr)" must be "if (ptr ! null)"
25Classes
- 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
26Classes
- 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.
27class 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(dxdx dydy) double
distance_to_next() if (next
null) return 0 else
return distance_to(next)
28What 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).
29What 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)
30Problem 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
31Like 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
32If 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 -gt
- (back to problems)
33Problem 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...
34public 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(dxdx
dydy) public double
distance_to_next() if (next
null) return 0 else
return distance_to(next)
35Specifying protection Members can be
- public
- protected
- private
- ltunlabeledgt
- Accessible to all
- Accessible to classes within the same package and
subclasses - Accessible only within the class itself
- Inside package protected
- Outside package private
- (no subclass access outside package).
36Specifying 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
37Point 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.
38Point 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)
39Problem 3 no constructor
- Haven't provided a way to create any useful
objects of this type - Java initializes instance variables
- int et al. 0
- boolean false
- float, double 0.0
- char \0
- Object null
40Initialization
- You can also explicitly initialize instance vars
- protected int x 0
protected int y 0
protected point_list
next null
41Declaring 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
42Declaring constructors
- public point_list(
- int xv,
- int yv,
- point_list nxt)
-
- x xv y yv next nxt
-
43Declaring 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)
-
44Declaring 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)
45Some 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...
46Some 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 non-shortcutting
operations. - and ! mean "refer to the same object".
47Some misc. basics
- Like C can declare variables anywhere a
statement is legal - including inside parens of for statements
- Same scoping rules
- scope limited to enclosing block ...
- Don't have to declare before use.
48Hierarchical Types and Inheritance
- The big wins in object-oriented programming come
from hierarchical typing and inheritance.
49Hierarchical 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).
50Inheritance
- 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
51Inheritance
- 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
52Declaring inheritance in class declarations
- Suppose we wanted to create a colored_point_list
which keeps a color value with each point...
53Declaring 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)
-
-
54Declaring 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.
55Declaring 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.
56Get 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.
57Another (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 ((val8 gt
4)?10) - super.set_x(rounded)
-
- ...
58Notes on this example
- public class grid8_point_list extends point_list
- public void set_x(int val)
-
- int rounded (val / 8)8 ((val8 gt
4)?10) - super.set_x(rounded)
-
- ...
-
- Boy its a good thing we put that set_x() in
there - We call set_x() dont set x directly
59This
- 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".
60Abstract 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.
61Abstract 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()
62Abstract classes
- Can't instantiate an abstract class (but can
declare variables).
63Interfaces
- 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
64Interfaces
- Interfaces are used as a "promise".
- Class can say "implementsinterface_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.
65Interfaces
- Can inherit from (implement) multiple
interfaces.
66Substitutability 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
67Packages
- 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
68Packages
- 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
69Packages
- 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
70Packages
- Also have an effect on protection rules
- recall protected members can be accessed by
classes in same package
71Imports
- 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
72Imports
- 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!)
73Packages
- java.lang. is imported automatically.
74Static 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
-
75Static 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)
76Initialization 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
77Final 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.PIMath.PI
- For methods, this means you cannot override the
method in subclasses. - For classes this means all the methods are final.
78Final 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.
79Strings
- 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.
80Strings
- 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)
81Conversion 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
82Arrays
- 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)
83Arrays
- Array size is not part of the type
- that gets established by the instance
- int foo new int52
- ...
- foo new int42
- Each array object has a read-only field length
- foo.length 42
84Arrays
- 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()
85Array 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 sub42
86Checking 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.
87Checking and converting types at runtime
- Can convert to a sub- or super-class 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).
88Output 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.
89Threads
- Threads are built into the language
- Concurrent threads can greatly simplify program
structure and design for a number of things
90Threads
- 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!
91Threads
- 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
92Good 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.
93(No Transcript)