A quick intro to java for c and c programmers
1 / 93

- PowerPoint PPT Presentation

  • Uploaded on

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. .

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
Download Presentation

PowerPoint Slideshow about '' - sherise

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
A quick intro to java for c and c programmers l.jpg

A Quick Intro to Java for C and C++ Programmers

Scott Hudson

HCI 631

Fall 2000

About this lecture l.jpg
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.

What is java l.jpg
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...)

What is java4 l.jpg
What is Java

  • "A pretty good object oriented language with C++ camouflage on"

  • Once was "The latest thing" and massively hyped

Why was there hype about java l.jpg
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)

Beyond the hype and loss thereof l.jpg
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

Beyond the hype and loss thereof7 l.jpg
Beyond the Hype (and loss thereof)

  • In my opinion its the best current language with wide platform support (backing of many solid implementations)

Goals l.jpg

  • 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

Major differences from c l.jpg
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

What s been added from c all in c l.jpg
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)

What s been added beyond c l.jpg
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

What s been added beyond c cont l.jpg
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)

What s been added beyond c cont13 l.jpg
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

Things that are missing but we probably won t miss l.jpg
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)

Things that are missing but we probably won t miss15 l.jpg
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)

Things that are missing but we probably won t miss16 l.jpg
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

Things that are missing but we probably won t miss17 l.jpg
Things that are missing (but we probably won't miss):

  • Operator functions

  • Macros, include files, and conditional compilation (the preprocessor)

Other things that are missing that we might miss l.jpg
Other things that are missing (that we might miss):

  • Independent functions

  • Pointers to functions

  • Default parameters

  • Unsigned types

  • Bare metal performance(?)

So is it too slow l.jpg
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!

More details on differences with c lexical level l.jpg
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

More details on differences with c syntactic level l.jpg
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

More details on differences with c control flow l.jpg
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

Exception syntax l.jpg
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 …


More details on differences with c control flow cont l.jpg
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)"

Classes l.jpg

  • 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

Classes26 l.jpg

  • 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.

Slide27 l.jpg

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;


return distance_to(next);



What have we got here l.jpg
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).

What have we got here29 l.jpg
What have we got here.

  • If we had two points: pt1 and pt2, then we could compute the distance between them as


  • Except... we have some problems here what are they? (p, v, c, after)

Problem 1 self containment l.jpg
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

Like c two forms of data primitive and objects l.jpg
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

If its not a primitive its an object l.jpg
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)

Problem 2 visibility l.jpg
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...

Slide34 l.jpg

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;


return distance_to(next);



Specifying protection members can be l.jpg





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).

Specifying protection Members can be:

Specifying protection classes can be l.jpg
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

Point of style l.jpg
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.

Point of style38 l.jpg
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)

Problem 3 no constructor l.jpg
Problem #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

Initialization l.jpg

  • You can also explicitly initialize instance vars

    protected int x = 0; protected int y = 0; protected point_list next = null;

Declaring constructors l.jpg
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:

Declaring constructors42 l.jpg
Declaring constructors

public point_list(

int xv,

int yv,

point_list nxt)


x = xv; y = yv; next = nxt;


Declaring multiple constructors l.jpg
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); }

Declaring multiple constructors44 l.jpg
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)

Some misc basics l.jpg
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...

Some misc basics46 l.jpg
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 non-shortcutting operations.

    • == and != mean "refer to the same object".

Some misc basics47 l.jpg
Some 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.

Hierarchical types and inheritance l.jpg
Hierarchical Types and Inheritance

  • The big wins in object-oriented programming come from hierarchical typing and inheritance.

Hierarchical types and inheritance49 l.jpg
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).

Inheritance l.jpg

  • 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

Inheritance51 l.jpg

  • 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

Declaring inheritance in class declarations l.jpg
Declaring inheritance in class declarations

  • Suppose we wanted to create a colored_point_list which keeps a color value with each point...

Declaring inheritance l.jpg
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);




Declaring inheritance54 l.jpg
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.

Declaring inheritance55 l.jpg
Declaring inheritance

  • Note also that we call the superclass constructor (might as well let them do the work here) using the special form:


  • Like "this()" this must be the first thing in the constructor.

Get substitutability l.jpg
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.

Another different use of super l.jpg
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);





Notes on this example l.jpg
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);





  • Boy it’s a good thing we put that set_x() in there

  • We call set_x() don’t set x directly

Slide59 l.jpg

  • 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:


  • Note that instance variable references such as "_x" above are really shorthand for "this._x".

Abstract classes l.jpg
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.

Abstract classes61 l.jpg
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();


Abstract classes62 l.jpg
Abstract classes

  • Can't instantiate an abstract class (but can declare variables).

Interfaces l.jpg

  • 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

Interfaces64 l.jpg

  • 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.

Interfaces65 l.jpg

  • Can inherit from (“implement”) multiple interfaces.

Substitutability for interfaces l.jpg
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

Packages l.jpg

  • 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;

Packages68 l.jpg

  • 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

Packages69 l.jpg

  • 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

Packages70 l.jpg

  • Also have an effect on protection rules

    • recall: protected members can be accessed by classes in same package

Imports l.jpg

  • 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;

Imports72 l.jpg

  • 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!)

Packages73 l.jpg

  • java.lang.* is imported automatically.

Static members l.jpg
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++;}


Static members75 l.jpg
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)

Initialization of statics l.jpg
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

Final members l.jpg
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.

Final members78 l.jpg
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.

Strings l.jpg

  • 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.

Strings80 l.jpg

  • 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)

Conversion to strings l.jpg
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

Arrays l.jpg

  • 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)

Arrays83 l.jpg

  • 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

Arrays84 l.jpg

  • 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()};

Array types l.jpg
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];

Checking types at runtime l.jpg
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.

Checking and converting types at runtime l.jpg
Checking 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).

Output to stdout l.jpg
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.

Threads l.jpg

  • Threads are built into the language

  • Concurrent threads can greatly simplify program structure and design for a number of things

Threads90 l.jpg

  • 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!

Threads91 l.jpg

  • 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

Good luck l.jpg
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.