Copyright @ 2000 Jordan Anastasiade. All rights reserved. 1 A Quick Tour of Java In this lesson you...

Copyright @ 2000 Jordan Anastasiade. All rights reserved. 1

A Quick Tour of Java

In this lesson you will be learning about:

The Java Platform.

Basics elements of the Java Language: Variables Named Constants Flow of Control

Classes and Objects.

How to compile and execute a Java program.


Getting Started

Java programs are built from classes.A class is a template to build objects and contains members of the following type: Fields – Data belonging either to class or object of the class. Methods – Collections of statements that operate on fields. Classes – Nested or inner classes defined inside a class.

Example: First.java file

class First { public static void main(String[] args) { System.out.println(“The first program in Java –

PRO404”); }}


Java Platform – JDK 1.2

Java Platform has 3 components: 1. Java Programming Language. 2. Java Packages. 3. Java Virtual Machine.

Java Programming Language – called simply Java. General-purpose, ease of programming, safety features.

Java Packages. Grouping of related interfaces and classes. Ex: java.lang.

Java Virtual Machine. The Java virtual machine is an abstract computing machine.


How to Use Java Platform

Learn Java Programming Language Concepts, Vocabulary, Syntax, Semantics and Patterns. Write program and safe source code in files according with the Java

Programming Language rules.

Learn the structure of packages that come with JDK. Use classes already defined in the JDK packages according with

your program design. Do not invent the wheel!

Compile and run your program using tools from JDK. Compile using java compiler: javac MyProgramName.java Run your program using JVM: java MyProgrmName


From Birth to Execution

1. Coding: Java code is produced by the programmer.

COMPILER: javac2. Compiling: Build the Java program into byte-code, which is saved as a ".class" file.

JAVA VIRTUAL MACHINE: java 3. Loading: The class file is loaded by the Java Virtual Machine with its attached digital signature.

4. Bytecode Verification: The JVM verifies the class file digital signature. The JVM is simply an interpreter.

6. Internal Integrity: Verification checks are made to insure that the loaded Java program is well formed. Data types are verified along with other syntax structure.

7. Execution: Program execution begins from the main entry point.


Variables

Java has build-in primitives to support boolean, character, integer and floating-point values.----------------------------------------------------------------------------------------- boolean either true or false boolean b = true;------------------------------------------------------------------------------------------ char 16-bit Unicode 1.1 character char ch = ‘J’;------------------------------------------------------------------------------------------ byte 8-bit integer (signed) byte bt = 127; short 16-bit integer (signed) short sh = 32767; int 32-bit integer (signed) int i = 2147483647; long 64-bit integer (signed) long l =

9223372036854775807L;------------------------------------------------------------------------------------------- float 32-bit floating-point (IEEE 754-1985) float f = 1.0f; double 64-bit floating-point (IEEE 754-1985) double d = 1.e-1;-------------------------------------------------------------------------------------------


Comments, Named Constants

Comments in Code – enable to write descriptive text.

/* Comment type 1 – This text is ignored by the compiler */ // Comment type 2 – The text up to the end of line is ignored

/** Documentation comment is extracted by javadoc tool */

Named Constants – name used to describe constants.

public static final int MAX_INDEX = 1000;

class MathConstant { static final double E = 2.71; //the base of the natural

logarithms static final double PI = 3.14; }


Flow of Control

Flow of control is the term used for describing which statements are executed in a program.

Flow statements are: if – else for switch do – while while block of code – statements group within { and }.


Fibonaci sequenceThe Fibonacci sequence is an infinite sequence that starts with terms 1 and 1 and each successive term is the sum of the previous two terms.

class Fibonacci { /** Print out the Fibonacii numbers */ static final int MAX_INDEX = 10;

public static void main(String[] args) { int lo = 1;

int hi = 1; System.out.println(“1: “ + lo);

for (int i = 2; i < MAX_INDEX; i++) { System.out.println(“i: “ + hi); hi = lo + hi; //new hi is the sum of previous two

terms. lo = hi – lo; //new lo is the old hi i. e. sum – old hi } }}


Classes and Objects

Each class has three kinds of members: Fields are data variables of a class that store results of computations

performed by class’s methods. Methods contain the executable code, built from statements. Classes and interfaces can in the same time be members of a class.

Every object in Java has a state and a behavior. class Point { private double x_ = 0; //the state of object is defined by values of its data

private double y_ = 0;

/* the behaviors of an object is defined by its methods */

public void movePoint(double x, double y) { x_ = x; y_ = y;

}

}


Creating Objects

Objects are created using an expression containing

the new keyword.

Point lowerLeft = new Point();All objects are allocated within an area of system memory known as Heap and are accessed only via an object reference.Each Point object is unique and has its own copy of x and y fields.

x = 0 y = 0Point object

lowerLeft reference

Memory Heap


Identifiers

The name you choose for anything in java is called a java identifier.

Identifiers must start with a letter, an underscore ( _ ) or a dollar sign ( $ ) followed by letters or digits.

There is no limit for the length of identifiers and they are composed from the Unicode charter set.

Ex: toStart _color $accountÉvalué übung

Java language keywords cannot be used as identifiers.


Java Keywordsabstract boolean break

byte case catch

char class const

continue default do

double else extends

final finally float

for goto if

implements import instanceof

int interface long

native new package

private protected public

return short static

super switch synchronized

this throw throws

transient try void

volatile while


Literals

Each type in Java has literals, which are the way that constant values of that type are written. Integer constants are string of octal, decimal, hexadecimal digits.Ex: decimal 58L, octal 027, hexadecimal 0x8AF

Floating-point numbers are decimal numbers optional followed by an exponent.

Ex: double 18. .234E3 1.8e-1; float 1.234f 0.2e-5F

Characters literals appear between single quotes. Any valid Unicode character can appear between the quotes. Certain special characters are represented as escape sequence.

Ex: ‘J’, ‘A’, ‘V’, ‘A’ ‘\n’ newline ‘\u000A’ ‘\t ‘tab ‘\u0009’

\ddd a char by octal value d 0-7 String literals appear between double quote. Ex: “JAVA”


Numeric operators in Java

Prec Operator Description Example1 ++ Increment by 1(or 1.0)

k++

1 -- Decrement by 1(or 1.0) k--1 + Unary plus +value1 - Unary minus -value2 * Multiplication x * y2 / Division x / y2 % Modulo x % y3 + Addition x + y3 - Subtraction x - y5 < Less than x < y5 > Greater than x > y5 <= Less than/equal x <= y5 >= Greater than/equal x >= y6 == Equals (identical values) x == y6 != Is not equal to x != y13 op= op assignment(+ =, - =, *=, etc) x += y


Bitwise and logic operators

Prec Operator Type Description Example

1 ~ Integral Unary bitwise complement ~x1 ! Logical Unary logical complement !b4 << Integral Left shift x << 24 >> Integral Right shift (keep sign) x >> 54 >>> Integral Right shift (zero fill) x >>> 35 instanceof Obj type Tests class membership o instanceof

X6 == Object Equals (same object) x == y6 != Object Unequal (different object) x != y7 & Integral Bitwise AND x & y7 & Logical Logical AND b1 & b28 ^ Integral Bitwise XOR x ^ y8 ^ Logical Logical XOR b1 ^ b29 | Integral Bitwise OR x | y9 | Logical Logical OR b1 | b2


Bitwise and logic operators (continued)

Prec Operator Type Description Examp.10 && Logical Logical AND (conditional) b && c11 || Logical Logical OR (conditional) b1 ||

b212 ?: Logical Conditional (ternary) b ? x :

y13 = Variable,any Assignment x = 113 <<= Binary Left shift with assignment x <<=

213 >>= Binary Right shift with assignment x =>>

313 >>>= Binary Right shift, zero fill, assign x =>>

413 &= Binary Bitwise AND with assign x &= y13 &= Logical Logical AND with assign b1

&=b213 |= Binary Bitwise OR with assignment x |= y13 |= Logical Logical OR with assignment b1 |

=b213 ^= Binary Bitwise XOR with assignment x ^= y13 ^= Logical Logical XOR with

assignmentb1 ^=b2


Bitwise logic rules

AND 0 1

0 0 0

1 0 1

OR 0 1

0 0 1

1 1 1

XOR 0 1

0 0 1

1 1 0

0 & 0 = 0 0 & 1 = 01 & 0 = 0 1 & 1 = 1

0 | 0 = 0 0 | 1 = 11 | 0 = 1 1 | 1 = 1

0 ^ 0 = 0 0 ^ 1 = 11 ^ 0 = 1 1 ^ 1 = 0


Bitwise operations on short primitives (16 bit integers)

Binary Operation Decimal Hex

0000 0000 0101 0100 op1 84 0x0054

0000 0001 0100 0111 op2 327 0x0147

0000 0000 0100 0100 op1 & op2 68 0x0044

0000 0001 0101 0111 op1 | op2 343 0x0157

0000 0001 0001 0011 op1 ^ op2 275 0x0113

1111 1110 1011 1000 ~op2 -328 0xFEB8


Results of some bit-shifting

0000 0000 0000 0000 0000 0000 0110 0011 starting a = 99

0 0 0 0 0 0 6 3 a = 0x00000063

0000 0000 0000 0000 0000 0011 0001 1000 after a << 3 (792)

0 0 0 0 0 3 1 8 a = 0x00000318

0000 0000 0000 0000 0000 0000 0001 1000 after a >> 2 (24)

0 0 0 0 0 0 1 8 a = 0x00000018

1111 1111 1111 1111 1111 1111 1001 1101 stating b = -99

F F F F F F 9 D b = 0xFFFFFF9D

1111 1111 1111 1111 1111 1111 1111 1001 after b >> 4 = -7

F F F F F F F 9 b = 0xFFFFFFF9

0000 0000 0000 1111 1111 1111 1111 1111 after b >>> 12 = 1048575

0 0 0 F F F F F b = 0x000FFFFF


Type Conversions

Java is a strong typed language.

Implicit conversion for primitive value: any numeric value can be assigned to any numeric value whose type supports a larger range of values.

byte short int long float double

Explicit conversion – casting. boolean type doesn’t allow any casting at all. A char can be cast to any integer type and vice versa

excepting to a short type. When chart is cast to int type upper bits are filled with zeros.

Attention: Interger types are converted by chopping off the upper bits. If the larger integer has a value outside the range off the smaller type, dropping the

upper bits changes the value, including possibly changing sign.

Ex: short sh = -129; byte b = (byte)sh; b will have the value 127


if, if-else, if else –if else

1. if (boolean-expression) {

statements; }

2. if (boolean-expression) { statements;

} else {statements;

}

3. if (boolean-expression) { statements;

} else if (boolean-expresion ) {statements;

} else {statements;

}


for Statement

A for statement should have the following form:

for (initialization; condition; update) {

statements;}

Ex:for (k = 0, flag; k < 10 && flag; k++ ) {

. . .}


while, do - while Statements

while, do-while and for control looping are classified as iteration statements.

while (condition) {statements;

}

do {statements;

} while (condition);


break - Labeled break

A break “drops out of the bottom” of the loop. The break statement with no label attempts to transfer control to the innermost enclosing switch, for, while or do-while of immediately enclosing statement.A labeled break drops out of the bottom of the end of the loop denoted by the label. Ex:

out: for (int i = 0; i < 10; i++ ) {for (int k = 0; k < 10; k++) {

if (i == k) break out;

}}


continue – Labeled continue

A plain continue goes to the top of the innermost loop and continues. A labeled continue goes to the label and re-enters the loop right after that label.

Ex: Calculates the factorials of odd number.outerLoop: for (int i = 0; i < limit; i++ ) {

for (int k = 2; k < i; k++) {if (i % 2) continue outerLoop;factory *= i;

}}


switch

The switch is classified as a selection statement.switch (integral-selector) {

case integral-value1: statements;

break; default:

statements; } Integral-selector is an expression that produces an integral value.

The switch compares the result of integral-selector to each integral-value. If it finds a match, the corresponding statement (simple or compound) executes. If no match occurs, the default statement executes.


Array

An array is simply a sequence of either objects or primitives, all the same type and accessed together under one identifier name.

Arrays are implicit extensions of Object.

Arrays are defined and used with square-brackets indexing operator [ ].

int [ ] integerArray = new int[3];A Java array is guaranteed to be initialized and cannot be

accessed outside of its range.

for (int k = 0; k < integerArray.length; k++)integerArray[k] = k;

Creating an array of objects, one are really creating an array of references, and each of those references is automatically initialized to null.

CelestialBody[ ] celBoliesArray = new CelestialBody[5];

Regardless of what type of array you’re working with, the array identifier is actually a reference to a true object that’s created on the heap.


Strings

Java strings are standard objects with built-in language support.

The String class represents character strings. All string literals in Java programs, such as "abc", are implemented as instances of String class.

Strings are constant; their values cannot be changed after they are created. Stringbuffer class supports mutable strings. Because String objects are immutable they can be shared.

For example:

String str = "abc";

is equivalent to:

char data[] = {'a', 'b', 'c'}; String str = new String(data);


String Examples

Here are some more examples of how strings can be used: System.out.println("abc"); String cde = "cde"; System.out.println("abc" + cde); String c = "abc".substring(2,3); String d = cde.substring(1, 2);The basic two methods:int length(); Returns the length of this string.char charAt(int index); Returns the character at the specified index. The Java language provides special support for the string concatentation operator ( + ), and for conversion of other objects to strings. String concatenation is implemented through the StringBuffer class and its append method. String conversions are implemented through the method toString, defined by Object and inherited by all classes in Java.


Strings’ Methods

Constructor Summary:

String();String(byte[] bytes);String(byte[] bytes, String enc);String(char[] value);String(char[] value, int offset, int count);String(String value);String(StringBuffer buffer);

char charAt(int index);int compareTo(String anotherString);int compareToIgnoreCase(String str);


Strings’ Methods (cont)

static String copyValueOf(char[] data, int offset, int count);

boolean equals(Object anObject);boolean equalsIgnoreCase(String anotherString);byte[] getBytes(String enc);int hashCode();int indexOf(int ch);int lastIndexOf(int ch);int length();String replace(char oldChar, char newChar);boolean startsWith(String prefix);String substring(int beginIndex, int endIndex);char[] toCharArray();String toLowerCase();String toString();String toUpperCase();String trim();

static String alueOf(Object obj);


Conclusions

After completion of this lesson you should know:How to write a simple Java Program.

How to work with primitives: Integers and Floats.

To use Java Tools: compiler, interpreter, debugger.

Copyright @ 2000 Jordan Anastasiade. All rights reserved. 1 A Quick Tour of Java In this lesson you...

Documents

Transcript of Copyright @ 2000 Jordan Anastasiade. All rights reserved. 1 A Quick Tour of Java In this lesson you...