JAVA PROGRAMMING
Introduction
Compiling
Java
First Program
class Hello {
public static void main(String[ ]
arguments){
// Program execution begins here
System.out.println("Hello world.");
}
}
Program Structure
class CLASSNAME {
public static void main(String[ ]
arguments){
STATEMENTS
}
}
Output
System.out.println(some
String)
outputs tothe console
Example:
System.out.println(output);
Second Program
class
Hello2 {
public static void main(String[ ]
arguments){
System.out.println("Hello world.");
// Print once
System.out.println("Line number 2");
// Again!
}
Types
Kinds
of values that can be stored
and manipulated.
boolean: Truth value (true or false).
int: Integer (0, 1, -47).
double: Real number (3.14, 1.0, -2.1).
String: Text (hello, example).
void means no type
Mismatched Types
Java
verifies that types always
match:
String five = 5; // ERROR!
test.java.2: incompatible
types found: int
required: java.lang.String
String five = 5;
Variables
Named
location that stores a value
of one particular type.
Form:
TYPE NAME;
Example:
String foo;
Assignment
Use
= to give variables a value.
Example:
String foo;
foo = IAP 6.092;
Assignment
Can
be combined with a variable
declaration.
Example:
double badPi = 3.14;
boolean isJanuary = true;
EXAMPLE
class Hello3 {
public static void main(String[ ]
arguments){
String foo = "IAP 6.092;
System.out.println(foo);
foo = "Something else;
System.out.println(foo);
}
}
Operators
Symbols
that perform simple
computations
Assignment:
Addition:
+
Subtraction:
Multiplication: *
Division:
/
Division
Division
(/) operates differently on
integers and on doubles!
Example:
double a = 5.0/2.0;
// a = 2.5
int b = 4/2;
// b = 2
int c = 5/2;
// c = 2
double d = 5/2;
// d = 2.0
Order of Operations
Follows
standard math rules:
1. Parentheses
2. Multiplication and division
3. Addition and subtraction
Precedence like math, left to right
Right hand side of = evaluated first
Parenthesis increase precedence
double x = 3 / 2 + 1;
double y = 3 / (2 + 1);
// x = 2.0
// y = 1.0
EXAMPLE
class DoMath {
public static void main(String[ ]
arguments){
double score = 1.0 + 2.0 * 3.0;
System.out.println(score);
score = score / 2.0;
System.out.println(score);
}
}
EXAMPLE
class DoMath2 {
public static void main(String[]
arguments){
double score = 1.0 + 2.0 * 3.0;
System.out.println(score);
double copy = score;
copy = copy / 2.0;
System.out.println(copy);
System.out.println(score);
}
}
String Concatenation (+)
String
text = "hello" + " world";
text = text + " number " + 5;
//
text = "hello world number 5"
Conversion by casting
int
a = 2;
// a = 2
double a = 2;
// a = 2.0 (Implicit)
int
a = 18.7;
// ERROR
int a = (int)18.7; // a = 18
double
a = 2/3;
// a = 0.0
double a = (double)2/3; // a =
0.6666
Assignment:
GravityCalculator
Compute
the position of a falling object:
x(t) = 0.5 at2 + vit + xi
Gravitasi,
a = -9.81
Waktu, t = 10.0
Kecepatan awal, vi = 0.0
Posisi awal, xi = 0.0
Hitung posisi akhir,x(t) dimana t =
10.0
Methods
Adding Methods
public static void NAME() {
STATEMENTS
}
To call a method:
NAME();
Parameters
public static void NAME(TYPE NAME)
{
STATEMENTS
}
To call:
NAME(EXPRESSION);
Square
class Square {
public static void printSquare(int x){
System.out.println(x*x);
}
public static void main(String[ ] arguments){
int value = 2;
printSquare(value);
printSquare(3);
printSquare(value*2);
}
}
Whats wrong here?
class Square2 {
public static void printSquare(int x){
System.out.println(x*x);
}
public static void main(String[ ]
arguments){
printSquare("hello");
printSquare(5.5);
}
}
Multiple Parameters
[] NAME(TYPE NAME, TYPE
NAME) { STATEMENTS
}
To
call:
NAME(arg1, arg2);
class Multiply {
public static void times (double a, double b){
System.out.println(a * b);
}
public static void main(String[ ] arguments){
times (2, 2);
times (3, 4);
}
}
Return Values
public static TYPE NAME() {
STATEMENTS
return EXPRESSION;
}
class Square3 {
public static void printSquare(double x){
System.out.println(x*x);
}
public static void main(String[ ]
arguments){
printSquare(5);
}
}
class Square4 {
public static double square(double x){
return x*x;
}
public static void main(String[ ]
arguments){
System.out.println(square(5));
System.out.println(square(2));
}
}
Variable Scope
Variables
live in the block ( { } )
where they are defined (scope)
Method parameters are like defining
a new variable in the method
class SquareChange {
public static void printSquare(int x){
System.out.println("printSquare x = " + x);
x = x * x;
System.out.println("printSquare x = " + x);
}
public static void main(String[] arguments){
int x = 5;
System.out.println("main x = " + x);
printSquare(x);
System.out.println("main x = " + x);
}
}
class Scope {
public static void main(String[] arguments){
int x = 5;
if (x == 5){
int x = 6;
int y = 72;
System.out.println("x = " + x + " y = " + y);
}
System.out.println("x = " + x + " y = " + y);
}
}
Methods: Building
Blocks
Big
programs are built out of small
methods
Methods can be individually
developed, tested and reused
User of method does not need to
know how it works
In Computer Science, this is called
abstraction
Mathematical Functions
Math.sin(x)
Math.cos(Math.PI
Math.pow(2,
/ 2)
3)
Math.log(Math.log(x + y))
if statement
if (CONDITION) {
STATEMENTS
}
public static void test(int x){
if (x > 5){
System.out.println(x + " is >
5");
}
}
public static void main(String[]
arguments){ test(6); test(5); test(4);
}
Comparison operators
x
> y: x is greater than y
x < y: x is less than y
x >= y: x is greater than or equal to
x
x <= y: x is less than or equal to y
x == y: x equals y
( equality: ==, assignment: = )
Boolean operators
&&:
logical AND
||: logical OR
else
if (CONDITION) {
STATEMENTS
} else {
STATEMENTS
}
public static void test(int x){
if (x > 5){
System.out.println(x + " is > 5");
} else {
System.out.println(x + " is not > 5");
}
}
public static void main(String[]
arguments){ test(6); test(5); test(4);
}
else if
if (CONDITION) {
STATEMENTS
} else if (CONDITION) {
STATEMENTS
} else if (CONDITION) {
STATEMENTS
} else {
STATEMENTS
}
public static void test(int x){
if (x > 5){
System.out.println(x + " is > 5");
} else if (x == 5){
System.out.println(x + " equals 5");
} else {
System.out.println(x + " is < 5");
}
}
Questions?
Conversion by method
int
to String:
String five = 5; // ERROR!
String five = Integer.toString (5);
String five = + 5; // five = 5
String
to int:
int foo = 18; // ERROR!
int foo = Integer.parseInt (18);
Comparison operators
Do
NOT call == on doubles! EVER.
double
a = Math.cos (Math.PI / 2);
double b = 0.0;
a
= 6.123233995736766E-17
a == b will return FALSE
Frequent Issues
The
signature of the main method
cannot be modified.
public static void main(String[ ]
arguments) {
...
}
Frequent Issues
Return
values:
if you declare that the method is not void, then it has
to return something!
public
static int bayar(double wg, int jam) {
if (wg < 15000) return -1;
else if (jam > 60) return -1;
else {
int upah = 0;
return upah;
}
}
Frequent Issues
Don't
create duplicate variables with the
same name (in the same scope)
public static int bayar(double wg, int jam) {
int upah = 0; // OK
int upah = 0; // upah sudah didefinisikan!!
double upah = 0; // upah sudah didefinisikan!!
What we have learned
so far
Variables
& types
Operators
Type conversions & casting
Methods & parameters
If statement
Question
Good Programming Style
The
goal of good style is to make
your code more readable.
By you and
by others
Rule #1:
use good (meaningful)
names
String a1;
int a2;
double b;
// BAD!!
String firstName; // GOOD
String lastName; // GOOD
int temperature; // GOOD
Rule #2:
Use indentation
public static void main (String[ ]
arguments) {
int x = 5;
x = x * x;
if (x > 20) {
System.out.println(x + > 20 );
}
double y = 3.4;
}
Rule #3:
Use whitespaces
Put
whitespaces in complex
expressions:
// BAD!!
double cel=fahr*42.0/(13.0-7.0);
// GOOD
double cel = fahr * 42.0 / (13.0 -7.0);
Rule #3:
Use whitespaces
Put
blank lines to improve readability:
public static void main (String[] arguments) {
int x = 5;
x = x * x;
if (x > 20) {
System.out.println(x + is > 20.);
}
double y = 3.4;
}
Rule #4:
Do not duplicate tests
if (minJam < 8.0) {
...
} else if (jmlJam > 60) {
...
} else if (minJam >= 8.0 && jmlJam
<= 60) {
...
}
BA
Good programming style
Summary
Use
good names for variables and
methods
Use
indentation
Add
whitespaces
Don't
duplicate tests
Loops
Loop
operators allow to loop through
a block of code.
There are several loop operators in
Java.
The while operator
while (condition) {
statements
}
int i= 0;
while(i < 3) {
System.out.println(Rule # + i);
i = i+1;
}
Make sure that your loop has a chance
to finish
The for operator
for (initialization;condition;update){
statements
}
for (inti = 0; i <3; i=i+1)
{ System.out.println(Rule # + i);
}
Note:
i = i+1 may be replaced by i++
int i = 0, j=0;
for ( i=0; i<3;j++ ) {
System.out.println(Rule # + i);
}
Branching Statements
break
terminates a for or while loop
for ( int i = 0; i < 20; i++ ) {
if ( i == 10)
break;
System.out.println(Rule # + i);
}
64
Branching Statements
continue
skips the current iteration of a loop and
proceeds directly to the next iteration
for
( int i = 0; i < 20; i++ ) {
if ( i == 10)
continue;
System.out.println(Rule # + i);
For
(int i = 0; i < 10 ; i ++ ) {
continue ;
if (i % 2) cetak i;
}
Embedded loops
for (int i = 0; i < 3; i++) {
for (int j = 2; j < 4; j++) {
System.out.println (i + + j);
}
}
Scope
of the variable defined in the
initialization: respective for block
Arrays
An
array is an indexed list of values.
You can make an array of any type
int, double, String, etc..
All elements of an array must have
the same type.
Arrays
Example:
double [ ]
Arrays
The
index starts at zero and ends at
length-1.
Example:
int[] values = new int[5];
values[0] = 12; // CORRECT
values[4] = 12; // CORRECT
values[5] = 12; // WRONG!! compiles but
// throws an Exception
// at run-time
Arrays
An
array is defined using
TYPE[ ]
Arrays are just another type.
EXAMPLE
int[ ] values;
// array of int
int[ ][ ] values; // int[ ] is a type
Arrays
To
create an array of a given size, use
the operator new :
int[ ] values = new int[5];
or you may use a variable to specify the
size:
int size = 12;
int[ ] values = new int[size];
Array Initialization
Curly
braces ( { and } ) can be used
to initialize an array.
It can ONLY be used when you
declare the variable.
int[ ] values = { 12, 24, -23, 47 };
Accessing Arrays
To
access the elements of an array,
use the [ ] operator:
values[index]
Example:
int[] values = { 12, 24, -23, 47 };
values[3] = 18; // {12,24,-23,18}
int x = values[1] + 3; // {12,24,23,18}
The length variable
Each
array has a length variable
built-in that contains the length of
the array.
int[ ] values = new int[12];
int size = values.length; // 12
int[ ] values2 = {1,2,3,4,5}
int size2 = values2.length; // 5
A side note : string array
public static void main (String[ ]
arguments)
{ System.out.println(arguments.leng
th);
System.out.println(arguments[0]);
System.out.println(arguments[1]);
}
Combining Loops and
Arrays
Looping
through an array
Example 1:
int[ ] values = new int[5];
for (int i=0; i<values.length; i++) {
values[i] = i;
int y = values[i] * values[i];
System.out.println(y);
}
Looping through an
array
Example
2:
int[ ] values = new int[5];
int i = 0;
while (i < values.length) {
values[i] = i;
int y = values[i] * values[i];
System.out.println(y);
i++;
Popular Issues 1
Array
Index vs Array Value
int[ ] values = {99, 100, 101};
System.out.println(values[0] );
// 99
Popular Issues 2
Curly
braces { } after if/else,
for/while
for(int i= 0; i< 5; i++)
System.out.println(Hi);
System.out.println(Bye);
What does this print?
Popular Issues 3
Variable
initialization
int getMinValue(int[ ] vals) {
int min = 0;
for (int i = 0; i < vals.length; i++) {
if (vals[i] < min) {
min = vals[i]
}
}
}
What if vals = {1,2,3}?
Set min = Integer.MAX_VALUE or vals[0]
Popular Issues 4
Variable
Initialization
int minIdx = getMin(vals)
int secondIdx = 0;
for (int i = 0; i < vals.length; i++) {
if (i == minIdx) continue;
if (vals[i] < vals[secondIdx]) secondIdx
= i;
}
What if vals = {0, 1, 2}?
Popular Issues 5
Defining
a method inside a method
Summary
Programming
Loops
Arrays
Style
Class Constructors
public class CLASSNAME {
CLASSNAME ( ) {
}
CLASSNAME ([ARGUMENTS]) {
}
}
======================//
CLASSNAME obj1 = new CLASSNAME();
CLASSNAME obj2 = new
CLASSNAME([ARGUMENTS])
Constructors
Constructor
name == the class name
No return type never returns anything
Usually initialize fields
All classes need at least one constructor
If you dont write one, defaults to
CLASSNAME () {
}
Constructor
public class Baby {
String name;
boolean isMale;
Baby(String myname, boolean
maleBaby){
name = myname;
isMale = maleBaby;
}
}
Method
public class Baby {
String name = Slim Shady;
...
void sayHi() {
System.out.println( Hi, my name
is.. +
name);
}
}
Method
public class Baby {
String weight = 5.0;
void eat(double foodWeight) {
if (foodWeight >= 0 &&
foodWeight < weight) {
weight = weight + foodWeight;
}
}
}
Class
public class Baby {
String name;
double weight = 5.0;
boolean isMale;
int numPoops = 0;
Baby[ ] siblings;
void sayHi() {
}
void eat(double foodWeight) {
}
}
Classes and Instances
// class Definition
public class Baby {}
// class Instances
Baby shiloh = new Baby(Shiloh JoliePitt,true);
Baby knox = new Baby(Knox Jolie-Pitt,
true);
Accessing fields
Object.FIELDNAME
Baby shiloh = new Baby(Shiloh JoliePitt,true);
System.out.println(shiloh.name);
System.out.println(shiloh.numPoops);
Calling Methods
Object.METHODNAME([ARGUMENTS])
Baby shiloh = new Baby(Shiloh JoliePitt,true);
shiloh.sayHi();
// Hi, my name
is ...
shiloh.eat(1);
References vs Values
Primitives vs References
Primitive
types are basic java types
int, long, double, boolean, char, short,
byte, float
The actual values are stored in the
variable
Reference
types are arrays and
objects
String, int[ ], Baby,
How java stores
primitives
Variables
are like fixed size cups
Primitives are small enough that
they just fit into the cup
How java stores objects
Objects
are too big to fit in a variable
Stored somewhere else
Variable stores a number that locates
the object
How java stores objects
Objects
are too big to fit in a variable
Stored somewhere else
Variable stores a number that locates
the object
References
The
objects location is called a
reference
==
compares the references
Baby shiloh1 = new Baby(shiloh);
Baby shiloh2 = new Baby(shiloh);
Does
shiloh1 == shiloh2? NO
References
Baby
shiloh1 = new Baby(shiloh);
Baby shiloh2 = new Baby(shiloh);
References
Baby
mybaby = new Baby(davy,
true);
mybaby.name = david
References
Baby
mybaby = new Baby(davy,
true);
mybaby.name = david
References
Using
= updates the reference.
baby1 = baby2
References
Using
= updates the reference.
baby1 = baby2
References
using
[ ] or .
Follows the reference to the object
May modify the object, but never the
reference
Imagine
Following directions to a house
Moving the furniture around
Analogous
to
Following the reference to an object
Changing fields in the object
Methods and references
void doSomething(int x, int[] ys, Baby b) {
x = 99; ys[0] = 99;
b.name = 99;
}
...
nt i= 0;
int[] j = {0};
Baby k = new Baby(50, true);
doSomething(i, j, k);
i=? j=? k=?
static
Applies
Means
to fields and methods
the field/method
Is defined for the class declaration,
Is not unique for each instance
static
public class Baby {
static int numBabiesMade = 0;
}
Baby.numBabiesMade = 100;
Baby b1 = new Baby();
Baby b2 = new Baby();
Baby.numBabiesMade = 2;
What
is
b1.numBabiesMade?
b2.numBabiesMade?
static example
Keep
track of the number of babies
that have been made.
public class Baby {
int numBabiesMade = 0;
Baby() {
numBabiesMade += 1;
}
}
static field
Keep
track of the number of babies
that have been made.
public class Baby {
static int numBabiesMade = 0;
Baby() {
numBabiesMade += 1;
}
}
static method
public class Baby {
static void cry(Baby thebaby) {
System.out.println(thebaby.name + cries);
}
}
Or
public class Baby {
void cry() {
System.out.println(name + cries);
}
}
