COS 240COS 240

Object-Oriented LanguagesObject-Oriented Languages

The Anatomy of a Java ProgramThe Anatomy of a Java Program

AUBG, Spring 2014AUBG, Spring 2014

Svetla Boytcheva

Course Text Book:

Y. Daniel Liang,

Introduction to Java Programming, Comprehensive Version,

9th edition, Pearson, 2013

Aditional Book: Thinking in Java

• Bruce Eckel, Thinking in Java (4th Edition) – http://www.planetpdf.com/developer/article.asp?ContentID=6632– http://www.codeguru.com/java/tij/

• Other useful links (comparisson between C++ and Java):– http://www.javacoffeebreak.com/articles/thinkinginjava/comparingc++andjava.html

Eclipse

• Downloads:– http://www.eclipse.org/downloads/

• Tutorials:– http://www.vogella.de/articles/Eclipse/article.html– http://eclipsetutorial.sourceforge.net/totalbeginner.html

Overview

From the very beginning, Java was designed as an object-oriented language

- unlike C++ which is just an object-oriented extension to C. But like C#.

Classes are the building blocks of Java programs

- again, unlike C++. But like C#.

Java is case sensitive. Like C#.

- a is different to A

Versions of Java

Java 1

Java 2

Java 5.0

Java 1.1: Adds inner classes and a completely new event-handling model

Java 1.2: Includes “Swing” but no new syntax

Java 1.3: Additional methods and packages, but no new syntax

Java 1.4: More additions and the assert statement

Java 1.5: Generics, enums, new for loop, and other new syntax

Java: Original, not very good version (but it had applets)

Java 6 (=1.6): A few new features, mostly at the advanced level

How Java Works

• Java's platform independence is achieved by the use of the Java Virtual Machine (JVM).

• A Java program consists of one or more files with a .java extension

• these are just text (i.e. source) files.

• When a Java program is compiled, the .java files are fed to the compiler which produces a .class file for each .java file.

• The .class file contains Java bytecode. • • Java bytecode is like machine language, but it is

intended for the Java Virtual Machine, not a specific processor.

Executing a Java program

• To run a Java program, the bytecode in a .class file is fed to an interpreter/compiler which converts the bytecode to machine code for a specific processor.

• Some people refer to the interpreter/compiler as "The Java Virtual Machine" (JVM).

• The interpreter/compiler is platform specific because it takes the platform-independent bytecode and produces machine language instructions for a particular processor.

• So a Java program could be run an any type of computer that has a JVM written for it.

Java was initially developed by Sun Microsystems

- producers of Unix platforms and Unix OS.

Java programs may be applications or applets.

Applications are standalone programs, similar to .NET Console and Windows applications.

Applets are similar to applications, but they do not run as standalone programs.

- Instead, applets adhere to a set of conventions that lets them run within a Java-compatible browser (client-side).

- You can only run an applet from an HTML page.

JVM is an Emulation

• The difficult part of creating Java byte code is that the source code is compiled for a machine that does not exist.

• This machine is called the Java Virtual Machine, and it exists only in the memory of our computer.

• Fooling the Java compiler into creating byte code for a nonexistent machine is only one-half of the ingenious process that makes the Java architecture neutral.

• The Java interpreter must also make our computer and the byte code file believe they are running on a real machine. It does this by acting as the intermediary between the Virtual Machine and our real machine.

JVM emulation run on a physical machine

JVM

• The Java Virtual Machine is responsible for interpreting Java byte code and translating this into actions or Operating System calls.

• For example, a request to establish a socket connection to a remote machine will involve an Operating System call.

• Different Operating Systems handle sockets in different ways - but the programmer doesn't need to worry about such details. It is the responsibility of the JVM to handle these translations so that the Operating System and the CPU architecture on which the Java software is running is completely irrelevant to the developer.

JVM handles translations

Preview to Java Language

• Basic syntax the same as C++ (which was then copied by C#!).

• Pointers exist but in a simplified and hidden form. – Object references

• Garbage Collection is used– No need for destructors (but may have!).– Memory leaks very unlikely .– Not as many memory management issues (Memory is

still managed, but by the run time system instead of the programmer.).

• Array index out of bounds causes a runtime error– Java uses the term Exceptions for runtime errors

Basic syntax for class declaration

In Java, a class comprises a class header and class body.

public class class_name{

class body;}

Note: No semicolon (;) to terminate class block.

But statements must be terminated with a ;

Class body comprises class members – constructor, data fields and methods.

Each feature (constructor, data fields and methods) is individually tagged as public or private. (There are other qualifiers …)

E.g.

public class class_name{

private data_type name;

public method_name(parameters){

...}

public another_method(parameters){

...}

}

Reference Types

• Non-primitive types in Java are called reference types.

• Variable does not really hold an object, it holds a

reference to (i.e. address of) the object.

• Java hides this indirection from you. Like C#.

In Java, declaring a variable to hold an object does not create the object (instance) itself. Need to invoke constructor (via new) to create and initialize instance.

The variable only holds a reference to the object.

class_name variable_name;

To create an instance of a class, use the new operator which invokes the class constructor.

new class_name(parameters)

Variables of type class_name can be created in this way:

class_name instance_name = new class_name(params);

An object of type String can be created by simply enclosing the characters in double quotes

String s = “Here is a string”;

The dot operator . is used in conjunction with the object to access the members of a class (like C++ and C#).

Every class defined in Java must extend some other object

– Default: implicit extension of the Object class

Syntax for simple Java program

public class class_name{

public static void main(String[] args){

implementation of method}

}

The first method that will be invoked when execution commences must be called main().

Note the case of main() and String !

- C# has public static void Main(string[] args)

// Javapublic class Hello { public static void main(String[] args) { System.out.println("Hello world in Java"); }}

// C#

public class Hello {

public static void Main(string[] args) {

System.Console.WriteLine("Hello world in C#");

System.Console.ReadLine();

}

}

The general syntax for a method

modifers return_type method_name(parameters){

data declarationssequence of statements

}

E.g.

public static void main(String[] args)

Import statement

A Java program is never entirely self-contained butinstead must execute in the “world” provided by theJava runtime system.

Use of the import statement:

import java.lang.*;

This statement makes the methods in the library packagejava.lang available to the class following it.

java.lang is just one package in the Java library or API.

Actually, importing java.lang is not required since it is automatically available to all Java programs.

The package java.lang is important because it contains the class System which itself contains I/O methods.

E.g. Methods System.out.print(...)and System.out.println(...)and System.in.read()

A Java package is similar to a C# namespace.

Standard Output

• To print to standard output use

System.out.print( expression ); // no newline

System.out.println( expression ); // newline

System.out.println( ); // just a newline

Common behaviour is to build up expression to be printed out

System.out.println( "x is: " + x + " y is: " + y );

// Package Declarationimport java.lang.*; // not required

// Program start class public class HelloWorld { // Main begins program execution public static void main(string[] args) { // This is a single line comment

/* This is a multiple line comment */

System.out.println("Hello World!"); } }

Example

public class HelloWorldApp {

public static void main(String[] args) {

// Display "Hello World!" System.out.println("Hello World!");

} }

Example

import java.io.*;public class Testclass{ public static void main( String args[] ) { int count = 0; while ( count < 10 ) { System.out.println("counter is " + count ); count++; } }}

Example

public class HelloWorld {

public static void main(String[] args) {

String name = "Java";

// See if an argument was passed from the command line

if (args.length == 1)

name = args[0];

System.out.println("Hello, " + name + "!");

}

}

Example

import java.util.*;

public class test11 {

public static void main(String[] args) {

System.out.println("Hello, it’s: ");

System.out.println(new Date());

}

}

Language Basics

• Data types– 8 primitive types:

• boolean, byte, short, int, long, float, double, char

– Class types, either provided by Java, or made by programmers (Reference types)• String, Object, Frame, Person, Animal, …

– Array types (also reference types)

• Variables– dataType identifier [ = Expression]:– Example variable declarations and initializations:

int x; x=5;boolean b = true;Frame win = new Frame();String x = “How are you?”;

int[] intArray;intArray = new int[2];intArray[0] = 12;intArray[1] = 6;Person pArray = new Person[10];

Constants via final

Assigned value cannot be changed

– Similar to the const keyword in C

Variables declared with final

– must be initialized in the declaration

– can be initialized in a constructor, but must be assigned a value in every constructor of the class

Flow of control if, if-else, if-else if

switch

for, while, do-while

break

continue

If-else

/**

* return the difference of x and y

*/

public static int abs(int x, int y){

if (x < y)

return y - x;

else if(x > y)

return x - y;

else

return 0;

}

Switch-case

switch ( N ) { // (Assume N is an integer variable.) case 1: System.out.println("The number is 1."); break; case 2: case 4: case 8: System.out.println("The number is 2, 4, or 8."); System.out.println("(That's a power of 2!)"); break; case 3: case 6: case 9: System.out.println("The number is 3, 6, or 9."); System.out.println("(That's a multiple of 3!)"); break; case 5: System.out.println("The number is 5."); break; default: System.out.println("The number is 7 or is outside the range 1 to 9.");}

For-loop

For (int i=1, j=10; i < j; i++, j-=2)

System.out.println("i="+i+" j="+j);

for (int i = 0; i < 4; i++){ for( char letter = 'A'; letter <= 'A' + i; letter++) System.out.print(letter); System.out.println();}

i=1 j=10i=2 j=8i=3 j=6

AABABCABCD

The break statement

• Inside any loop, the break statement will immediately get you out of the loop– If you are in nested loops, break gets you out of the

innermost loop

• It doesn’t make any sense to break out of a loop unconditionally - you should do it only as the result of an if test

Example: for (int i = 1; i <= 12; i++) { if (badEgg(i)) break;}

• break is not the normal way to leave a loop– Use it when necessary, but don’t overuse it

The continue statement

• Inside any loop, the continue statement will start the next pass through the loop

– In a while or do-while loop, the continue statement will bring you to the test

– In a for loop, the continue statement will bring you to the increment, then to the test