Java Language and OOP

Part I
By Hari Christian
Agenda
01 Java Keyword
02 Primitive Data Type
03 Wrapper Class
04 Variabel or Identifier
05 Expression Statement
06 Comment in Java
07 Comment Single Line
08 Comment Multiple Line
09 Casting
10 Overflow
Keywords
Keywords are reserved words, which means
they cannot be used as identifiers. Java now has
50 keywords ("enum" became a keyword in JDK
1.5)
Keywords
abstract continue for new switch

assert default goto package synchronized

boolean do if private this

break double implements protected throw

byte else import public throws
Keywords
case enum instanceof return transient

catch extends int short try

char final interface static void

class finally long strictfp volatile

const float native super while
Primitive Data Type
There are eight built-in, non-object types in
Java, known as primitive types. Every piece of
data in a class is ultimately represented in terms
of these primitive types. The eight primitive types
are:
boolean (for true/false values)
char (for character data, ultimately to be input or
printed)
int, long, byte, short (for arithmetic on whole numbers)
double, float (for arithmetic on the real numbers)

Primitive Data Type - Literal
As we mention each of the eight primitive types,
we'll show a typical declaration; say what range
of values it can hold; and also describe the literal
values for the type.

A "literal" is a value provided at compile time.
Just write down the value that you mean, and
that's the literal.
Primitive Data Type - Literal
Example:
int i = 2; // 2 is a literal
double d = 3.14; // 3.14 is a literal
if ( c == 'j' ) // 'j' is a literal
Primitive Data Type - Literal
Every literal has a type, just like every variable
has a type.

The literal written as 2 has type int.

The literal written as 3.14 belongs to the type
double.

For booleans, the literals are the words false
and true.
Primitive Data Type - Literal
It is not valid to directly assign a literal of one
type to a variable of another. In other words, this
code is invalid:

int i = 3.14; // type mismatch! BAD CODE
Primitive Data Type The Eigth
Data Type Size Min Max
byte 8 bit -128 127
short 16 bit -32.768 32.767
int 32 bit -2.147.483.648 2.147.483.647
long 64 bit -9.223.372.036.854.775.808 9.223.372.036.854.775.807
float 32 bit -3.4E38 3.4E38
double 64 bit -1.7E308 1.7E308
boolean - - -
char 16 bit '\u0000' atau 0 '\uffff atau 65535
Primitive Data Type - byte
Example declaration:
byte aByte;

Range of values: 128 to 127

Literals: There are no byte literals. You can use,
without a cast, int literals provided their values fit
in 8 bits. You can use char, long, and floating-
point literals if you cast them
Primitive Data Type - byte
You always have to cast a (non-literal) value of a
larger type if you want to put it into a variable of
a smaller type

Since arithmetic is always performed at least at
32-bit precision, this means that assignments to
a byte variable must always be cast into the
result if they involve any arithmetic, like this:
byte b1=1, b2=2;
byte b3 = b2 + b1; // NO! compilation error
byte b3 = (byte) (b2 + b1); // correct, uses a cast
Primitive Data Type - short
Example declaration:
short aShort;

Range of values: 32,768 to 32,767

Literals: There are no short literals. You can use,
without a cast, int literals provided their values
will fit in 16 bits. You can use char, long, and
floating-point literals if you cast them
Primitive Data Type - int
Example declaration:
int i;

Range of values: 2,147,483,648 to 2,147,483,647

Literals:
A decimal literal, e.g., 10 or 256
With a leading zero, meaning an octal literal, e.g.,
077777
With a leading 0x, meaning a hexadecimal literal,
e.g., 0xA5 or 0Xa5

Primitive Data Type - long
Example declaration:
long debt;

Range of values: 9,223,372,036,854,775,808 to 9,223,372,036,854,775,807

Literals: (always put L)
A decimal literal, e.g., 2047L or 10L
An octal literal, e.g., 0777777L
A hexadecimal literal, e.g., 0xA5L or
OxABadBabbeL

Primitive Data Type - float
Example declaration:
float total;

Range of values: 3.4E38 to 3.4E38

Literals: (always put f)
1e1f 2.f .3f 3.14f 6.02e+23f
Primitive Data Type - double
Example declaration:
double salary;

Range of values: 1.7E308 to +1.7E308

Literals: (optionally put d)
1e1 2. .3 3.14 6.02e+23d
Primitive Data Type - boolean
Example declaration:
boolean b;

Range of values: false, true

Literals: false true
Primitive Data Type - char
Example declaration:
char grade;

Range of values: a value in the Unicode code set 0 to 65,535

Literals: Char literals are always between single
quotes. String literals are always between
double quotes, so you can tell apart a one-
character String from a char
Primitive Data Type - char
Here are the four ways you can write a char literal:
A single character in single quotes, char tShirtSize = 'L';
A character escape sequence





An octal escape sequence
A Unicode escape sequence
Character Description
\n Linefeed
\r Carriage Return
\f Formfeed
\b Backspace
Character Description
\t Tab
\\ Backslash
\ Double Quote
\ Single Quote
Wrapper Class
Each of the eight primitive types we have just
seen has a corresponding class type, predefined
in the Java library

For example, there is a class java.lang.Integer
that corresponds to primitive type int

These class types accompanying the primitive
types are known as object wrappers
Wrapper Class
Wrapper Class serve several purposes:
The class is a convenient place to store constants like
the biggest and smallest values the primitive type can
store
The class also has methods that can convert both
ways between primitive values of each type and
printable Strings. Some wrapper classes have
additional utility methods
Some data structure library classes only operate on
objects, not primitive variables. The object wrappers
provide a convenient way to convert a primitive into
the equivalent object, so it can be processed by these
data structure classes
Wrapper Class The Eight
Primitive Type Wrapper Class
byte java.lang.Byte
short java.lang.Short
int java.lang.Integer
long java.lang.Long
float java.lang.Float
double java.lang.Double
boolean java.lang.Boolean
char java.lang.Character
Wrapper Class
Example:
int i = 15;
Integer myInt = new Integer(i); //wrap an int in a object
// get the printable representation of an Integer
String s = myInt.toString();
// gets the Integer as a printable hex string
String s = myInt.toHexString(15); // s is now "f"
// reads a string, and gives you back an
int i = myInt.parseInt( "2047" );
// reads a string, and gives you back an Integer object
myInt = myInt.valueOf( "2047" );
Identifier
Identifiers are the names provided by the
programmer, and can be ANY LENGTH in Java

Identifiers must start with a LETTER,
UNDERSCORE, or DOLAR SIGN, and in
subsequent positions can also contain digits.

Letter with unicode character also valid
Identifier

calories
Legal Java identifiers
calories Hagen_Dazs

dconnage
_99

Puetas fotto
i $_ p
Identifier Forward Reference
public class Identifier {
public int calculate() {
// not yet declared
print(METHOD FORWARD REFERENCE);
return total;
}

public void print(String aString) {
System.out.println(aString);
}

int total;
}
Expression Statement
Example:
public static void main(String[] args) {
int a = b; // assignment
int number = 5; // assignment
w.setSize(200,100); // method invocation
new WarningWindow(f); // Instance creation
Person p = new Person(); // Instance creation
++i; // pre-increment
}

Expression Statement
Example:
public static void main(String[] args) {
int i = 4;
int j = 6;
int x = i++ + ++i - --j + ++j + j++;
System.out.println(x = + x);
System.out.println(i = + i);
System.out.println(j = + j);
}

Expression


Expression in Java
A literal 245
This object reference this
A field access now.hh
A method call now.fillTimes()
An object creation new Timestamp(12, 0, 0)
An array creation new int[27]
An array access myArray[i][j]
Any expression with operator now.mins / 60
Any Expression in parens (now.millisecs * 1000)
Comment in Java
Comment is used to make a description of a
program

Comment can be used to make a program
readable

Comment is ignored by compiler

Comment Single Line
Use double slash

Example:
// This is a single line comment
Comment Multiple Line
Use /* */

Example:
/*
This is a multiple line comment
Use this if we want to make multiple line of comment
Just remember the format:
/* = to open the comment
*/ = to close the comment
*/

Comment Multiple Line
Use /** */

Example:
/**
This is a multiple line comment for Java Documentation
Use this if we want to make multiple line of comment
And also want to publish to Java Documentation
We can also use HTML tag like this <br/>
Just remember the format:
/** = to open the comment
*/ = to close the comment
*/

Casting
When you assign an expression to a variable, a
conversion must be done.

Conversions among the primitive types are
either identity, widening, or narrowing
conversions.

Casting - Identity
Identity conversions are an assignment between
two identical types, like an int to int assignment.

The conversion is trivial: just copy the bits
unchanged.
Casting - Identity
Example:
int i = 5;
int j = i; // The result is ?

Casting - Widening
Widening conversions occur when you assign
from a less capacious type (such as a short) to a
more capacious one (such as a long). You may
lose some digits of precision when you convert
either way between an integer type and a
floating point type. An example of this appeared
in the previous section with a long-to-float
assignment. Widening conversions preserve the
approximate magnitude of the result, even if it
cannot be represented exactly in the new type.
Casting - Widening
Example:
int i = 5;
double d = i; // The result is ?

Casting - Narrowing
Narrowing conversions are the remaining
conversions. These are assignments from one
type to a different type with a smaller range.
They may lose the magnitude information.
Magnitude means the largeness of a number, as
in the phrase "order of magnitude." So a
conversion from a long to a byte will lose
information about the millions and billions, but
will preserve the least significant digits.
Casting - Narrowing
Example:
double d = 5.5;
int i = (int) d; // The result is ?
Overflow
When a result is too big for the type intended to
hold it because of a cast, an implicit type
conversion, or the evaluation of an expression,
something has to give!

What happens depends on whether the result
type is integer or floating point.

Overflow
When an integer-valued expression is too big for
its type, only the low end (least significant) bits
get stored

Because of the way two's-complement numbers
are stored, adding one to the highest positive
integer value gives a result of the highest
negative integer value. Watch out for this (it's
true for all languages that use standard
arithmetic, not just Java)
Overflow
There is only one case in which integer
calculation ceases and overflow is reported to
the programmer: division by zero (using / or %)
will throw an exception
Overflow
Example:
int min = Integer.MIN_VALUE; // -2147483648
int max = Integer.MAX_VALUE; // 2147483647
int num1 = 2147483648; // The result is ?
int num2 = max + 1; // The result is ?
int num3 = min - 1; // The result is ?
int num4 = 5 / 0; // The result is ?
Thank You