Intro to Java for C++ Developers

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

 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

 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

 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

 Not specific to the Java language. Other
languages compile for the JVM:

◦ Groovy
◦ Clojure
◦ Jython
◦ JRuby
◦ Dozens of others…

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

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.

 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

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

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

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

public void foo()
{
class Point
{
public int x;
public int y;
}

Point p = new Point();
}

 You can even declare a class inside a method!

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.

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.

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

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

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!

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

 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/

Intro to Java for C++ Developers

Intro to Java for C++ Developers

More Related Content

What's hot (19)

Similar to Intro to Java for C++ Developers (20)

Recently uploaded (20)

Intro to Java for C++ Developers