An Intro to Java for C++ Developers

1. Zachary Blair
April 10, 2012

2.  Intro to Java and the JVM
 Basic Types/Arrays
 Classes/Inheritance
 Nested Classes
 Exceptions
 Enums
 Autoboxing/unboxing
 Annotations
 Generics

3.  Originally developed by Sun for embedded
devices, version 1.0 released in 1996
 James Gosling (Father of Java, Officer of the
Order of Canada), photo by Peter Campbell

4.  Intended as an alternative to C++ that is:
◦ Simpler
◦ Higher-level
◦ Multithreaded
◦ Dynamic
◦ Object-oriented
◦ Trivially portable (“Write Once, Run Everywhere”)
◦ No pointer arithmetic
◦ Automatic garbage collection

5.  Emulates a “virtual” CPU Java Source
Files (.java)
Executes “bytecode”
javac

(each opcode is one byte Java bytecode
long) stored in ‘.class’ files (.class)
files
 The same “bytecode” can x86 Java ARM Java
run on any machine with Virtual Virtual
Machine (JVM) Machine (JVM)
a JVM implemented for it

6.  Not specific to the Java language. Other
languages compile for the JVM:
◦ Groovy
◦ Clojure
◦ Jython
◦ JRuby
◦ Dozens of others…

7.  Similar to C:
byte -> 8 bits
short -> 16 bits
int -> 32 bits
long -> 64 bits
float -> 32 bits
double -> 64 bits
char -> 16 bits
boolean
 Numeric types are always signed
 ‘char’ is a 16 bits instead of 8!
 No conversion between int and boolean as in C++.
if(0) or while(1) are compile-time errors in Java.

8. Eight bytes walk into a bar. The bartender
asks, “Can I get you anything?”
“Yeah,” reply the bytes. “Make us a double.”
** I didn’t come up with this joke, but it’s comedy Gold.

9.  Similar to C in syntax
int[] numbers = new int[10];
numbers[0] = 1000;
 Arrays are Objects with members and
methods (member functions)!
for (int i = 0; i < numbers.length; i++) {
System.out.println(numbers[i]);
}
 Trying to index past the end of an array
results in ArrayIndexOutOfBoundsException

10. public class Vector2D
{
public int x;
public int y;
public float magnitude()
{
return Math.sqrt(x * x + y * y);
}
}
 Method implementations must be defined in the
class body. No ‘.h’ files, just ‘.java’!
 Classes themselves can have access modifiers!
 Each ‘public’ class must reside in a ‘.java’ file of
the same name (e.g. Vector2D.java).

11. public class Velocity extends Point2D
{
public boolean isTooFast()
{
return (magnitude() > 60);
}
}
 Uses ‘extends’ to specify a base class
 Only single inheritance is supported
 All inheritance equivalent to ‘public’ in C++
 All classes implicitly inherit from Object

12. public class OuterClass
{
public int var;
class InnerClass
{
public void foo()
{
System.out.println(var);
}
}
}
 Non-static inner classes have access to the
outer class’s members!
 Instantiated using ‘this.new’ instead of ‘new’.

13. public void foo()
{
class Point
{
public int x;
public int y;
}
Point p = new Point();
}
 You can even declare a class inside a method!

14. button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
System.out.println(“The button was pressed”);
}
}
 Defined and instantiated an anonymous
class that implements an “ActionListener”
interface, all in the parameter list to a method
call!
 Used as Java’s alternative to function pointers
in C for callbacks.

15. try {
int a[] = new int[2];
System.out.println(“A three:" + a[3]);
}
catch (ArrayIndexOutOfBoundsException e) {
System.out.println("Exception:" + e);
}
 Handle error conditions, similar to C++’s try/catch.
 Some exceptions are ‘checked’, meaning it is a
compile-time error to not either catch them, or
explicitly mark your method as possibly throwing
that exception to its caller.

16. public enum Color
{
RED, ORANGE, YELLOW, GREEN, BLUE
}
…
Color c = Color.RED;
 Like C enums, but in Java, enum is a sort of
class with enum values as static members.
 You can add data and methods to the enum!
Color c = Color.RED;
if (c.isWarmColor())
System.out.println(c.toString());

17. int x = 10;
Integer y = new Integer(x);
Integer z = x;
int a = z;
list list = new List();
list.append(x); // x converted to
Integer
 Automatically convert between primitive types
(e.g. int, double, char) to their Object-based
(boxed) types (e.g. Integer, Double, Character).
 Useful because boxed types can be stored in
collection classes just like any other Object

18. public class Base
{
public void foo() { }
}
…
public class Subtype extends Base
{
@Override public void foo() { bar(); }
}
 @Override marks a method as explicitly
overriding a base class method, triggering a
compilation error if it doesn’t!

19. class<T> Pair
{
public T first;
public T second;
}
Pair<int> p = new Pair<int>();
p.first = 10;
p.second = 20;
 A bit like templates in C++ (except that
internally only one implementation is
created).

20.  Java has some similar syntax to C++
 Rather than compiling to native code, it
compiles to bytecode for the JVM to execute
 Java makes it more difficult to make certain
mistakes (automatic garbage collection and
no pointer arithmetic).
 Learn more at http://docs.oracle.com/javase/