JAVA SYNTAX
BY MUHAMMAD ABU BAKAR
WRITING BASIC JAVA PROGRAM
SYNTAX FOR C++ PROGRAMMERS
SOFTWARE REQUIREMENTS
• For the start following software will do the job
• You need to have the latest version of JDK. (J2SE 5.0) You can
download it for free from
http://java.sun.com/j2se/
A little older versions such JDK 1.4 or 1.3 will also work
• Notepad
• And you should set your path variable.
CANONICAL EXAMPLE
HELLOWORLD APPLICATION IN JAVA
/* The HelloWorldApp class implements an application that simply displays
"Hello World!" to the standard output. */
public class HelloWorldApp {
public static void main(String[] args) {
//Display the string. No global main
System.out.println("Hello World!"); }
}
COMPILING AND RUNNING
THE PROGRAM
• Save this file in some directory and compile it using
• javac HelloWorldApp.java
• Run the compiled file by using the command
• java HelloWorldApp
JAVA PROGRAM DEVELOPMENT AND EXECUTION
STEPS
• Java Systems
• Consist of environment, language, Java Applications
Programming Interface (API)
• Java programs have five phases
1. Edit
• .java extension
2. Compile
• javac command: javac MyProgram.java
• Creates .class file containing bytecodes with similar name
JAVA PROGRAM DEVELOPMENT AND EXECUTION
STEPS…
3. Loading
• Class loader transfers .class file into memory
• Classes loaded and executed by interpreter with java
command
• To load,
appletviewer Welcome.html
OR
java MyProgram
JAVA PROGRAM DEVELOPMENT AND EXECUTION
STEPS…
4. Verify
• Bytecode verifier makes sure bytecodes are valid and do
not violate security
5. Execute
• Computer interprets program one bytecode at a time
• Performs actions specified in program
Program is created in
Phase 1 Editor Disk the editor and stored
on disk.
Compiler creates
Phase 2 Compiler Disk bytecodes and stores
them on disk.
Primary
Memory
Class Loader
Phase 3
Class loader puts
bytecodes in memory.
Disk
..
..
..
Primary
Memory
Bytecode Verifier
Phase 4 Bytecode verifier
confirms that all
bytecodes are valid
and do not violate
Java’s security
.. restrictions.
..
..
Primary
Interpreter Memory Interpreter reads
Phase 5 bytecodes and
translates them into a
language that the
computer can
understand, possibly
.. storing data values as
.. the program executes.
..
UNDERSTANDING BASICS
• Naming Conventions
• MyClass
• myMethod()
• myVariable
• MY_CONSTANT
PERFORMING BASIC
TASKS
IN JAVA
TOPICS
• Things to Remember
• Taking in command line arguments
• Primitives vs. Objects
• Wrapper classes and Conversions
• Taking Input and Output using Swing
• Selection and Control Structures
• OOP in java (Defining and using class)
THINGS TO REMEMBER
• Name of file must match name of class
• It is case sensitive
• Processing starts in main
• public static void main(String[] args)
• Printing is done with System.out
• System.out.println, System.out.print
• Compile with “javac”
• Open DOS/command prompt window; work from
there
• Supply full case-sensitive file name (with file
extension)
• Execute with “java”
AN IDIOM EXPLAINED
• You will see the following line of code often:
• public static void main(String args[]) { …}
• About main()
• “main” is the function from which your program
starts
• Why public?
• So that run time can call it from outside
• Why static ?
• it is made static so that we can call it without creating an
object
• What is String args[] ?
• Way of specifying input at startup of application
THINGS TO REMEMBER
• “+” operator when used with Strings concatenates them
• System.out.pritln(“Hello” + “World”) will produce Hello World
on console
• String concatenated with any other data type such as int will
also convert that datatype to String and the result will be a
concatenated String displayed on console
• For Example
• int i = 4
• int j = 5 ;
• System .out.println (“Hello” + i) // will print Hello 4 on screen
• However
• System,.out..println( i+j) ; // will print 9 on the console
• For comparing Strings never use == operator, use
equals methos.
• == compares addresses (shallow comparison) while equals
compares values (deep comparison)
• E.g string1.equals(string2)
STRING CONCATENATION
public class StringTest {
public static void main(String[] args) {
int i = 4;
int j = 5;
System.out.println("Hello" + i);
System.out.println(i + j);
String s1 = new String (“pakistan”);
String s2 = “pakistan”;
if (s1 == s2) {
System.out.println(“comparing string using == operator”);
}
if (s1.equals( s2) ) {
System.out.println(“comparing string using equal method”);
}
}
COMPILE AND EXECUTE
TAKING IN COMMAND
LINE ARGUMENTS
TAKING IN COMMAND LINE
ARGUMENTS
/* This program will take two arguments Hello World from the
command prompt and prints them to standard console. If you
specify less than two arguments an exception will be thrown */
public class TwoArgsApp {
public static void main(String[] args) {
//Displays the first argument on console
System.out.println(“First argument “ +
args[0]);
//Displays the second argument on console
System.out.println(“Second argument “ + args[1]);
}
PASSING ANY NUMBER OF
ARGUMENTS
/* This program is able to receive any number of arguments and prints them to
console using for loop. In java, arrays knows about their size by using length
property
*/
public class AnyArgsApp {
public static void main(String[] args) {
for (int i=0; i<args.length; i++)
{
// The “+” operator here works similar to “<<“ operator in C++. This line
is // equivalent to
cout<<“Arguments:”<<i<<“value”<<args[i];
// where cout is replaced by System.out.println, and “<<“ is
replaced by + for // concatenation
System.out.println(“Argument:” + i + “value: ” + args[i] );
}
COMPILE AND EXECUTE
PRIMITIVES VS. OBJECTS
PRIMITIVES VS. OBJECTS
• Everything in Java is an “Object”, as every class by default inherits from
class “Object” , except a few primitive data types, which are there for
efficiency reasons.
• Primitive Data Types
• 8 Primitive Data types of java
• boolean, byte 1 byte
• char, short 2 bytes
• int, float 4 bytes
• long, double 8 bytes
• Primitive data types are generally used for local variables, parameters and
instance variables (properties of an object)
• Primitive datatypes are located on the stack and we can only access their
value, while objects are located on heap and we have a reference to these
objects
• Also primitive data types are always passed by value while objects are
always passed by reference in java. There is no C++ like methods
STACK VS. HEAP
Stack Heap
public static void main(String args[])
{
int num= 5; num
5
Student st = new Student();
} 0F59
name
ali
st
0F59
PRIMITIVES (CONT)
• For all built-in primitive data types java uses lowercase. E.g int , float
etc
• Primitives can be stored in arrays
• You cannot get a reference to a primitive
• To do that you need an Object or a Wrapper class
WRAPPER CLASSES
WRAPPER CLASSES
• Each primitive data type
has a corresponding Primitive Corresponding
object (wrapper class) Data Type Object Class
byte Byte
short Short
• These Wrapper classes int
long
Integer
Long
provides additional float Float
functionality double Double
(conversion, size char Character
checking etc), which a boolean Boolean
primitive data type can
not provide
WRAPPER USE
• You can create an object of Wrapper class using a String or a
primitive data type
• Integer num = new Integer(4); or
• Integer num = new Integer(“4”);
• Num is an object over here not a primitive data type
• You can get a primitive data type from a Wrapper using the
corresponding value function
• int primNum = num.intValue();
STACK VS. HEAP
Stack Heap
public static void main(String args[])
{
int num= 5; num
5
Integer numObj = new Integer (10);
}
04E2
10
numObj
04E2
WRAPPER USES
• Defines useful constants for each data type
• For example,
Integer.MAX_VALUE
• Convert between data types
• Use parseXxx method to convert a String to the
corresponding primitive data type
• String value = “532";
int d = Integer.parseInt(value);
• String value = "3.14e6";
double d = Double.parseDouble(value);
WRAPPERS: CONVERTING
STRINGS
Data Type Convert String using either …
byte Byte.parseByte( string )
new Byte(string ).byteValue()
short Short.parseShort( string )
new Short(string ).shortValue()
int (stringstring
Integer.parseInteger( ) )
new Integer( string ).intValue()
long Long.parseLong( string )
new Long(string ).longValue()
float Float.parseFloat( string )
new Float(string ).floatValue()
double Double.parseDouble( string )
new Double( string ).doubleValue()
WRAPPER USES
• When a method does not except an int primitive but still you need to pass an int value, you can
use the corresponding Wrapper.
• someVector.add(new Integer(4) ); // this was required prior to jdk5.0 the l
• Boxing/Unboxing Conversions
• New feature added in j2se 5.0
• Boxing
• Integer iWrapper = 10;
• Prior to J2SE 5.0, we use
• Integer a = new Integer(10);
• Unboxing
• int iPrimitive = iWrapper;
• Prior to J2SE 5.0, we use
• int b = iWrapper.intValue();
INPUT / OUTPUT
CONSOLE BASED OUTPUT
SYSTEM.OUT
• System class
• Out represents the screen
• System.out.println()
• Prints the string followed by an end of line
• Forces a flush
• System.out.print()
• Does not print the end of line
• Does not force a flush
• System.out.flush()
• Force a flush
INPUT / OUTPUT
/* This program will takes the input (number) through GUI and prints its square on the console as
well as on the GUI. */
import javax.swing.*;
public class InputOutputTest {
public static void main(String[] args) {
//takes input through GUI
String input = JOptionPane.showInputDialog("Enter the number");
int number = Integer.parseInt(input);
int square = number * number;
//Display square on console
System.out.println("square:" + square);
//Display square on GUI
JOptionPane.showMessageDialog(null, "square:"+ square);
System.exit(0); //Don’t forget to write when using JOptionPane. Don’t need it in
//J2SE 5.0
}
COMPILE AND EXECUTE
SELECTION STRUCTURES
IF-ELSE AND SWITCH
IF–ELSE SELECTION STRUCTURE
/* This program will demonstrates the use of if-else selection structure.
Note that its syntax is very similar to C++
*/
public class IfElseTest {
public static void main(String[] args) {
int firstNumber = 10;
int secondNumber = 20;
//comparing first number with second number
if (firstNumber > secondNumber) {
System.out.println(“first number is greater than second”);
}
else if (firstNumber == secondNumber) {
System.out.println(“first number is equals to second number”);
}
else {
System.out.println(“first number is smaller than second number”);
}
COMPILE AND EXECUTE
BOOLEAN OPERATORS
• ==, !=
• Equality, inequality. In addition to comparing primitive
types, == tests if two objects are identical (the same
object), not just if they appear equal (have the same
fields). More details when we introduce objects.
• <, <=, >, >=
• Numeric less than, less than or equal to, greater than,
greater than or equal to.
• &&, ||
• Logical AND, OR. Both use short-circuit evaluation to
more efficiently compute the results of complicated
expressions.
•!
• Logical negation.
SWITCH SELECTION
STRUCTURE
import javax.swing.*;
public class SwitchTest {
public static void main(String[] args) {
int operand1 = 10;
int operand2 = 20;
String choice = JOptionPane.showInputDialog(“Enter
1 for sum, 2 for product”);
int ch = Integer.parseInt(choice);
// continue….
SWITCH SELECTION
STRUCTURE…
switch(ch)
{
case 1:
int sum = operand1 + operand2;
System.out.println(“sum: ” + sum );
break;
case 2:
int product = operand1 * operand2;
System.out.println(“product: ” + product );
break;
default:
System.out.println(“wrong choice!”);
System.exit(0);
}
}
COMPILE AND EXECUTE
CONTROL STRUCTURES
FOR, WHILE & DO-WHILE
LOOPING CONSTRUCTS
• while
while (continueTest) {
body;
}
• do
do {
body;
} while (continueTest);
// ^ don’t forget semicolon
• for
for(init; continueTest; updateOp) {
body;
}
CONTROL STRUCTURES
public class ControlStructTest {
public static void main(String[] args) {
// for loop
for (int i=1; i<= 5; i++) {
System.out.println("hello from for");
}
// while loop
int j = 1;
while (j <= 5) {
System.out.println("Hello from while");
j++;
}
//do while loop
int k =1;
do{
System.out.println("Hello from do-while");
k++;
}while(k <= 5);
}
}
COMPILE AND EXECUTE
