Reference for the Programming Language JJ

Reference for the Programming Language JJ JJ is a version of the Java language designed for beginners; it is not a "toy" language, but is a "junior", gentler version of a "senior" language. It is meant as a bridge or "step-stone" for learning the basic concepts of programming, without the distractions of a large language. It ultimately introduces both programming principles and practice in Java in a very short time. This reference is a brief description of the language JJ. It is meant to be a definition and reference for beginners. However, it is not a tutorial on the language; it is not sufficient for beginners to learn programming. It concentrates mainly on the details of the language and does not deal with how best to use the language. It could be read over quickly now, so that you may know where to go when you have questions about the language. It could be read quickly also at various later times to serve as a review. The formal definition of the language in an abstract form called EBNF is also available elsewhere for programmers and professors. A diagrammatic definition is also given in the main text. This reference describes the form (look, structure, layout, style, indentation, grammar, etc) of programs in Jr; it does not describe the process of programming, or the meaning (semantics) or the use (pragmatics) of the language. Examples Traditionally, the first example is to output "Hello world!"; in JJ the entire program is simply the following one-line command (instruction or statement): JJS.outputString ("Hello world!"); Incidentally, this same first example in Java would involve six new words (class, public, static, void, main, String, args) and three different kinds of brackets (rounded, square, and curly shapes). These concepts will be introduced in JJ, (and justified in Java) but at a later, more appropriate time A short program follows to show the typical form (or syntax, layout) of a simple program in JJ. Programs involving classes and methods (functions and routines) are somewhat more complex, and discussed later. The part to the right, consisting of line numbers and comments is not part of the language, and not part of the documentation; it just serves to describe what is happening in this case. You could guess at the meaning (or semantics). // Name Ann Onymous // Does simple gross pay // 1. indicates the name of the programmer // 2. documents the purpose of the program int pay, hours; // 3. declares 2 integer boxes pay & hours JJS.outputString ("Enter the hours "); JJS.inputInt (hours); JJS.outputInt(hours); // 4. prompts the user to enter data // 5. waits for input of data hours // 6. echoes the data entered if (hours < 40) { pay = 10 * hours; } else { pay = 400 + 15 * (hours - 40); }//end if // // // // // 7. Checks if hours are less than 40 8. and if true sets pay to the product 9. otherwise it computes overtime pay 10. which is given by this formula 11. end of the Choice construct JJS.outputString ("The gross pay is "); // 12. prints everything within the quotes JJS.outputlnInt (pay); // 13. prints the pay on the line above // 14. and then prints a new line Run, or execution of the program is as follows: first is a prompt for an input, and when a number such as 40 is entered the outputs is "The gross pay is 400". Similarly in a second run, when an input of 50 is entered the output is "The gross pay is 550". Structure: Form of the Code Program code is a mix of English, mathematics and logic. A semicolon is used to end or terminate a command. Two commands cannot be on the same line; but a command can extend over many lines. Case-sensitivity is important; capital letters (upperCase characters) are considered very different from lower case letters. For example, a word like PAY all in upper case is not the same word as the word pay all in lower case or Pay in mixed case. Furthermore, the same word involving letters in different cases should not be used because humans do not easily see the differences between words like pay and Pay. Spacing is significant. Note the gaps between some lines, which serves to separate some parts while at the same time unifying parts; for example lines 4, 5, and 6 all involve input and are separated from line 3 involving declaration and from line 7 involving a decision on the pay. Similarly lines 12 and 13 involve output. Tokens are "clumps" or sequences of characters. Some tokens, consisting of decimal digits (0 to 9), represent numbers, and other clumps of characters represent words. Another token is the two character sequence "<=" which represents "less than or equal to". The two characters cannot have spaces between them; the two must be together. Tokens however should have spaces on either side of them. Comments provide documentation or help for human readers. In JJ comments involve two slashes which make up the token "//". A comment consists of this token followed by any number of characters, up to the end of line. For example line 9 has a comment indicating overtime. Programming deals with entities which are viewed as boxes (or variables) of a certain type (size) having values (contents) and given identifiers (names). Identifiers are names that programmers may choose for various objects and actions. Identifiers begin with any letter (a .. z, A .. Z) followed by any number of letters or digits (0 .. 9) or underscores "_". Identifiers are not limited in length. An underscore should not end an identifier. Examples of proper identifiers are: pay, hours, i, over21, maxAge, min_Age Keywords are words which are part of the language (such as int, true, if and while) and so are reused often. They are often called "reserved" words, and should not be used as identifiers or in any other ways in any program. If they are used in unintended ways an error message results. Data Types JJ is a strongly typed language; all boxes (variables) must be declared along with their type. The basic (simple or primitive) data types are int, double and boolean. Strings are similar to the basic types but come from a String class. They consist of sequences of characters surrounded by quotes. Examples are: "a", "CA", "Hi mom", "(123) 456-7890" Characters are small strings having only one item within them; they are not considered a separate data type in JJ (but they are a separate type in Java). Declarations bind (associate or fix) an identifier with a data type. They consist of a type followed by one or more identifiers separated by commas and ending with a semi colon. Declarations have the following forms, where angular braces < and > surround words that are not in the JJ language but in the meta-language describing the language: Examples of some declarations follow; they appear early in the code before their use. int age; double radius, area, diameter; boolean tall, dark, handsome; string reply, grade, LastName; Numeric types in JJ are only two; integer and double ; in Java there are about 6 integer types, and two real types (called double and float). Integers are used for counting, reals are used for measuring. Integer is the type which describes whole numbers, both positive and negative. The type "int" in JJ refers to values whose maximum is about 2 billion (actually - 2,147,483,647 to 2,147,483,647, based on the binary; 2 raised to the power 31). Examples of ints are: 1, 7, -13, 1984, 1234567890 Real numbers (which have the type double) have a fractional part, and involve a decimal point. They are usually the result of some measurement (of size, weight, rainfall, etc). Examples of real values are: 0.1, 2.0 -3.4, 3.14159, 98.6, 123456.789 1.23e4 (which is also 12300) 4.56E-5 (which is 0.0000456) Mixing of different types is not possible in JJ. For example, reals cannot be added to ints; one of them must be converted. Conversion is not done automatically, but the conversion (or casting) can be done with functions such as intToDouble or doubleToString described later. Arithmetic operators on both ints and reals are the four familiar arithmetic functions, corresponding to addition, subtraction, multiplication and division, which have the symbols (+, -, *, /). Division of reals and ints differs. Division of reals results in a quotient which is a real. Division of ints results in a quotient which is an int. For example, division of the reals 9.0 / 5.0 results in 1.8 5.0 / 9.0 results in 0.5555555 ... Division of ints, in the form x/y results in the quotient: 9 / 5 results in 1 5 / 9 results in 0 Mod, sometimes called modulus or rem (remainder) is another operator which also applies only to ints, and has the operator symbol %. x%y results in the remainder when x divides y For example 9 % 5 results in the remainder 4 5 % 9 results in the remainder 5 Arithmetic expressions, involve operators, values, boxes, and may include round parentheses for grouping. The binary operators of multiplication and division have precedence over addition and subtraction, so that x*y + z is (x*y) + z ; it is not x*(y+z) . Operators of the same precedence are associated from left to right. For example the expression (1 - 2 - 3) is evaluated as (1 - 2) -3 which is -4 rather than 1 - (2 - 3) which is 2. Logical boxes (of type boolean) can have one of only two values: true, false. Operations of this type, in JJ, are three: and (&&), or (||) and not (!). the result of (x && y) is true only when both x and y are true, the result of (x || y) is true when either one or both x, or y are true, the result of (! x) is true when x is false; it is false when x is true. Relational operators, as follows, compare two values: < >= stands for "less than" stands for "greater than or equal to" <= > stands for "less than or equal to stands for "greater than" == != stands for "equal to" stands for "not equal to" Notice that the lines are in pairs which are complements (opposite or negative). For example, the complement of (x < y) is (x >= y); it is not (x > y). Conditions are logical (boolean) expressions; they consist of proper combinations of relations, operators, and values.Some examples are: (x != y) (x <= y) && (y <= z) (a == 7) || (a == 11) Actions (commands or instructions) in JJ include Set, Input and Output. Set, also called assignment, is of the form = which replaces the current value of a box (indicated by lhs, leftHandSide) by the new value corresponding to the expression; both must be of the same type. This is read as "Left hand side gets expression". Examples of the Set command follow: count = 0; rate = maxRate; area = PI * radius * radius ; Boxes (or variables) are not automatically initialized; they must be set before they can be used. Input of a value to a box depends on the type, as given in the four forms: JJS.inputInt() JJS.inputDouble() JJS.inputBoolean() JJS.inputString() as in the example: age = inputInt(); radius = inputDouble(); Output and Outputln (Output-line) are similar in form JJS.outputInt(i); JJS.outputlnInt(i); JJS.outputDouble(d); JJS.outputlnDouble(d); JJS.outputString(s); JJS.outputlnString(s); JJS.outputBoolean(b); JJS.outputlnBoolena(b); The expression within the brackets is evaluated and the value is printed. Any above command containing "outputln" prints a new line after it has printed the required value. Type conversions (or casts) in JJ are of the form: JJS.intToDouble (i) JJS.doubleToInt (d) JJS.IntToString (i) JJS.doubleToString (d) JJS.booleanToString (b) and are used as parts of commands as for example: roundedx = JJS.doubleToInt (x + 0.5); Arithmetic functions are operations or actions (such as sine, square-root) which are in Math class and can be used by prefixing each operation by the library Math (such as Math.sin(r), or Math.sqrt(r) ). Some of the many functions in the Math class are: sin(r) cos(r) tan(r) asin(r) acos(r) atan(r) returns returns returns returns returns returns the the the the the the sine of an angle r, given as a real value in radians cosine of an angle r, given as a real value in radians tangent of an angle r, given as a real value in radians arcsine of real value r, where r is in range [-1.0 to +1.0] arccosine of real value r, in range [-1.0 to +1.0] arctangent of real value r, where r goes from -Pi to Pi sqrt(r) pow(x,n) log(r) exp(r) returns the square root of any positive real value returns the value of real value x raised to real power n returns the natural logarithm of real value r returns value of e raised to the r-th power where (e = 2.718..., the base of the natural logarithm) ceil(r) returns the smallest integer value which is not less than real value floor(r) returns the largest integer value less than or equal to r random() returns a real value between 0.0 and 1.0 (but not including 1.0) Control Constructs: Choice and Loop Programming constructs in JJ are few; the Choice construct (if) for selecting and the Loop construct (while) for iterating. Both involve conditions and actions, in different ways. Choice is a construct of the form: if (expr) { action } else if { action } else action }//end if where there may be any number of "else if" parts and zero or one "else" parts. The actions may be Set, Input, Output or another construct (Choice or Loop). The ending comment "}//end if" allows JJ to provide good, meaninful error messages. Such a comment is not requred but is also useful as documentation. Examples of Choice forms follow, showing four basic forms: // Comment on high grade if (grade >= 90) { JJS.outputString ("Very Good!"); }//end if // Select maximum and minimum if (first < second) { max = second; min = first; }else{ max = first; min = second; }// endIf // Indicate polarity if (value < 0) { JJS.outputString ("Negative"); } else if (value > 0) { JJS.outputString ("Positive"); }//end If // Price depends on quantity if (quantity == 1) { price = 99; }else if (quantity == 2) { price = 95; }else if (quantity <= 4) { price = 90; }else if (quantity < 6) { price = 85; }else // half dozen or more price = 75; }//end if Loop is an iterating construct of the form: while () { }//end while The ending comment "}//end while" is preferred again in JJ in order to provide good, meaninful error messages. Other loops constructs are possible, but this one is sufficient. An example of this looping construct follows: // Average many real values // ending with any negative terminator sum = 0.0; // real value num = 0; // int count JJS.outputString ("Enter a value "); value = JJS.inputDouble (); while (value > 0.0) { JJS.outputln (value); sum = sum + value; num = num + 1; value = JJS.inputDouble (); }//end while JJS.outputString ("The mean is "); JJS.outputDouble (sum / JJS.intToDouble(num) ); Methods (Functions and Routines) Methods in JJ are of two very different forms (functions and routines, or void functions). Both methods involve a name and slots (parameters or arguments). Function methods are parts of expressions, and have a type; their names are usually nouns (maximum, average, etc). Routines are commands that stand on their own; their names are usually verbs (sort, spellOut, etc). Calling (or invoking) functions differs from that of routines in that functions are parts of expressions as in: hypotenuse = Math.sqrt (x*x + y+y); largest = maximum (first, second); whereas routines stand on their own as in spellOut (digit); outRow (7, "Ho "); Routines are defined in the following form, consisting of a head and a body which follows the Does part. static void ( ) { [] // Does [Start] //end void function Heads of routines (or headers, or signatures) consist of a name and a bracketed list of slots along with their type. This is followed by a declaration of local boxes. Bodies of a routine consists of a number of actions; one of the actions (only one per class) may be "Start". In "real" Java there is a routine called main which "starts". Does, is a comment line which separates the head from the body; it indicates briefly the purpose of the method. Names of routines at the head must match the name on the last line (tail) of the definition. An example routine, outRow (times, mark) prints a row of marks a given number of times. For example, the command outRow (80, "*") prints a row of 80 asterisks, and the command outRow (7, "Ho "); prints out the three-character string "Ho " seven times as: Ho Ho Ho Ho Ho Ho Ho Definition of the routine outRow follows: public static void outRow (int times, String mark) { int count; // Does draw a row of marks count = 0; while (count < times) { JJS.outputString (mark); count = count + 1; }//end while }//end void function outRow Functions are defined in the following form: static ( ) { [] // Does result = ; return result; }//end function This is very similar to the definition of a Routine except that the first line of the header must indicate the return type. Also there is a local variable result which must be declared as a local box. And the result must be assigned a value within the body. Example of function definitions follow; one returns a boolean value, the other a real: public static boolean isEven (int num) { boolean result; // Does indicate if num is even result = ((num % 2) == 0); return result; }//end function isEven public static boolean triArea ( double a; double b; double c ) { double result; double s, t; // Does use Hero's formula s = (a + b + c) / 2.0 ; t = s*(s-a)*(s-b)*(s-c); result = Math.Sqrt (t); return result; }//end function triArea Both kinds of methods when used within a class may have their visibility specified by appending to the first header either "public" or "private"; public ones are shared whereas private ones are hidden. Arrays in JJ are limited to a single-dimension; arrays of two dimensions and more dimensions can be created as classes from the single-dimensional arrays. Arrays are accessed by integer indices within square parens "[" and "]" where the indices range from 0 to (n-1). Declarations of arrays simply specify the type in the form []; as for example: double hours []; int score []; String name []; Creation of arrays specifies the size in the form: = new [size] where n is the size , so the largest index is (n-1). for example: hours = new double [6]; // for 7 weeks of days 0 to 6 name = new String [n] // for a given value of n Arrays could also be declared and created in one line as: double hours = new double[6]; //week of work int temp = new int [30]; //month of mean temperatures boolean didRain = new boolean [365] //year of rainfall? String LastName = new String [classSize]; //names, given size Arrays could be declared, created, and assigned values in one line as: int MaxTempF[] = {55,66,72,70,68,66,69}; //week of temperatures Storing and retrieving entries of an array arr is done as: arr[i] = x; // put value x into positon i of array arr y = arr[j]; // get value y from positon j of array arr To find the max = num = while if maximum value max of an array arr of given size: arr[0]; 1 (num < size) { (max < arr[num] { max = arr[num] }//end if num = num + 1; }//end while Classes in JJ consist of attributes (or fields), constructors and methods, of the form: import ; class { // Name: // Does: }//end Class Constructors have the form: ( ) { }//end Constructor Access of an attribute (such as the name) of an object (such as first of a class Person) is done with a dot notation such as: fname = first.name ; JJ does not allow the left hand side to be of the form "obj.attribute"; it does not allow attributes (or fields) of an object to be changed directly. Access must be done using a method. Java does not have such a strict restriction. Account, which follows, is an example of a class describing a simple bank account. class Account { // Name Ann Onymous // Does provide a simple savings bank account public static final double MIN_BALANCE = 200.00; // Data attributes, fields private double balance; private String name; private int idNumber; // Constructor Account (double b, String n) { // Does initialize or open the account balance = b; name = n; }//end constructor Account public void setId (int number) { // Does set or reset the id number idNumber = number; }//end method setId public void credit (double amount) { // Does deposit an amount into account if (amount > 0) { balance = balance + amount; }//end if }//end method credit public boolean canCover (double amount) { boolean result; // Does check if balance covers amount result = (balance >= amount); return result; }//end method canCover public double getBal () { double result; // Does return balance in account result = balance; return result; }//end method getBal // Routine Start public static void main (String arg[]) { Account first, second; double amount; // Does test the Account class first = new Account (100.0, "Jack"); first.credit (500.00); System.out.print ("The balance is "); System.out.println (first.getBal()); amount = first.getBal() - MIN_BALANCE; if (first.canCover (amount)) { System.out.print ("Can cover "); System.out.println (amount); }//end if }//end method main }//end class Account //a run // The balance is 600 // Can cover 400 Not covered in this reference are some advanced concepts involving design by contact, which include: invariant, check, preCheck, postCheck, debug, TryCall, TrySet. jmm 2001 03 20