01 Java Language And OOP PART I

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.


• Example:

int i = 2; // 2 is a literal

double d = 3.14; // 3.14 is a literal

if ( c == 'j' ) // 'j' is a 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.


• 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 EigthData 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


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


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


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


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


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


boolean b;

• Range of values: false, true

• Literals: false true

Primitive Data Type - char


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 EightPrimitive 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 Häagen_Dazs déconnage

_99 Puñetas fottío

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);

}

ExpressionExpression 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

Software

01 Java Language And OOP PART I