Modul 2 DASAR PEMPROGRAMAN

Monggo di Baca... ^_^

JAWABAN TUGAS 2 PRAKTIKUM DASAR PEMROGRAMAN

A. DASAR TEORI
1. Netbeans dan Eclipse

Pada 1991, sekelompok insinyur Sun dipimpin oleh Patrick Naughton dan James Gosling ingin merancang bahasa komputer untuk perangkat konsumer seperti cable TV Box. Dikarenakan perangkat tersebut tidak memiliki banyak memori, bahasa harus berukuran kecil dan mengandung kode yang liat. Juga karena manufakturmanufaktur berbeda memilih processor yang berbeda pula, maka bahasa harus bebas dari manufaktur manapun. Proyek diberi nama kode ”Green”.
Kebutuhan untuk fleksibilitas, kecil, liat dan kode yang netral terhadap platform mengantar tim mempelajari implementasi Pascal yang pernah dicoba. Niklaus Wirth, pencipta bahasa Pascal telah merancang bahasa portabel yang menghasilkan intermediate code untuk mesin hipotesis. Mesin ini sering disebut dengan mesin maya (virtual machine). Kode ini kemudian dapat digunakan di sembarang mesin yang memiliki interpreter. Proyek Green menggunakan mesin maya untuk mengatasi isu utama tentang netral terhadap arsitektur mesin.
Karena orang–orang di proyek Green berbasis C++ dan bukan Pascal maka kebanyakan sintaks diambil dari C++, serta mengadopsi orientasi objek dan bukan prosedural. Mulanya bahasa yang diciptakan diberi nama ”Oak” oleh James Gosling yang mendapat inspirasi dari sebuah pohon yang berada pada seberang kantornya, namun dikarenakan nama Oak sendiri merupakan nama bahasa pemrograman yang telah ada sebelumnya, kemudian SUN menggantinya dengan JAVA. Nama JAVA sendiri terinspirasi pada saat mereka sedang menikmati secangkir kopi di sebuah kedai kopi yang kemudian dengan tidak sengaja salah satu dari mereka menyebutkan kata JAVA yang mengandung arti asal bijih kopi. Akhirnya mereka sepakat untuk memberikan nama bahasa pemrograman tersebut dengan nama Java.
Java telah mengakomodasi hampir seluruh fitur penting bahasa–bahasa pemrograman yang ada semenjak perkembangan komputasi modern manusia :
1. Dari SIMULA, bahasa pada tahun 65-an, bahasa yang paling mempengaruhi Java sekaligus C++. Dari bahasa ini diadopsi bentukan–bentukan dasar dari pemrograman berorientasi objek.
2. Dari LISP – bahasa tahun 55-an. Diadopsi fasilitas garbage collection, serta kemampuan untuk meniru generic list processing, meski fasilitas ini jarang yang memanfaatkannya.
3. Dari Algol – bahasa pada tahun 60-an, diambil struktur kendali yang dimilikinya.
4. Dari C++, diadopsi sintaks, sebagian semantiks dan exception handling
5. Dari bahasa Ada, diambil strongly type, dan exception handling.
6. Dari Objective C, diambil fasilitas interface.
7. Dari bahasa SmallTalk, diambil pendekatan single-root class hiérarchie, dimana object adalah satu kesatuan hirarki pewarisan
8. Dari bahasa Eiffel, fasilitas assertion yang mulai diterapkan di sebagian JDK 1.4

2. Penulisan Program di Java, Input, Output
Sekarang, kita akan mencoba untuk menganalisa program Java pertama :
public class Hello
{
/**
* My first java program
*/
public static void main(String[] args)
{
//menampilkan string ”Hello world” pada layar
System.out.println("Hello world!");
}
}
Baris pertama kode :

public class Hello

menandakan nama class yaitu Hello. Dalam Java, semua kode seharusnya ditempatkan di dalam deklarasi class. kita melakukannya dengan menggunakan kata kunci class. Sebagai tambahan, class menggunakan access specifier public, yang mengindikasikan bahwa class kita mempunyai akses bebas ke class yang lain dari package yang lain pula (package merupakan kumpulan class-class). Kita akan membahas lebih dalam mengenai package dan access specifier pada pembahasan selanjutnya.
Baris berikutnya yaitu yang terdiri atas kurung kurawal { menandakan awal blok. Pada kode ini, kita menempatkan kurung kurawal pada baris selanjutnya setelah deklarasi class, bagaimanapun, kita dapat juga meletakkan kurung kurawal ini setelah baris pertama dari kode yang kita tulis. Jadi, kita dapat menulis kode kita sebagai berikut :

public class Hello
{
atau
public class Hello {

Tiga baris selanjutnya menandakan adanya komentar Java. Komentar adalah sesuatu yang digunakan untuk mendokumentasikan setiap bagian dari kode yang ditulis. Komentar bukan merupakan bagian dari program itu sendiri, tetapi digunakan untuk tujuan dokumentasi. Komentar itu sendiri dapat ditambahkan pada kode yang Anda tulis sebagai petunjuk yang dapat membantu proses pembelajaran pemrograman yang baik.

/**
* My first java program
*/

Komentar dinyatakan dengan tanda “/*” dan “*/”. Segala sesuatu yang ada diantara tanda tersebut diabaikan oleh compiler Java, dan mereka hanya dianggap sebagai komentar. Baris selanjutnya,

public static void main(String[] args){
atau dapat juga ditulis sebagai berikut,
public static void main(String[] args)
{
mengindikasikan nama suatu method dalam class Hello yang bertindak sebagai method utama. Method utama adalah titik awal dari suatu program Java. Semua program kecuali applet yang ditulis dalam bahasa Java dimulai dengan method utama. Yakinkan untuk mengikuti kaidah penulisan tanda yang benar. Baris selanjutnya juga merupakan komentar,

//Menampilkan string "Hello world" pada layar
Sekarang kita mempelajari 2 cara untuk membuat komentar. Cara pertama adalah dengan menempatkan komentar dalam /* dan */, dan cara yang lain adalah dengan menuliskan tanda // pada awal komentar

System.out.println("Hello world!");

menampilkan teks “Hello World!” pada layar. Perintah System.out.println(), menampilkan teks yang diapit oleh tanda double pute (“ ”) pada layar.
Dua baris terakhir yang terdiri atas dua kurung kurawal digunakan untuk menutup method utama dan masing-masing class secara berurutan.

3. Operator: Assigment, Matematika, Perbandingan, Logika
Assignment, Arithmetic, and Unary Operators
The Simple Assignment Operator
One of the most common operators that you'll encounter is the simple assignment operator "=". You saw this operator in the Bicycle class; it assigns the value on its right to the operand on its left:
 int cadence = 0;
 int speed = 0;
 int gear = 1;
This operator can also be used on objects to assign object references, as discussed in Creating Objects.
The Arithmetic Operators
The Java programming language provides operators that perform addition, subtraction, multiplication, and division. There's a good chance you'll recognize them by their counterparts in basic mathematics. The only symbol that might look new to you is "%", which divides one operand by another and returns the remainder as its result.
+       additive operator (also used for
        String concatenation)
-       subtraction operator
*       multiplication operator
/       division operator
%       remainder operator
The following program, ArithmeticDemo, tests the arithmetic operators.

class ArithmeticDemo {

    public static void main (String[] args){
       
        // result is now 3
        int result = 1 + 2;
        System.out.println(result);

        // result is now 2
        result = result - 1;
        System.out.println(result);

        // result is now 4
        result = result * 2;
        System.out.println(result);

        // result is now 2
        result = result / 2;
        System.out.println(result);

        // result is now 10
        result = result + 8;
        // result is now 3
        result = result % 7;
        System.out.println(result);
    }
}
You can also combine the arithmetic operators with the simple assignment operator to create compound assignments. For example, x+=1; and x=x+1; both increment the value of x by 1.
The + operator can also be used for concatenating (joining) two strings together, as shown in the following ConcatDemo program:

class ConcatDemo {
    public static void main(String[] args){
        String firstString = "This is";
        String secondString = " a concatenated string.";
        String thirdString = firstString+secondString;
        System.out.println(thirdString);
    }
}
By the end of this program, the variable thirdString contains "This is a concatenated string.", which gets printed to standard output.
The Unary Operators
The unary operators require only one operand; they perform various operations such as incrementing/decrementing a value by one, negating an expression, or inverting the value of a boolean.
+       Unary plus operator; indicates
        positive value (numbers are
        positive without this, however)
-       Unary minus operator; negates
        an expression
++      Increment operator; increments
        a value by 1
--      Decrement operator; decrements
        a value by 1
!       Logical complement operator;
        inverts the value of a boolean
The following program, UnaryDemo, tests the unary operators:

class UnaryDemo {

    public static void main(String[] args){
        // result is now 1
        int result = +1;
        System.out.println(result);
        // result is now 0
        result--;
        System.out.println(result);
        // result is now 1
        result++;
        System.out.println(result);
        // result is now -1
        result = -result;
        System.out.println(result);
        boolean success = false;
        // false
        System.out.println(success);
        // true
        System.out.println(!success);
    }
}
The increment/decrement operators can be applied before (prefix) or after (postfix) the operand. The code result++; and ++result; will both end in result being incremented by one. The only difference is that the prefix version (++result) evaluates to the incremented value, whereas the postfix version (result++) evaluates to the original value. If you are just performing a simple increment/decrement, it doesn't really matter which version you choose. But if you use this operator in part of a larger expression, the one that you choose may make a significant difference.
The following program, PrePostDemo, illustrates the prefix/postfix unary increment operator:

class PrePostDemo {
    public static void main(String[] args){
        int i = 3;
        i++;
        // prints 4
        System.out.println(i);
        ++i;  
        // prints 5
        System.out.println(i);
        // prints 6
        System.out.println(++i);
        // prints 6
        System.out.println(i++);
        // prints 7
        System.out.println(i);
    }
}



 
4. Tingkatan Operator

Operator
Operator adalah karakter khusus yang memerintahkan compiler untuk melakukan operasi terhadap sejumlah operand . Perintah operasi dispesifikasikan oleh operator yang operandnya berupa variabel , pernyataan atau konstanta
Menurut tempatnya dan Operand yang diproses, operator dibagi menjadi 5 yaitu :
• Operator unary : Operator yang mengolah satu operand
• Operator prefix : Operator yang ditempatkan sebelum operand
• Operator biner infiks : Operator yang ditempatkan diantara dua operand
• Operator postfiks : Operator yang ditempatkan setelah operand .
• Operator ternary : Operator yang membutuhkan tiga operand
Menurut jenisnya operator dasar Java ada 4 yaitu : aritmatika, bitwise,relasi dal logika.

Operator dan Aritmatika
Digunakan untuk proses matematika . Operator aritmatika tidak bisa digunakan untuk tipe Boolean tetapi dapat digunakan pada tipe char . Anggota dari operator aritmatika sebagai berikut :
Operator Hasil
+ Penjumlahan
+= Persamaan Penjumlahan
- Pengurangan ( unary minus )
-= Persamaan Pengurangan
* Perkalian
*= Persamaan Perkalian
/ Pembagian
/= Persamaan Pembagian
% Modulus (Sisa Pembagian)
%= Persamaan Modulus
++ Penambahan
-- Pengurangan

Contoh :
int a = 1 + 1;
int b = a * 5;
int c = b / 10;
int d = c - 1;
int e = -a;
int x = 42 % 10; //Modulus/Pembagian sisa nilai x =2

i+ = 4; //artinya i = i + 4
j- = 2; //artinya j = j - 2
k* = 3; //artinya k = k * 3
a/ = 2; //artinya a = a/2
b% = 2; //artinya b = b % 2

Operator Bitwise Integer
Tipe numeric integer : long , int , short , char dan byte memiliki operator tambahan yang dapat memodifikasi dan memeriksa bit bit yang menyusun nilainya. Operatornya adalah sebagai berikut :
Operator Hasil
~ Unary Not
& AND
| OR
^ Exclusive OR
>> Shift kanan
>>> Shift kanan , isi dengan nol
<< Shift kiri
&= Pernyatataan AND
|= Pernyataan OR
^= Pernyataan exclusive OR
>>= Pernyataan shift kanan
>>>= Pernyataan shift kanan , isi dengan nol
<<= Pernyataan shift kiri

Operator bitwise mengkonversi bilangan decimal ke dalam bentuk biner kemudian dimanipulasi sesuai dengan operatornya . Contoh :
10 diubah menjadi 1010
~10 hasilnya : NOT 1010 = 0101 ( membalikkan / invers semua bit )
10 & 2 = 1010 10|2= 1010
0010 0010
_____ & ____ |
0010 1010

Operator Relasi
Digunakan untuk membandingkan dua buah nilai , yang dijabarkan pada table berikut :
Operator Hasil
== Sama dengan
!= Tidak sama dengan
> Lebih besar dari
< Lebih kecil dar
>= Lebih besar sama dengan
<= Lebih kecil sama dengan

Semua operator diatas akan menghasilkan nlai Boolean (true dan false ) contoh :

int a = 4
int b = 2
Boolean c = a < b; // c bernilai false

Operator Logika Boolean
Operator ini bekerja pada operand Boolean , yang akan memanipulasi nilai Boolean untuk menghasilkan nilai Boolean pula , contoh :
Operator Hasil
& Logika AND
| Logika OR
^ Logika XOR
|| Hubungan – singkat OR
&& Hubungan – singkat AND
! Hubungan – singkat NOT
&= Pernyataan AND
!= Pernyataan OR
^= Pernyataan XOR
== Sama Dengan
!= Tidak sama dengan
?: Operator tenary if-then-else

Boolean q=true;
Boolean b=false;
Boolean c=a | b;
Boolean d=a & b;

Operator hubungan singkat ( short circuit logical operator) digunakan apabila ada dua operan ( operan kanan dan operan kiri ) dimana operan kanan bergantung pada operan kiri, baik true maupun false.
Contoh : if 9 denom ! = 0 && num / denom > 10)
Keterangan :
       Bila nilai denom = 0 , maka nilainya adalah false sehingga operan kanan tidak akan diperiksa karena hasilnya false sesuai dengan operan kiri.
       Bila nilai denom !=0 , maka nilainya adalah true dan perlu di ANDkan dengan num/denom >10, sehingga operan kiri dan kanan perlu diANDkan untuk mengetahui hasil logikanya (TRUE atau FALSE)
Operator Ternary if – then – else membutuhkan 3 parameter yang bentuknya adalah sebagai berikut ;
Expression ? statement1 : statemen2
Keterangan : Expression berupa pernyataan yang memeriksa besaran Boolean . Jika hasilnya true maka statement1 dijalankan , sebaliknya jika hasilnya false maka statemen2 dijalankan . Syaratnya statement1 dan 2 harus menghasilkan tipe yang sama dan tidak boleh void.
Contoh:
Ratio = denom == 0 ? 0 : num / denom;
Ketika dijalankan Java akanmemeriksa pernyataan disebalah kiri ? ( denom == 0) , jiks denom = 0 maka pernyataan diantara tanda tanda ? dan : akan diperiksa dan ditetapkan sebagai hasil / nilai Ratio, sebaliknya jika tidak sama dengan 0 maka pernyataan num/ denom yang ditetapkan sebagai hasil / nila Ratio.

Preseden Operator
Preseden operator menunjukkan adanya urutan tingkatan operator ( hirarki) yang penjabarannya pada table berikut :
tertinggi
( ) [ ]
++ -- ~ !
* / %
+ -
>> >>> <<
> >= < <=
== !=
&
^
|
&&
||
? :
terendah


5. Percabangan (if, if....else, if...elseif...., switch)
The if-then and if-then-else Statements
The if-then Statement
The if-then statement is the most basic of all the control flow statements. It tells your program to execute a certain section of code only if a particular test evaluates to true. For example, the Bicycle class could allow the brakes to decrease the bicycle's speed only if the bicycle is already in motion. One possible implementation of the applyBrakes method could be as follows:
void applyBrakes() {
    // the "if" clause: bicycle must be moving
    if (isMoving){
        // the "then" clause: decrease current speed
        currentSpeed--;
    }
}
If this test evaluates to false (meaning that the bicycle is not in motion), control jumps to the end of the if-then statement.
In addition, the opening and closing braces are optional, provided that the "then" clause contains only one statement:
void applyBrakes() {
    // same as above, but without braces
    if (isMoving)
        currentSpeed--;
}
Deciding when to omit the braces is a matter of personal taste. Omitting them can make the code more brittle. If a second statement is later added to the "then" clause, a common mistake would be forgetting to add the newly required braces. The compiler cannot catch this sort of error; you'll just get the wrong results.
The if-then-else Statement
The if-then-else statement provides a secondary path of execution when an "if" clause evaluates to false. You could use an if-then-else statement in the applyBrakes method to take some action if the brakes are applied when the bicycle is not in motion. In this case, the action is to simply print an error message stating that the bicycle has already stopped.
void applyBrakes() {
    if (isMoving) {
        currentSpeed--;
    } else {
        System.err.println("The bicycle has already stopped!");
    }
}
The following program, IfElseDemo, assigns a grade based on the value of a test score: an A for a score of 90% or above, a B for a score of 80% or above, and so on.

class IfElseDemo {
    public static void main(String[] args) {

        int testscore = 76;
        char grade;

        if (testscore >= 90) {
            grade = 'A';
        } else if (testscore >= 80) {
            grade = 'B';
        } else if (testscore >= 70) {
            grade = 'C';
        } else if (testscore >= 60) {
            grade = 'D';
        } else {
            grade = 'F';
        }
        System.out.println("Grade = " + grade);
    }
}
The output from the program is:
    Grade = C
You may have noticed that the value of testscore can satisfy more than one expression in the compound statement: 76 >= 70 and 76 >= 60. However, once a condition is satisfied, the appropriate statements are executed (grade = 'C';) and the remaining conditions are not evaluated.
The switch Statement
Unlike if-then and if-then-else statements, the switch statement can have a number of possible execution paths. A switch works with the byte, short, char, and int primitive data types. It also works with enumerated types (discussed in Enum Types), the String class, and a few special classes that wrap certain primitive types: Character, Byte, Short, and Integer (discussed in Numbers and Strings).
The following code example, SwitchDemo, declares an int named month whose value represents a month. The code displays the name of the month, based on the value of month, using the switch statement.

public class SwitchDemo {
    public static void main(String[] args) {

        int month = 8;
        String monthString;
        switch (month) {
            case 1:  monthString = "January";
                     break;
            case 2:  monthString = "February";
                     break;
            case 3:  monthString = "March";
                     break;
            case 4:  monthString = "April";
                     break;
            case 5:  monthString = "May";
                     break;
            case 6:  monthString = "June";
                     break;
            case 7:  monthString = "July";
                     break;
            case 8:  monthString = "August";
                     break;
            case 9:  monthString = "September";
                     break;
            case 10: monthString = "October";
                     break;
            case 11: monthString = "November";
                     break;
            case 12: monthString = "December";
                     break;
            default: monthString = "Invalid month";
                     break;
        }
        System.out.println(monthString);
    }
}
In this case, August is printed to standard output.
The body of a switch statement is known as a switch block. A statement in the switch block can be labeled with one or more case or default labels. The switch statement evaluates its expression, then executes all statements that follow the matching case label.
You could also display the name of the month with if-then-else statements:
int month = 8;
if (month == 1) {
    System.out.println("January");
} else if (month == 2) {
    System.out.println("February");
}
...  // and so on
Deciding whether to use if-then-else statements or a switch statement is based on readability and the expression that the statement is testing. An if-then-else statement can test expressions based on ranges of values or conditions, whereas a switch statement tests expressions based only on a single integer, enumerated value, or String object.
Another point of interest is the break statement. Each break statement terminates the enclosing switch statement. Control flow continues with the first statement following the switch block. The break statements are necessary because without them, statements in switch blocks fall through: All statements after the matching case label are executed in sequence, regardless of the expression of subsequent case labels, until a break statement is encountered. The program SwitchDemoFallThrough shows statements in a switch block that fall through. The program displays the month corresponding to the integer month and the months that follow in the year:

public class SwitchDemoFallThrough {

    public static void main(String[] args) {
        java.util.ArrayList<String> futureMonths =
            new java.util.ArrayList<String>();

        int month = 8;

        switch (month) {
            case 1:  futureMonths.add("January");
            case 2:  futureMonths.add("February");
            case 3:  futureMonths.add("March");
            case 4:  futureMonths.add("April");
            case 5:  futureMonths.add("May");
            case 6:  futureMonths.add("June");
            case 7:  futureMonths.add("July");
            case 8:  futureMonths.add("August");
            case 9:  futureMonths.add("September");
            case 10: futureMonths.add("October");
            case 11: futureMonths.add("November");
            case 12: futureMonths.add("December");
                     break;
            default: break;
        }

        if (futureMonths.isEmpty()) {
            System.out.println("Invalid month number");
        } else {
            for (String monthName : futureMonths) {
               System.out.println(monthName);
            }
        }
    }
}
This is the output from the code:
August
September
October
November
December
Technically, the final break is not required because flow falls out of the switch statement. Using a break is recommended so that modifying the code is easier and less error prone. The default section handles all values that are not explicitly handled by one of the case sections.
The following code example, SwitchDemo2, shows how a statement can have multiple case labels. The code example calculates the number of days in a particular month:

class SwitchDemo2 {
    public static void main(String[] args) {

        int month = 2;
        int year = 2000;
        int numDays = 0;

        switch (month) {
            case 1: case 3: case 5:
            case 7: case 8: case 10:
            case 12:
                numDays = 31;
                break;
            case 4: case 6:
            case 9: case 11:
                numDays = 30;
                break;
            case 2:
                if (((year % 4 == 0) &&
                     !(year % 100 == 0))
                     || (year % 400 == 0))
                    numDays = 29;
                else
                    numDays = 28;
                break;
            default:
                System.out.println("Invalid month.");
                break;
        }
        System.out.println("Number of Days = "
                           + numDays);
    }
}
This is the output from the code:
Number of Days = 29
Using Strings in switch Statements
In Java SE 7 and later, you can use a String object in the switch statement's expression. The following code example, StringSwitchDemo, displays the number of the month based on the value of the String named month:

public class StringSwitchDemo {

    public static int getMonthNumber(String month) {

        int monthNumber = 0;

        if (month == null) {
            return monthNumber;
        }

        switch (month.toLowerCase()) {
            case "january":
                monthNumber = 1;
                break;
            case "february":
                monthNumber = 2;
                break;
            case "march":
                monthNumber = 3;
                break;
            case "april":
                monthNumber = 4;
                break;
            case "may":
                monthNumber = 5;
                break;
            case "june":
                monthNumber = 6;
                break;
            case "july":
                monthNumber = 7;
                break;
            case "august":
                monthNumber = 8;
                break;
            case "september":
                monthNumber = 9;
                break;
            case "october":
                monthNumber = 10;
                break;
            case "november":
                monthNumber = 11;
                break;
            case "december":
                monthNumber = 12;
                break;
            default:
                monthNumber = 0;
                break;
        }

        return monthNumber;
    }

    public static void main(String[] args) {

        String month = "August";

        int returnedMonthNumber =
            StringSwitchDemo.getMonthNumber(month);

        if (returnedMonthNumber == 0) {
            System.out.println("Invalid month");
        } else {
            System.out.println(returnedMonthNumber);
        }
    }
}
The output from this code is 8.
The String in the switch expression is compared with the expressions associated with each case label as if the String.equals method were being used. In order for the StringSwitchDemo example to accept any month regardless of case, month is converted to lowercase (with the toLowerCase method), and all the strings associated with the case labels are in lowercase.
Note: This example checks if the expression in the switch statement is null. Ensure that the expression in any switch statement is not null to prevent a NullPointerException from being thrown.
The while and do-while Statements
The while statement continually executes a block of statements while a particular condition is true. Its syntax can be expressed as:
while (expression) {
     statement(s)
}
The while statement evaluates expression, which must return a boolean value. If the expression evaluates to true, the while statement executes the statement(s) in the while block. The while statement continues testing the expression and executing its block until the expression evaluates to false. Using the while statement to print the values from 1 through 10 can be accomplished as in the following WhileDemo program:

class WhileDemo {
    public static void main(String[] args){
        int count = 1;
        while (count < 11) {
            System.out.println("Count is: " + count);
            count++;
        }
    }
}
You can implement an infinite loop using the while statement as follows:
while (true){
    // your code goes here
}
The Java programming language also provides a do-while statement, which can be expressed as follows:
do {
     statement(s)
} while (expression);
The difference between do-while and while is that do-while evaluates its expression at the bottom of the loop instead of the top. Therefore, the statements within the do block are always executed at least once, as shown in the following DoWhileDemo program:

class DoWhileDemo {
    public static void main(String[] args){
        int count = 1;
        do {
            System.out.println("Count is: " + count);
            count++;
        } while (count < 11);
    }
}

The for Statement
The for statement provides a compact way to iterate over a range of values. Programmers often refer to it as the "for loop" because of the way in which it repeatedly loops until a particular condition is satisfied. The general form of the for statement can be expressed as follows:
for (initialization; termination;
     increment) {
    statement(s)
}
When using this version of the for statement, keep in mind that:
• The initialization expression initializes the loop; it's executed once, as the loop begins.
• When the termination expression evaluates to false, the loop terminates.
• The increment expression is invoked after each iteration through the loop; it is perfectly acceptable for this expression to increment or decrement a value.
The following program, ForDemo, uses the general form of the for statement to print the numbers 1 through 10 to standard output:

class ForDemo {
    public static void main(String[] args){
         for(int i=1; i<11; i++){
              System.out.println("Count is: " + i);
         }
    }
}
The output of this program is:
Count is: 1
Count is: 2
Count is: 3
Count is: 4
Count is: 5
Count is: 6
Count is: 7
Count is: 8
Count is: 9
Count is: 10
Notice how the code declares a variable within the initialization expression. The scope of this variable extends from its declaration to the end of the block governed by the for statement, so it can be used in the termination and increment expressions as well. If the variable that controls a for statement is not needed outside of the loop, it's best to declare the variable in the initialization expression. The names i, j, and k are often used to control for loops; declaring them within the initialization expression limits their life span and reduces errors.
The three expressions of the for loop are optional; an infinite loop can be created as follows:
// infinite loop
for ( ; ; ) {
   
    // your code goes here
}
The for statement also has another form designed for iteration through Collections and arrays This form is sometimes referred to as the enhanced for statement, and can be used to make your loops more compact and easy to read. To demonstrate, consider the following array, which holds the numbers 1 through 10:
int[] numbers = {1,2,3,4,5,6,7,8,9,10};
The following program, EnhancedForDemo, uses the enhanced for to loop through the array:

class EnhancedForDemo {
    public static void main(String[] args){
         int[] numbers =
             {1,2,3,4,5,6,7,8,9,10};
         for (int item : numbers) {
             System.out.println("Count is: " + item);
         }
    }
}
In this example, the variable item holds the current value from the numbers array. The output from this program is the same as before:
Count is: 1
Count is: 2
Count is: 3
Count is: 4
Count is: 5
Count is: 6
Count is: 7
Count is: 8
Count is: 9
Count is: 10
We recommend using this form of the for statement instead of the general form whenever possible.
Branching Statements
The break Statement
The break statement has two forms: labeled and unlabeled. You saw the unlabeled form in the previous discussion of the switch statement. You can also use an unlabeled break to terminate a for, while, or do-while loop, as shown in the following BreakDemo program:
class BreakDemo {
    public static void main(String[] args) {

        int[] arrayOfInts =
            { 32, 87, 3, 589,
              12, 1076, 2000,
              8, 622, 127 };
        int searchfor = 12;

        int i;
        boolean foundIt = false;

        for (i = 0; i < arrayOfInts.length; i++) {
            if (arrayOfInts[i] == searchfor) {
                foundIt = true;
                break;
            }
        }

        if (foundIt) {
            System.out.println("Found " + searchfor + " at index " + i);
        } else {
            System.out.println(searchfor + " not in the array");
        }
    }
}
This program searches for the number 12 in an array. The break statement, shown in boldface, terminates the for loop when that value is found. Control flow then transfers to the statement after the for loop. This program's output is:
Found 12 at index 4
An unlabeled break statement terminates the innermost switch, for, while, or do-while statement, but a labeled break terminates an outer statement. The following program, BreakWithLabelDemo, is similar to the previous program, but uses nested for loops to search for a value in a two-dimensional array. When the value is found, a labeled break terminates the outer for loop (labeled "search"):

class BreakWithLabelDemo {
    public static void main(String[] args) {

        int[][] arrayOfInts = {
            { 32, 87, 3, 589 },
            { 12, 1076, 2000, 8 },
            { 622, 127, 77, 955 }
        };
        int searchfor = 12;

        int i;
        int j = 0;
        boolean foundIt = false;

    search:
        for (i = 0; i < arrayOfInts.length; i++) {
            for (j = 0; j < arrayOfInts[i].length;
                 j++) {
                if (arrayOfInts[i][j] == searchfor) {
                    foundIt = true;
                    break search;
                }
            }
        }

        if (foundIt) {
            System.out.println("Found " + searchfor + " at " + i + ", " + j);
        } else {
            System.out.println(searchfor + " not in the array");
        }
    }
}
This is the output of the program.
Found 12 at 1, 0
The break statement terminates the labeled statement; it does not transfer the flow of control to the label. Control flow is transferred to the statement immediately following the labeled (terminated) statement.
The continue Statement
The continue statement skips the current iteration of a for, while , or do-while loop. The unlabeled form skips to the end of the innermost loop's body and evaluates the boolean expression that controls the loop. The following program, ContinueDemo , steps through a String, counting the occurences of the letter "p". If the current character is not a p, the continue statement skips the rest of the loop and proceeds to the next character. If it is a "p", the program increments the letter count.

class ContinueDemo {
    public static void main(String[] args) {

        String searchMe = "peter piper picked a " + "peck of pickled peppers";
        int max = searchMe.length();
        int numPs = 0;

        for (int i = 0; i < max; i++) {
            // interested only in p's
            if (searchMe.charAt(i) != 'p')
                continue;

            // process p's
            numPs++;
        }
        System.out.println("Found " + numPs + " p's in the string.");
    }
}
Here is the output of this program:
Found 9 p's in the string.
To see this effect more clearly, try removing the continue statement and recompiling. When you run the program again, the count will be wrong, saying that it found 35 p's instead of 9.
A labeled continue statement skips the current iteration of an outer loop marked with the given label. The following example program, ContinueWithLabelDemo, uses nested loops to search for a substring within another string. Two nested loops are required: one to iterate over the substring and one to iterate over the string being searched. The following program, ContinueWithLabelDemo, uses the labeled form of continue to skip an iteration in the outer loop.

class ContinueWithLabelDemo {
    public static void main(String[] args) {

        String searchMe = "Look for a substring in me";
        String substring = "sub";
        boolean foundIt = false;

        int max = searchMe.length() -
                  substring.length();

    test:
        for (int i = 0; i <= max; i++) {
            int n = substring.length();
            int j = i;
            int k = 0;
            while (n-- != 0) {
                if (searchMe.charAt(j++) != substring.charAt(k++)) {
                    continue test;
                }
            }
            foundIt = true;
                break test;
        }
        System.out.println(foundIt ? "Found it" : "Didn't find it");
    }
}
Here is the output from this program.
Found it
The return Statement
The last of the branching statements is the return statement. The return statement exits from the current method, and control flow returns to where the method was invoked. The return statement has two forms: one that returns a value, and one that doesn't. To return a value, simply put the value (or an expression that calculates the value) after the return keyword.
return ++count;
The data type of the returned value must match the type of the method's declared return value. When a method is declared void, use the form of return that doesn't return a value.
return;
The Classes and Objects lesson will cover everything you need to know about writing methods.
(http://docs.oracle.com/javase/tutorial/java/nutsandbolts/)

Jawaban Modul 1 DASPROG

1.      Langkah-langkah pemecahan masalah (TUGAS)

1.      Gelas

Agar isi di di gelas A bisa ditukar ke gelas B kita memerlukan sebuah gelas tambahan untuk tempat penampungan sementara, dan kita namakan gelas tambahan tersebut adalah gelas C dan  dengan menggunakan gelas  C ini sebagai media pertukaran,  algoritma pertukaran isi kedua buah gelas adalah sebagai berikut :

a        Tuangkan air dari Gelas A ke dalam Gelas C.

b        Tuangkan air dari Gelas B ke dalam Gelas A.

c         Tuangkan air dari Gelas B ke dalam Gelas A.

d        Tuangkan air dari Gelas C ke dalam Gelas B.

2.      Ember

Penyelesian :

ALGORITMA Mendapatkan air 4 liter dari dua buah ember bervolume 5 dan 3 liter

Isi penuh ember 3 liter dengan air (ember 3 liter berisi 3 liter air)

Tuangkan air dari ember 3 liter ke dalam ember air 5 liter (ember 5 liter,sekarang berisi 3 liter air)

Isi penuh kembali ember ember 3 liter dengan air (ember 3 liter berisi 3 liter air)

tuangkan air dari ember 3 liter kedalam ember 5 liter hingga penuh (di dalam ember 3 liter sekarang tersisa 1 liter air)

Buang seluruh air dari ember 5 liter air (ember 5 liter kosong)

tuangkan air dari ember 3 liter(yang tersisa 1 liter tadi) kedalam ember 5 liter (ember 5 liter sekarang berisi 1 liter air, ember 3 liter kosong)

Isi penuh ember 3 liter dengan air (ember 3 liter berisi air 3 liter)

Tuangkan air dari ember 3 liter ke dalam ember 5 liter (ember 5 liter sekarang berisi 1 + 3 = 4 liter air)



3. Plastelina Game

Gini nih Caranya :

a.Cara pertama: Seberangkan si 1 detik bersamaan dengan si 3 Detik. Jadi waktu yang tersisa ada 30 – 3 detik yang memegang lampu = 27 detik lagi).
b.Setelah si 3 detik diseberangkan, maka si 1 detik tadi balik ke semula, menjemput yang 6 detik. Sekarang waktu yang tersisa 27 detik – 1 detik yang memegang lampu=26 detik.
c.Sama seperti langkah pertama, si 1 detik dan 6 detik menyebrang ke kiri. Lalu si 1 detik balik lagi. Dengan waktu tersisa 26 detik - 6 detik yang pegang lampu - 1 detik yang balik ke sisi a = sisa 19 detik. 
d.Sekarang. Seberangkan secara bersama-sama si 12 detik (aki-aki) dengan si 8 detik. Disini hanya berkurang 12 detik saja, karena si 12 detik yang pegang lampu. Jadi, waktu tersisa 19 detik - 12 detik yang pegang lampu = 7 detik. 
e.Selanjutnya, yang si 3 detik balik lagi menjemput si 1 detik. Sekarang, waktu tersisa 7 detik - 3 detik yang balik ke sisi a = sisa 4 detik.
f.Terakhir, si 1 detik dan 3 detik menuju sisi kiri bersama-sama. (waktu tersisa 4 detik - 3 detik yang pegang lampu = 1 detik)

PERFECT.................... Selesai deh ^_^ 

4.
 (Canibal Game)
Misal : r1 = Rahib 1
ra2 = Rahib 2
ra3 = Rahib 3
Ka1 = Kanibal 1
Ka2 = Kanibal 2

Ka3 = Kanibal 3
Gini nih maen Gamenya:
a. Pertama Si Kanibal dulu yang harus diseberangkan ke pulau kiri. Seberangkan dua Kanibal, yaitu Ka1 dan Ka2 terlebih dahulu.
b. Setelahni sampai dipulau yang kiri, turunkan salah satu kanibal di kiri, lalu kanibal yang satu kembali ke pulau kanan.
c. Selanjutnya Ka2 seberangkan Ka3 kepulau kiri juga.
d.Setelah sampai di pulau kiri, turunkan Ka2 , lalu Ka3 kembali ke pulau kanan
e. Setelah sampai di pulau kanan, turunkan Ka3 tadi di pulau kanan, terus naikkan Rahib1 dan Rahib2 ke perahu untuk menyeberang ke pulau kiri
f. Keluarkan Rahib1 (r1) di pulau kiri, lalu naikkan Ka1 ke perahu dan seberangkan kembali ke pulau kanan bersama Rahib2 (r2).
g. Keluarkan Ka2 masukkan r3 dari pulau yang kanan, lalu sebrangkan mereka ke pulau kiri.
h.Keluarkan Rahib2 dan Rahib3, lalu Naikkan Kanibal 3 yang tertinggal di kiri tadi,, biarkan Ka3 kembali ke pulau kanan menjemput temannya sesama kanibal.
i. Setelah itu Masukkan Ka1, untuk menyebrangkan ke pulau kiri bersama Ka3 tadi.
j. Setelah sampai di Pulau kiri, turunkan Ka1, lalu Ka3 kembali ke pulau kanan untuk menjemput Ka2.
k. Langkah terakhir, Masukkan K2 lalu sebrangkan ke pulau kiri bersamaan dengan Ka3.
l. Setelah sampai di pulau kiri, turunkan kedua Kanibal tersebut, Selesai deh gamenya.


5. (wolf game)
a. Langkah Pertama : Manusia mengangkut kambingnya dulu menuju Kota kiri, biarkan serigala dan sayuran tetap di kota kanan, karena tidak akan mungkin serigala memakan sayuran itu tadi.

b. Setelah manusia kembali ke kota kanan, sekarang gilaran sayuran yang akan diseberangkkan ke kota kiri. Sampai di Kota kiri, Turunkan Sayuran, dan naikkan kembali si Kambing, seberangkan kembali si kambing ke Kota Kanan.

c. Setelah Kambing diturunkan di Kota kanan, Sekarang seberangkan Serigala ke Kota Kiri

d. Sekarang, Langkah terakhir, jemput kembali si Kabing ke kota kanan tadi, Seberangkan ke Kota Kiri seperti langkah awal.

e. Selesai deh.. Well Done kannn?? 

Mata Kuliah Dasar Pemprograman

1.      Dasar Teori

-         Dasar Teori tentang algoritma dan pemrograman

1.1 Algoritma

Ditinjau dari asal-usul katanya, kata Algoritma sendiri mempunyai sejarah yang aneh. Orang hanya menemukan kata algorism yang berarti proses menghitung dengan angka arab. Anda dikatakan algorist jika Anda menghitung menggunakan angka arab. Para ahli bahasa berusaha menemukan asal kata ini namun hasilnya kurang memuaskan. Akhirnya para ahli sejarah matematika menemukan asal kata tersebut yang berasal dari nama penulis buku arab yang terkenal yaitu Abu Ja’far Muhammad Ibnu Musa Al-Khuwarizmi. Al-Khuwarizmi dibaca orang barat menjadi Algorism. Al-Khuwarizmi menulis buku yang berjudul Kitab Al Jabar Wal-Muqabala yang artinya “Buku pemugaran dan pengurangan” (The book of restoration and reduction). Dari judul buku itu kita juga memperoleh akar kata “Aljabar” (Algebra). Perubahan kata dari algorism menjadi algorithm muncul karena kata algorism sering dikelirukan dengan arithmetic, sehingga akhiran –sm berubah menjadi –thm. Karena perhitungan dengan angka Arab sudah menjadi hal yang biasa, maka lambat laun kata algorithm berangsur-angsur dipakai sebagai metode perhitungan (komputasi) secara umum, sehingga kehilangan makna kata aslinya. Dalam bahasa Indonesia, kata algorithm diserap menjadi algoritma.

1.2  Pemrograman

Pemrograman berasal dar i kata  program  yang diberi awalan pe– dan akhiran –an. Dalam buku ini, program berarti progr am komputer. Pengertian   program   computer menurut John M. Zelle,  Ph.D.  dalam bukunya  yang  berjudul “Python  Programming: An  Introduction to  Computer  Science”  (2002,  p1)  adalah  sekumpulan  instruksi langkah per langkah yang member itahukan mengenai yang harus dilakukan computer secara  tepat.   Pemrograman   adalah  segala  kegiatan  pembuatan  program  computer.

Kemudian  terdapat  pula  istilah   bahasa  pemrograman   yang  berarti  bahasa  yang digunakan dalam pembuatan program komputer. Berdasarkan  pengertian  algor itma  dan  pemrograman,  maka  dapat  dikatakan bahwa  progr am  merupakan  hasil  penerapan  dari  algoritma- algoritma.  Akan  tetapi, dalam  buku  ini  tidak dibahas  materi  mengenai  pembuatan  program  komputer.  Buku ini  memfokuskan teknik-teknik pembuatan  algoritma  itu  sendir i.  Nama  mata  kuliah Algor itma dan Pemrogr aman dalam hal ini berarti mempelajari pembuatan algoritma- algoritma yang dapat diterapkan dalam pemrograman.

-         Karakteristik algoritma

1.      Algoritma harus berhenti setelah mengerjakan sejumlah langkah terbatas. Sebagai contoh, dalam algoritma Euclidean, pada langkah 1, jika n = 0, algoritma berhenti, jika n tidak = 0 maka nilai n selalu berkurang sebagai akibat dari langkah 2 dan 3, dan pada akhirnya nilai n = 0. Program yang tidak pernah berhenti mengindikasikan bahwa program tersebut berisi algoritma yang salah.

2.      Setiap langkah harus di defenisikan dengan tepat dan tidak berarti dua (ambiguous). Pembaca harus mengerti apa yang di maksud dengan “m” dan “n” adalah bilangan bulat tak negatif (-). Contoh lainnya pernyataan ” bagilah p dengan beberapa sejumlah bilangan bulat positif” dapat bermakna ganda. Berapakah yang di maksud dengan “berapa” ? Algoritma menjadi jelas jika langkah tersebut di tulis “bagilah p dengan 10 buah bilangan bulat positif”

3.      Algoritma memiliki nol atau lebih masukan (input). Masukan ialah besaran yang diberikan kepada algoritma untuk di proses. Algoritma Euclidean mempunyai dua buah masukan, yaitu m dan n.

4.      Algoritma mempunya nol atau lebih keluaran (output). Keluaran dapat berupa pesan atau besaran yang memiliki hubungan dengan masukan. Algoritma Euclidean mempunyai 1 keluaran, yaitu m pada langkah 1, yang merupakan pembagi bersama terbesar dari kedua bilangan.

5.      Algoritma harus sangkil (effective). Setiap langkah harus sederhana sehingga dapat di kerjakan dalam sejumlah waktu yang masuk akal.      

-         Flowchart

Selain dalam bentuk tulisan, algoritma juga dapat ditulis dalam  bentuk diagram- diagram dengan anak panah sebagai penunjuk urutan langkah algoritmanya. Algor itma yang ditulis dengan simbol-simbol demikian yang dinamakan  flow chart . Mengenai  lambang- lambang  yang  digunakan  akan  dibahas  pada  bagian selanjutnya. Sekarang diberikan suatu contoh algoritma menentukan bilangan terbesar dar i 3 bilangan seperti yang dicontohkan sebelumnya, tetapi ditulis dalam bentuk flow chart.

-         Psoudecode

Pseudo  berarti imitasi dan  code  ber arti kode yang dihubungkan dengan instruksi yang  ditulis  dalam  bahasa  komputer  (kode  bahasa  pemrograman).  Apabila diterjemahkan  secar a  bebas,  maka  pseudocode  berarti  tiruan  atau  imitasi  dari  kode bahasa pemrograman. Pada  dasarnya,  pseudocode  merupakan  suatu  bahasa  yang  memungkinkan programmer untuk berpikir terhadap per masalahan yang harus dipecahkan tanpa harus memikirkan   syntax   dar i  bahasa  pemrogr aman  yang  tertentu.  Tidak  ada  aturan penulisan   syntax   di  dalam  pseudocode.  Jadi  pseudocode  digunakan  untuk menggambarkan logika urut-urutan dari program tanpa memandang bagaimana bahasa pemrogramannya.

Walaupun pseudocode tidak ada aturan penulisan syntax, di dalam buku ini akan diberikan  suatu aturan-aturan  penulisan syntax yang cukup  seder hana  agar  pembaca dapat  lebih  mudah  dalam  mempelajari algoritma-algor itma  yang  ada  di  dalam  buku ini.  Pseudocode  yang  ditulis  di  dalam  buku  ini  akan  menyerupai  (meniru)  syntax- syntax dalam bahasa Pascal. Namun dibuat sesederhana mungkin sehingga tidak akan ada  kesulitan  bagi  pembaca  untuk  memahami  algoritma- algor itma  dalam  buku  ini walaupun pembaca belum pernah mempelajar i bahasa Pascal.

-         Bahasa pemrograman

Bahasa pemrograman, atau sering diistilahkan juga dengan bahasa komputer, adalah teknik komando/instruksi standar untuk memerintah komputer. Bahasa pemrograman ini merupakan suatu himpunan dari aturan sintaks dan semantik yang dipakai untuk mendefinisikan program komputer. Bahasa ini memungkinkan seorang programmer dapat menentukan secara persis data mana yang akan diolah oleh komputer, bagaimana data ini akan disimpan/diteruskan, dan jenis langkah apa secara persis yang akan diambil dalam berbagai situasi.

Menurut tingkat kedekatannya dengan mesin komputer, bahasa pemrograman terdiri dari:

Bahasa Mesin, yaitu memberikan perintah kepada komputer dengan memakai kode bahasa biner, contohnya 01100101100110

Bahasa Tingkat Rendah, atau dikenal dengan istilah bahasa rakitan (bah.Inggris Assembly), yaitu memberikan perintah kepada komputer dengan memakai kode-kode singkat (kode mnemonic), contohnya MOV, SUB, CMP, JMP, JGE, JL, LOOP, dsb.

Bahasa Tingkat Menengah, yaitu bahasa komputer yang memakai campuran instruksi dalam kata-kata bahasa manusia (lihat contoh Bahasa Tingkat Tinggi di bawah) dan instruksi yang bersifat simbolik, contohnya {, }, ?, <<, >>, &&, ||, dsb.

Bahasa Tingkat Tinggi, yaitu bahasa komputer yang memakai instruksi berasal dari unsur kata-kata bahasa manusia, contohnya begin, end, if, for, while, and, or, dsb.

Sebagian besar bahasa pemrograman digolongkan sebagai Bahasa Tingkat Tinggi, hanya bahasa C yang digolongkan sebagai Bahasa Tingkat Menengah dan Assembly yang merupakan Bahasa Tingkat Rendah.