Pemrograman Dasar. Basic Elements Of Java

(1)

Pemrograman Dasar

Basic Elements

Of Java

(2)

Compiling and Running a Java Application

2

(3)

3

Portable Java Application

(4)

Java Platform

 Platform: hardware or software environment in which a program runs.

 Oracle has two products that implement Java Platform Standard Edition (Java SE) 7:

– Java SE Development Kit (JDK) 7

– Java SE Runtime Environment (JRE) 7.

4

(5)

Java Platform SE 7

5

(6)

Typical Java Development Environment

(7)

Basic Lexical Elements

 Character set

– 16-bit Unicode – Legal characters

 Keywords

– Reserved words, special meaning, illegal for identifiers

 Identifiers

– Names of declared entities, e.g. variables, constants

 Variables

– A variable is a storage location, something that can hold a value to which a value can be assigned

 Literals

– Constants or values, e.g. 12, 17.9, “Hello”

7

(8)

Basic Lexical Elements

 Other notations

– Operators, e.g. +, -, *, /, etc.

– Block symbols, e.g. pair of {}

 Comments

– Help developers, ignored by compiler – e.g.

/* Program 1 */

// Function to count Circle area

8

(9)

Character Set

 Java programs are written using Unicode character set (16 bit), which include:

 Capital letters: A .. Z

 Small letters: a .. z

 Numbers: 0 .. 9

 Punctuation marks, e.g. ‘!’ , ‘,’,’?’, etc.

 Other characters or symbols, e.g.

– Arithmetic symbols, e.g. ‘+’, ‘-’, ‘/’, etc.

– from many natural languages

Pengantar Bahasa C - TIF UB 2010 9

(10)

Keywords

 Keywords cannot be used as identifiers (reserved)

because they have special meaning within the language.

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

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

(11)

Identifiers (Naming)

 Used for names of declared entities such as variables, constants, and labels

 Must start with a letter, followed by letters, digits, or both.

 Identifiers are case-sensitive

 The terms letter and digit are broad in Unicode: if something is considered a letter or digit in a human language, you can probably use it in identifiers.

 "Letters" can come from Chinese, Korean, Gurmukhi, Georgian, Devanagari, and almost any other script written in the world today.

(12)

Identifiers (Naming)

 Letters also include any currency symbol (such as $, ¥, and £) and connecting punctuation (such as _).

 Identifiers can be as long as you like, but use some taste.

 Identifiers that are too long are hard to use correctly and actually obscure your code.

 Cannot use keywords (e.g. for, if, while, etc)

 Valid identifiers, e.g.:

– name, x1, _total, cubic

 Invalid identifiers, e.g.:

– 1kali, int

(13)

Variables

 A variable is a storage location, something that can hold a value to which a value can be assigned.

 A variable declaration states the identifier (name), type, and other attributes of a variable.

 e.g.

float x, y;

// is the same as float x; float y;

float x = 3.14f, y = 2.81f;

// is the same as float x = 3.14f,

y = 2.81f;

// is the same as

float x = 3.14f; float y = 2.81f; ¹³

(14)

Variables

 Instance variables (non-static fields)

 Class variables (static fields)

 Local variables

 Parameters

14

(15)

Variables

public class Bicycle {

int cadence = 0; // instance variable

static int wheels = 2; // static variable

…

// formal parameter: decrement

void applyBrakes(int decrement) { speed = speed - decrement;

}

// local variable: states void printStates() {

String states = "cadence: "+cadence+

",speed: "+speed+", gear: "+gear;

System.out.println(states);

} }

15

(16)

(Data) Types

 Every expression has a type that determines what values the expression can produce.

 The type of an expression is determined by the types of values and variables used within that expression.

 Types are divided into the primitive types and the reference types.

16

(17)

Primitive Data Types

17 Type Contains Default

(for fields)

Size Range

boolean true or false

false 1 bit NA Unicode

character

16 bits or 0 to 2¹⁶-1 or

unsigned 2 bytes '\u0000' (0) to '\uFFFF' (65535)

8 bit or -2⁷ to 2⁷-1 or 1 byte -128 to 127 16 bit or -2¹⁵ to 2¹⁵-1 or 2 bytes -32768 to 32767 32 bit or -2³¹ to 2³¹-1 or

4 bytes -2147483648 to 2147483647

64 bit or -2⁶³ to 2⁶³-1 or

8 bytes -9223372036854775808 to 9223372036854775807 IEEE 754

floating point

32 bit or 1.4E-45 to 3.4028235E+38

single- precision

4 bytes IEEE 754

floating point

64 bit or 439E-324 to

double- precision

8 bytes 1.7976931348623157E+308

float 0.0f

double 0

int Signed integer

0

long Signed integer

0 short Signed

integer

0

char '\u0000'

byte Signed integer

0

(18)

Literals

 Also known as “values” or “constants”

 Each (data) type has literals, which are the way that constant values of that type are written.

– Boolean literals – Character literals – Integer literals

– Floating-point literals – String literals

– Reference literals – Class literals

18

(19)

Literals

 Boolean literals

– Only true and false

 Character literals

– Appear with single quotes, e.g. ‘Z’, ‘a’, ‘2’,

‘\u004e’

– Certain special characters can be represented by an escape sequence, e.g.:

19

\n newline (\u000A)

\t tab (\u0009)

\b backspace (\u0008)

\r return (\u000D)

\f form feed (\u000C)

\\ backslash itself (\u005C)

\' single quote (\u0027)

\" double quote (\u0022)

(20)

Literals

 Integer literals

– An integer literal is of type long if it ends with the letter L or l; otherwise it is of type int.

– It is recommended that you use the upper case letter L because the lower case letter l is hard to

distinguish from the digit 1.

– Values of the integral types byte, short, int, and long can be created from int literals. Values of

type long that exceed the range of int can be created from long literals.

20

(21)

Literals

 Integer literals (cont’d)

– Integer constants are a sequence of octal, decimal, or hexadecimal digits.

– The start of a constant declares the number's base:

A 0 (zero) starts an octal number (base 8); a 0x or 0X starts a hexadecimal number (base 16); and any other digit starts a decimal number (base 10).

– E.g. all the following numbers have the same value

29 035 0x1D 0X1d

21

(22)

Literals

 Floating-point literals

– A floating-point literal is of type float if it ends with the letter F or f; otherwise its type is double and it can optionally end with the letter D or d.

– The floating point types (float and double) can also be expressed using E or e (for scientific

notation), F or f (32-bit float literal) and D or d (64- bit double literal; this is the default and by

convention is omitted).

22

(23)

Literals

 Floating-point literals (cont’d)

– Expressed in either decimal or hexadecimal

– The decimal form consists of a string of decimal digits with an optional decimal point, optionally followed by an exponent the letter e or E, followed by an optionally signed integer.

– e.g. all these literals denote the same floating-point number:

18. 1.8e1 .18E+2 180.0e-1

23

(24)

Literals

 Floating-point literals (continued)

– The hexadecimal form consists of 0x (or 0X), a string of hexadecimal digits with an optional hexadecimal point, followed by a mandatory binary exponent the letter p or P, followed by an optionally signed

integer.

– The binary exponent represents scaling by two raised to a power.

– e.g. all these literals denote the same floating-point number (decimal 18.0):

0x12p0 0x1.2p4 0x.12P+8 0x120p-4

24

(25)

Literals

 Floating-point literals (continued)

– There are two zeros: positive (0.0) and negative (- 0.0).

– Positive and negative zero are considered equal

when you use == but produce different results when used in some calculations.

25

(26)

Literals

 String literals (continued)

– String literals appear with double quotes, e.g.

“Welcome”, “salam”,

"\u0633\u064e\u0644\u064e\u0627\u0645\u064C".

– Any character can be included in string literals, with the exception of newline and " (double quote).

– Newlines are not allowed in the middle of strings.

– If you want to embed a newline character in the string, use the escape sequence \n.

– To embed a double quote use the escape sequence \".

– A string literal references an object of type String.

26