/*File simple1.java Copyright 1997, R.G.Baldwin
This Java application reads bytes from the keyboard until
encountering the integer representation of '#'.  At 
the end of each iteration, it saves the byte received and 
goes back to get the next byte.

When the '#' is entered, the program terminates input and
displays the character which was entered before the #.
**********************************************************/

class simple1 { //define the controlling class

  //It is necessary to declare that this method 
  // can throw the exception shown below (or catch it).
  public static void main(String[] args) //define main 
                        throws java.io.IOException {

    //It is necessary to initialize ch2 to avoid a compiler
    // error (possibly unitialized variable) at the 
    // statementwhich displays ch2.
    int ch1, ch2 = '0';

    System.out.println(
                      "Enter some text, terminate with #");

    //Get and save individual bytes
    while( (ch1 = System.in.read() ) != '#') 
      ch2 = ch1;

    //Display the character immediately before the #
    System.out.println(
          "The char before the # was " + (char)ch2);
  }//end main
}//End simple1 class.

Enter some text, terminate with #
abcde#
The char before the # was e

The following C++ program is designed to mimic the previous Java program. In particular, in a Java application, the interpreter invokes the class method named main of the controlling class. The main method controls the subsequent flow of the program. 

In this C++ program, the required main function emulates the action of the Java interpreter, invoking a class method named classMain. There are no other statements in the main function. As in the previous Java application, the class method named classMain controls the subsequent flow of the program. This is different from a "typical" C++ program where the function named main controls the flow of the entire program. This approach will be used for illustration purposes in many of the example C++ programs in these lessons because of the manner in which it mimics the operation of a Java program.
 

/*File simple1.cpp Copyright 1997, R.G.Baldwin
This C++ application reads bytes from the keyboard until
encountering the # character.  At the end
of each iteration, it saves the byte received and goes back
to get the next byte.

When the '#' is entered, the program terminates input and
displays the character which was entered before the #.
**********************************************************/

#include<stdio.h //use C-style input/output

class simple1 {
public:
  static void classMain();
};//End simple1 class definition.

//The while loop in this function requires the function to
// be defined outside class (loops not allowed in inline
// functions)
void simple1::classMain(){
  char ch1, ch2;
  printf("%s", "Enter some text, terminate with #\n");

  while( (ch1 = getchar()) != '#') ch2 = ch1; //input bytes

  //Display the character immediately before the #
  printf("%s %c","The char before the # was ",ch2);

}//end classMain

//=======================================================//

void main(){
  //call the class method named classMain
  simple1::classMain();
}//end main

The output from running this program is shown below with the user input in bold italics. 
 

Enter some text, terminate with #
abcde#
The char before the # was  e

Variables are used in a Java program to contain data that changes during the execution of the program.

int ch1, ch2 = '0';

The value of the zero character is not the same as the numeric value of zero, but hopefully you already knew that. 

As an aside, characters in Java are 16-bit entities called Unicode characters instead of 8-bit entities as is the case with many programming languages. The purpose is to provide many more possible characters including characters used in alphabets other than the one used in the United States..

System.out.println("The char before the # was " 
                                       + (char)ch2);

As another aside, instance variables in Java are automatically initialized to zero or the equivalent of zero. However, local variables, of which ch2 is an example, are not automatically initialized.

while( (ch1 = System.in.read() ) != '#') ch2 = ch1;

The corresponding initialization statement in the C++ program was as shown below. 

char ch1, ch2;

In C++, the variables were initialized to type char which is the type normally used to store characters in C++, although characters can also be stored in variables of type int as well. 

Variables in C++ can also be initialized when declared. However, in this case, there was no requirement to initialize the variable. 

Even though it is also possible in the C++ program to reach the following statement without purposely storing a value in the variable named ch2, the C++ compiler is not alert to such potential problems and does not force good programming practice as is the case with Java. 
 

printf("%s %c","The char before the # was ",ch2);

There is essentially no difference in declaring and possibly initializing simple variables of primitive types between Java and C++ 

public static void main(String[] args) //define main method

There was no corresponding variable declared in the C++ program because C++ does not require the declaration of variables to capture command-line arguments unless the use of command-line arguments is designed into the program. 

The type determines the set of values that can be stored in the variable and the operations that can be performed on the variable. 

In Java, all variables of type int contain signed values. 

C++ supports the use of both signed and unsigned (all positive) integer types. 

In C++ however, the way that a variable of a given type is represented may vary from one platform to the next and even from one version of a given brand of compiler to another version of the same brand compiler on the same hardware platform. These variations can lead to significant program portability problems in C++. 

Type       Size/Format                 Description
byte      8-bit two's complement     Byte-length integer
short    16-bit two's complement     Short integer
int      32-bit two's complement     Integer               
long     64-bit two's complement     Long Integer
float    32-bit IEEE 754 format      Single-precision 
                                     floating point
double   64-bit IEEE 754 format      Double-precision 
                                     floating point
char     16-bit Unicode character    Single character
boolean  true or false               True or False

The char type in C++ is typically 8 bits, and is simply an 8-bit integer often used to store the ASCII (or other collating table) representation of a human-readable symbol. 

As of this writing in December of 1997, there is no boolean type in C++ (but rumors indicate that it may be added by the committee working on the evolving C++ standard). True and false in C++ is indicated simply by the value of an integer with a value of zero indicating false and a non-zero value indicating true. 

Although the names of the various types in C++ tend to match the names in the above Java table, the programmer can have no confidence that the size of (range of values for) a particular type will remain fixed as a program is ported from one platform to the next or that all of the types will actually be implemented on all platforms. 

/*File wrapper1.java Copyright 1997, R.G.Baldwin
This Java application illustrates the use of wrappers 
for the primitive types.

This program produces the following output:

My wrapped double is 5.5
My primitive double is 10.5

**********************************************************/
class wrapper1 { //define the controlling class
  public static void main(String[] args){//define main

    //The following is the declaration and instantiation of 
    // a Double object, or a double value wrapped in an 
    // object. Note the use of the upper-case D.
    Double myWrappedData = new Double(5.5);

    //The following is the declaration and initialization 
    // of a primitive double variable. Note the use of the
    // lower-case d.
    double myPrimitiveData = 10.5;

    //Note the use of the doubleValue() method to obtain 
    // the value of the double wrapped in the Double 
    // object.
    System.out.println(
      "My wrapped double is " 
        + myWrappedData.doubleValue());
    System.out.println(
             "My primitive double is " + myPrimitiveData );
  }//end main
}//End wrapper1 class.

C++ provides no such wrapper classes for the primitive types, but it is possible to create your own wrappers. The following program creates and uses such a wrapper class to mimic the previous Java program.

/*File wrapper1.cpp Copyright 1997, R.G.Baldwin
This C++ application illustrates the creation of a class
in C++ which mimics the behavior of a wrapper in Java.

The output from this program is:

My wrapped double is 5.5
My primitive double is 10.5

**********************************************************/

#include<iostream.h
#include<new.h
#include<stdlib.h

//Create a wrapper class to instantiate a primitive double
// instance variable inside an object.
class Double {
  double data;//private data member inside the Double class
public:
  //method to return value 
  double doubleValue(){return data;} 
  Double(double inData){data = inData;}//constructor
};//end class Double

class wrapper1 {//mimics controlling class in Java program
public:
  static void classMain(){
    //Prepare for possibility of memory allocation failure.
    set_new_handler(0);

    //Declare, instantiate, and initialize an object of the
    // Double class.
    Double* ptr = new Double(5.5);
    if(!ptr) exit(1); //terminate on failure to allocate

    //Declare and initialize a variable of the primitive
    // double type.
    double primitiveDoubleValue = 10.5;

    //Display the value stored in the Double object and the
    // value of the primitive double variable.
    cout << "My wrapped double is "
      << ptr-doubleValue() << endl;
    cout << "My primitive double is "
      << primitiveDoubleValue << endl;
  }//end classMain

};//End wrapper1 class definition.

//=======================================================//

void main()
{
  //call the class method named classMain
  wrapper1::classMain();
}//end main

//End C++ program

At least we can think of it that way. In fact, depending on the particular JVM in use, the reference variable may reference a table in memory where the address of the object is stored. In that case the second level of indirection is handled behind the scenes and we don't have to worry about it. 

Why would a JVM elect to implement another level of indirection? Wouldn't that make programs run more slowly?

One reason has to do with the need to compact memory when it becomes highly fragmented. If the reference variables all refer directly to the objects, there may be many reference variables that refer to the same object. If that object is moved for compaction purposes, then the values stored in every one of those reference variables would have to be modified. However, if those reference variables all refer to a table that has one entry that specifies where the object is stored, then when the object is moved, only the value of that one entry in the table must be modified.

In C++, any variable (or object) can be represented in any of three ways: 

• in a manner akin to a Java primitive type (name evaluates to value), 
• by the address stored in a pointer variable, or 
• by a reference similar to a reference type in Java. 

This provides considerable flexibility as to how programs are coded in C++, and can also lead to errors which are not detectable at compile time, but manifest themselves later at runtime. Java does not support pointers. Although a reference variable in Java contains an address, or a reference to an address (as does a pointer variable in C++) Java does not allow you to arbitrarily modify that address as is the case with pointer variables in C++.

In addition to pointers, C++ also supports struct and union which are not supported by Java. The struct is redundant in C++, easily replaceable by use of a class. A union, on the other hand, is not redundant, in C++ and has its uses. It is unfortunate that Java does not support a union because there are some situations that can be handled very well with a union (such as conversion between big Endian and little Endian formats).

Double myWrappedData = new Double(5.5);
   . . .
//Note the use of the doubleValue() method to obtain the
// value of the double wrapped in the Double object.
System.out.println
  ("My wrapped double is " + myWrappedData.doubleValue() );

In comparison, the following code fragment from the previous C++ program dealing with wrappers declares, instantiates, initializes, and manipulates a pointer type named ptr. In this case, ptr is a pointer to an object of type Double. 

Double* ptr = new Double(5.5);
. . .
//Display the value stored in the Double object and the
// value of the primitive double variable.
cout << "My wrapped double is "<< 
       ptr-doubleValue() << endl;

Reference variables in Java are similar to pointer variables in C++. However, reference variables in Java are easier to use, and are inherently safer because the value stored in a reference variable cannot be changed to some arbitrary location in memory as is the case with pointers in C++ 

• Must be a legal Java identifier (see below) consisting of a series of Unicode characters. Unicode characters are stored in sixteen bits, allowing for a very large number of different characters. A subset of the possible character values matches the 127 possible characters in the ASCII character set, and the extended 8-bit character set, ISO-Latin-1 (The Java Handbook, page 60, by Patrick Naughton). 
• Must not be the same as a Java keyword and must not be true or false. 
• Must not be the same as another variable whose declaration appears in the same scope. 

• In Java, a legal identifier is a sequence of Unicode letters and digits of unlimited length. 
• The first character must be a letter. 
• All subsequent characters must be letters or numerals from any alphabet that Unicode supports. 
• In addition, the underscore character (_) and the dollar sign ($) are considered letters and may be used as any character including the first one. 

• member variable 
• local variable 
• method parameter 
• exception handler parameter 

/*File member1.java Copyright 1997, R.G.Baldwin
Illustrates class variables, instance
variables, local variables, and method parameters.

Output from this program is:

Class variable is 5
Instance variable is 6
Method parameter is 7
Local variable is 8

**********************************************************/
class member1 { //define the controlling class
  //declare and initialize class variable
  static int classVariable = 5; 
  //declare and initialize instance variable
  int instanceVariable = 6; 

  public static void main(String[] args){ //main method
    System.out.println("Class variable is " 
                                          + classVariable);

    //Instantiate an object of the class to allow for 
    // access to instance variable and method.
    member1 obj = new member1();
    System.out.println("Instance variable is " 
                                   + obj.instanceVariable);
    obj.myMethod(7); //invoke the method

    //declare and intitialize a local variable
    int localVariable = 8; 
    System.out.println("Local variable is " 
                                          + localVariable);

  }//end main

  void myMethod(int methodParameter){
    System.out.println("Method parameter is " 
                                        + methodParameter);
  }//end myMethod
}//End member1 class. 

While C++ does support both class variables and instance variables, it does not support the direct initialization of member variables using code such as the following. 

static int classVariable = 5;
int instanceVariable = 6;

The following program is a C++ program which mimics the behavior of the above Java program. Note that in C++, it necessary to re-declare all static or class variables outside the class definition. The output from the program is shown in the comments at the beginning. 
 

/*File member1.cpp Copyright 1997, R.G.Baldwin
Illustrates class variables, instance
variables, local variables, and method parameters.

The output from this program is:

Class variable is 5
Instance variable is 6
Method parameter is 7
Local variable is 8

**********************************************************/

#include<iostream.h

class member1 {
public:
  static int classVariable; //declare class variable
  int instanceVariable;     //declare instance variable

  member1(){ //constructor
    instanceVariable = 6; //initialize instance variable
  }//end constructor

  static void classMain(){
    classVariable = 5; //initialize class variable
    cout << "Class variable is " << classVariable << endl;

    member1 obj;//instantiate an object of this type
         cout << "Instance variable is "
                           << obj.instanceVariable << endl;
    obj.myMethod(7); //call the method

    //declare and display a local variable
    int localVariable = 8;
    cout << "Local variable is " << localVariable << endl;
  }//end classMain

  //displays method parameter
  void myMethod(int methodParameter){
    cout << "Method parameter is "
                                << methodParameter << endl;
  }//end myMethod
};//End member1 class definition.

int member1::classVariable; //must be re-declared in C++
//=======================================================//

void main()
{
  //call the class method named classMain
  member1::classMain();
}//end main

Thus, in Java, the scope can be the entire method, or can reduced by placing it within a block of code within the method. 

This scope-reduction feature is also supported in C++, at least that is true with the newest C++ compilers. This is illustrated by the following code fragment which will be presented as part of a complete C++ program in a subsequent lesson. 

/*File cleanup1.cpp Copyright 1997, R.G.Baldwin
**********************************************************/
class cleanup1{ //simulates controlling class in Java
public:
  static void classMain(){//simulates main method in Java
    //prepare new operator for null return on failure
    set_new_handler(0);

    { //begin scope-reduction block
    //instantiate and initialize object
    newClass newObject(5);
    newObject.showData();  //display contents of object
    cout << "Leaving scope-reduction block. "
                             "Object will be destroyed.\n";
    } //end scope-reduction block

    cout << "No longer in scope-reduction block."
                                 "\nTerminating program\n";
  }//end classMain
};//End cleanup1 class definition.

It will be shown that when this program is compiled under Borland's version 5.0 compiler, the object goes out of scope and destroys when control leaves the block of code defined by the { ... }. 

Java and some of the very latest C++ compilers treat the scope of a variable declared within the initialization clause of a for statement to be limited to the total extent of the for statement. 

int MyVar, UrVar = 6, HisVar;

/*File simple4.java
This application reads bytes from the keyboard until 
encountering the # character and echoes each character to 
the screen. The program terminates when the user enters 
the # character.
**********************************************************/
class simple4 { //define the controlling class
  public static void main(String[] args) 
                               throws java.io.IOException {
    int ch1 = 0;
    System.out.println(
                      "Enter some text, terminate with #");
    while( (ch1 = System.in.read() ) != '#') 
      System.out.print((char)ch1);
    System.out.println("Goodbye");
  }//end main
}//End simple4 class.

/*File SampProg04.java from lesson 20
Copyright 1997, R.G.Baldwin
Without reviewing the solution that follows, write a Java 
application that puts the following prompt on the screen:

Enter some text, terminate with #  

Then it echoes each character that you enter (when you 
press the Enter key.  However, it doesn't echo 
the # character. When you enter the # character, the 
program terminates and displays your name.

Does your program insert extra blank lines?  If so, can you
explain why?

**********************************************************/
class SampProg04 { 
  public static void main(String[] args) //define main 
                               throws java.io.IOException {
    int ch1;
    System.out.println(
                      "Enter some text, terminate with #");
    while( (ch1 = System.in.read() ) != '#')
      System.out.println("" + (char)ch1);
    System.out.println("Terminating, Dick Baldwin");
  }//end main
}//End SampProg04 class.

/*File SampProg05.java from lesson 20
Copyright 1997, R.G.Baldwin
Without reviewing he following solution, write a java 
application that wraps the value 3.14 in a Double object, 
and then displays two times the value using the 
doubleValue() method of the object.

Also have the application create a primitive double
variable containing 3.14 and display twice the value
contained in the variable without using a wrapper.

Provide appropriate text in the output.

Also display your name on the screen along with a 
terminating message.
=========================================================
*/
class SampProg05 { 
  public static void main(String[] args){ 
    Double myWrappedData = new Double(3.14);
    double myPrimitiveData = 3.14;
    System.out.println
      ("Twice my wrapped double is " + 
        2*myWrappedData.doubleValue() );
    System.out.println
      ("Twice my primitive double is " + 
        2*myPrimitiveData );
    System.out.println("Terminating, Dick Baldwin");
  }//end main
}//End SampProg05 class.  Note no semicolon required

/*File SampProg06.java from lesson 20
Copyright 1997, R.G.Baldwin
Without reviewing the following solution, write a Java 
application that illustrates the use of member variables, 
local variables, and method parameters.  Make all of them 
type double.

Illustrate two different member variables:  a class 
variable and instance variable.

Display each of them along with appropriate text, and also 
display a terminating message along with your name.
**********************************************************/
class SampProg06 {
  static double classVariable = 3.14; 
  double instanceVariable = 2*3.14; 

  public static void main(String[] args){ 
    System.out.println(
                     "Class variable is " + classVariable);
    SampProg06 obj = new SampProg06();
    System.out.println("Instance variable is " 
                                   + obj.instanceVariable);
    obj.myMethod(3*3.14); 

    //declare and intitialize a local variable
    double localVariable = 4*3.14; 

    System.out.println(
                     "Local variable is " + localVariable);
    System.out.println("Terminating, Dick Baldwin");
  }//end main

  void myMethod(double methodParameter){
    System.out.println(
                 "Method parameter is " + methodParameter);
  }//end myMethod
}//End SampProg06 class.