From Alice to Java
From Alice to Java
Santa Monica College
Computer Science 3
Java Course Pack
By Computer Science Faculty – Santa Monica College
Introduction
This tutorial is intended for CS 3 students who have learned how to create programs using Alice (an environment for learning introductory programming techniques) and now wish to learn how to write programs in Java (the most popular programming language in the world according to the TIOBE Programming Community Index[1] survey of programming language popularity).
Getting Started with Java
The Java Tutorial - Getting started with Java at website by Sun Microsystems, Inc., the creators of Java, is an excellent introduction to the language. Rather than repeating that material here (that would be reinventing the wheel) you are encouraged to read it now.
Nature of Programming and Using Compiler Software
In writing computer programs we give the computer step-by-step instructions on how to accomplish the task we need done. This step-by-step direction is called an algorithm. An algorithm must finish in a finite amount of time. Computer programs are simply algorithms coded in some computer language. You saw these step-by-step instructions in Alice programs. There when you run the Alice world, it will execute the first statement, then the second and so on. Alice is a graphical development environment in the sense that, when you add objects to the Alice world and then you drag and drop the object’s methods into the code window (or you use functions that return values), behind the scenes Alice generated some of the code for you. This automatically generated code (which is invisible to you) is run when you play your Alice world. In Java programming you will start to write programs on your own without the kind of help that the Alice environment provided to you incognito. Among the many tools available to write Java programs is the Notepad[2] text editor which allows you to type your Java program and save it as a text file. We show an example below. Imagine that you wish to say hello to the world through a Java program. The Java program below can accomplish that.
Listing 1
public class HelloWorldApp {
public static void main (String [ ] args) {
System.out.println (“Hello, World!”);
} // main
} // HelloWorldApp
After typing above program in a Notepad file you would save it in a file named HelloWorldApp.java. All Java programs require that .java be used as the file extension. This is no different from the fact that all Microsoft word files must have an extension doc or docx. In addition Java requires that file name be same as class name. We do not expect you to understand all the words in this program at this point. However, by end of this course pack they will become clear to you.
After writing a Java program and saving it in a file, we need to compile the program. Compilers are translator programs that scan through the program you typed and check that the correct syntax has been used in program typing. Notice that you did not have worry about that with Alice because Alice, being a drag-and-drop graphical environment, did not let you make a mistake similar to the one you could make when you type a program with Notepad. If the compiler finds no mistakes in your program, then it will create a file called a class file that will allow you to run your Java program. Understand that not all programs need a compiler. Some programming languages (for example JavaScript) use a different kind of translator program called an interpreter that translates and runs the program line by line on the fly, without any compilation. Let us talk about how to use Java compiler a bit more.
How to Use the Java Compiler
You can use Sun’s Java Software Development Kit (SDK) to compile and run your Java programs. You will use two tools from the kit:
1. javac - the Java compiler. This is used to compile (translate) your Java source code (.java file) into bytecode (object code).
2. java - the Java interpreter. This is used to run your Java bytecode (.class file) on the Java Virtual Machine (JVM).
To use the Java SDK, first open a command prompt window as follows:
Start | All Programs | Accessories | Command Prompt
Then navigate to folder where your .java file is. For this you will need to learn how to navigate to a folder on certain drive through the Command Prompt environment (formerly known as the DOS environment). The compilation is done using the following syntax. Imagine that your file name is HelloWorldApp.java. Then compilation will be done using the following syntax:
>javac HelloWorldApp.java
Note: If entering the above command results in the following error message:
'javac' is not recognized as an internal or external command, operable program or batch file.
then you will need to set the 'path' environment variable as follows:
path=m:\programs\jdk\bin
This assumes you are working in the classroom (B203) or the Programming Lab (B231).
If there are no compile errors, then you get no output whatsoever. If there are compile errors, the Java compiler outputs an error message with a line number appended to it. When your program has no errors you can execute your program using the command below:
>java HelloWorldApp
If code has no runtime failure, then it will print out the program message or interact with user as required by the code. For example, the code shown in Listing 1 on previous page will print out following words on your Command Prompt console
Hello, World!
Let us now compare some features of Java and Alice.
A Comparison of Alice and Java
Since we learn something new (Java) by relating it to something already known (Alice), we will now review the HelloWorldApp example shown earlier, comparing each Java feature to its Alice analog.
HelloWorldApp in Alice
Note that Java Style in Color has been selected from the Edit | Preferences menu in Alice. Adding Java Syntax adds semicolons and curly braces to your Alice code.
[pic]
[pic]
HelloWorldApp in Java
The source code for similar hello world program in Java is given in Listing 1 above. The console output for this Java program is shown in Figure below.
[pic]
Based on what we have seen so far we can compare Java and Alice programs as follows:
|A Comparison of HelloWorldApp in Alice and Java |
|Comparison Basis |Alice |Java |
|Program (aka an |The HelloWorldApp program in Alice is a 3D virtual |The HelloWorldApp program in Java is seven lines of text that define |
|application or app, |world. |the HelloWorldApp class. |
|for short) | | |
|Entering source code|An Alice program is created using the Alice 3D |A Java program is created using a text editor (e.g., Notepad) or, |
| |Authoring system, a graphical development |better yet, a programmer’s editor that does code coloring. Dreamweaver|
| |environment in which the programmer uses drag ‘n’ |is good for this. |
| |drop graphical tools. The only keyboard entries are | |
| |for data values, such as what Alice says. | |
|To save your program|On the File menu, click Save. Give your world a |On the File menu, click Save. Save your program with a java extension.|
| |meaningful name. Alice saves your program with an |The classname and filename must agree exactly. Thus, the HelloWorldApp|
| |A2W (Alice version 2 world) extension. Save your |class definition is saved in a file named HelloWorldApp.java |
| |world often, especially after making a lot of | |
| |changes. | |
|classes |In this program we used the AliceLiddell class from |In this program we used the System class from the predefined class |
| |the Local Gallery. |libraries that are part of Java. We also defined a class named |
| | |HelloWorldApp. |
|objects |The objects in this world are world, camera, light, |There is one object in this program - System.out. It represents the |
| |ground, and aliceLiddell. |standard output device on the host computer (usually the display |
| | |screen). |
|comments |A comment in Alice begins with //and ends at the end|Same as in Alice. |
| |of the line. | |
|methods |This program has two methods - my_first_method() and|This program has two methods - main() and println(). main() |
| |say() |corresponds to Alice’s my_first_method() and println() corresponds to |
| | |Alice’s say() . |
|Where shall I begin?|When you run this Alice program, it begins with the |When you run this Java program it begins with the first statement in |
| |first statement in my_first_method(). |main(). |
|To compile your |Compiling is not necessary in Alice. The Alice |Java source code must be compiled into bytecode using the javac |
|program |source code is interpreted, not compiled. |compiler tool. To do this, at the command prompt, enter |
| | |javac HelloWorldApp.java |
| | |Bytecode is an intermediate portable language, not native machine |
| | |code. javac saves the bytecode in a file called HelloWorldApp.class |
|debugging syntax |It is impossible to make a syntax error in Alice. |The javac tool will inform you of any syntax errors. For each error it|
|errors |This is one of the things that make Alice so cool |will give the line number, a ^ marker indicating where it detected the|
| |for teaching introductory programming techniques. |error, and an error message describing the type of error. |
| | |Fix the errors by editing your source code (HelloWorldApp.java). |
| | |Save your source file. |
| | |Recompile using the javac tool. |
|To run the program |Click the Play button. |Use the java launcher tool. At the command prompt, enter |
| | |java HelloWorldApp |
| | |This runs the HelloWorldApp.class file on the Java Virtual Machine |
| | |(JVM) which interprets the bytecode. |
|debugging runtime |If a runtime error occurs, Alice will display an |The java tool will inform you if a runtime error occurs. It will give |
|errors |Error Dialog box. Fix the error. Click Play to test |the line number and an error message describing the type of error. |
| |your fix. |Fix the error by editing your source code. |
| | |Save your source file. |
| | |Recompile using the javac tool. |
| | |Run it again using the java tool to test your fix. |
|debugging logic |If the program doesn’t do what you want: |If the program doesn’t do what you want: |
|errors |Change/fix the program. |Change/fix the source code. |
| |Run it again by clicking the Play button to test |Save your source file. |
| |your changes. |Recompile using the javac tool. |
| | |Run it again using the java tool to test your changes. |
Simple Graphical Output in Java
We wish to ascertain that you are not too disappointed by the non-graphical nature of our first Java example where console is used for input and output. Some graphical input and output is quite easy in Java. We show a simple example in Listing 2 below.
Listing 2
//Save in file HelloWorldGraphic.java
import javax.swing.*;
public class HelloWorldGraphic {
public static void main(String[] args) {
JOptionPane.showMessageDialog(null, “Hello, World!”);
} // end main
} // end class
Figure below shows the popup box output from this program.
[pic]
In Java program shown in Listing 2 we have used a class called JOptionPane. Just like Alice stores their objects and classes in galleries, Java stores them in packages. The first statement in Listing 2 , import javax.swing.*; tells compiler that include the package with name javax.swing into our program where we find class called JOptionPane. The single line in the main method in Listing 2
JOptionPane.showMessageDialog(null, “Hello, World!”);
uses the class JOptionPane and its method showMessageDialog, which has second argument as “Hello, World!”, which is printed on the popup box from your Java program. Notice that the sytnax of calling methods in Java is identical to that of Alice. When Alice Liddell says Hello world, the syntax in your Alice code window was something like below
aliceLiddell.say (“Hello, World!”); …………..
then you can see that object with name aliceLiddell invokes its say method with argument “Hello, World!”. In the above two examples, the objects JOptionPane and aliceLiddell are similar in nature. Both call their methods (in one case method say() and in other the method showMessageDialog()) and pass to it the string they wish to print or display. In Java, the JOptionPane object can also be used for getting an input from user. We show simple example below (Listing 3).
public class HelloWorldGraphic2 //Save in file HelloWorldGraphic2.java
{
public static void main(String[] args)
{
String Name = “”;
Name = JOptionPane.showInputDialog(null,
“Please type your name, and then click on OK”);
JOptionPane.showMessageDialog(null, “Hello “ + Name);
}
}//Listing 3
When above program is compiled and run it first displays an input box shown by Figure below:
[pic]
Then I type my name in the inputbox and then click on OK (see Figure below).
[pic]
Upon clicking on OK, the program in Listing 3 pops up the message box shown below.
[pic]
The popup box is disposed by clicking on OK. Let us dissect the Listing 3 to understand some of its components. First line defines a variable called Name which is of type String and it is initialized to “”, which is a zero length string. Notice that variables in Java rquire a type before their name. Alice environment allows you to choose a data type for a variable when you create new variables. If you recall, the types of variables in Alice were: Number, Boolean, Object, and Other. Similarily Java has data types, which of course are much more extensive than Alice. The type string used in Listing 3 define text or string types which is also available in Alice uder category labeled “other”. The second line in Listing 3 again uses the JOptionPane class. This time however, it calls a different method – showInputDialog, with second argument as string “Please type your name, and then click on OK”. Notice that when second line is executed, the program pops up the input dialog box inside which user can type their name (see first figure above). Once user types their name and then clicks on OK, the second popup box says “Hello Satish Singhal” as it takes the name inputted by the user and appends word “Hello “ before it. The last program line in Listing 3 is similar to the one shown earlier in Listing 2, except the second argument to method showMessageDialog concatenates strings “Hello “ and Name using a plus (+) sign. This indicates that you can combine strings in Java simply using plus sign, as if you are adding two numbers.
Other Data Types in Java
Java has data types other than string. Table below shows various Java data types and their minimum and maximum ranges. Do not be too overwhelmed by plethora of types Java makes available for you. In the beginning you would only use four main types. These are char, int, double and boolean.
|Type |Size (bytes) |Minimum Value |Maximum Value |
|char |2 |Uses Unicode characters. Language dependent. |
|byte |1 |-128 |127 |
|short |2 |-32768 |32767 |
|int |4 |-2147483648 |2147483647 |
|long |8 |-9223372036854775808 |9223372036854775807 |
|float |4 |+/- 1.4E-45 |+/- 3.4028235E+38 |
|double |8 |+/- 4.9E-324 |+/- 1.7976931348623157E+308 |
|boolean |1 |false |true |
|These values are for Windows 9X system. Values can be Java Virtual Machine dependent for an operating system. |
In above table int (short for integer) stores whole numbers. A Java declaration to store integer would look like below:
int year_of_birth = 1950; // Notice that data type precedes the variable name
When above statement is executed, Java creates a location in RAM with name year_of_birth, which is 4 bytes in size, and it stores integer value 1950 in it. Recall that while Alice did not differentiate between whole numbers and fractional ones, Java does. This is required for better precision and memory management. We would not be able to store cost of one gallon of gasoline inside an int data type because cost includes fractions. For such case we would need to make following type of declaration in Java:
double cost_of_gasoline = 3.99;
For better memory management Java also provides two different mechanisms for storing text data. If one needs to store a single character then it is preferred to use data type char. However, the multi character text is stored in string data type. Look at the code fragment below, where a person’s first name, middle initial and last name is stored in three different variables.
String First = “John”;
Char Middle = ‘Q’;
String Last = “Public”;
The reason for storing the middle initial in a char data type is because while strings can use tens of bytes of memory, the char uses only two bytes (see Table on previous page). Thus storing single characters in a char data type is more memory efficient. Therefore, while from user perspective ‘Q’ or “Q” would have same contents, ‘Q’ would use only a fraction of memory compared to “Q”.
Variable and Identifier Naming in Java
While Alice is very relaxed in naming of variables, Java is strict. Java requires one to follow following rules for identifier naming.
1. Identifiers must only contain alphabets, underscore ( _ ), digits (0 to 9 ), and a $ sign.
2. An identifier must begin with an alphabet, underscore or $. It cannot begin with a digit.
3. An identifier cannot contain blank spaces.
4. An identifier cannot be a Java reserved word.
Examples of Valid and Invalid Programmer Created Identifiers:
The Table below gives the examples of valid and invalid identifiers:
|Valid Identifiers |Invalid Identifiers/ Comments |
|A |a1 |Sum+var |+ is illegal |
|student_name |stdntNm |2names |First character invalid |
|_aSystemName |_anthrSysNm |Stdnt Nmbr |Contains Space |
|$class |_public |int |Reserved word |
The identifier sum+var violates the rule #1. Identifier 2names violates rule #2. The identifier Stdnt Nmbr violates the rule #3 and use of int as an identifier violates the rule #4. Identifiers in left hand column are valid. It is important to use meaningful identifiers.
Java reserves certain words that are not allowed to be used as identifiers. This is done because compiler for its functionality assigns special meanings to certain words and confusion would result, if those words are also used for variable/identifier naming. The list of Java reserved words is given below.
|abstract |continue |goto |package |this |
|assert |default |if |private |throw |
|boolean |do |implements |protected |throws |
|break |double |import |public |transient |
|byte |else |instanceof |return |try |
|case |extends |int |short |void |
|catch |final |interface |static |volatile |
|char |finally |long |super |while |
|class |float |native |switch |strictfp |
|const |for |new |synchronized | byvalue |
|outer |operator |null | | |
|Java Reserved words |
Operators in Java
Operators are used in computer programs to assign values, do arithmetic, compare values, and perform logical operations on boolean data. Table below gives a list of operators in Alice and Java. Table also shows which operators are identical in both and which ones exist in one and not in other.
|Operator Function/Purpose |Java |Alice |
|Assign value to operand on left |= |set value |
|Arithmetic |* / + - |* / + - |
|Modulus or remainder |% |IEEERemainder |
|Compare contents of two operands for equality |== != |== != |
|Comparison or relational operators |< >= |< >= |
|Logical negation (NOT) |! |not |
|Logical AND |&& |both a and b |
|Logical OR ||| |either a or b, or both |
|Compound operators (Combining arithmetic and assignment into one |+= -= *= /= %= |Do not exist in Alice |
|action) | | |
|Prefix or postfix increment or decrement |++ -- | |
Notice that Java never uses word for operators. This has been done for conciseness. Since in Alice you never have to type operators, words that can convey meaning accurately have been used as operators. We show applications of operators that do not exist in Alice.
Compound Operators
Java provides compound operators to make code writing concise. For example following operations are identical.
int x = 5;
x = x+ 7 ; is identical to x+=7;
Table below shows other compound operations and their expanded counterparts.
|Expanded Operation |Equivalent Compound Operation |
|x = x – 7; |x-=7; |
|x = x*2; |x*=2; |
|x= x/2; |x/=2; |
|x = x%2; |x%=2; |
For sake of brevity, we do not discuss the postfix increment and decrement operators here. However, when you take your first Java class, you will learn them quickly. The meaning of prefix increment and decrement operators is as follows:
int x = 5;
++x; // Increases current value of x by one. Thus stores 6 in x.
• x; // Reduces x by one. Thus current value of x is 5.
Understand that increment or decrement operator do not need an assignment operator (=) to change to new value. The assignment is implicit in the use of these operators.
Creating Objects in Java
In order to create objects in Alice all you had to do was to go to object gallery, pick your object and drag and drop them on your world. Since Java requires you to write code for every thing, it uses a reserved word to create an object. You have seen so far that in Java String objects can be created merely by using an assignment operator. For example the String object Professor created below would contain “James Geddes”.
String Professor = “James Geddes”;
This short hand procedure, where assignment operator followed by value is enough to create object is only available to Java Strings. For creation of all other objects, Java requires using a reserved word new, followed by the name of the class and a pair of parenthesis with or without arguments. This whole process is called invoking a constructor. Imagine we write a Java class called Car. This may be done to simulate the real car objects or to hold data about cars that is stored in a file or in a database. For sake of simplicity we only use two properties of a real life car, its color and number of doors. (Every car has a color and doors). The car class can be written in Java as follows:
public class Car
{
private String Color;
private int number_of_doors;
public Car(String Clr, int doors)
{
Color = Clr;
number_of_doors = doors;
}
public string getColor()
{
return Color;
}
public int getDoors()
{
return number_of_doors;
}
}//Listing 4A
The Car class has two data members: Color, and number_of_doors. The data members in Java are similar to the properties for objects in Alice. The keyword private in front of member data types simply means that we cannot access them directly. Rather we would need to use two get methods getColor and getDoors to access them. This kind of data hiding by using the keyword private for data members is a special characteristic of Java, which is added to make software more secure. This type of security was not needed in Alice because Alice is simply a vehicle to learn programming, while Java is a full fledged commercial software generation system. The Car class also has a special method-like member which has same name as the class and takes a string and an int as arguments. This method-like member is called a constructor. Notice that constructor does not have a return type. This behavior is different from two methods that are also part of class Car. The method getColor has a return type String, whereas the getDoors has an int return type. You must learn the difference between methods and constructors, namely the constructor has same name as class name and has no return type. Now we show how to create objects in Java and learn their properties. Listing 4B shows a class with main method that creates object MyCar of type Car.
public class Main
{
public static void main(String[] args)
{
Car MyCar = new Car(“Metallic Green”,2);
String MyCarColor = MyCar.getColor();
int MyCarDoors = MyCar.getDoors();
String ColorAndDoors = MyCarColor+ “ color and “
• MyCarDoors + “ doors.”;
JOptionPane.showMessageDialog(null,
“My Car has following properties: “ + ColorAndDoors);
}
}//Listing 4B
We discuss the relationship between Listings 4A and 4B using the line numbers in Listing 4 B. Inside the main method in Listing 4B, the line 6 has the following statement:
Car MyCar = new Car(“Metallic Green”,2);
This statement creates an object MyCar in which data member Color is set to Metallic Green and member number_of_doors to 2. The entire expression on right hand side is called “invoking a constructor”. The relationship between a class and objects of that class is one that of relationship between a cookie cutter and cookie itself. Cookie cutter has the outline for the cookie it would cut. Cookie on the other hand is the concrete product created by the cookie cutter. Class therefore contains the outline of objects it would create in terms of data members, methods, and constructors. Object is the concrete form created from a class that would simulate the real object. The kind of data the class holds is called metadata by software engineers. Class holds the design elements or rules for creating objects. The actual constructor call would instantiate that object inside the software.
Also notice that how Java requires a verbose syntax to create objects. The line 6 has the data type Car followed by the object name on left side of the assignment expression. The keyword new and call to the constructor are on the right side of the assignment expression. Lines 7 and 8 get access to data members, Color, and number_of_doors for object MyCar and store them in local variables MyCarColor, and MyCarDoors respectively. Line 9 & 10 concatenate the strings that I would like to print for user informing details of object MyCar. In string concatenation, as long as one expression is string type, all others can be primitive or string types. Thus the int MyCarDoors is converted automatically to string type, since other expressions around it (before and after plus sign) are strings. Lines 11 & 12 use a JOptionPane object and its showMessageDialog method, to print characteristics of object MyCar as a popup message for the user (See Figure below).
[pic]
Creating Graphical Objects in Java Using Java Applets
Java Applets were the first major application of Java programming language that animated web pages. Java therefore was responsible for early revolution in web development. Almost all Java graphical technology relies on a technique call inheritance. Inheritance allows an existing class to be used as a springboard for more refined and developed classes. Graphical objects need to conform to some basic operating system rules. Therefore, classes that are used in creating graphics are developed as basic tools in the language library. Programmers then use these classes as pre-existing widgets to create their own graphical applications. Java has a class called JApplet that is used as a base class for writing applets. When we say “using as a base class”, what we mean is that virtually all data and method members in that class are usable by our class that would extend the base class. All we are going to do here in terms of showing graphical Java objects is to create a graphical version of Hello World program using Java applet. Applets do not require constructors the way stand-alone Java applications do. However, they do need a method that works similar to a constructor. This method is called init which is short for initialization. All Java applets also need another method called paint, which would paint the graphics on the applet when it shows on web page. The basic source code is shown in Listing 5 below.
import java.awt.*;
import java.applet.*;
public class HelloWorldApplet extends Applet
{
// override init( ) method to set background color of screen
public void init()
{
setBackground(new Color(250,0,100));
}
// override paint() method to automatically display information
// in the applet’s window
public void paint(Graphics g)
{
// set font, and color and display message on
// the screen at position 250,150
g.setFont(new Font(“Ariel”, Font.BOLD, 48));
g.setColor(Color.blue);
g.drawString(“Hello to World from Santa Monica!”,0,150);
}
}//Listing 5
The first two lines show the Java packages that we need to import as we are using classes from them in our code. Line 4 shows that our class HelloWorldApplet extends the Java class Applet which is inside package java.applet. Using keyword extends in line 4 establishes an inheritance relationship between HelloWorldApplet class and Java provided Applet class. Another way of saying that is that HelloWorldApplet class is a child class of Applet class. The init method simply has one line in this case which sets the background color for the applet. It does that by calling the setBackground method and passes it a Color object. The Color object is created by calling its constructor
new Color (250,0,100);
where the numbers inside parenthesis are values of red, green and blue components of overall color scheme.
The paint method is responsible for painting the applet on the web page that displays it. It takes a Graphics class object g as an argument and then uses it to set font, font color, and finally draw the string “Hello to world from Santa Monica!” at location 0 and 150 pixels from top left corner of browser window. The applets are compiled exactly the way stand-alone applications are, i. e. using the tool javac. They are however run first by creating an html file and then opening that file using a web browser. After compiling a file called HelloWorldApplet.class is created. This file is similar to executable file in Windows program. The following code is typed in a notepad to build the webpage that would show the Java applet (Listing 7).
//Listing 7
Most important line in listing 7 is the line with applet tag. This includes the name of the class file that applet would open when webpage based on code in Listing 7 is displayed. For applet to work the file HelloWorldApplet.class and html file that has the code of Listing 7 must be in the same folder. Imagine that code of listing 7 is typed and saved in a file HelloWorldApplet.html. When you double click on this file your web browser would attempt to open tjis file and display the applet. The web broswer may give a security warning similar to the figure below.
[pic]
The security warning says “To help protect your security, Internet Explorer has restricted this webpage from running scripts or Activex controls that could access your computer. Click here for options”. To display the applet you should click on this message and then click on “Allow blocked content”. That will display a dialog box shown below.
[pic]
In above box click on yes and then the applet will be shown in the webpage as shown in the Figure below.
[pic]
Creating Java applets is an easy way to create interesting java graphics and include them in WebPages. When you take a full fledged Java class, you will learn more about Java graphics.
Selection Structures
Computer languages use selection structure to alter the flow of program and make decisions. At some points in the program the software may need to make a decision so that it executes one set of code if certain condition is true, or execute an alternate code if condition is false. One example of this is if or if/else structure. You have seen both of these in Alice which we revisit here.
The if Statement
SelectionApp in Alice shows a
[pic]
[pic]
SelectionApp in Java
public class SelectionApp {
/* output message “Hello, ____” using command line arg if present;
otherwise, output “Hello, world!” */
public static void main(String[] args) { // args is the array of command line arguments
if (args.length > 0) { // if there is at least one argument
// greet the user
System.out.println(“Hello, “ + args[0] + “!”); // args[0] is the first argument
} else { // there are no command line arguments
System.out.println(“Hello, world!”); // greet the world
} // else
} // main
} // SelectionApp
[pic]
|A Comparison of SelectionApp in Alice and Java |
| |Alice |Java |
|command line | | |
|arguments | | |
|running the program | | |
|boolean datatype | | |
|if statement | |SelectionApp.java |
The Repetition Control Structure
The For Statement
RepetitionApp in Alice
[pic]
| [pic] |[pic] |
|[pic] |[pic] |
RepetitionApp in Java
public class RepetitionApp {
// output the song “For He’s a Jolly Good Fellow”
public static void main(String[] args) {
for (int i = 0; i < 3; i++) {
System.out.println(“For he’s a jolly good fellow,”);
} // for i
System.out.println(“Which nobody can deny.”);
} // main
} // RepetitionApp
[pic]
|A Comparison of RepetitionApp in Alice and Java |
| |Alice |Java |
|the increment | | |
|operator | | |
|for statement | |RepetitionApp.java |
Last Modified: [pic]02/22/2008 14:48:57
-----------------------
[1]
[2] Notepad software is available on all Windows XP Operating systems by clicking on Start | All Programs | Accessories | Notepad
-----------------------
Data members
Constructor
Methods
................
................
In order to avoid copyright disputes, this page is only a partial summary.
To fulfill the demand for quickly locating and searching documents.
It is intelligent file search solution for home and business.
Related download
- the articles of the constitution worksheets answer key
- grammar lesson 1 plain local school district
- review for final
- english 1 version
- examining bias and distortion in mass media in america
- УПРАВЛІННЯ ОСВІТИ І НАУКИ ДОНЕЦЬКОЇ ОБЛДЕРЖАДМІНІСТРАЦІЇ
- from alice to java
- answers to even numbered questions
- overview mrs educate trying to create and educate
- appalachian state university
Related searches
- intro to java pdf
- introduction to java programming pdf
- intro to java liang pdf
- introduction to java 10th pdf
- introduction to java programming and data structures
- introduction to java programming 10th
- introduction to java liang pdf
- introduction to java programming liang
- introduction to java pdf
- introduction to java programming ppt
- introduction to java daniel liang
- string to java util date