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:

Post a Comment

Subscribe to: Post Comments (Atom)