MODUL V,PBO 1

KONSTRUKTOR
 

TUJUAN:
·         Membuat dan menjelaskan tentang Konstruktor
TEORI SINGKAT:
Konstruktor adalah sebuah tipe khusus dari mehod yang digunakan untuk membuat dan menginisiaslisasi sebuah obhjek baru. Ingat bahwa konstruktor bukan member (yaitu atribut, method, atau inner class dari sebuah objek)
PELAKSANAAN PRAKTIKUM:
Praktik 1. Membuat Konstruktor dan Pemanggilannya
<!–[if gte vml 1]>

Nasabah

public int noId;

private String nama;

private String alamat;

private String identitas;

private String noIdentitas;

double saldo;

 

Nasbah();

Nasabah(noId);

Nasabah(int noId, String nm);

Nasabah(int noId,String nm, double saldo);

Public void lihatAccount()

Void setoran(double jml)

Void pengambilan(double jml)

public static void main(String args)

 

<![endif]–>

 

public class Nasabah{
     public int noId;
     private String nama;
     private String alamat;
     private String identitas;
     private String noIdentitas;
     double saldo;
//KONSTRUKTOR 1
Nasabah(){
     //Konstruktor Default
     }
Konstruktor yang pertama adalah konstruktor non parametric dengan tidak menuliskan satu statemenpun, sehingga tidak menghasilkan apa-apa. Namun berfungsi sebagai konstruktor default.
//KONSTRUKTOR 2
Nasabah(int noId){
     this.noId=noId;
     }
Konstruktor kedua adalah adalah konstruktor dengan satu parameter yang berfungsi untuk mendefinisikan variable noId yang menunjuk kepada variable private noId yang berada di kelas ini. Apabila ada konstruktor tersebut dipanggil melalui objek yang dibentuk kelas ini maka tergantung pemanggilan objek yang digunakan apakah menggunakan parameter atau tidak. Jika menggunakan 1 buah parameter, maka konstruktor ini akan difungsikan.
//KONSTRUKTOR 3
Nasabah(int noId, String nama){
     this.noId=noId;
     this.nama=nama;
     }
Sebagaimana konstruktor kedua, konstruktor ketiga ini berfungsi untuk untuk mendefinisikan variable noId dan nama, sehingga pada saat dipanggil dengan objek yang dibentuk akan melihat parameter dalam pemanggilan objek tersebut. Jika menggunakan dua buah parameter dan sesuai dengan tipe variable maka konstruktor ini akan difungsikan.
//KONSTRUKTOR 4
Nasabah(int noId, String nama, double saldo){
     this.noId=noId;
     this.nama=nama;
     this.saldo=saldo;
     }
Konstruktor yang ke empat sama tetapi mendefinisikan variable saldo agar mempunyai value.
public void lihatAccount(){
     System.out.println(“No.Id         :  “+noId);
     System.out.println(“Nama          :  “+nama);
     System.out.println(“Alamat        :  “+alamat);
     System.out.println(“SALDO         :  “+saldo);
     }
Sedangkan method diatas ini adalah method non static yang dapat dipanggil langsung pada kelas ini. Method void ini berfungsi untuk menampilkan variable-variabel yang akan didefinisikan oleh konstruktor sesuai dengan karakter parameter yang diisikannya.
void setoran(double jml){
     saldo = saldo + jml;
     }
void pengambilan(double jml){
     saldo = saldo – jml;
     }
Sedangkan dua method di atas yaitu method void setoran dan pengambilan akan bekerja sebagai mesin penghitung variable jml yang juga diambil dari dari pendefinisan parameter. Namun pada program praktek ini variable jml belum digunakan karena tidak ada nilai parameter yang mendefinisikan variable jml, sehingga ketika saldo tidak mengalami operasi melalui method setoran dan pengambilan.
Sebagaimana dibawah ini beberapa statemen yang menunjukkan penggunaan konstruktor 1, 2, 3 dan 4. Masing-masing konstruktor berfungsi dan berjalan sesuai dengan karakter parameter yang dimasukkan. Dapat kita lihat pada saat pemanggilan konstruktor 1 parameter tidak diisi sehingga pada tampilan hasil tidak menghasilkan apapun. Pada Konstruktor ke-2 parameter diisi dengan satu parameter sehingga yang akan terisi sewaktu dilakukan pemanggilan method lihatAccaunt(), adalah hanya noId saja. Pada pemanggilan konstruktor ke-3 diisi dengan noId dan nama “pulut”, maka hasil pemanggilan method lihatAccaunt adalah noId, dan nama. Demikian juga dengan konstruktor ke-4 setelah diisi dengan noId, nama saldo 200000 maka yang akan keluar adalah noId, nama dan nilai saldo. Sedangkan alamat tidak pernah keluar atau bernilai null karena tidak ada satupun pendefinisan pada konstruktor variable alamat. Coba lihat pada tampilan hasil program.
public static void main(String []args){
//Pemanggilan Object dengan pemanggilan KONSTRUKTOR 1
     Nasabah nasabah1=new Nasabah();
     System.out.println(“Data Nasabah 1”);
     nasabah1.lihatAccount();
//Pemanggilan Object dengan pemanggilan KONSTRUKTOR 2
     Nasabah nasabah2=new Nasabah(2);
     System.out.println(“Data Nasabah 2”);
     nasabah2.lihatAccount();
//Pemanggilan Object dengan pemanggilan KONSTRUKTOR 3
     Nasabah nasabah3=new Nasabah(3, “Pulut”);
     System.out.println(“Data Nasabah 1”);
     nasabah3.lihatAccount();
//Pemanggilan Object dengan pemanggilan KONSTRUKTOR 4
     Nasabah nasabah4=new Nasabah(4, “Agung”,200000);
     System.out.println(“Data Nasabah 1”);
     nasabah4.lihatAccount();
     }
}
Hasil Running:
               
Akan kita coba membuat satu konstruktor lagi agar dapat mengisi alamat sebagaimana dibawah:
//KONSTRUKTOR 5
Nasabah(int noId, String nama, String alamat, double saldo){
      this.noId=noId;
      this.nama=nama;
      this.alamat=alamat;
      this.saldo=saldo;
      }
Dan statemen untuk pemanggilan konstruktor yang kita buat tadi;
//Pemanggilan Object dengan pemanggilan KONSTRUKTOR 5
      Nasabah nasabah5=new Nasabah(5, “Agung”,”Janti”,200000);
      System.out.println(“Data Nasabah 5”);
      nasabah5.lihatAccount();
Dan hasilnya sebagaimana berikut:
Praktek 2. Menggunakan Konstruktor dari class yang ada di Java
/*Contoh ini diambil dari catatan Dr. Encarnacion*/
class StringConstructorsDemo{
      public static void main(String args[]){
      String s1=new String();//Membuat string kosong
      char chars[]={‘h’,’e’,’l’,’l’,’o’};
      String s2=new String(chars); //s2=”hello”
      byte bytes[]={‘w’,’o’,’r’,’l’,’d’};
      String s3=new String(bytes); //s3=”world”
      String s4=new String(chars, 1, 3);
      String s5=new String(s2);
      String s6=s2;
      System.out.println(s1);
      System.out.println(s2);
      System.out.println(s3);
      System.out.println(s4);
      System.out.println(s5);
      System.out.println(s6);
      }
}
Mari kita bahas praktek yang kedua ini, program java ini memperlihatkan fungsi konstruktor bertipe string. Nilai s1 belum mempunyai nilai pada karena variable string s1 diisi dengan parameter kosong. Artinya s1 tidak mempunyai nilai atau null. Sedangkan pada objek s2 yang dipanggil akan menghasilkan tulisan “hello” karena adanya konstruktor char dengan variabel chars yang diisi dengan array nilai {‘h’,’e’,’l’,’l’,’o’}berupa karakter. Demikian juga pada pada konstruktor byte akan menghasilkan nilai s3 sewaktu dipanggil dengan nilai “world”.  Konstruktor string yang sudah terdapat pada paket java String mempunyai konstruktor dengan tipe penulisan String(chars, 1, 3) yang artinya bahwa variable akan diisi dengan nilai variable chars yang dipanggil mulai dari nilai character pertama sebanyak 3 buah karakter. Chars bernilai deretan karakter “hello” maka dari kiri karakter pertama adalah e, karakterk ke 2 adalah l dan karakter ke 3 adalah l. sehingga menghasilkan tulisan “ell”.  Perlu diingat dalam menghitung deret character atau array pada java dimulai dari angka 0 dan bukan 1. Pada pemanggilan s5 dan s6 sudah jelas, apa dan bagaimana varaiebel tersebut dilakukan.
                Hasil Running Program:
               
LATIHAN:
  1. Buatlah overloading konstruktor untuk kelas Lingkaran (lihat modul2) yaitu konstruktor default dan konstruktor yang berfungsi untuk inisialisasi atribut jejari.
  2. Buat kelas Baru yang terdiri dari metode main yang berfungsi :
  1. Membuat objek dari kelas Lingkaran denga konstruktor yang telah Anda buat (konstruktor default dan konstruktor yag berfungsi untuk inisialisasi jari-jari).
  2. Cek nilai dengan menambahkan nilai atribut jejari dan menampilkan luas Lingkaran.
Pengerjaan:
public class Lingkar{
      double jejari;
Lingkar(){
      jejari=12;
      }
Lingkar(double jejari){
      this.jejari=jejari;
      }
public double luas(){
      return (3.14 * this.jejari * this.jejari);
      }
public double keliling(){
      return (0.5 * this.jejari * this.jejari);
      }
Dengan menambahkan method keliling dengan nilai balik bertipe double yang kita gunakan sebagai fungsi menghitung keliling lingkaran dengan rumus sebagaimana di atas. Pada program ini merupakan contoh konstruktor overloading dimana konstruktor Lingkaran ada dua. Konstruktor pertama non parameter dan yang kedua dengan satu buah parameter bertipe double.
Coba kita lihat hasil dari penampilan konstruktor di bawah ini, konstruktor pertama dengan instan variable yang didefinisikan jejari=12, akan diproses melalui luas dan keliling lingkaran 1. Sedangkan pada konstruktor dengan parameter 20.5 maka akan diproses melalui objek lingkaran 2. Artinya konstruktor tersebut dapat memilih sendiri tipe yang paling sesuai dengan karakter pemanggilnya. Ini yang sering disebut sebagai konstruktor overloading sebagaimana yang lazim dilakukan oleh method overloading juga.
public static void main(String []args){
      Lingkar bunder1=new Lingkar();
      double jembar=bunder1.luas();
      double muter=bunder1.keliling();
      System.out.println(“================================”);
      System.out.println(“Hasil Perhitungan Lingkaran 1 :”);
      System.out.println(“================================”);
      System.out.println(“Luas Lingkaran :”+jembar);
      System.out.println(“Luas Keliling  :”+muter);
      Lingkar bunder2=new Lingkar(20.5);
      System.out.println(“================================”);
      System.out.println(“Hasil Perhitungan Lingkaran 2 :”);
      System.out.println(“================================”);
      System.out.println(“Luas Lingkaran :”+bunder2.luas());
      System.out.println(“Luas Keliling  :”+bunder2.keliling());
      }
}
Hasil Program:
TUGAS:
  1. Lengkapi kelas Segitiga (modul 2) dengan konstruktor default, konstruktor yang menginisalisasi alas dan tinggi.
public class Segitiga{
       //daftar field
       double alas;
       double tinggi;
       //konstruktor
       public Segitiga(){
              tinggi=4;
              alas=6;
              }
       public void setAlas(double alas){
              this.alas=alas;
              }
       public void setTinggi(double tinggi){
              this.tinggi=tinggi;
              }
       //method hitung luas segitiga
       public double luas(){
              return(0.5 * this.alas * this.tinggi);
              }
       public static double luas(double alas, double tinggi){
              return (0.5 * alas * tinggi);
              }
public static void main(String []args){
       Segitiga segitiga1=new Segitiga();
       double luas=segitiga1.luas();
       System.out.println(“================================”);
       System.out.println(“Hasil Perhitungan Segitiga 1 :”);
       System.out.println(“================================”);
       System.out.println(“Luas Segitiga :”+luas);
       Segitiga segitiga2=new Segitiga();
       System.out.println(“================================”);
       System.out.println(“Hasil Perhitungan Segitiga 2 :”);
       System.out.println(“================================”);
       System.out.println(“Luas Lingkaran :”+segitiga2.luas(10,12));
       }
}
Hasil Running:
  1. Lakukan pengujian konstruktor yang telah dibuat!
       //konstruktor
       public Segitiga(){
              tinggi=10.5;
              alas=11.4;
       System.out.println(“Luas Lingkaran :”+segitiga2.luas(3.5,8.9));
  1. Sebutkan konstruktor yang dimiliki kelas Scanner (dalam packet java.util)
Contains the collections framework, legacy collection classes, event model, date and time facilities, internationalization, and miscellaneous utility classes (a string tokenizer, a random-number generator, and a bit array). 
 
Uses of Scanner in java.util
 
Methods in java.util that return Scanner
Scanner.skip(Pattern pattern)
          Skips input that matches the specified pattern, ignoring delimiters.
Scanner.skip(String pattern)
          Skips input that matches a pattern constructed from the specified string.
Scanner.useDelimiter(Pattern pattern)
          Sets this scanner’s delimiting pattern to the specified pattern.
Scanner.useDelimiter(String pattern)
          Sets this scanner’s delimiting pattern to a pattern constructed from the specified
String.
Scanner.useLocale(Locale locale)
          Sets this scanner’s locale to the specified locale.
Scanner.useRadix(int radix)
          Sets this scanner’s default radix to the specified radix.

java.util
Class Scanner

java.lang.Object
  <!--[if gte vml 1]><v:shape
id="_x0000_i1032" type="#_x0000_t75" alt="extended by " style='width:11.25pt;
height:10.5pt'>
<v:imagedata src="file:///C:\Users\De\AppData\Local\Temp\msohtmlclip11\clip_image017.gif"
o:href="http://java.sun.com/j2se/1.5.0/docs/api/resources/inherit.gif"/>
<![endif]-->extended by java.util.Scanner
All Implemented Interfaces:
public final class Scanner
extends Object
implements Iterator<String>

A simple text scanner which can parse primitive types and strings using regular expressions.
A Scanner breaks its input into tokens using a delimiter pattern, which by default matches whitespace. The resulting tokens may then be converted into values of different types using the various nextmethods.
For example, this code allows a user to read a number from System.in:

     Scanner sc = new Scanner(System.in);
     int i = sc.nextInt();

As another example, this code allows longtypes to be assigned from entries in a file myNumbers:

      Scanner sc = new Scanner(new File("myNumbers"));
      while (sc.hasNextLong()) {
          long aLong = sc.nextLong();
      }

The scanner can also use delimiters other than whitespace. This example reads several items in from a string:

     String input = "1 fish 2 fish red fish blue fish";
     Scanner s = new Scanner(input).useDelimiter("\\s*fish\\s*");
     System.out.println(s.nextInt());
     System.out.println(s.nextInt());
     System.out.println(s.next());
     System.out.println(s.next());
     s.close(); 

prints the following output:

     1
     2
     red
     blue 

The same output can be generated with this code, which uses a regular expression to parse all four tokens at once:

     String input = "1 fish 2 fish red fish blue fish";
     Scanner s = new Scanner(input);
     s.findInLine("(\\d+) fish (\\d+) fish (\\w+) fish (\\w+)");
     MatchResult result = s.match();
     for (int i=1; i<=result.groupCount(); i++)
         System.out.println(result.group(i);
     s.close(); 
  1. Buatlah program yang membuat object dari kelas Scanner;
import java.util.Scanner;
public class SegitigaInput{
       //daftar field
       double alas;
       double tinggi;
       //konstruktor
       public SegitigaInput(){
              tinggi=3;
              alas=4;
              }
       public void setAlas(double alas){
              this.alas=alas;
              }
       public void setTinggi(double tinggi){
              this.tinggi=tinggi;
              }
       //method hitung luas segitiga
       public double luas(){
              return(0.5 * this.alas * this.tinggi);
              }
       public static double luas(double alas, double tinggi){
              return (0.5 * alas * tinggi);
              }
public static void main(String []args){
       Scanner masuk=new Scanner(System.in);
       SegitigaInput segitiga1=new SegitigaInput();
       double luas=segitiga1.luas();
       System.out.println(“================================”);
       System.out.println(“Hasil Perhitungan Segitiga 1 :”);
       System.out.println(“(Dgn Variabel Instan tinggi=3, alas=4)”);
       System.out.println(“================================”);
       System.out.println(“Luas Segitiga : “+luas);
       SegitigaInput segitiga2=new SegitigaInput();
       System.out.println(“=====================================”);
       System.out.print(“Masukkan tinggi segitiga 2 : “);
       double ting=masuk.nextDouble();
       System.out.print(“Masukkan alas   segitiga 2 : “);
       double ala=masuk.nextDouble();
       System.out.println(“================================”);
       System.out.println(“Hasil Perhitungan Segitiga 2 :”);
       System.out.println(“(Dengan Variabel input keyboard”);
       System.out.println(“================================”);
       System.out.println(“Luas Lingkaran : “+segitiga2.luas(ting,ala));
       }
}
Hasil Running Program:
KESIMPULAN:
  1. Selain ada method overloading juga ada konstruktor overloading juga. Hampir sama dengan method, konstruktor overloading adalah suatu konstruktor yang mempunyai nama sama tetapi dengan karakter parameter dan pendefinisian variable berbeda, sehingga ketika kita melakukan pemanggilan sebaiknya berhati-hati karena bisa jadi hasil keluaran tidak sesuai dengan yang kita harapkan.
  2.  Program java banyak dilengkapi dengan berbagai method maupun konstruktor bawaan sehingga kita tinggal menggunakan. Sebagaimana method Scanner, dan semacamnya.
Advertisements

Leave a Reply

Please log in using one of these methods to post your comment:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s