Sunday, November 26, 2017

Kelas dan Objek Dalam Java 16: Pewarisan Hibrida


Konsep pewarisan hierarkis ditunjukkan seperti gambar di bawah ini:


Ini berarti bahwa kelas D mewarisi kelas B dan kelas C, dan kedua kelas B dan kelas C mewarisi kelas A. Pewarisan hibrida, secara sederhana, dapat dilakukan oleh kode berikut:


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package PBO1;

interface A {
    public void metodeA();
}

interface B extends A {
    public void metodeB();
}

interface C extends A {
    public void metodeC();
}

class PHibrida implements B, C {
    public void metodeA() {
        System.out.println("Memanggil metodeA");
    }

    public void metodeB() {
        System.out.println("Memanggil metodeB");
    }

    public void metodeC() {
        System.out.println("Memanggil metodeC");
    }
}

public class PewarisanHibrida {
    public static void main(String args[]) {
     PHibrida obj = new PHibrida();
        obj.metodeA();
        obj.metodeB();
        obj.metodeC();
    }
}



KELUARAN PROGRAM:

Memanggil metodeA
Memanggil metodeB
Memanggil metodeC
Pada kasus berikut, kelas Uji mewarisi kelas Siswa. Kemudian kelas Hasil mewarisi kelas Uji dan mengimplementasikan antarmuka Olahraga. Jadi, ini merupakan pewarisan hibrida juga.



 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
package PBO1;

class Siswa
{
    int nomorPendaftaran;
 
 // Ini adalah konstruktor tanpa argumen dari kelas Siswa
 public Siswa() {
  this.nomorPendaftaran = 0;
 }
 
    public void setNomor(int n)
    {
     this.nomorPendaftaran=n;
    }
 
    public void tampilNomor()
    {
        System.out.println("Nomor Pendaftaran :: "+this.nomorPendaftaran);
    }
}

class Uji extends Siswa
{
    float bagian1, bagian2;
 
 // Ini adalah konstruktor tanpa argumen dari kelas Uji
 public Uji() {
  this.bagian1 = 0.0F;
  this.bagian2 = 0.0F;
 }
 
    public void setNilai(float m1,float m2)
    {
     this.bagian1=m1;
        this.bagian2=m2;
    }
 
    public void tampilNilai()
    {
        System.out.println("Nilai yang didapatkan\n");
        System.out.println("BAGIAN1: "+this.bagian1);
        System.out.println("BAGIAN2: "+this.bagian2);
    }
}

interface OlahRaga
{
    float nilaiOlahraga=6.0F;
    void tampilOlahraga();
}

class Hasil extends Uji implements OlahRaga
{
    float total;
 
 // Ini adalah konstruktor tanpa argumen dari kelas Hasil
 public Hasil() {
  this.total = 0.0F;
 }
 
    public void tampilOlahraga()
    {
        System.out.println("Nilai Olahraga="+nilaiOlahraga);
    }
 
    public void tampil()
    {
        this.total=bagian1+bagian2+nilaiOlahraga;
        tampilNomor();
        tampilNilai();
        tampilOlahraga();
        System.out.println("Skor total= "+this.total);
    }
}

class Hibrida
{
    public static void main(String args[])
    {
        Hasil siswa1 = new Hasil();
        siswa1.setNomor(1234);
        siswa1.setNilai(17.4F, 33.0F);
        siswa1.tampil();
    }
}

KELUARAN PROGRAM:

Nomor Pendaftaran :: 0
Nilai yang didapatkan

 BAGIAN1: 0.0
BAGIAN2: 0.0
Nilai Olahraga=6.0
Skor total= 6.0



Kasus pewarisan hibrida dapat diimplementasikan untuk kasus array. KelasRerata mewarisi superkelas KelasArray. KelasVariansi kemudian mewarisi KelasRerata dan mengimplementasikan antarmuka Antarmuka.




 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
package PBO2;
import java.util.*;

public class KelasArray {
 ArrayList<Double> arr = new ArrayList<Double>();
 int ukuran;
 
 // Ini adalah konstruktor tanpa argumen dari kelas KelasRerata
 public KelasArray() {
  this.ukuran = 10;
  arrayAcak(10,this.ukuran);
 }
 
 // Ini adalah konstruktor satu-argumen dari kelas KelasRerata
 public KelasArray(int ukuran) {
  arrayAcak(10,ukuran);
 }
 
 
 /* Ini adalah metode helper untuk membangkitkan
  * array acak yang dipakai untuk konstruktor
  */
 public void arrayAcak(int pengali, int ukuran) {
  ArrayList<Double> arrayKu = new ArrayList<Double>();

        for (int i=0; i<ukuran; i++)
        {
            Random rand = new Random();
            rand.setSeed(System.currentTimeMillis());
            Double r = rand.nextDouble()*1000;
            arrayKu.add(r);

        }
  
  this.arr = arrayKu;
 }
 
 public void inisialisasiArray() {
  // Metode untuk menginisialisasi array
  Scanner s=new Scanner(System.in);

  System.out.println("Masukkan banyak elemen array: ");
  int n=s.nextInt();
 
  // Menciptakan array dengan ukuran dinamis
  ArrayList<Double> arrayKu = new ArrayList<Double>();

  //Membaca array
  System.out.println("Masukkan elemen-elemen array: ");
  int i=0; double temp = 0.0;

  while(i<n){
   temp =s.nextDouble();
   arrayKu.add(temp);
   i++;
  }
  
  this.arr = arrayKu;
 }

}




 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
package PBO2;
import java.util.*;

public class KelasRerata extends KelasArray {
 double rerata;
 
 // Ini adalah konstruktor tanpa argumen dari kelas KelasRerata
 public KelasRerata() {
  this.rerata = 0.0;
 }
 
    //Metode untuk menghitung rerata
 //Menghitung dan menampilkan rerata array
 public void hitungRerata(ArrayList<Double> arrayKu) {
  //Menghitung rerata array dinamis dengan memanfaatkan iterator
  double jum = 0.0; double rerata = 0.0;
  Iterator<Double> itr = arrayKu.iterator();
 
  while(itr.hasNext()){
   jum += itr.next();
  }
  rerata = jum/arrayKu.size();
  this.rerata = rerata;
 }
}






 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
package PBO2;
import java.util.*;

interface Antarmuka
{
    float sportWt=6.0F;
    void tampilkanArray(ArrayList<Double> arrayKu);
}

public class KelasVariansi extends KelasRerata implements Antarmuka{
 double variansi;
 
 //Mengimplementasikan antarmuka
 public void tampilkanArray(ArrayList<Double> arrayKu) {
  System.out.println("Elemen-elemen array: ");
  System.out.println(arrayKu);
 }
 
 // Ini adalah konstruktor tanpa argumen dari kelas KelasVariansi
 public KelasVariansi() {
  this.variansi = 0.0;
 }
 
    // Metode untuk menghitung dan menampilkan variansi array
 public void hitungVariansi(ArrayList<Double> arrayKu, double rerata) {
  // Menghitung dan menampilkan variansi array dengan memanfaatkan iterator
  double variansi = 0.0; double var = 0.0; double temp2 = 0.0;
  Iterator<Double> itr2 = arrayKu.iterator();
 
  while(itr2.hasNext()){
   temp2 = itr2.next();
   var += (temp2-rerata)*(temp2-rerata);
  }
  variansi = var / arrayKu.size();
  this.variansi = variansi;
 }
 
}




 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
package PBO2;

public class PewarisanHibrida {
 public static void main(String args[]){
  //Menciptakan objek KelasVariansi
  KelasVariansi objek1 = new KelasVariansi();

  //Menampilkan isi dari objek KelasVariansi
  //Menggunakan metode tampilkanArray yang diimplementasikan
  //dari antarmuka Antarmuka
  objek1.tampilkanArray(objek1.arr);
  
  
  //========KONSEP PEWARISAN HIBRIDA DI SINI=============
  //Menciptakan objek dari subkelas KelasVariansi
  //Ini berarti memanggil konstruktor default dari
  //superkelas KelasRerata dan konstruktor default dari
  //superkelas atas KelasArray
  System.out.println("\n");
  System.out.println("Nilai-nilai data pada objek2: ");
  KelasVariansi objek2 = new KelasVariansi();
  System.out.println("Array pada objek1 adalah: "+objek2.arr);
    
  
  /* Objek subkelas KelasVariansi dipakai untuk memanggil metode superkelas
   * KelasRerata untuk menghitung rerata menggunakan pewarisan
   */
  System.out.println("\n");
  objek2.hitungRerata(objek2.arr);
  System.out.println("Rerata pada objek2 adalah: "+objek2.rerata);
  
  /* Objek subkelas dipakai untuk memanggil metode dari kelas sama (KelasVariansi)
   * untuk menghitung variansi menggunakan pewarisan
   */
  objek2.hitungVariansi(objek2.arr,objek2.rerata);
  System.out.println("Variansi pada objek2 adalah: "+objek2.rerata);
  
  
  //Objek subkelas objek2 dipakai untuk memanggil metode dari
  //superkelas paling-atas (KelasArray) yaitu metode inisialisasiArray()
  //dan metode tampilkanArray()
  System.out.println("\n");
  System.out.println("Nilai-nilai data pada objek objek2: ");
  objek2.inisialisasiArray();
  objek2.tampilkanArray(objek2.arr);
  //==========================================================
 }
}


KELUARAN PROGRAM:

Elemen-elemen array:
[836.608897938795, 836.608897938795, 836.608897938795, 836.608897938795, 836.608897938795, 836.608897938795, 836.608897938795, 836.608897938795, 836.608897938795, 836.608897938795]
Nilai-nilai data pada objek2:
Array pada objek1 adalah: [836.2505708499751, 836.2505708499751, 836.2505708499751, 836.2505708499751, 836.2505708499751, 836.2505708499751, 836.2505708499751, 836.2505708499751, 836.2505708499751, 836.2505708499751]
Rerata pada objek2 adalah: 836.250570849975
Variansi pada objek2 adalah: 836.250570849975
Nilai-nilai data pada objek objek2:
Masukkan banyak elemen array:
3
Masukkan elemen-elemen array:
1.1
2.2
3.3
Elemen-elemen array:
[1.1, 2.2, 3.3]


Posted by at No comments:

Kelas dan Objek Dalam Java 15: Pewarisan Hierarkis


Konsep pewarisan hierarkis ditunjukkan seperti gambar di bawah ini:


Ini berarti bahwa KelasB mewarisi KelasA, dan KelasC juga mewarisi KelasA. Pewarisan hierarkis, secara sederhana, dapat dilakukan oleh kode berikut:

======================================================================
Hal ini diilustrasikan pada kode ini:


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package tugasPBO;

class Orang{
 void makan(){System.out.println("sedang makan...");}
}

class Remaja extends Orang{
 void bohong(){System.out.println("suka berbohong...");}
}

class Balita extends Orang{
 void nangis(){System.out.println("menangis...");}
}

public class PewarisanHierarkis {
 public static void main(String args[]){
  Bayi d = new Bayi();
  d.makan();
  d.nangis();
  
  //d.bohong();  Error!
 }
}

KELUARAN PROGRAM:

sedang makan...
menangis...

========================================================================

Dari kode di atas dapat dilihat bahwa kelas Remaja mewarisi kelas Orang. Jadi, objek-objek dari kelas Remaja dapat menggunakan metode maupun data dari kelas yang diwarisinya (kelas Orang). Begitu pula, kelas Balita mewarisi kelas Orang. Jadi, objek-objek dari kelas Balita dapat menggunakan metode maupun data dari kelas yang diwarisinya (kelas Orang).

Pada kasus di atas, sebuah objek Balita, yaitu d, dapat memanggil metode  makan() dari kelas Orang, dalam hal ini kelas Orang. 


========================================================================
Untuk kasus yang lebih kompleks, berikut dituliskan kode untuk menerapkan konsep pewarisan hierarkis. Pada kasus ini, kelas KelasVariansi mewarisi KelasArray, dan KelasRerata juga mewarisi KelasArray. 


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
package PBO1;
import java.util.*;

public class KelasArray {
 ArrayList<Double> arr = new ArrayList<Double>();
 int ukuran;
 
 // Ini adalah konstruktor tanpa argumen dari kelas KelasRerata
 public KelasArray() {
  this.ukuran = 10;
  arrayAcak(10,this.ukuran);
 }
 
 // Ini adalah konstruktor satu-argumen dari kelas KelasRerata
 public KelasArray(int ukuran) {
  arrayAcak(10,ukuran);
 }
 
 
 /* Ini adalah metode helper untuk membangkitkan
  * array acak yang dipakai untuk konstruktor
  */
 public void arrayAcak(int pengali, int ukuran) {
  ArrayList<Double> arrayKu = new ArrayList<Double>();

        for (int i=0; i<ukuran; i++)
        {
            Random rand = new Random();
            rand.setSeed(System.currentTimeMillis());
            Double r = rand.nextDouble()*1000;
            arrayKu.add(r);

        }
  
  this.arr = arrayKu;
 }
 
 public void inisialisasiArray() {
  // Metode untuk menginisialisasi array
  Scanner s=new Scanner(System.in);

  System.out.println("Masukkan banyak elemen array: ");
  int n=s.nextInt();
 
  // Menciptakan array dengan ukuran dinamis
  ArrayList<Double> arrayKu = new ArrayList<Double>();

  //Membaca array
  System.out.println("Masukkan elemen-elemen array: ");
  int i=0; double temp = 0.0;

  while(i<n){
   temp =s.nextDouble();
   arrayKu.add(temp);
   i++;
  }
  
  this.arr = arrayKu;
 }
 
 //Metode untuk menampilkan array
 public void tampilkanArray(ArrayList<Double> arrayKu) {
  System.out.println("Elemen-elemen array: ");
  System.out.println(arrayKu);
 }
}


========================================================================


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
package PBO1;
import java.util.*;

public class KelasRerata extends KelasArray {
 double rerata;
 
 // Ini adalah konstruktor tanpa argumen dari kelas KelasRerata
 public KelasRerata() {
  this.rerata = 0.0;
 }
 
    //Metode untuk menghitung rerata
 //Menghitung dan menampilkan rerata array
 public void hitungRerata(ArrayList<Double> arrayKu) {
  //Menghitung rerata array dinamis dengan memanfaatkan iterator
  double jum = 0.0; double rerata = 0.0;
  Iterator<Double> itr = arrayKu.iterator();
 
  while(itr.hasNext()){
   jum += itr.next();
  }
  rerata = jum/arrayKu.size();
  this.rerata = rerata;
 }
}
========================================================================


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package PBO1;
import java.util.*;

public class KelasVariansi extends KelasArray {
 double variansi;
 
 // Ini adalah konstruktor tanpa argumen dari kelas KelasVariansi
 public KelasVariansi() {
  this.variansi = 0.0;
 }
  
    // Metode untuk menghitung dan menampilkan variansi array
 public void hitungVariansi(ArrayList<Double> arrayKu, double rerata) {
  // Menghitung dan menampilkan variansi array dengan memanfaatkan iterator
  double variansi = 0.0; double var = 0.0; double temp2 = 0.0;
  Iterator<Double> itr2 = arrayKu.iterator();
 
  while(itr2.hasNext()){
   temp2 = itr2.next();
   var += (temp2-rerata)*(temp2-rerata);
  }
  variansi = var / arrayKu.size();
  this.variansi = variansi;
 }
 
}

========================================================================


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
package PBO1;

public class PewarisanHierarkis {
 public static void main(String args[]){
  //Menciptakan sebuah objek superkelas (KelasArray)
  //Ini juga berarti memanggil konstruktor default
  //tanpa-argumen dari superkelas
  KelasArray objekSuper = new KelasArray();
  
  //Objek superkelas dipakai untuk memanggil metode dari superkelas (KelasArray)
  System.out.println("Nilai-nilai data pada objek objekSuper (superkelas): ");
  objekSuper.tampilkanArray(objekSuper.arr);
  
  //Menciptakan sebuah objek superkelas (KelasArray) lain
  //Ini juga berarti memanggil konstruktor
  //satu-argumen dari superkelas
  KelasArray objekSuper2 = new KelasArray(15);
  
  //Objek superkelas objekSuper2 dipakai untuk memanggil metode dari superkelas (KelasArray)
  System.out.println("\n");
  System.out.println("Nilai-nilai data pada objek objekSuper2 (superkelas): ");
  objekSuper2.tampilkanArray(objekSuper2.arr);

  
  //========KONSEP PEWARISAN HIERARKIS SUBKELAS KELASRERATA======
  //Menciptakan objek dari subkelas KelasRerata
  //Ini berarti memanggil konstruktor default dari
  //superkelas KelasArray
  System.out.println("\n");
  System.out.println("====KONSEP PEWARISAN HIERARKIS SUBKELAS KELASRERATA===");
  System.out.println("Nilai-nilai data pada objek1 (subkelas KelasRerata): ");
  KelasRerata objek1 = new KelasRerata();
  System.out.println("Array pada objek1 adalah: "+objek1.arr);
  
  /* Objek subkelas dipakai untuk memanggil metode subkelas KelasRerata
   * untuk menghitung rerata menggunakan pewarisan
   */
  System.out.println("\n");
  objek1.hitungRerata(objek1.arr);
  System.out.println("Rerata pada objek1 adalah: "+objek1.rerata);
  
  //Objek subkelas objek1 dipakai untuk memanggil metode dari
  //superkelas (KelasArray) yaitu metode inisialisasiArray()
  //dan metode tampilkanArray()
  System.out.println("\n");
  System.out.println("Nilai-nilai data pada objek objek1 (subkelas KelasRerata): ");
  objek1.inisialisasiArray();
  objek1.tampilkanArray(objek1.arr);
  System.out.println("=================================================");
  //================================================================
  
  
  //=======KONSEP PEWARISAN HIERARKIS SUBKELAS KELASVARIANSI=====
  //Menciptakan objek dari subkelas KelasVariansi
  //Ini berarti memanggil konstruktor default dari
  //superkelas KelasArray
  System.out.println("\n");
  System.out.println("=====KONSEP PEWARISAN HIERARKIS SUBKELAS KELASVARIANSI======");
  System.out.println("Nilai-nilai data pada objek2 (subkelas KelasVariansi): ");
  KelasVariansi objek2 = new KelasVariansi();
  System.out.println("Array pada objek2 adalah: "+objek2.arr);
  
  /* Objek subkelas dipakai untuk memanggil metode subkelas KelasVariansi
   * untuk menghitung rerata menggunakan pewarisan
   */
  System.out.println("\n");
  objek2.hitungVariansi(objek2.arr,objek1.rerata);
  System.out.println("Variansi pada objek2 adalah: "+objek2.variansi);
  
  //Objek subkelas objek2 dipakai untuk memanggil metode dari
  //superkelas (KelasArray) yaitu metode inisialisasiArray()
  //dan metode tampilkanArray()
  System.out.println("\n");
  System.out.println("Nilai-nilai data pada objek objek2 (subkelas KelasVariansi): ");
  objek2.inisialisasiArray();
  objek2.tampilkanArray(objek2.arr);
  System.out.println("=================================================");
  //============================================================== 
  
 }
}
========================================================================

KELUARAN PROGRAM:

Nilai-nilai data pada objek objekSuper (superkelas):
Elemen-elemen array:
[200.38069285421145, 200.38069285421145, 200.38069285421145, 200.38069285421145, 200.38069285421145, 200.38069285421145, 200.38069285421145, 200.38069285421145, 200.38069285421145, 200.38069285421145]
Nilai-nilai data pada objek objekSuper2 (superkelas):
Elemen-elemen array:
[200.02238066655275, 200.02238066655275, 200.02238066655275, 200.02238066655275, 200.02238066655275, 200.02238066655275, 200.02238066655275, 200.02238066655275, 200.02238066655275, 200.02238066655275, 200.02238066655275, 200.02238066655275, 200.02238066655275, 200.02238066655275, 200.02238066655275]
========KONSEP PEWARISAN HIERARKIS SUBKELAS KELASRERATA==============
Nilai-nilai data pada objek1 (subkelas KelasRerata):
Array pada objek1 adalah: [199.9327839931866, 199.9327839931866, 199.9327839931866, 199.9327839931866, 199.9327839931866, 199.9327839931866, 199.9327839931866, 199.9327839931866, 199.9327839931866, 199.9327839931866]
Rerata pada objek1 adalah: 199.9327839931866
Nilai-nilai data pada objek objek1 (subkelas KelasRerata):
Masukkan banyak elemen array:
5
Masukkan elemen-elemen array:
1.1
2.2
3.3
4.4
5.5
Elemen-elemen array:
[1.1, 2.2, 3.3, 4.4, 5.5]
========================================================================
========KONSEP PEWARISAN HIERARKIS SUBKELAS KELASVARIANSI==============
Nilai-nilai data pada objek2 (subkelas KelasVariansi):
Array pada objek2 adalah: [190.7130499742572, 190.7130499742572, 190.7130499742572, 190.7130499742572, 190.7130499742572, 190.7130499742572, 190.7130499742572, 190.7130499742572, 190.7130499742572, 190.7130499742572]
Variansi pada objek2 adalah: 85.00349537980435
Nilai-nilai data pada objek objek2 (subkelas KelasVariansi):
Masukkan banyak elemen array:
3
Masukkan elemen-elemen array:
6.6
7.7
8.8
Elemen-elemen array:
[6.6, 7.7, 8.8]
=======================================================================

Posted by at No comments:
Subscribe to: Posts (Atom)