laporan java pertemuan 5

Nama  : Martha Natalina Damanik

Kelas : MI 92

Pertemuan 5

Abstract Class, Interface, Inner Class

A.       Abstract class

Abstract class memiliki suatu atau lebih abstract method,biasanya dijadikan kelas induk/super dari kelas-kelas yang membuat objek, dan tidak dapat diinstansiasi.

Program  MakhlukHidup.java

// Program ini bukan fungsi utama karena tidak memeliki public static void main(String [] args) {

public abstract class MakhlukHidup {

//kelas abstract dari kelas MaklukHidup

     protected boolean BisaTerbang = false;

// tipe data Boolean dengan atribut BisaTerbang  dan nilai false

     protected String Nama;

// tipe data String dengan atribut Nama 

     protected int JlhKaki;

// tipe data integer  dengan atribut JlhKaki

     public  MakhlukHidup(String  Nama1,  int  JlhKaki1,boolean

BisaTerbang1) {

//constructor MakhlukHidup

//method MakhlukHidup dengan tipe data String parameter Nama1,tipe data  integer parameter JlhKaki, tipe data Boolean parameter BisaTerbang1

     this.Nama = Nama1;

     // untuk mengeset atribut nama dengan nilai Nama1

     this.JlhKaki = JlhKaki1;

// untuk mengeset atribut JlhKaki dengan nilai Jlhkaki1

     this.BisaTerbang = BisaTerbang1;

     // untuk mengeset atribut BisaTerbang dengan nilai BisaTerbang1

     }

     abstract void bernafas();

     //memanggil abstract method bernafas dan tidak ada implementasi

     public void status() {

     //memanggil abstract method status dan tidak ada implementasi

           System.out.println("Nama : " +Nama);

           //memanggil atribut nama

           System.out.println("Jumlah kaki : " +JlhKaki);

           //memanggil atribut Jumlah kaki

           System.out.println("Bisa terbang : " +BisaTerbang);

          //memanggil atribut bisa terbang

}

}

Program Manusia.java

Ini adalah proram fungsi utama

public class Manusia extends MakhlukHidup {

//kelas Manusia adalah turunan dari kelasMakhlukHidup

     Manusia(String Nama) {

     // constructor Manusia

            // Method Manusia dengan tipe data String dan parameter Nama

           super(Nama,2, false);

           //memanggil kelas induk yaitu kelas MakhlukHidup dengan nama sayuti, jumlah kaki 2 dan bisaterbang false

}

public void bernafas() {

// memanggil method bernafas

     System.out.println(Nama+" bernafas dengan menghirup 02");

     //memanggil atribut nama dengn nilai bernafas denganmenghiup O2

}

public static void main(String [] args) {

//memnggil fungsi utama

     Manusia m = new Manusia ("Sayuti");

     //membuat objek baru dari kelas Manusia yaitu m = memanggil constructor Manusia

     m.status();

            //memanggil method status dari objek m dari kelas Manusia

     m.bernafas();

//memanggil method status dari objek m dari kelas Manusia

     }

}

Hasil output program Manusia

Program Tumbuhan.java

public class Tumbuhan extends MakhlukHidup {

//kelas Tumbuhan  adalah turunan dari kelasMakhlukHidup

     Tumbuhan() {

// constructor Tumbuhan

            // Method Tumbuhan

           super(Nama,0, false);

           //memanggil kelas induk yaitu kelas MakhlukHidup dengan nama Bayam, jumlah kaki 0 dan bisaterbang  false

     }

     public void bernafas() {

            // memanggil method bernafas

           System.out.println(Nama+" bernafas dengan menghirup CO2");

//memanggil atribut nama dengn nilai bernafas denganmenghiup CO2

}

     public static void main(String [] args) {

//memnggil fungsi utama

           Tumbuhan t = new Tumbuhan ("Bayam");

//membuat objek baru dari kelas Tumbuhan yaitu t = memanggil constructor Tumbuhan

           t.status();

           //memanggil method status dari objek t dari kelas Tumbuhan

           t.bernafas();

     //memanggil method bernafas dari objek t dari kelas Tumbuhan

     }

}

B.     Interface

Adalah suatu kelas yang berisi method-method tanpa implementasi, tanpa modifier abstract jika ada atribut maka berlaku sebagai konstata.

Program Pekerjaan. java

interface Pekerjaan {

//interaface dengan nama pekerjaan

     public void namaPekerjaan();

            //method  pekerjaan dan tanpa implementasi

     public void gaji();

//method  gaji  dan tanpa implementasi

}

Program Sasya.java

public class Sasya extends Manusia implements Pekerjaan {

//kelas Sasya turunan kelas Manusia  tempat implementasi dari interface Pekerjaan

     public Sasya() {

            //memanggil method Sasya

            //memanggil constuktor Sasya

           super("Sasya");

           // memanggil constructor kelas induk dengan nama Sasya

     }

     public void namaPekerjaan () {

     //memanggil method namaPekerjaan dari kelas inteface  Pekerjeraan

           System.out.println("Pekerjaan :Sekretaris");

           //memanggil atribut Pekerjaan dengan nilai sekretaris

     }

     public void gaji() {

     // memanggil method gaji dari kelas interface Pekerjaan

           System.out.println("Gaji : Rp. 3.000.00");

//memanggil atribut gaji  dengan nilai Rp.3.000.000

     }

     public static void main(String[] args) {

     //fungsi utama

           Sasya s = new Sasya();

//membuat objek baru dari kelas Sasta yaitu s = memanggil constructor Sasya

           s.status();

           //memanggil method status dari objek s dari kelas Manusia

           s.bernafas();

           //memanggil method bernafas dari objek s dari kelas Manusia

           s.namaPekerjaan();

           //memanggil method namaPekerjaan dari objek s kelas inteface  Pekerjeraan

           s.gaji();

// memanggil method gaji dari objek s kelas interface Pekerjaan

     }

}

Hasil output program Sasya

C.  Inner class

Adalah kelas yang disisipkan did lam kelas yang lain, fungsi untuk mendukung suatu proses yang akan dijalankan oleh kelas utamanya, dan bersifat tersarang dari kelas utamanya.

Program JantungManusia.java

class Orang {

// kelas orang

     private int jumlKaki=2;

     //tipe data integer atribut jumlKaki dengan nilai= 2

     public void dengarBunyiJantung() {

            // method dengarBunyiJantung

           Jantung j =new Jantung();

           //membuat objek baru dengan nama  j =memanggilconstruktor jantung

           j.bunyiJantung();

           //memanggil method BunyiJantung dari objek j kelas Orang

     }

     public void tahanNafas() {

     //method tahanNafas

           System.out.println("Jantung berhenti berdetak!");

     }

//inner class

class Jantung {

//kelas Jantung

     public void bunyiJantung() {

     //memanggil method bunyiJantung dari kelas Orang

           System.out.println("deg...deg...deg...");

     }

     public void istirahat() {

     //method istirahat

           System.out.println("Silangkan ke "+jumlKaki+" kaki.");

           tahanNafas();

     }

}

}

class JantungManusia {

//kelas JantungManusia

     public static void main(String[] args) {

     //fungsi utama

           Orang o = new Orang();

           //membuat  objek baru dengan nama o dari kelas Orang

           Orang.Jantung p = o.new Jantung();

           //membuat  objek baru dengan nama p  dari kelas Orang dan kelas Jantung

           o.dengarBunyiJantung();

//memanggil method dengarBunyiJantung dari  objek o dari kelas Orang dan kelas Jantung

p.istirahat();

//memanggil method istirahat dari p dari kelas Jantung

     }

}

Hasil output JantungManusia

Tugas java 4

Nama       : Martha Natalina Damanik

Mik         : 92

B.Study   : Tugas Java Pertemuan.4

 

Inherentance

Inheritanceatau pewarisan pada pemrograman berorientasi objek merupakan suatu hubungan dua buah kelas atau lebih. Dalam hal ini ada kelas yang memiliki atribut dan metode yang sama dengan kelas lainnya beserta atribut dan metode tambahan yang merupakan sifat khusus kelas yang menjadi turunannya. Sebagai contoh, misalkan ada sebuah kelas Titik yang mempunyai kelas turunan Titik3D:

class Titik
      private integer x
      private integer y
         Titik()
            x < 0
            y < 0
         {end Titik}

         public getX() -> integer
            -> x
         {end getX}

         public getY() -> integer
            -> y
         {end getY}
   {end class}
   class Titik3D: Titik
      private integer z

      Titik3D()
         z <- 0
      {end Titik3D}

         public getZ() -> integer
            -> z
         {end getZ}

   {end class}

Keterkaitan antara kelas Titik dan Titik3D adalah kelas Titik3D merupakan kelas turunan dari kelas Titik. Dalam hal ini kelas Titik disebut dengan kelas dasar atau super classatau base classsedangkan kelas Titik3D disebut sebagai kelas turunan atau derived classatau subclass.
Pada contoh di atas, ketika kelas Titik3D dibuat objeknya maka objek tersebut dapat menggunakan metode yang ada pada kelas Titik walau pada kode programnya metode itu tidak dituliskan, misalkan sebagai berikut:

Titik3D p <-  new Titik3D()
   integer x <-  p.getX()
   integer y <-  p.getY()
   integer z <-  p.getZ()

Keuntungan dari pewarisan adalah tidak perlu mengutak atik kode kelas yang membutuhkan tambahan atribut atau metode saja, karena tinggal membuat kelas turunannya tanpa harus mengubah kode kelas dasarnya. Kelas dasar akan mewariskan semua atribut dan kodenya kecuali konstruktor dan destruktor yang memiliki izin akses publicdan protectedke kelas turunannya dengan izin akses yang sama dengan pada kelas dasar.
Ketika sebuah kelas turunan dibuat objeknya saat eksekusi, maka secara implisit konstruktor kelas dasar dipanggil terlebih dahulu baru kemudian konstruktor kelas turunan dijalankan. Begitu juga saat objek dimusnahkan maka secara destruktor kelas turunan akan dijalankan baru kemudian destruktor kelas dasar dijalankan.

Enkapsulasi

Enkapsulasi adalah pembungkus, pembungkus disini dimaksudkan untuk menjaga suatu proses program agar tidak dapat diakses secara sembarangan atau di intervensi oleh program lain. Konsep enkapsulasi sangat penting dilakukan untuk menjaga kebutuhan program agar dapat diakses sewaktu-waktu, sekaligus menjaga program tersebut.
Dalam kehidupan sehari hari enkapsulasi dapat dimisalkan sebagai arus listrik pada generator, dan sistem perputaran generator untuk menghasilkan arus listrik. Kerja arus listrik tidak mempengaruhi kerja dari sistem perputaran generator, begitu pula sebaliknya. Karena didalam arus listrik tersebut, kita tidak perlu mengetahui bagaimana kinerja sistem perputaran generator, apakah generator berputar kebelakang atau ke depan atau bahkan serong. Begitu pula dalam sistem perputaran generator, kita tidak perlu tahu bagaimana arus listrik, apakah menyala atau tidak.
Begitulah konsep kerja dari enkapsulasi, dia akan melindungi sebuah program dari akses ataupun intervensi dari program lain yang mempengaruhinya. Hal ini sangat menjaga keutuhan program yang telah dibuat dengan konsep dan rencana yang sudah ditentukan dari awal.
Contoh dalam program
Belajar.Java
class belajar{
public String x =”Pintar”;
private String y = “Java”;
}
Pintar.Java
public class Pintar{
public static void main(String[]args){
Coba panggil = new Belajar();
System.out.println(“Panggil X : “+panggil.x);
System.out.println(“Panggil Y : “+panggil.y);
}}
Tipe public dan private mempunyai fungsi yang berbeda. Fungsi public yang terdapat dalam class Coba pada variable x, memungkinkan nilai dari variable x dapat diakses oleh class Belajar. Sedangkan variable y yang menggunakan fungsi private tidak dapat dipanggil didalam class Belajar.

Polymorphisme

Polymorphism, suatu aksi yang memungkinkan pemrogram menyampaikan pesan tertentu keluar dari hirarki obyeknya, dimana obyek yang berbeda memberikan tanggapan/respon terhadap pesan yang sama sesuai dengan sifat masing-masing obyek.
Atau Polymorphic dapat berarti banyak bentuk, maksudnya yaitu kita dapat menimpa (override), suatu method, yang berasal dari parent class (super class) dimana object tersebut diturunkan, sehingga memiliki kelakuan yang berbeda.
Contoh program java nya :
Simpan dengan nama BeautyfullMahasiswa.java
public class BeautyfullMahasiswa extends Mahasiswa{
public void printNama(){
System.out.println(“Hallo, saya Mahasiswa yg cantik n baik”);
Super.printNama();
}
}
Simpan dengan nama Main.java
public class Main{
public static void main(String[] args]) {
BeautyfullMahasiswa mhs = new BeautyfullMahasiswa();
mhs.setNim(“09530524”);
mhs.setNama(“Afrida Asna”);
mhs.printNim();
mhs.printNama();
}
}
Kemudian compile dan run.
C:\>javac BeautyfullMahasiswa.java
C:\>javac Main.java
C:\>java Main
Kontruksi objek mahasiswa
Nim:09530524
Hallo, saya Mahasiswa yg cantik  n baik
Nama: Afrida Asna
C:\>

Penjelasan dari program :

MEMBUAT PROGRAM SuperClass.java

             Ini bukan kelas utama karena tidak memiliki fungsi utama.
            Memiliki 2 method.
public class SuperClass{
                public SuperClass() {                                          method 1 / construktor
                                System.out.println("Ini Konstruktor Milik SuperClass");
                }

                public void methodSuperClass () {                                  method 2

                                System.out.println("Ini Method Milik SuperClass");
                }

}

MEMBUAT PROGRAM SubClass.java
            Dengan turunan maka subclass bisa mengakses ke kelas superclass,

subclass => kelas anak, dan superclass=> kelas induk.

public class SubClass extends SuperClass{
                public SubClass() {                                 method/ construktor
                                super ();                                 perintah untuk memanggil constructor kelas induk.
                }
                public void methodSubClass() {                                       method
                                super.methodSuperClass();                               perintah untuk memanggil method superclass dari kelas induk
                }
}

MEMBUAT PROGRAM DemoInheritance,java
            Merupakan kelas utama, karena ada fungsi utamanya.
public class DemoInheritance {
public static void main (String[] args){
            SubClass sc = new SubClass ();
            sc.methodSubClass();             perintah untuk memanggil method subclass dr objek sc
            }
}                     

sc = nama objek              perintah untuk membuat objek baru

MEMBUAT PROGRAM Persegi.java
public class Persegi {

                private double panjang;                                    
                private double lebar;                                                  disembunyikan, karena ada modifier private
                private double tinggi;

                public Persegi() {
                                panjang = 0;
                                lebar = 0;
                }

                private double luas (double p, double l) {          method yang disembunyikan krn ada private dan kelas lain tidak bisa diakses dan wilayah aksesnya kelas yang utama.
                                return p*l;
                }
                public void setpanjang (double panjang1) {
                                this.panjang = panjang1;
                }
                public void setlebar (double lebar1) {
                                this.lebar = lebar1;
                }
                public double getpanjang () {
                                return panjang;
                }
                public double getlebar () {
                                return lebar;
                }
                public double getluas () {
                                return luas (panjang, lebar);                 (double p, double l => 10 * 20 = 200)
                }
}

MEMBUAT PROGRAM MainPersegi.java
public class MainPersegi {
                public static void main (String[] args) {
                Persegi pg = new Persegi();
                pg.setpanjang(10);
                pg.setlebar(20);

                System.out.println ("Panjang : "+pg.getpanjang());
                System.out.println ("Lebar   : "+pg.getlebar());
                System.out.println ("Luas    : "+pg.getluas());
                }
}

MEMBUAT PROGRAM Karyawan.java
abstract class Karyawan {
                int gaji;
                Karyawan() {
                                gaji = 1000000;
                }
                int getgaji() {
                                return gaji;
                }
                abstract void naikgaji();
}

MEMBUAT PROGRAM Manager.java
class Manager extends Karyawan{
                Manager () {
                                gaji += 2000000;
                }
                void naikgaji () {
                                gaji+= 3000000;
                }
}

MEMBUAT PROGRAM Receptionist.java
class Receptionist extends Karyawan{
                Receptionist () {
                                gaji += 1000000;
                }
                void naikgaji () {
                                gaji+= 1000000;
                }
}

MEMBUAT PROGRAM Polymorphisme.java
class Polymorphisme {
                public static void main (String[] args) {
                Karyawan K[]  = new Karyawan [3];

                K[0] = new Manager ();
                K[1] = new Receptionist ();
                K[2] = new Manager ();

                for (int i=0; i<3; i++)
                                System.out.println ("Gaji Karyawan "+i+" adalah "+K[i].getgaji());

                for (int i=0; i<3; i++)
                                K[i].naikgaji();

                for (int i=0; i<3; i++)
                                System.out.println ("Gaji Sekarang "+i+" adalah "+K[i].getgaji());
                                }
                }



 PROGRAM INPUT MAUPUN OUTPUT PADA JAVA

sc :Memanggil subclass
subclass : Memanggil konstruktor subclass dan membuat objek baru
demoinheritas : memanggil objek dari superclass dengan membuat nama objek

new persegi : memanggil kostruktor persegi
pg  : membuat objek baru
pg.setpanjang(10); memanggil objek setpanjang dari pg
pg.setlebar(20); memanggil method set lebar dr pg

System.out.println("panjang : "+pg.getpanjang());
 : memanggil method get panjang dari get persegi
System.out.println("lebar : "+pg.getlebar()); : memanggil method get lebar dari get persegi
System.out.println("luas : "+pg.getluas()); : memanggil method get luas dari get persegi

k[0] = new Manager( ); : memanggil konstruktor manajer
k[1]= new receptionist( ); : memanggil konstruktor receptionist
k[2]= new Manager ( ); : memanggil kostruktor manajer