A few pointers for C++ students working with Java/Lejos on the RCX

CS460 students: Those of you not familiar with java may find this page useful since you will need to program in Java for your project.

It is not necessary to know the vast library of classes that are available to most standard java implementations since the lejos JVM that runs on the RCX doesn't implement those library classes anyway.

A tutorial for using lejos might be useful and can be found here on this German site
The API documentation for the library classes available to you might also be useful
Additional tutorials and information is available on the Lejos FAQ page

Some important differences between Java and C++:

Java was designed with syntax similar to c++ so that it would be fairly easy to learn for C++ programmers. Unfortuately there are just enough peculiarities that the transition from one to the other takes some work. Because so much is the same between the two languages, I'll only concentrate on those things that strike me as being quite different. Feel free to ask any questions in class, during my office hours or by email.

Memory management:

In C++ for every object that you create on the heap (every object that you create with the new keyword) you must free up the memory and resources yourself using the delete keyword. Object that you create by simply declaring them are created on the stack and are cleaned up for you when they go out of scope.

In java, all objects are created using the new keyword and they are all created on the heap, however you do not have to do your own memory management. Java has a garbage collector that will clean up unused memory for you. You still need to clean up other resources in your class destructors though.

No C-functions (Not even main)

Unlike C++, there are no C-functions available in Java, every function is a method of some object or some class.
Static (class) methods do exist , these are the closest to C-functions that are available.
The main function is also a class function in Java. The prototype is
public static void main (String[] arg){
    //body of function here.
This method becomes part of one of your classes.

To run your program you will use lejos <your class that includes the main method>

Using other classes

Since there are no header files, you can't really use the #include preprocessor directive as in C++. Instead, one uses the java keyword 'import' to tell the compiler that this classes uses some other classes. You can import a single class using the import statement like:
import java.lang.System;

Or you can import an entire package (a group of classes that are related and are located in the same directory)  For example
 import josx.platform.rcx.*;
imports all of the classes in the josx.platform.rcx package. (Something you will probably do while you are building RCX programs.)


Everything is an object in Java. To drive that home, there is no seperation of class declaration in a header file and class definition in a code file the way htere is in C++. The class declaration and definition are one.  For example, in the RCX hello world example included in the lejos examples directory (class reproduced below), The main method in implemented right in the class declaration. All other classes are implemeted the same way.

public class HelloWorld
  public static void main (String[] aArg)
  throws Exception
     TextLCD.print ("hello");
     TextLCD.print ("world");
Instance variables are included in the class difinition as usual, though they may appear below the methods/member functions that use them and still be syntactically correct, it is generally good form to put them at the top of the class.

It is important to note that to encourage good programming, each file can only contain one public class and that class must have the same name as the Java file name (without the .java extension)


There is no multiple inheritance in java. A class can only directly inherit from one class at a time. To do that the class uses the extends keyword. If a class doesn't explicitly extend another class, then it extends the Object class, which is a simple class that is the root of the Java class hierarchy.

For example from the lejos examples directory
public class MotorView extends PortView //Class MoterView inherits from
                                         //class Portview

  static final int MAXSTATE = 3; //some constants
  static final int MAXPOWER = 7;

  int iState;
  int iPower;

  MotorView( Motor m, int n ) //constructor as one would expect
    super( true, n);
    motor = m;

    iState = 0;
    iPower = 7;

 public void showValues() //member function/ method as one would expect
    LCDProgramNumber.set (iState);
    LCDNumber.set (iPower, 0, true);




To get around the limits of multiple inheritance, java provides interfaces which can be thought of somewhat akin to pure virtual classes which have no member functions defined at all.

Interfaces are a list of capabilities that every class that implementes the interface must make available. Interfaces can be used as the type for formal parameters, return types,  variable definitions and most other places that a type must be used. You cannot however try to create an object of the interfact type. Rather, you create an object of the class that implements the interface and use that object where you need the interface. To implement an interface one must use the implements keyword and then implement all of the methods declared by the interface for example:

class Subsumption implements ButtonListener {
    public void buttonPressed(Button b) {
    public void buttonReleased(Button b) {

The ButtonListener interface requires the two methods
buttonPressed and buttonReleased to be implemented to implement the interface. There are several interfaces in the lejos API that might be of interest.

Thats all for now.

These are the basic differences between Java and C++ that you are likely to run into in your early work on your project. Please let me know if you encounter any other oddities and I'll add them to this page.