Transition from C++ to Java

Java: even a simple program is not simple.

public class Program1 { public static void main(String[] arg) { System.out.println("Hello World"); } }

Some Similarities between C++ and Java

Simple

(primitive) types: int, double,

char Control Structures if-else, switch, while, for Arithmetic expressions Both have a string type: C++ string, Java String. Arrays Both have classes. Both have a "main".

Some Differences between C++ and Java

Java

has automatic garbage collection. C++ does not. C++ has operator overloading. Java does not. C++ says "function". Java says "method". These require no explanation, unless students already know C++.

More Differences
C++

classes can be avoided. Java classes cannot reasonably be avoided. C++ has built in console I/O. Java has no standard console input (but does have standard console output.) C++ and Java divide a program into pieces (for separate compilation) in different ways. These require some explanation.

C++ classes can be avoided. Java classes cannot reasonably be avoided.

Every compilation unit in Java is a class. A program is a class with a method named main:
public class Program1 { public static void main(String[] arg) {

In Java, every method is a member of some class. You cannot have a freestanding (global) function in Java.

You can fake a "no classes" program in Java by making all methods static.

But dont do it!

A Sample Java Class

public class PetRecord { private String name; private int age;//in years public PetRecord(String initName, int initAge) { name = initName; if ((initAge < 0)) System.out.println("Error"); else age = initAge; }

public void writeOutput() { System.out.println("Name: " + name); System.out.println("Age: " + age + " years"); }

C++ has built in console I/O. Java has no standard console input

(but Java does have standard console output.)

C++: has cin, cout, cerr Java has:

System.out.print and System.out.println

but NO console input. Solutions?

C++ and Java divide a program into pieces (for separate compilation) in different ways.

C++: Traditionally has an interface (header) file, implementation file(s), application (driver) file. C++: Can confine a program to a single file if you want.

 Java: A compilation

unit is always a class definition. Every class is in a separate file (except for some special cases). No header files. Normally, you have no one file programs in Java.

More Subtle Differences

C++ has pointer types. Java has no pointer types . Assignment (=) and equality comparison (==) have minor differences. C++ gives a choice of parameter types. Java: No choice of parameter types. Exception handling can be avoided in C++ Exception handling is needed for some fundamental things in Java, e.g. file I/O.

Java has no pointer types

But

Java does have "pointers". In Java class (and array) types are REFERENCE TYPES. A reference is a "pointer". All class values in Java are handled as references, but it is all automatic. In Java primitive types are just like in C++.

 In

Java a primitive type variable holds values, just as in C++. int n = 42; Java a class type variable contains a reference ("pointer") to the object (value). However, this is all automatic. There are no pointer types as such in Java.
PetRecord myDog = new PetRecord("Fido", 3);

Note that all class objects are created dynamically.

Assignment (=) and equality comparison (==) have minor differences.

On

primitive (simple) types, = and == are the same in C++ and Java. In Java, = and == on classes (or arrays) are comparing references ("pointers"), and you cannot overload (redefine) = and == in Java.

Assignment (=) and equality comparison (==) have minor differences. If (n = 0) . In C++ this is probably an error with no error message, assuming you meant to use ==. In Java this generates a compiler error. In Java ints neither are nor can they be type cast to Booleans

C++: a choice of parameter types. Java: no choice of parameter types.

C++: Call-by-value void f(int n); C++: Call-by-reference void f(int& n); Other C++ variants: void f(const int& n); void f(const int n);

C++: a choice of parameter types. Java: no choice of parameter types.

Java

all parameters are call-by-value. But, it is almost like there are different parameter types for primitive types and classes.

Java: no choice of parameter types, but All primitive type parameters are automatically call-byvalue.
public void f(int n) {...}

All

class types are automatically something very much like call-byreference.

public void f(String n) {...}

C++: a choice of parameter types. Java: no choice of parameter types.

Java Full Story: In Java primitive types are just like in C++. In Java class (and array) types are REFERENCE TYPES. A reference is a "pointer". All class values in Java are handled as references, but it is all automatic.

All

parameters are call-by-value of a reference.

C++: a choice of parameter types. Java: no choice of parameter types.

Java Full Story:

In Java all parameters are call-by-value. Parameter is a local variable initialized to the value of the argument. Primitive types no surprises. Class type (local) variables hold references. Class parameters are call-by-value of a reference.

Java: no choice of parameter types.

public void change(PetRecord r) { r.name = "FooFoo"; } This really changes its PetRecord argument. public void change(int n) { n = 42; } This does not change its int argument.

Java: no choice of parameter types.

public void change(int n)
{
n = 42; } This does not change its int argument.

There is no way to write a Java method that has a parameter for an int variable and that changes the value of an argument variable.

There is no way to write a Java method that has a parameter for an int variable and that changes the value of an argument variable. So, how do you manage to cope?

int n = computeNewValue();

OR use class objects.

public class Stuff { private int n; .... public void changeTheN(Stuff s) { s.n = 42; } }

Exception handling can be avoided in C++ Exception handling is needed for some fundamental things in Java, e.g. file I/O. Solutions:

Exception handling in Java

Fake it with "magic formulas" approach:
public class TextFileOutputDemo

{
public static void main(String[] arg) throws IOException {

PrintWriter outputStream = new PrintWriter()); outputStream.println("To file");

public class TextFileOutputDemo { //without magic formula: public static void main(String[] arg) { PrintWriter outputStream = null; try { outputStream = new PrintWriter( new FileOutputStream("out.txt")); } catch(FileNotFoundException e) {} outputStream.println("To file");

Style Comparison C++/Java

Java uses loooong names: e.g. FileNotFoundException while C++ uses some abbreviations Java spelling conventions: ClassName, variableName, methodName, LITERAL_NAME Java has an official commenting style: javadoc

javadoc
Extracts an interface from a class definition. May not need full blown details for AP course, but be consistent with javadoc. Comments before method headings: /** javadoc comment style. */

THANK YOU