Java Syntax

Written by Amir Kirsh

Amir Kirsh

Lessons Objectives
By the end of this lesson you will:
Be familiar with Java environment and characteristics

Know the Java language basic syntax

Know how to write Java based Object Oriented programs

Agenda

Java History What can be done with Java? Language Characteristics The Java Environment

Hello World
Basic Syntax

Java API
Java as an OO language Exercise

Java History
Started as an internal project at Sun Microsystems in Dec-1990

Main architect of the language - James Gosling

Initially designed for use in a set top box project and called OAK Starting from Java 6 the source code of Java is released by Sun as open source under GNU GPL

Today Java progress is ruled by the Java Community Process (JCP) based on Java Specification Requests (JSRs)
4

Java History - Chronology

Dec-1990: Internal project at Sun (OAK, OS Green project) May-1995: 1st Java public release as part of the HotJava browser

Jan-1996: JDK 1.0

Feb-1997: JDK 1.1 (added inner classes, JDBC, AWT changes) Dec-1998: J2SE 1.2 (added reflection, Swing, Collections utils)

Sep-2004: J2SE 5.0 (added Generics, annotations, ) Dec-2006: Java SE 6 (support in code compilation, scripting, )

Agenda

Java History What can be done with Java? Language Characteristics The Java Environment

Hello World
Basic Syntax

Java API
Java as an OO language Exercise

What can be done with Java?

Simple Console Applications: Hello world, Utilities Desktop Applications: Swing, SWT, e.g. Eclipse Web Applets (less common today) Web Applications: Servlets, JSPs

Server Side DB connectivity, Client-Server, Networking, Web-Services

Mobile Applications J2ME, Android

When would Java not be our choice?

Real-Time applications
(though Java is taking some steps in this direction)

Device Drivers when you need access to device memory and specific resources (C/C++ would be a choice)
When the device does not support Java
Handsets which dont have J2ME/Android old OS

Java can still be layered on top of native code, using JNI or Inter-Process-Communication:
User Interface above a Device Driver or other native code Management of the Real-Time part of an application

Agenda

Java History What can be done with Java? Language Characteristics The Java Environment

Hello World
Basic Syntax

Java API
Java as an OO language Exercise

Language Characteristics
You know you've achieved perfection in design, Not when you have nothing more to add, But when you have nothing more to take away.
Antoine de Saint Exupery

This is NOT related, but he also wrote:

We do not inherit the Earth from our ancestors, we borrow it from our children
Antoine de Saint Exupery

10

Language Characteristics
You know you've achieved perfection in design, Not when you have nothing more to add, But when you have nothing more to take away.
Antoine de Saint Exupery

Stated in "The Java Language Environment", a white paper by James Gosling and Henry McGilton, May 1996, Chapter 2:
http://java.sun.com/docs/white/langenv/Simple.doc.html

11

Language Characteristics
You know you've achieved perfection in design, Not when you have nothing more to add, But when you have nothing more to take away.
Antoine de Saint Exupery

Becoming a bit shaky starting from Java 5 and on - Generics, Annotations, etc. - Closures in Java 7 ! The language is becoming more and more complex
12

Language Characteristics
Java: A simple, object-oriented, network-savvy, interpreted, robust, secure, architecture neutral, portable, high-performance, multithreaded, dynamic language.

"The Java Language: An Overview",

http://java.sun.com/docs/overviews/java/java-overview-1.html

13

Language Characteristics
Java: A simple, object-oriented, network-savvy, interpreted, robust, secure, architecture neutral, portable, high-performance, multithreaded, dynamic language.
Based on C++ but without some complicated or annoying elements of C++ (e.g. pointers, operator overloading, header files) Automatic Garbage Collection! Useful libraries that are part of the language

14

Language Characteristics
Java: A simple, object-oriented, network-savvy, interpreted, robust, secure, architecture neutral, portable, high-performance, multithreaded, dynamic language.
Inheritance and Polymorphism Object class is base for all classes No global variables or functions!

15

Language Characteristics
Java: A simple, object-oriented, network-savvy, interpreted, robust, secure, architecture neutral, portable, high-performance, multithreaded, dynamic language.
Local and remote files are treated similarly Supports distributed applications Rich libraries for network operations

16

Language Characteristics
Java: A simple, object-oriented, network-savvy, interpreted, robust, secure, architecture neutral, portable, high-performance, multithreaded, dynamic language.
Java code is compiled to intermediate language (Java byte-code class file) and is interpreted in Runtime by the Java Virtual Machine No need to Link the application, linking is always done dynamically at Runtime JIT (just-in-time) JVMs make the interpretation efficient

17

Language Characteristics
Java: A simple, object-oriented, network-savvy, interpreted, robust, secure, architecture neutral, portable, high-performance, multithreaded, dynamic language.
The language is much more robust compared to C++ - No pointers, arrays bounds and variable initialization are checked: it is almost impossible to corrupt memory - Garbage Collection: harder (though possible) to create memory leaks - Strict type safety: very limited casting allowed
18

Language Characteristics
Java: A simple, object-oriented, network-savvy, interpreted, robust, secure, architecture neutral, portable, high-performance, multithreaded, dynamic language.
The byte-code is checked by the JVM before execution for any unsafe or vulnerable operations Code cannot access memory directly Additional security restrictions for code that comes from the network (e.g. Applets)

19

Language Characteristics
Java: A simple, object-oriented, network-savvy, interpreted, robust, secure, architecture neutral, portable, high-performance, multithreaded, dynamic language.
The code is agnostic to the physical architecture due to the JVM layer Code can be written and compiled on one environment and then executed on another one!

20

Language Characteristics
Java: A simple, object-oriented, network-savvy, interpreted, robust, secure, architecture neutral, portable, high-performance, multithreaded, dynamic language.
The language clearly defines issues that in other languages are left open: exact binary form of each data type, thread behavior, GUI behavior, etc. The JVM implementation takes care of the differences between the different environments

21

Language Characteristics
Java: A simple, object-oriented, network-savvy, interpreted, robust, secure, architecture neutral, portable, high-performance, multithreaded, dynamic language.
Java is much more efficient than other interpreted languages Java applications are of similar order of performance as C/C++, based on sophisticated JVM optimizations

22

Language Characteristics
Java: A simple, object-oriented, network-savvy, interpreted, robust, secure, architecture neutral, portable, high-performance, multithreaded, dynamic language.
Multithreading and thread synchronization are part of the language As with anything else, same multithreading API for all Operating Systems

23

Language Characteristics
Java: A simple, object-oriented, network-savvy, interpreted, robust, secure, architecture neutral, portable, high-performance, multithreaded, dynamic language.
24

The application can load classes after it has started Since linking is done in Runtime adding new stuff to existing classes doesnt break any binaries using it Reflection (though added after the above was stated) Can compile code in Runtime and use it (again, added after the above was stated but what the hell)

Language Characteristics
Java: A simple, object-oriented, network-savvy, interpreted, robust, secure, architecture neutral, portable, high-performance, multithreaded, dynamic language.

Sounds Good!

25

Agenda

Java History What can be done with Java? Language Characteristics The Java Environment

Hello World
Basic Syntax

Java API
Java as an OO language Exercise

The Java Environment

Java Program
(Text files with .java suffix)

Java byte-code
(Binary files with .class suffix)

Java Compiler
javac [<params>] <java files> - Compile time classpath + required jars

Run your program

java [<params>] <app Main class> - Runtime classpath + required jars

JDK
27

JRE (JVM + libs)

The Java Environment Terms

JDK = Java Development Kit JRE = Java Runtime Environment

JVM = Java Virtual Machine (part of the JRE) GC = Garbage Collector (part of the JVM) JSE = Java Standard Edition (the basic Java / pure java) JEE = Java Enterprise Edition (some more classes) Java API = The Java Application Programming Interface Classpath = Where to look for classes (well talk about it) JAR = a file packaging many classes together IDE = Integrated Development Environment
(not a must, one can use notepad or vi but we will use Eclipse)
28

The Java Environment JVM

Usage: java [-options] class [args...] or: java [-options] -jar jarfile [args...] (to execute a class) (to execute a jar file)

where options include: -client to select the "client" VM -server to select the "server" VM -cp <class search path of directories and zip/jar files> -classpath <class search path of directories and zip/jar files> A ; separated list of directories, JAR archives, and ZIP archives to search for class files. -D<name>=<value> set a system property -? -help print this help message -Xms<size> set initial Java heap size -Xmx<size> set maximum Java heap size -Xss<size> set java thread stack size -Xprof output cpu profiling data
29

The Java Environment GC

Why GC? Saves the need to deallocate memory explicitly, freeing the developer from explicit heap handling Eliminates the possibility of:
Memory Leaks (well, in fact there can be Leaks, or "Loiterers", also with GC) Releasing memory that is in use (creating a "dangling pointer") Use of memory that was released or has not been allocated

Increases productivity while making applications robust

30

The Java Environment GC

GC History Invented by John McCarthy around 1959 for Lisp Integral part of many other programming languages
Smalltalk, Eiffel, Haskell, ML, Scheme, Modula-3, VB, C# and almost all of the scripting languages (Perl, Python, Ruby, PHP)

Trends in hardware and software made garbage collection far more practical:
Empirical studies in the 1970s and 1980s show garbage collection consuming between 25 percent and 40 percent of the runtime in large Lisp programs

31

The Java Environment GC

GC Roles
Detect unused memory and free it Manage the heap to allow fast allocations
Compact the heap Manage a "list" of free spots and their sizes

32

The Java Environment GC

GC Tracing Techniques Reference Counting
Problems: cyclic references, sync-lock costs Never used by Java GC, not used by modern GCs

Trace by reachability
Objects should be kept alive if they are reachable from:
- Static references - References on Stack

- References from reachable objects on heap

Use of hints and tricks!

33

The Java Environment GC

Java GC Generations

34

Agenda

Java History What can be done with Java? Language Characteristics The Java Environment

Hello World
Basic Syntax

Java API
Java as an OO language Exercise

Hello World

public class HelloWorld { public static void main(String[] args) { System.out.println("Hello World"); }

Method return value is similar to C. In this case void means that the method does not return a value

36

Hello World
main in Java is a static method inside a class public class HelloWorld { public static void main(String[] args) { System.out.println("Hello World"); } Each type in the class should declare its access modifier String[] means array of String objects String is a class defined in the Java language itself main gets array of strings from the command line

No ; at end of class
37

println is a method of the static field out inside System class

Hello World Compile and Run

Open cmd window (Start -> Run -> cmd) Run:
javac HelloWorld.java
javac should be in your path if it is not, add the /bin directory of your java installation to the path

Run:
java HelloWorld

Result should be:

Hello World

38

Agenda

Java History What can be done with Java? Language Characteristics The Java Environment

Hello World
Basic Syntax

Java API
Java as an OO language Exercise

Java Syntax but lets first start with an IDE

40

Java Syntax
Java Syntax is very similar to C++. In the following slides we will cover both the Java things that are similar to C++ as well as things that do not appear in C++ or work differently.

41

Data Types
Primitive Type
byte short int long float double

Class
Integer Short Integer Long Float Double

Usage
8 bit integer number in the range of: -128 to 127 16 bit integer number in the range of: -32,768 to 32,767 32 bit integer number in the range of: -2,147,483,648 to 2,147,483,647 64 bit integer number in the range of: -9,223,372,036,854,775,808 to ...807 32 bit floating point number 64 bit floating point number

For numbers that require exact accuracy use java.math.BigDecimal

boolean
char --42

Boolean

true/false, unspecified size in runtime, 1 byte when serialized

Character 16-bit single Unicode character String

Characters string, as Hello World

Primitive Variables
Primitive variables are variables of primitive types (i.e. not objects) they pass By Value

Example:
int i = 3; foo(i); System.out.println(i); // prints 3 void foo(int i) { i = 5; }

The original i is NOT changed!

43

Objects and References

Object variables in Java are ALWAYS a reference to an instance

Example:
void someMethod(Person p) { p.setName("Momo"); }

The original person sent to this method is modified

(In case p is null we will get an Exception we will talk about this later)

44

Objects and References

Object variables MUST be initialized or otherwise they are:
uninitialized in case of local variables null in case of a field

Example 1:
void someMethod() { Person p; p.setName("Koko"); }

The above will not compile

(compilation error: variable p might not have been initialized)
45

Objects and References

Object variables MUST be initialized or otherwise they are:
uninitialized in case of local variables null in case of a field

Example 2:
class Foo { Person p; // field p is initialized to null void someMethod() { p.setName("Annul"); Well, in fact its a } null reference }

NullPointerException thrown at runtime

46

Objects and References

To create an instance of an object you should use new Example:
Person p = new Person("Noa"); // use Person ctor System.out.println(p.getName());

The person p references is created on the heap

(You shouldnt worry about the deallocation!) We will talk about constructors (== ctors) later

47

Objects and References

When setting a reference to an object variable its old reference (if existed) is detached with no harm

Example 1:
void someMethod(Person p) { p = new Person("New Person"); p.setAge(0); }

The original person sent to this method is unmodified!

(Which makes this method a bit useless but this is only an example)

48

Objects and References

When setting a reference to an object variable its old reference (if existed) is detached with no harm

Example 2:
void someMethod(String s) { s = "123"; }

So how do I change a String that was sent to me? You CANT. String is Immutable. As well as all the wrapper classes (Integer, Long etc.)

The original String sent to this method is unmodified!!!

(Which again makes this method a bit useless)

49

Objects and References

Assignment is assignment of references!

Example:
Person p = new Person("Noa"); Person q = p; q.setName("Q");

Both p and q are the same person (called now Q)

To create a copy you should use clone method (but we will not go through it now)

50

Objects and References

The == checks for references equality The equals function is for deep equality, under the responsibility of the class

51

Objects and References

The == checks for references equality Example 1:
Person p = new Person("Noa"); Person q = new Person("Noa"); if(p==q) { System.out.println("Equal!"); } else { System.out.println("NOT Equal!"); }

Since p and q do not share the same reference We will see NOT Equal! (== checks for reference equality)
52

Objects and References

The equals function is for deep equality, under the responsibility of the class Example 2:
String s1 = "Noa, s2 = "Noa"; if(s1.equals(s2)) { System.out.println("Equal!"); } else { System.out.println(NOT Equal!"); }

Since class String implemented equals appropriately We will see Equal!

53

Arrays
Examples: [1] int[] intArr = {1,2,3}; // or = new int[]{1,2,3}; [2] String[] sArr = new String[]{"a", "b", "c"}; [3] Person[][] personArr2d = new Person[3][2]; for(int i=0; i < personArr2d.length; i++) { for(int j=0; j < personArr2d[i].length; j++) { personArr2d[i][j] = new Person(); } }

54

Arrays
Examples (cont): [4] String[][] strArr2d = new String[3][]; for(int i=0; i < strArr2d.length; i++) { strArr2d = new String[i+1]; } strArr2d
0 1 2

null null null

null

null

null

55

foreach loop
New kind of loop introduced in Java 5 Example:
String[] sArr = {"Noa", "Koko", "Momo"}; for(String str : sArr) { System.out.println(str); }

- "foreach" is the common name for this new type of loop, but its not a keyword in the language

56

Other Conditions and Loops

Switch
switch(number) { case 1: doSomething(); break; case 2: doSomethingElse(); break; default: doSomeDefaultThing(); }

57

Other Conditions and Loops

While, Do-While loops
while(!isDone()) { doSomething(); }

do { doSomething(); } while(!isDone());

What the difference between the two?

58

Exceptions
Unchecked: RuntimeException (and Error)
Can throw without declaring in the methods signature

Checked:

All the rest

If thrown must be declared in the methods signature Throwable Error Exception

Unchecked

RuntimeException

Unchecked
59

Exceptions
Keywords:
throw, throws, try, catch, finally
Not a must, since this is a RuntimeException

Example:

void foo(String snum) throws NumberFormatException { try { int number = Integer.valueOf(snum); System.out.println(Math.pow(number, 2)); } finally { System.out.println("getting out of foo"); } } Example continues in next page
60

Exceptions
Keywords:
throw, throws, try, catch, finally

Example (cont):
void bar() { try { foo("abc"); System.out.println("foo was OK"); } catch(NumberFormatException e) {
// an example, not really what we do with exceptions

System.out.println("foo had a problem"); throw new RuntimeException(e);

} }
61

Exceptions
Never absorb Exceptions!!!

Bad:

try { doSomething(); } catch(Exception e) { // this should never happen... System.out.println("Surprise!"); } try { doSomething(); } catch(Exception e) { // this should never happen... throw new RuntimeException(e); }

Instead:

62

Varargs
printf in Java (yes, there is such a thing!)
System.out.printf("i = %d, with message = %s", i, msg); The signature of printf (in classes PrintStream and PrintWriter) is: printf(String format, Object... args) Object... means that the user can send any number of parameters of type object (including zero number) The function gets the Object... as an array of Objects (=Object[])

63

Varargs Writing our own method

// here is our own example static public String max(String... strings) { int length = strings.length; if(length == 0) { return null; } String max = strings[0]; for(int i=1; i<length; i++) { if(max.compareTo(strings[i]) < 0) { max = strings[i]; } } return max; } // and calling the function can go like this: String maxStr = max("hello", "world", "!!!");

64

Classes and Packages

A class represents an encapsulated Entity - with its own fields, representing the entity's info - with its own methods the things that this entity can do

Fields and Methods can be private or public (or protected or package friendly)
Classes themselves can be private or public (or package friendly)

A package represents a set of classes, related by topic

65

Classes and Packages

Public class must sit in a file with an identical name Classes sits in packages, having no package means being in the "default package" Package is like a namespace in C++ Each package needs a directory with the same name Nested packages (package inside a package) are common To use classes from other packages without having to use their fully qualified name, the import statement is used import is like using namespace in C++ import is NOT like include in C++ (Java has no .h files)

66

Classes and Packages

Example:
package com.feathersys.geno.engine; import com.feathersys.geno.infrastructure.*; // all classes import com.feathersys.geno.utils.StringUtils; // one class public class EngineElement { ... };

The class EngineElement sits in a file called EngineElement.java under <project_location>/com/feathersys/geno/engine/

67

Java Syntax whats not in Java

The following features that are in C++ are omitted from Java:

No default parameters No operators overloading (methods overloading do exist) No multiple inheritance nor private / protected inheritance
(we will talk about inheritance later)

OK, we are ready for the journey!

68

Agenda

Java History What can be done with Java? Language Characteristics The Java Environment

Hello World
Basic Syntax

Java API
Java as an OO language Exercise

Java API
Java API is the Help for Java libraries

We will start from here: http://java.sun.com/javase/6/docs/api/ Then take an example from here: http://java.sun.com/javase/6/docs/api/java/lang/String.html

70

Agenda

Java History What can be done with Java? Language Characteristics The Java Environment

Hello World
Basic Syntax

Java API
Java as an OO language Exercise

Java as an OO language

Well, we talked too much so far so we will have to leave it for after the break

BUT
Some exercise before!

72

Agenda

Java History What can be done with Java? Language Characteristics The Java Environment

Hello World
Basic Syntax

Java API
Java as an OO language Exercise

Exercise 1
Get strings from the command line and print to screen only those which contain the word Java (with a capital J).

74

Exercise 2
Get integers from the command line (well, you will get Strings but should find a way to turn them to ints), calculate the average then print to screen all the numbers and the average.

75

Exercise 3
Get Strings from the command line, present in the console a vertical bar chart of the frequency of each letter in the input.
Treat small and capital letters the same -- as capital Ignore any char that is not an English letter

Example
For the following input: we expect the following chart:
A E H O R Y U W # ## ## ## # ## # #

Hey how are you?

76

Exercise 4
This exercise is called the Rectangles game. Get from the command line the coordinates of two rectangles. The winning rectangle is set according to these rules:
If a rectangle is contained (even partially) in the other, the contained (=inner) rectangle wins If no one contains the other, the bigger by both area and perimeter wins If no one is bigger by both area and perimeter, we have a tie

Example
Rectangle A: 1 1 10 10 Rectangle B: 5 5 10 10 (which means: x1=1, y1=1, x2=10, y2=10) (which means: x1=5, y1=5, x2=10, y2=10)

The winner is Rectangle B (contained in A!)

77

That concludes this chapter

amirk at mta ac il
78